diff options
Diffstat (limited to 'source/blender/windowmanager/gizmo/intern/wm_gizmo.c')
| -rw-r--r-- | source/blender/windowmanager/gizmo/intern/wm_gizmo.c | 314 |
1 files changed, 157 insertions, 157 deletions
diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo.c index bef193f6c56..da8b301b536 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo.c @@ -59,42 +59,42 @@ #include "BPY_extern.h" #endif -/* only for own init/exit calls (wm_manipulatortype_init/wm_manipulatortype_free) */ +/* only for own init/exit calls (wm_gizmotype_init/wm_gizmotype_free) */ #include "wm.h" /* own includes */ #include "wm_gizmo_wmapi.h" #include "wm_gizmo_intern.h" -static void wm_manipulator_register( - wmManipulatorGroup *mgroup, wmManipulator *mpr); +static void wm_gizmo_register( + wmGizmoGroup *mgroup, wmGizmo *mpr); /** * \note Follow #wm_operator_create convention. */ -static wmManipulator *wm_manipulator_create( - const wmManipulatorType *wt, +static wmGizmo *wm_gizmo_create( + const wmGizmoType *wt, PointerRNA *properties) { BLI_assert(wt != NULL); - BLI_assert(wt->struct_size >= sizeof(wmManipulator)); + BLI_assert(wt->struct_size >= sizeof(wmGizmo)); - wmManipulator *mpr = MEM_callocN( - wt->struct_size + (sizeof(wmManipulatorProperty) * wt->target_property_defs_len), __func__); + wmGizmo *mpr = MEM_callocN( + wt->struct_size + (sizeof(wmGizmoProperty) * wt->target_property_defs_len), __func__); mpr->type = wt; /* initialize properties, either copy or create */ - mpr->ptr = MEM_callocN(sizeof(PointerRNA), "wmManipulatorPtrRNA"); + mpr->ptr = MEM_callocN(sizeof(PointerRNA), "wmGizmoPtrRNA"); if (properties && properties->data) { mpr->properties = IDP_CopyProperty(properties->data); } else { IDPropertyTemplate val = {0}; - mpr->properties = IDP_New(IDP_GROUP, &val, "wmManipulatorProperties"); + mpr->properties = IDP_New(IDP_GROUP, &val, "wmGizmoProperties"); } RNA_pointer_create(G_MAIN->wm.first, wt->srna, mpr->properties, mpr->ptr); - WM_manipulator_properties_sanitize(mpr->ptr, 0); + WM_gizmo_properties_sanitize(mpr->ptr, 0); unit_m4(mpr->matrix_space); unit_m4(mpr->matrix_basis); @@ -105,13 +105,13 @@ static wmManipulator *wm_manipulator_create( return mpr; } -wmManipulator *WM_manipulator_new_ptr( - const wmManipulatorType *wt, wmManipulatorGroup *mgroup, +wmGizmo *WM_gizmo_new_ptr( + const wmGizmoType *wt, wmGizmoGroup *mgroup, PointerRNA *properties) { - wmManipulator *mpr = wm_manipulator_create(wt, properties); + wmGizmo *mpr = wm_gizmo_create(wt, properties); - wm_manipulator_register(mgroup, mpr); + wm_gizmo_register(mgroup, mpr); if (mpr->type->setup != NULL) { mpr->type->setup(mpr); @@ -122,21 +122,21 @@ wmManipulator *WM_manipulator_new_ptr( /** * \param wt: Must be valid, - * if you need to check it exists use #WM_manipulator_new_ptr + * if you need to check it exists use #WM_gizmo_new_ptr * because callers of this function don't NULL check the return value. */ -wmManipulator *WM_manipulator_new( - const char *idname, wmManipulatorGroup *mgroup, +wmGizmo *WM_gizmo_new( + const char *idname, wmGizmoGroup *mgroup, PointerRNA *properties) { - const wmManipulatorType *wt = WM_manipulatortype_find(idname, false); - return WM_manipulator_new_ptr(wt, mgroup, properties); + const wmGizmoType *wt = WM_gizmotype_find(idname, false); + return WM_gizmo_new_ptr(wt, mgroup, properties); } /** * Initialize default values and allocate needed memory for members. */ -static void manipulator_init(wmManipulator *mpr) +static void gizmo_init(wmGizmo *mpr) { const float color_default[4] = {1.0f, 1.0f, 1.0f, 1.0f}; @@ -149,24 +149,24 @@ static void manipulator_init(wmManipulator *mpr) } /** - * Register \a manipulator. + * Register \a gizmo. * - * \param name: name used to create a unique idname for \a manipulator in \a mgroup + * \param name: name used to create a unique idname for \a gizmo in \a mgroup * * \note Not to be confused with type registration from RNA. */ -static void wm_manipulator_register(wmManipulatorGroup *mgroup, wmManipulator *mpr) +static void wm_gizmo_register(wmGizmoGroup *mgroup, wmGizmo *mpr) { - manipulator_init(mpr); - wm_manipulatorgroup_manipulator_register(mgroup, mpr); + gizmo_init(mpr); + wm_gizmogroup_gizmo_register(mgroup, mpr); } /** - * \warning this doesn't check #wmManipulatorMap (highlight, selection etc). + * \warning this doesn't check #wmGizmoMap (highlight, selection etc). * Typical use is when freeing the windowing data, * where caller can manage clearing selection, highlight... etc. */ -void WM_manipulator_free(wmManipulator *mpr) +void WM_gizmo_free(wmGizmo *mpr) { if (mpr->type->free != NULL) { mpr->type->free(mpr); @@ -188,14 +188,14 @@ void WM_manipulator_free(wmManipulator *mpr) } if (mpr->ptr != NULL) { - WM_manipulator_properties_free(mpr->ptr); + WM_gizmo_properties_free(mpr->ptr); MEM_freeN(mpr->ptr); } if (mpr->type->target_property_defs_len != 0) { - wmManipulatorProperty *mpr_prop_array = WM_manipulator_target_property_array(mpr); + wmGizmoProperty *mpr_prop_array = WM_gizmo_target_property_array(mpr); for (int i = 0; i < mpr->type->target_property_defs_len; i++) { - wmManipulatorProperty *mpr_prop = &mpr_prop_array[i]; + wmGizmoProperty *mpr_prop = &mpr_prop_array[i]; if (mpr_prop->custom_func.free_fn) { mpr_prop->custom_func.free_fn(mpr, mpr_prop); } @@ -206,41 +206,41 @@ void WM_manipulator_free(wmManipulator *mpr) } /** - * Free \a manipulator and unlink from \a manipulatorlist. - * \a manipulatorlist is allowed to be NULL. + * Free \a gizmo and unlink from \a gizmolist. + * \a gizmolist is allowed to be NULL. */ -void WM_manipulator_unlink(ListBase *manipulatorlist, wmManipulatorMap *mmap, wmManipulator *mpr, bContext *C) +void WM_gizmo_unlink(ListBase *gizmolist, wmGizmoMap *mmap, wmGizmo *mpr, bContext *C) { - if (mpr->state & WM_MANIPULATOR_STATE_HIGHLIGHT) { - wm_manipulatormap_highlight_set(mmap, C, NULL, 0); + if (mpr->state & WM_GIZMO_STATE_HIGHLIGHT) { + wm_gizmomap_highlight_set(mmap, C, NULL, 0); } - if (mpr->state & WM_MANIPULATOR_STATE_MODAL) { - wm_manipulatormap_modal_set(mmap, C, mpr, NULL, false); + if (mpr->state & WM_GIZMO_STATE_MODAL) { + wm_gizmomap_modal_set(mmap, C, mpr, NULL, false); } /* Unlink instead of setting so we don't run callbacks. */ - if (mpr->state & WM_MANIPULATOR_STATE_SELECT) { - WM_manipulator_select_unlink(mmap, mpr); + if (mpr->state & WM_GIZMO_STATE_SELECT) { + WM_gizmo_select_unlink(mmap, mpr); } - if (manipulatorlist) { - BLI_remlink(manipulatorlist, mpr); + if (gizmolist) { + BLI_remlink(gizmolist, mpr); } BLI_assert(mmap->mmap_context.highlight != mpr); BLI_assert(mmap->mmap_context.modal != mpr); - WM_manipulator_free(mpr); + WM_gizmo_free(mpr); } /* -------------------------------------------------------------------- */ -/** \name Manipulator Creation API +/** \name Gizmo Creation API * - * API for defining data on manipulator creation. + * API for defining data on gizmo creation. * * \{ */ -struct wmManipulatorOpElem *WM_manipulator_operator_get( - wmManipulator *mpr, int part_index) +struct wmGizmoOpElem *WM_gizmo_operator_get( + wmGizmo *mpr, int part_index) { if (mpr->op_data && ((part_index >= 0) && (part_index < mpr->op_data_len))) { return &mpr->op_data[part_index]; @@ -248,8 +248,8 @@ struct wmManipulatorOpElem *WM_manipulator_operator_get( return NULL; } -PointerRNA *WM_manipulator_operator_set( - wmManipulator *mpr, int part_index, +PointerRNA *WM_gizmo_operator_set( + wmGizmo *mpr, int part_index, wmOperatorType *ot, IDProperty *properties) { BLI_assert(part_index < 255); @@ -258,7 +258,7 @@ PointerRNA *WM_manipulator_operator_set( mpr->op_data_len = part_index + 1; mpr->op_data = MEM_recallocN(mpr->op_data, sizeof(*mpr->op_data) * mpr->op_data_len); } - wmManipulatorOpElem *mpop = &mpr->op_data[part_index]; + wmGizmoOpElem *mpop = &mpr->op_data[part_index]; mpop->type = ot; if (mpop->ptr.data) { @@ -273,7 +273,7 @@ PointerRNA *WM_manipulator_operator_set( return &mpop->ptr; } -static void wm_manipulator_set_matrix_rotation_from_z_axis__internal( +static void wm_gizmo_set_matrix_rotation_from_z_axis__internal( float matrix[4][4], const float z_axis[3]) { /* old code, seems we can use simpler method */ @@ -292,7 +292,7 @@ static void wm_manipulator_set_matrix_rotation_from_z_axis__internal( } -static void wm_manipulator_set_matrix_rotation_from_yz_axis__internal( +static void wm_gizmo_set_matrix_rotation_from_yz_axis__internal( float matrix[4][4], const float y_axis[3], const float z_axis[3]) { normalize_v3_v3(matrix[1], y_axis); @@ -302,42 +302,42 @@ static void wm_manipulator_set_matrix_rotation_from_yz_axis__internal( } /** - * wmManipulator.matrix utils. + * wmGizmo.matrix utils. */ -void WM_manipulator_set_matrix_rotation_from_z_axis( - wmManipulator *mpr, const float z_axis[3]) +void WM_gizmo_set_matrix_rotation_from_z_axis( + wmGizmo *mpr, const float z_axis[3]) { - wm_manipulator_set_matrix_rotation_from_z_axis__internal(mpr->matrix_basis, z_axis); + wm_gizmo_set_matrix_rotation_from_z_axis__internal(mpr->matrix_basis, z_axis); } -void WM_manipulator_set_matrix_rotation_from_yz_axis( - wmManipulator *mpr, const float y_axis[3], const float z_axis[3]) +void WM_gizmo_set_matrix_rotation_from_yz_axis( + wmGizmo *mpr, const float y_axis[3], const float z_axis[3]) { - wm_manipulator_set_matrix_rotation_from_yz_axis__internal(mpr->matrix_basis, y_axis, z_axis); + wm_gizmo_set_matrix_rotation_from_yz_axis__internal(mpr->matrix_basis, y_axis, z_axis); } -void WM_manipulator_set_matrix_location(wmManipulator *mpr, const float origin[3]) +void WM_gizmo_set_matrix_location(wmGizmo *mpr, const float origin[3]) { copy_v3_v3(mpr->matrix_basis[3], origin); } /** - * wmManipulator.matrix_offset utils. + * wmGizmo.matrix_offset utils. */ -void WM_manipulator_set_matrix_offset_rotation_from_z_axis( - wmManipulator *mpr, const float z_axis[3]) +void WM_gizmo_set_matrix_offset_rotation_from_z_axis( + wmGizmo *mpr, const float z_axis[3]) { - wm_manipulator_set_matrix_rotation_from_z_axis__internal(mpr->matrix_offset, z_axis); + wm_gizmo_set_matrix_rotation_from_z_axis__internal(mpr->matrix_offset, z_axis); } -void WM_manipulator_set_matrix_offset_rotation_from_yz_axis( - wmManipulator *mpr, const float y_axis[3], const float z_axis[3]) +void WM_gizmo_set_matrix_offset_rotation_from_yz_axis( + wmGizmo *mpr, const float y_axis[3], const float z_axis[3]) { - wm_manipulator_set_matrix_rotation_from_yz_axis__internal(mpr->matrix_offset, y_axis, z_axis); + wm_gizmo_set_matrix_rotation_from_yz_axis__internal(mpr->matrix_offset, y_axis, z_axis); } -void WM_manipulator_set_matrix_offset_location(wmManipulator *mpr, const float offset[3]) +void WM_gizmo_set_matrix_offset_location(wmGizmo *mpr, const float offset[3]) { copy_v3_v3(mpr->matrix_offset[3], offset); } -void WM_manipulator_set_flag(wmManipulator *mpr, const int flag, const bool enable) +void WM_gizmo_set_flag(wmGizmo *mpr, const int flag, const bool enable) { if (enable) { mpr->flag |= flag; @@ -347,50 +347,50 @@ void WM_manipulator_set_flag(wmManipulator *mpr, const int flag, const bool enab } } -void WM_manipulator_set_scale(wmManipulator *mpr, const float scale) +void WM_gizmo_set_scale(wmGizmo *mpr, const float scale) { mpr->scale_basis = scale; } -void WM_manipulator_set_line_width(wmManipulator *mpr, const float line_width) +void WM_gizmo_set_line_width(wmGizmo *mpr, const float line_width) { mpr->line_width = line_width; } /** - * Set manipulator rgba colors. + * Set gizmo rgba colors. * * \param col Normal state color. * \param col_hi Highlighted state color. */ -void WM_manipulator_get_color(const wmManipulator *mpr, float color[4]) +void WM_gizmo_get_color(const wmGizmo *mpr, float color[4]) { copy_v4_v4(color, mpr->color); } -void WM_manipulator_set_color(wmManipulator *mpr, const float color[4]) +void WM_gizmo_set_color(wmGizmo *mpr, const float color[4]) { copy_v4_v4(mpr->color, color); } -void WM_manipulator_get_color_highlight(const wmManipulator *mpr, float color_hi[4]) +void WM_gizmo_get_color_highlight(const wmGizmo *mpr, float color_hi[4]) { copy_v4_v4(color_hi, mpr->color_hi); } -void WM_manipulator_set_color_highlight(wmManipulator *mpr, const float color_hi[4]) +void WM_gizmo_set_color_highlight(wmGizmo *mpr, const float color_hi[4]) { copy_v4_v4(mpr->color_hi, color_hi); } -/** \} */ // Manipulator Creation API +/** \} */ // Gizmo Creation API /* -------------------------------------------------------------------- */ -/** \name Manipulator Callback Assignment +/** \name Gizmo Callback Assignment * * \{ */ -void WM_manipulator_set_fn_custom_modal(struct wmManipulator *mpr, wmManipulatorFnModal fn) +void WM_gizmo_set_fn_custom_modal(struct wmGizmo *mpr, wmGizmoFnModal fn) { mpr->custom_modal = fn; } @@ -401,32 +401,32 @@ void WM_manipulator_set_fn_custom_modal(struct wmManipulator *mpr, wmManipulator /* -------------------------------------------------------------------- */ /** - * Add/Remove \a manipulator to selection. - * Reallocates memory for selected manipulators so better not call for selecting multiple ones. + * Add/Remove \a gizmo to selection. + * Reallocates memory for selected gizmos so better not call for selecting multiple ones. * * \return if the selection has changed. */ -bool wm_manipulator_select_set_ex( - wmManipulatorMap *mmap, wmManipulator *mpr, bool select, +bool wm_gizmo_select_set_ex( + wmGizmoMap *mmap, wmGizmo *mpr, bool select, bool use_array, bool use_callback) { bool changed = false; if (select) { - if ((mpr->state & WM_MANIPULATOR_STATE_SELECT) == 0) { + if ((mpr->state & WM_GIZMO_STATE_SELECT) == 0) { if (use_array) { - wm_manipulatormap_select_array_push_back(mmap, mpr); + wm_gizmomap_select_array_push_back(mmap, mpr); } - mpr->state |= WM_MANIPULATOR_STATE_SELECT; + mpr->state |= WM_GIZMO_STATE_SELECT; changed = true; } } else { - if (mpr->state & WM_MANIPULATOR_STATE_SELECT) { + if (mpr->state & WM_GIZMO_STATE_SELECT) { if (use_array) { - wm_manipulatormap_select_array_remove(mmap, mpr); + wm_gizmomap_select_array_remove(mmap, mpr); } - mpr->state &= ~WM_MANIPULATOR_STATE_SELECT; + mpr->state &= ~WM_GIZMO_STATE_SELECT; changed = true; } } @@ -443,25 +443,25 @@ bool wm_manipulator_select_set_ex( } /* Remove from selection array without running callbacks. */ -bool WM_manipulator_select_unlink(wmManipulatorMap *mmap, wmManipulator *mpr) +bool WM_gizmo_select_unlink(wmGizmoMap *mmap, wmGizmo *mpr) { - return wm_manipulator_select_set_ex(mmap, mpr, false, true, false); + return wm_gizmo_select_set_ex(mmap, mpr, false, true, false); } -bool WM_manipulator_select_set(wmManipulatorMap *mmap, wmManipulator *mpr, bool select) +bool WM_gizmo_select_set(wmGizmoMap *mmap, wmGizmo *mpr, bool select) { - return wm_manipulator_select_set_ex(mmap, mpr, select, true, true); + return wm_gizmo_select_set_ex(mmap, mpr, select, true, true); } -void WM_manipulator_highlight_set(wmManipulatorMap *mmap, wmManipulator *mpr) +void WM_gizmo_highlight_set(wmGizmoMap *mmap, wmGizmo *mpr) { - wm_manipulatormap_highlight_set(mmap, NULL, mpr, mpr ? mpr->highlight_part : 0); + wm_gizmomap_highlight_set(mmap, NULL, mpr, mpr ? mpr->highlight_part : 0); } -bool wm_manipulator_select_and_highlight(bContext *C, wmManipulatorMap *mmap, wmManipulator *mpr) +bool wm_gizmo_select_and_highlight(bContext *C, wmGizmoMap *mmap, wmGizmo *mpr) { - if (WM_manipulator_select_set(mmap, mpr, true)) { - wm_manipulatormap_highlight_set(mmap, C, mpr, mpr->highlight_part); + if (WM_gizmo_select_set(mmap, mpr, true)) { + wm_gizmomap_highlight_set(mmap, C, mpr, mpr->highlight_part); return true; } else { @@ -470,32 +470,32 @@ bool wm_manipulator_select_and_highlight(bContext *C, wmManipulatorMap *mmap, wm } /** - * Special function to run from setup so manipulators start out interactive. + * Special function to run from setup so gizmos start out interactive. * * We could do this when linking them, but this complicates things since the window update code needs to run first. */ -void WM_manipulator_modal_set_from_setup( - struct wmManipulatorMap *mmap, struct bContext *C, - struct wmManipulator *mpr, int part_index, const wmEvent *event) +void WM_gizmo_modal_set_from_setup( + struct wmGizmoMap *mmap, struct bContext *C, + struct wmGizmo *mpr, int part_index, const wmEvent *event) { mpr->highlight_part = part_index; - WM_manipulator_highlight_set(mmap, mpr); + WM_gizmo_highlight_set(mmap, mpr); if (false) { - wm_manipulatormap_modal_set(mmap, C, mpr, event, true); + wm_gizmomap_modal_set(mmap, C, mpr, event, true); } else { /* WEAK: but it works. */ - WM_operator_name_call(C, "MANIPULATORGROUP_OT_manipulator_tweak", WM_OP_INVOKE_DEFAULT, NULL); + WM_operator_name_call(C, "GIZMOGROUP_OT_gizmo_tweak", WM_OP_INVOKE_DEFAULT, NULL); } } -void wm_manipulator_calculate_scale(wmManipulator *mpr, const bContext *C) +void wm_gizmo_calculate_scale(wmGizmo *mpr, const bContext *C) { const RegionView3D *rv3d = CTX_wm_region_view3d(C); float scale = UI_DPI_FAC; - if ((mpr->parent_mgroup->type->flag & WM_MANIPULATORGROUPTYPE_SCALE) == 0) { - scale *= U.manipulator_size; + if ((mpr->parent_mgroup->type->flag & WM_GIZMOGROUPTYPE_SCALE) == 0) { + scale *= U.gizmo_size; if (rv3d) { /* 'ED_view3d_pixel_size' includes 'U.pixelsize', remove it. */ float matrix_world[4][4]; @@ -519,53 +519,53 @@ void wm_manipulator_calculate_scale(wmManipulator *mpr, const bContext *C) mpr->scale_final = mpr->scale_basis * scale; } -static void manipulator_update_prop_data(wmManipulator *mpr) +static void gizmo_update_prop_data(wmGizmo *mpr) { - /* manipulator property might have been changed, so update manipulator */ + /* gizmo property might have been changed, so update gizmo */ if (mpr->type->property_update) { - wmManipulatorProperty *mpr_prop_array = WM_manipulator_target_property_array(mpr); + wmGizmoProperty *mpr_prop_array = WM_gizmo_target_property_array(mpr); for (int i = 0; i < mpr->type->target_property_defs_len; i++) { - wmManipulatorProperty *mpr_prop = &mpr_prop_array[i]; - if (WM_manipulator_target_property_is_valid(mpr_prop)) { + wmGizmoProperty *mpr_prop = &mpr_prop_array[i]; + if (WM_gizmo_target_property_is_valid(mpr_prop)) { mpr->type->property_update(mpr, mpr_prop); } } } } -void wm_manipulator_update(wmManipulator *mpr, const bContext *C, const bool refresh_map) +void wm_gizmo_update(wmGizmo *mpr, const bContext *C, const bool refresh_map) { if (refresh_map) { - manipulator_update_prop_data(mpr); + gizmo_update_prop_data(mpr); } - wm_manipulator_calculate_scale(mpr, C); + wm_gizmo_calculate_scale(mpr, C); } -int wm_manipulator_is_visible(wmManipulator *mpr) +int wm_gizmo_is_visible(wmGizmo *mpr) { - if (mpr->flag & WM_MANIPULATOR_HIDDEN) { + if (mpr->flag & WM_GIZMO_HIDDEN) { return 0; } - if ((mpr->state & WM_MANIPULATOR_STATE_MODAL) && - !(mpr->flag & (WM_MANIPULATOR_DRAW_MODAL | WM_MANIPULATOR_DRAW_VALUE))) + if ((mpr->state & WM_GIZMO_STATE_MODAL) && + !(mpr->flag & (WM_GIZMO_DRAW_MODAL | WM_GIZMO_DRAW_VALUE))) { /* don't draw while modal (dragging) */ return 0; } - if ((mpr->flag & WM_MANIPULATOR_DRAW_HOVER) && - !(mpr->state & WM_MANIPULATOR_STATE_HIGHLIGHT) && - !(mpr->state & WM_MANIPULATOR_STATE_SELECT)) /* still draw selected manipulators */ + if ((mpr->flag & WM_GIZMO_DRAW_HOVER) && + !(mpr->state & WM_GIZMO_STATE_HIGHLIGHT) && + !(mpr->state & WM_GIZMO_STATE_SELECT)) /* still draw selected gizmos */ { /* update but don't draw */ - return WM_MANIPULATOR_IS_VISIBLE_UPDATE; + return WM_GIZMO_IS_VISIBLE_UPDATE; } - return WM_MANIPULATOR_IS_VISIBLE_UPDATE | WM_MANIPULATOR_IS_VISIBLE_DRAW; + return WM_GIZMO_IS_VISIBLE_UPDATE | WM_GIZMO_IS_VISIBLE_DRAW; } -void WM_manipulator_calc_matrix_final_params( - const wmManipulator *mpr, - const struct WM_ManipulatorMatrixParams *params, +void WM_gizmo_calc_matrix_final_params( + const wmGizmo *mpr, + const struct WM_GizmoMatrixParams *params, float r_mat[4][4]) { const float (* const matrix_space)[4] = params->matrix_space ? params->matrix_space : mpr->matrix_space; @@ -581,11 +581,11 @@ void WM_manipulator_calc_matrix_final_params( copy_m4_m4(final_matrix, matrix_basis); } - if (mpr->flag & WM_MANIPULATOR_DRAW_NO_SCALE) { + if (mpr->flag & WM_GIZMO_DRAW_NO_SCALE) { mul_m4_m4m4(final_matrix, final_matrix, matrix_offset); } else { - if (mpr->flag & WM_MANIPULATOR_DRAW_OFFSET_SCALE) { + if (mpr->flag & WM_GIZMO_DRAW_OFFSET_SCALE) { mul_mat3_m4_fl(final_matrix, *scale_final); mul_m4_m4m4(final_matrix, final_matrix, matrix_offset); } @@ -598,14 +598,14 @@ void WM_manipulator_calc_matrix_final_params( mul_m4_m4m4(r_mat, matrix_space, final_matrix); } -void WM_manipulator_calc_matrix_final_no_offset(const wmManipulator *mpr, float r_mat[4][4]) +void WM_gizmo_calc_matrix_final_no_offset(const wmGizmo *mpr, float r_mat[4][4]) { float mat_identity[4][4]; unit_m4(mat_identity); - WM_manipulator_calc_matrix_final_params( + WM_gizmo_calc_matrix_final_params( mpr, - &((struct WM_ManipulatorMatrixParams) { + &((struct WM_GizmoMatrixParams) { .matrix_space = NULL, .matrix_basis = NULL, .matrix_offset = mat_identity, @@ -614,11 +614,11 @@ void WM_manipulator_calc_matrix_final_no_offset(const wmManipulator *mpr, float ); } -void WM_manipulator_calc_matrix_final(const wmManipulator *mpr, float r_mat[4][4]) +void WM_gizmo_calc_matrix_final(const wmGizmo *mpr, float r_mat[4][4]) { - WM_manipulator_calc_matrix_final_params( + WM_gizmo_calc_matrix_final_params( mpr, - &((struct WM_ManipulatorMatrixParams) { + &((struct WM_GizmoMatrixParams) { .matrix_space = NULL, .matrix_basis = NULL, .matrix_offset = NULL, @@ -627,31 +627,31 @@ void WM_manipulator_calc_matrix_final(const wmManipulator *mpr, float r_mat[4][4 ); } -/** \name Manipulator Propery Access +/** \name Gizmo Propery Access * * Matches `WM_operator_properties` conventions. * * \{ */ -void WM_manipulator_properties_create_ptr(PointerRNA *ptr, wmManipulatorType *wt) +void WM_gizmo_properties_create_ptr(PointerRNA *ptr, wmGizmoType *wt) { RNA_pointer_create(NULL, wt->srna, NULL, ptr); } -void WM_manipulator_properties_create(PointerRNA *ptr, const char *wtstring) +void WM_gizmo_properties_create(PointerRNA *ptr, const char *wtstring) { - const wmManipulatorType *wt = WM_manipulatortype_find(wtstring, false); + const wmGizmoType *wt = WM_gizmotype_find(wtstring, false); if (wt) - WM_manipulator_properties_create_ptr(ptr, (wmManipulatorType *)wt); + WM_gizmo_properties_create_ptr(ptr, (wmGizmoType *)wt); else - RNA_pointer_create(NULL, &RNA_ManipulatorProperties, NULL, ptr); + RNA_pointer_create(NULL, &RNA_GizmoProperties, NULL, ptr); } /* similar to the function above except its uses ID properties * used for keymaps and macros */ -void WM_manipulator_properties_alloc(PointerRNA **ptr, IDProperty **properties, const char *wtstring) +void WM_gizmo_properties_alloc(PointerRNA **ptr, IDProperty **properties, const char *wtstring) { if (*properties == NULL) { IDPropertyTemplate val = {0}; @@ -660,14 +660,14 @@ void WM_manipulator_properties_alloc(PointerRNA **ptr, IDProperty **properties, if (*ptr == NULL) { *ptr = MEM_callocN(sizeof(PointerRNA), "wmOpItemPtr"); - WM_manipulator_properties_create(*ptr, wtstring); + WM_gizmo_properties_create(*ptr, wtstring); } (*ptr)->data = *properties; } -void WM_manipulator_properties_sanitize(PointerRNA *ptr, const bool no_context) +void WM_gizmo_properties_sanitize(PointerRNA *ptr, const bool no_context) { RNA_STRUCT_BEGIN (ptr, prop) { @@ -682,10 +682,10 @@ void WM_manipulator_properties_sanitize(PointerRNA *ptr, const bool no_context) { StructRNA *ptype = RNA_property_pointer_type(ptr, prop); - /* recurse into manipulator properties */ - if (RNA_struct_is_a(ptype, &RNA_ManipulatorProperties)) { + /* recurse into gizmo properties */ + if (RNA_struct_is_a(ptype, &RNA_GizmoProperties)) { PointerRNA opptr = RNA_property_pointer_get(ptr, prop); - WM_manipulator_properties_sanitize(&opptr, no_context); + WM_gizmo_properties_sanitize(&opptr, no_context); } break; } @@ -700,10 +700,10 @@ void WM_manipulator_properties_sanitize(PointerRNA *ptr, const bool no_context) /** set all props to their default, * \param do_update Only update un-initialized props. * - * \note, theres nothing specific to manipulators here. + * \note, theres nothing specific to gizmos here. * this could be made a general function. */ -bool WM_manipulator_properties_default(PointerRNA *ptr, const bool do_update) +bool WM_gizmo_properties_default(PointerRNA *ptr, const bool do_update) { bool changed = false; RNA_STRUCT_BEGIN (ptr, prop) @@ -714,7 +714,7 @@ bool WM_manipulator_properties_default(PointerRNA *ptr, const bool do_update) StructRNA *ptype = RNA_property_pointer_type(ptr, prop); if (ptype != &RNA_Struct) { PointerRNA opptr = RNA_property_pointer_get(ptr, prop); - changed |= WM_manipulator_properties_default(&opptr, do_update); + changed |= WM_gizmo_properties_default(&opptr, do_update); } break; } @@ -733,7 +733,7 @@ bool WM_manipulator_properties_default(PointerRNA *ptr, const bool do_update) } /* remove all props without PROP_SKIP_SAVE */ -void WM_manipulator_properties_reset(wmManipulator *mpr) +void WM_gizmo_properties_reset(wmGizmo *mpr) { if (mpr->ptr->data) { PropertyRNA *iterprop; @@ -752,7 +752,7 @@ void WM_manipulator_properties_reset(wmManipulator *mpr) } } -void WM_manipulator_properties_clear(PointerRNA *ptr) +void WM_gizmo_properties_clear(PointerRNA *ptr) { IDProperty *properties = ptr->data; @@ -761,7 +761,7 @@ void WM_manipulator_properties_clear(PointerRNA *ptr) } } -void WM_manipulator_properties_free(PointerRNA *ptr) +void WM_gizmo_properties_free(PointerRNA *ptr) { IDProperty *properties = ptr->data; @@ -778,14 +778,14 @@ void WM_manipulator_properties_free(PointerRNA *ptr) * * \{ */ -bool WM_manipulator_context_check_drawstep(const struct bContext *C, eWM_ManipulatorMapDrawStep step) +bool WM_gizmo_context_check_drawstep(const struct bContext *C, eWM_GizmoFlagMapDrawStep step) { switch (step) { - case WM_MANIPULATORMAP_DRAWSTEP_2D: + case WM_GIZMOMAP_DRAWSTEP_2D: { break; } - case WM_MANIPULATORMAP_DRAWSTEP_3D: + case WM_GIZMOMAP_DRAWSTEP_3D: { wmWindowManager *wm = CTX_wm_manager(C); if (ED_screen_animation_playing(wm)) { |