Manipulator: experimental lamp positioning tool
authorCampbell Barton <ideasman42@gmail.com>
Sun, 6 Aug 2017 09:47:25 +0000 (19:47 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 6 Aug 2017 09:50:09 +0000 (19:50 +1000)
- New manipulator tracks lamps to position under cursor.
- Works with multiple lamps, keeping relative offsets.
- Holding Ctrl moves the lamp.
- Access via manipulator or Shift-T.

Code could be improved, but like to get feedback from users.

release/scripts/startup/bl_ui/space_view3d.py
source/blender/editors/object/object_intern.h
source/blender/editors/object/object_ops.c
source/blender/editors/object/object_transform.c
source/blender/editors/space_view3d/space_view3d.c
source/blender/editors/space_view3d/view3d_intern.h
source/blender/editors/space_view3d/view3d_manipulator_lamp.c
source/blender/editors/transform/transform_ops.c

index 28b9180bfa927ef7058375742b9effa5e16f88cb..761e6294ffaac92392dcdd879802ca4425a5d100 100644 (file)
@@ -300,6 +300,12 @@ class VIEW3D_MT_transform_object(VIEW3D_MT_transform_base):
         layout.operator("object.randomize_transform")
         layout.operator("object.align")
 
+        # TODO: there is a strange context bug here.
+        """
+        layout.operator_context = 'INVOKE_REGION_WIN'
+        layout.operator("object.transform_axis_target")
+        """
+
 
 # Armature EditMode extensions to Transform menu
 class VIEW3D_MT_transform_armature(VIEW3D_MT_transform_base):
index f6fb3cc75b88ce29653688fadfb18befd6c3b9a4..3e655fa04a4abec83e91e44f04e77aea9534b158 100644 (file)
@@ -55,6 +55,7 @@ void OBJECT_OT_scale_clear(struct wmOperatorType *ot);
 void OBJECT_OT_origin_clear(struct wmOperatorType *ot);
 void OBJECT_OT_visual_transform_apply(struct wmOperatorType *ot);
 void OBJECT_OT_transform_apply(struct wmOperatorType *ot);
+void OBJECT_OT_transform_axis_target(struct wmOperatorType *ot);
 void OBJECT_OT_origin_set(struct wmOperatorType *ot);
 
 /* object_relations.c */
index ca02457ba391a85fa581a25a6acfe7bcfa64bf6e..07922f2d3b24afbd91221493b65f0248f2fb340e 100644 (file)
@@ -61,6 +61,7 @@ void ED_operatortypes_object(void)
        WM_operatortype_append(OBJECT_OT_origin_clear);
        WM_operatortype_append(OBJECT_OT_visual_transform_apply);
        WM_operatortype_append(OBJECT_OT_transform_apply);
+       WM_operatortype_append(OBJECT_OT_transform_axis_target);
        WM_operatortype_append(OBJECT_OT_origin_set);
        
        WM_operatortype_append(OBJECT_OT_mode_set);
index 19f9c77913225bbc0799c511d1464ef375509521..cf68bd3e419638239a5590cd9fe72cf7ad0c34eb 100644 (file)
 #include "DNA_scene_types.h"
 #include "DNA_group_types.h"
 #include "DNA_lattice_types.h"
+#include "DNA_lamp_types.h"
 
 #include "BLI_math.h"
 #include "BLI_listbase.h"
 #include "BLI_utildefines.h"
+#include "BLI_array.h"
 
 #include "BKE_context.h"
 #include "BKE_curve.h"
@@ -72,6 +74,8 @@
 #include "ED_screen.h"
 #include "ED_view3d.h"
 
+#include "MEM_guardedalloc.h"
+
 #include "object_intern.h"
 
 /*************************** Clear Transformation ****************************/
@@ -1124,3 +1128,385 @@ void OBJECT_OT_origin_set(wmOperatorType *ot)
        ot->prop = RNA_def_enum(ot->srna, "type", prop_set_center_types, 0, "Type", "");
        RNA_def_enum(ot->srna, "center", prop_set_bounds_types, V3D_AROUND_CENTER_MEAN, "Center", "");
 }
+
+/* -------------------------------------------------------------------- */
+
+/** \name Transform Axis Target
+ *
+ * Note this is an experemental operator to point lamps/cameras at objects.
+ * We may re-work how this behaves based on user feedback.
+ * - campbell.
+ * \{ */
+
+/* When using multiple objects, apply their relative rotational offset to the active object. */
+#define USE_RELATIVE_ROTATION
+
+struct XFormAxisItem {
+       Object *ob;
+       float rot_mat[3][3];
+       void *obtfm;
+       float xform_dist;
+
+#ifdef USE_RELATIVE_ROTATION
+       /* use when translating multiple */
+       float xform_rot_offset[3][3];
+#endif
+};
+
+struct XFormAxisData {
+       ViewContext vc;
+       struct {
+               float depth;
+               float normal[3];
+               bool is_depth_valid;
+               bool is_normal_valid;
+       } prev;
+
+       struct XFormAxisItem *object_data;
+       uint object_data_len;
+       bool is_translate;
+
+       int init_event;
+};
+
+static bool object_is_target_compat(const Object *ob)
+{
+       if (ob->type == OB_LAMP) {
+               const Lamp *la = ob->data;
+               if (ELEM(la->type, LA_SUN, LA_SPOT, LA_HEMI, LA_AREA)) {
+                       return true;
+               }
+       }
+       /* We might want to enable this later, for now just lamps */
+#if 0
+       else if (ob->type == OB_CAMERA) {
+               return true;
+       }
+#endif
+       return false;
+}
+
+static void object_transform_axis_target_free_data(wmOperator *op)
+{
+       struct XFormAxisData *xfd = op->customdata;
+       struct XFormAxisItem *item = xfd->object_data;
+       for (int i = 0; i < xfd->object_data_len; i++, item++) {
+               MEM_freeN(item->obtfm);
+       }
+       MEM_freeN(xfd->object_data);
+       MEM_freeN(xfd);
+       op->customdata = NULL;
+}
+
+/* We may want to expose as alternative to: BKE_object_apply_rotation */
+static void object_apply_rotation(Object *ob, const float rmat[3][3])
+{
+       float size[3];
+       float loc[3];
+       float rmat4[4][4];
+       copy_m4_m3(rmat4, rmat);
+
+       copy_v3_v3(size, ob->size);
+       copy_v3_v3(loc, ob->loc);
+       BKE_object_apply_mat4(ob, rmat4, true, true);
+       copy_v3_v3(ob->size, size);
+       copy_v3_v3(ob->loc, loc);
+}
+/* We may want to extract this to: BKE_object_apply_location */
+static void object_apply_location(Object *ob, const float loc[3])
+{
+       /* quick but weak */
+       Object ob_prev = *ob;
+       float mat[4][4];
+       copy_m4_m4(mat, ob->obmat);
+       copy_v3_v3(mat[3], loc);
+       BKE_object_apply_mat4(ob, mat, true, true);
+       copy_v3_v3(mat[3], ob->loc);
+       *ob = ob_prev;
+       copy_v3_v3(ob->loc, mat[3]);
+}
+
+static void object_orient_to_location(
+        Object *ob, float rot_orig[3][3], const float axis[3], const float location[3])
+{
+       float delta[3];
+       sub_v3_v3v3(delta, ob->obmat[3], location);
+       if (normalize_v3(delta) != 0.0f) {
+               if (len_squared_v3v3(delta, axis) > FLT_EPSILON) {
+                       float delta_rot[3][3];
+                       float final_rot[3][3];
+                       rotation_between_vecs_to_mat3(delta_rot, axis, delta);
+
+                       mul_m3_m3m3(final_rot, delta_rot, rot_orig);
+
+                       object_apply_rotation(ob, final_rot);
+
+                       DEG_id_tag_update(&ob->id, OB_RECALC_OB);
+               }
+       }
+}
+
+static void object_transform_axis_target_cancel(bContext *C, wmOperator *op)
+{
+       struct XFormAxisData *xfd = op->customdata;
+       struct XFormAxisItem *item = xfd->object_data;
+       for (int i = 0; i < xfd->object_data_len; i++, item++) {
+               BKE_object_tfm_restore(item->ob, item->obtfm);
+               DEG_id_tag_update(&item->ob->id, OB_RECALC_OB);
+               WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
+       }
+
+       object_transform_axis_target_free_data(op);
+}
+
+static int object_transform_axis_target_invoke(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       ViewContext vc;
+       view3d_set_viewcontext(C, &vc);
+
+       if (!object_is_target_compat(vc.obact)) {
+               /* Falls back to texture space transform. */
+               return OPERATOR_PASS_THROUGH;
+       }
+
+       ED_view3d_autodist_init(C, vc.depsgraph, vc.ar, vc.v3d, 0);
+
+       if (vc.rv3d->depths != NULL) {
+               vc.rv3d->depths->damaged = true;
+       }
+       ED_view3d_depth_update(vc.ar);
+
+       if (vc.rv3d->depths == NULL) {
+               BKE_report(op->reports, RPT_WARNING, "Unable to access depth buffer, using view plane");
+               return OPERATOR_CANCELLED;
+       }
+
+       ED_region_tag_redraw(vc.ar);
+
+       struct XFormAxisData *xfd;
+       xfd = op->customdata = MEM_callocN(sizeof(struct XFormAxisData), __func__);
+
+       /* Don't change this at runtime. */
+       xfd->vc = vc;
+       xfd->vc.mval[0] = event->mval[0];
+       xfd->vc.mval[1] = event->mval[1];
+
+       xfd->prev.depth = 1.0f;
+       xfd->prev.is_depth_valid = false;
+       xfd->prev.is_normal_valid = false;
+       xfd->is_translate = false;
+
+       xfd->init_event = WM_userdef_event_type_from_keymap_type(event->type);
+
+       {
+               struct XFormAxisItem *object_data = NULL;
+               BLI_array_declare(object_data);
+
+               struct XFormAxisItem *item = BLI_array_append_ret(object_data);
+               item->ob = xfd->vc.obact;
+
+               CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects)
+               {
+                       if ((ob != xfd->vc.obact) && object_is_target_compat(ob)) {
+                               item = BLI_array_append_ret(object_data);
+                               item->ob = ob;
+                       }
+               }
+               CTX_DATA_END;
+
+               xfd->object_data = object_data;
+               xfd->object_data_len = BLI_array_count(object_data);
+
+               if (xfd->object_data_len != BLI_array_count(object_data)) {
+                       xfd->object_data = MEM_reallocN(xfd->object_data, xfd->object_data_len * sizeof(*xfd->object_data));
+               }
+       }
+
+       {
+               struct XFormAxisItem *item = xfd->object_data;
+               for (int i = 0; i < xfd->object_data_len; i++, item++) {
+                       item->obtfm = BKE_object_tfm_backup(item->ob);
+                       BKE_object_rot_to_mat3(item->ob, item->rot_mat, true);
+               }
+       }
+
+       WM_event_add_modal_handler(C, op);
+
+       return OPERATOR_RUNNING_MODAL;
+}
+
+static int object_transform_axis_target_modal(bContext *C, wmOperator *op, const wmEvent *event)
+{
+       struct XFormAxisData *xfd = op->customdata;
+       ARegion *ar = xfd->vc.ar;
+
+       view3d_operator_needs_opengl(C);
+
+       const bool is_translate = (event->ctrl != 0);
+       const bool is_translate_init = is_translate && (xfd->is_translate != is_translate);
+
+       if (event->type == MOUSEMOVE || is_translate_init) {
+               const ViewDepths *depths = xfd->vc.rv3d->depths;
+               if (depths &&
+                   ((unsigned int)event->mval[0] < depths->w) &&
+                   ((unsigned int)event->mval[1] < depths->h))
+               {
+                       double depth = (double)ED_view3d_depth_read_cached(&xfd->vc, event->mval);
+                       float location_world[3];
+                       if (depth == 1.0f) {
+                               if (xfd->prev.is_depth_valid) {
+                                       depth = (double)xfd->prev.depth;
+                               }
+                       }
+                       if ((depth > depths->depth_range[0]) && (depth < depths->depth_range[1])) {
+                               xfd->prev.depth = depth;
+                               xfd->prev.is_depth_valid = true;
+                               if (ED_view3d_depth_unproject(ar, event->mval, depth, location_world)) {
+                                       if (is_translate) {
+
+                                               float normal[3];
+                                               bool normal_found = false;
+                                               if (ED_view3d_depth_read_cached_normal(&xfd->vc, event->mval, normal)) {
+                                                       normal_found = true;
+
+                                                       /* cheap attempt to smooth normals out a bit! */
+                                                       const uint ofs = 2;
+                                                       for (uint x = -ofs; x <= ofs; x += ofs / 2) {
+                                                               for (uint y = -ofs; y <= ofs; y += ofs / 2) {
+                                                                       if (x != 0 && y != 0) {
+                                                                               int mval_ofs[2] = {event->mval[0] + x, event->mval[1] + y};
+                                                                               float n[3];
+                                                                               if (ED_view3d_depth_read_cached_normal(
+                                                                                       &xfd->vc, mval_ofs, n))
+                                                                               {
+                                                                                       add_v3_v3(normal, n);
+                                                                               }
+                                                                       }
+                                                               }
+                                                       }
+                                                       normalize_v3(normal);
+                                               }
+                                               else if (xfd->prev.is_normal_valid) {
+                                                       copy_v3_v3(normal, xfd->prev.normal);
+                                                       normal_found = true;
+                                               }
+
+                                               if (normal_found) {
+#ifdef USE_RELATIVE_ROTATION
+                                                       if (is_translate_init && xfd->object_data_len > 1) {
+                                                               float xform_rot_offset_inv_first[3][3];
+                                                               struct XFormAxisItem *item = xfd->object_data;
+                                                               for (int i = 0; i < xfd->object_data_len; i++, item++) {
+                                                                       copy_m3_m4(item->xform_rot_offset, item->ob->obmat);
+                                                                       normalize_m3(item->xform_rot_offset);
+
+                                                                       if (i == 0) {
+                                                                               invert_m3_m3(xform_rot_offset_inv_first, xfd->object_data[0].xform_rot_offset);
+                                                                       }
+                                                                       else {
+                                                                               mul_m3_m3m3(item->xform_rot_offset,
+                                                                                           item->xform_rot_offset,
+                                                                                           xform_rot_offset_inv_first);
+                                                                       }
+                                                               }
+                                                       }
+
+#endif
+
+                                                       struct XFormAxisItem *item = xfd->object_data;
+                                                       for (int i = 0; i < xfd->object_data_len; i++, item++) {
+                                                               if (is_translate_init) {
+                                                                       float ob_axis[3];
+                                                                       item->xform_dist = len_v3v3(item->ob->obmat[3], location_world);
+                                                                       normalize_v3_v3(ob_axis, item->ob->obmat[2]);
+                                                                       /* Scale to avoid adding distance when moving between surfaces. */
+                                                                       float scale = fabsf(dot_v3v3(ob_axis, normal));
+                                                                       item->xform_dist *= scale;
+                                                               }
+
+                                                               float target_normal[3];
+                                                               copy_v3_v3(target_normal, normal);
+
+#ifdef USE_RELATIVE_ROTATION
+                                                               if (i != 0) {
+                                                                       mul_m3_v3(item->xform_rot_offset, target_normal);
+                                                               }
+#endif
+                                                               {
+                                                                       float loc[3];
+
+                                                                       copy_v3_v3(loc, location_world);
+                                                                       madd_v3_v3fl(loc, target_normal, item->xform_dist);
+                                                                       object_apply_location(item->ob, loc);
+                                                                       copy_v3_v3(item->ob->obmat[3], loc);  /* so orient behaves as expected */
+                                                               }
+
+                                                               object_orient_to_location(item->ob, item->rot_mat, item->rot_mat[2], location_world);
+                                                               WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
+                                                       }
+                                                       copy_v3_v3(xfd->prev.normal, normal);
+                                                       xfd->prev.is_normal_valid = true;
+                                               }
+                                       }
+                                       else {
+                                               struct XFormAxisItem *item = xfd->object_data;
+                                               for (int i = 0; i < xfd->object_data_len; i++, item++) {
+                                                       object_orient_to_location(item->ob, item->rot_mat, item->rot_mat[2], location_world);
+                                                       WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, item->ob);
+                                               }
+                                               xfd->prev.is_normal_valid = false;
+                                       }
+                               }
+                       }
+               }
+               xfd->is_translate = is_translate;
+
+               ED_region_tag_redraw(xfd->vc.ar);
+       }
+
+       bool is_finished = false;
+
+       if (ISMOUSE(xfd->init_event)) {
+               if ((event->type == xfd->init_event) && (event->val == KM_RELEASE)) {
+                       is_finished = true;
+               }
+       }
+       else {
+               if (ELEM(event->type, LEFTMOUSE, RETKEY, PADENTER)) {
+                       is_finished = true;
+               }
+       }
+
+       if (is_finished) {
+               object_transform_axis_target_free_data(op);
+               return OPERATOR_FINISHED;
+       }
+       else if (ELEM(event->type, ESCKEY, RIGHTMOUSE)) {
+               object_transform_axis_target_cancel(C, op);
+               return OPERATOR_CANCELLED;
+       }
+
+
+       return OPERATOR_RUNNING_MODAL;
+}
+
+void OBJECT_OT_transform_axis_target(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name = "Interactive Lamp Track to Cursor";
+       ot->description = "Interactively point cameras and lamps to a location (Ctrl translates)";
+       ot->idname = "OBJECT_OT_transform_axis_target";
+
+       /* api callbacks */
+       ot->invoke = object_transform_axis_target_invoke;
+       ot->cancel = object_transform_axis_target_cancel;
+       ot->modal = object_transform_axis_target_modal;
+       ot->poll = ED_operator_region_view3d_active;
+
+       /* flags */
+       ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
+}
+
+#undef USE_RELATIVE_ROTATION
+
+/** \} */
index f67684295a6eb104e972674f7036d5626ecb9dcd..74103c4873d064f1685b3b420be19a46be761055 100644 (file)
@@ -737,6 +737,7 @@ static void view3d_widgets(void)
        WM_manipulatorgrouptype_append_and_link(mmap_type, TRANSFORM_WGT_manipulator);
        WM_manipulatorgrouptype_append_and_link(mmap_type, VIEW3D_WGT_lamp_spot);
        WM_manipulatorgrouptype_append_and_link(mmap_type, VIEW3D_WGT_lamp_area);
+       WM_manipulatorgrouptype_append_and_link(mmap_type, VIEW3D_WGT_lamp_target);
        WM_manipulatorgrouptype_append_and_link(mmap_type, VIEW3D_WGT_force_field);
        WM_manipulatorgrouptype_append_and_link(mmap_type, VIEW3D_WGT_camera);
        WM_manipulatorgrouptype_append_and_link(mmap_type, VIEW3D_WGT_camera_view);
index c9f48e137f5e3a807f19009e3cfbeb4cab10c99f..bc600f3e58e5fee935a537097cdc9ae6e23a79f8 100644 (file)
@@ -321,6 +321,7 @@ extern const char *view3d_context_dir[]; /* doc access */
 /* view3d_widgets.c */
 void VIEW3D_WGT_lamp_spot        (struct wmManipulatorGroupType *wgt);
 void VIEW3D_WGT_lamp_area        (struct wmManipulatorGroupType *wgt);
+void VIEW3D_WGT_lamp_target      (struct wmManipulatorGroupType *wgt);
 void VIEW3D_WGT_camera           (struct wmManipulatorGroupType *wgt);
 void VIEW3D_WGT_camera_view      (struct wmManipulatorGroupType *wgt);
 void VIEW3D_WGT_force_field      (struct wmManipulatorGroupType *wgt);
index 451addaaeae370dde7c35c93396518547852b96d..4b550fd0b2ecfdb468006cede8275d30455ec6e0 100644 (file)
@@ -50,8 +50,6 @@
 /** \name Spot Lamp Manipulators
  * \{ */
 
-/* Spot Lamp */
-
 static bool WIDGETGROUP_lamp_spot_poll(const bContext *C, wmManipulatorGroupType *UNUSED(wgt))
 {
        Object *ob = CTX_data_active_object(C);
@@ -122,8 +120,6 @@ void VIEW3D_WGT_lamp_spot(wmManipulatorGroupType *wgt)
 /** \name Area Lamp Manipulators
  * \{ */
 
-/* Area Lamp */
-
 /* translate callbacks */
 static void manipulator_area_lamp_prop_size_get(
         const wmManipulator *UNUSED(mpr), wmManipulatorProperty *mpr_prop,
@@ -231,3 +227,71 @@ void VIEW3D_WGT_lamp_area(wmManipulatorGroupType *wgt)
 }
 
 /** \} */
+
+
+/* -------------------------------------------------------------------- */
+
+/** \name Lamp Target Manipulator
+ * \{ */
+
+static bool WIDGETGROUP_lamp_target_poll(const bContext *C, wmManipulatorGroupType *UNUSED(wgt))
+{
+       Object *ob = CTX_data_active_object(C);
+
+       if (ob != NULL) {
+               if (ob->type == OB_LAMP) {
+                       Lamp *la = ob->data;
+                       return (ELEM(la->type, LA_SUN, LA_SPOT, LA_HEMI, LA_AREA));
+               }
+               else if (ob->type == OB_CAMERA) {
+                       return true;
+               }
+       }
+       return false;
+}
+
+static void WIDGETGROUP_lamp_target_setup(const bContext *UNUSED(C), wmManipulatorGroup *mgroup)
+{
+       const float color[4] = {1.0f, 1.0f, 0.5f, 1.0f};
+       const float color_hi[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+
+       wmManipulatorWrapper *wwrapper = MEM_mallocN(sizeof(wmManipulatorWrapper), __func__);
+       wwrapper->manipulator = WM_manipulator_new("MANIPULATOR_WT_grab_3d", mgroup, NULL);
+       wmManipulator *mpr = wwrapper->manipulator;
+
+       mgroup->customdata = wwrapper;
+
+       WM_manipulator_set_color(mpr, color);
+       WM_manipulator_set_color_highlight(mpr, color_hi);
+
+       mpr->scale_basis = 0.05f;
+
+       wmOperatorType *ot = WM_operatortype_find("OBJECT_OT_transform_axis_target", true);
+       WM_manipulator_set_operator(mpr, ot, NULL);
+}
+
+static void WIDGETGROUP_lamp_target_draw_prepare(const bContext *C, wmManipulatorGroup *mgroup)
+{
+       wmManipulatorWrapper *wwrapper = mgroup->customdata;
+       Object *ob = CTX_data_active_object(C);
+       wmManipulator *mpr = wwrapper->manipulator;
+
+       copy_m4_m4(mpr->matrix_basis, ob->obmat);
+       unit_m4(mpr->matrix_offset);
+       mpr->matrix_offset[3][2] = -2.4f / mpr->scale_basis;
+}
+
+void VIEW3D_WGT_lamp_target(wmManipulatorGroupType *wgt)
+{
+       wgt->name = "Target Lamp Widgets";
+       wgt->idname = "VIEW3D_WGT_lamp_target";
+
+       wgt->flag |= (WM_MANIPULATORGROUPTYPE_PERSISTENT |
+                     WM_MANIPULATORGROUPTYPE_3D);
+
+       wgt->poll = WIDGETGROUP_lamp_target_poll;
+       wgt->setup = WIDGETGROUP_lamp_target_setup;
+       wgt->draw_prepare = WIDGETGROUP_lamp_target_draw_prepare;
+}
+
+/** \} */
\ No newline at end of file
index dba442259d1bff90db07b7f35553e95adb0a955d..affa5183adaaae2928dce11b957f9f6e71d5564c 100644 (file)
@@ -1050,6 +1050,8 @@ void transform_keymap_for_space(wmKeyConfig *keyconf, wmKeyMap *keymap, int spac
                        kmi = WM_keymap_add_item(keymap, "WM_OT_context_menu_enum", TABKEY, KM_PRESS, KM_SHIFT | KM_CTRL, 0);
                        RNA_string_set(kmi->ptr, "data_path", "tool_settings.snap_element");
 
+                       /* Will fall-through to texture-space transform. */
+                       kmi = WM_keymap_add_item(keymap, "OBJECT_OT_transform_axis_target", TKEY, KM_PRESS, KM_SHIFT, 0);
 
                        kmi = WM_keymap_add_item(keymap, OP_TRANSLATION, TKEY, KM_PRESS, KM_SHIFT, 0);
                        RNA_boolean_set(kmi->ptr, "texture_space", true);