archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Transform Orientation Refactor

Browse Source 
- Use `t->spacemtx` as the orientation matrix instead `t->orient_matrix`.
- Unify constraint behavior between modal and non-modal.
- Simplify code to remove old workarounds and rearrange struct members.

This fix T66142 since the actual `orient_type` (in the case
`V3D_ORIENT_NORMAL`) is used during Redo instead of always using
`V3D_ORIENT_CUSTOM_MATRIX`).

Differential Revision: https://developer.blender.org/D7469
This commit is contained in:
Germano Cavalcante
2020-04-29 08:07:25 -03:00
parent 980cebc459
commit c57e4418bb
11 changed files with 178 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
source/blender/editors/transform/transform.c
View File

@@ -778,9 +778,10 @@ wmKeyMap *transform_modal_keymap(wmKeyConfig *keyconf)
return keymap;
}
static void transform_event_xyz_constraint(TransInfo *t, short key_type, char cmode, bool is_plane)
static void transform_event_xyz_constraint(TransInfo *t, short key_type, bool is_plane)
{
if (!(t->flag & T_NO_CONSTRAINT)) {
char cmode = constraintModeToChar(t);
int constraint_axis, constraint_plane;
const bool edit_2d = (t->flag & T_2D_EDIT) != 0;
const char *msg1 = "", *msg2 = "", *msg3 = "";
@@ -824,11 +825,18 @@ static void transform_event_xyz_constraint(TransInfo *t, short key_type, char cm
}
}
else if (!edit_2d) {
if (cmode != axis) {
/* First press, constraint to an axis. */
t->orientation.index = 0;
const short *orientation_ptr = t->orientation.types[t->orientation.index];
const short orientation = orientation_ptr ? *orientation_ptr : V3D_ORIENT_GLOBAL;
if (ELEM(cmode, '\0', axis)) {
/* Successive presses on existing axis, cycle orientation modes. */
t->orientation.index = (t->orientation.index + 1) % ARRAY_SIZE(t->orientation.types);
BLI_assert(t->orientation.types[0] != V3D_ORIENT_CUSTOM_MATRIX);
initTransformOrientation(t->context, t, t->orientation.types[t->orientation.index]);
}
if (t->orientation.index == 0) {
stopConstraint(t);
}
else {
const short orientation = t->orientation.types[t->orientation.index];
if (is_plane == false) {
setUserConstraint(t, orientation, constraint_axis, msg2);
}
@@ -836,24 +844,6 @@ static void transform_event_xyz_constraint(TransInfo *t, short key_type, char cm
setUserConstraint(t, orientation, constraint_plane, msg3);
}
}
else {
/* Successive presses on existing axis, cycle orientation modes. */
t->orientation.index = (t->orientation.index + 1) % ARRAY_SIZE(t->orientation.types);
if (t->orientation.index == 0) {
stopConstraint(t);
}
else {
const short *orientation_ptr = t->orientation.types[t->orientation.index];
const short orientation = orientation_ptr ? *orientation_ptr : V3D_ORIENT_GLOBAL;
if (is_plane == false) {
setUserConstraint(t, orientation, constraint_axis, msg2);
}
else {
setUserConstraint(t, orientation, constraint_plane, msg3);
}
}
}
}
t->redraw |= TREDRAW_HARD;
}
@@ -861,7 +851,6 @@ static void transform_event_xyz_constraint(TransInfo *t, short key_type, char cm
int transformEvent(TransInfo *t, const wmEvent *event)
{
char cmode = constraintModeToChar(t);
bool handled = false;
const int modifiers_prev = t->modifiers;
const int mode_prev = t->mode;
@@ -1047,42 +1036,42 @@ int transformEvent(TransInfo *t, const wmEvent *event)
break;
case TFM_MODAL_AXIS_X:
if (!(t->flag & T_NO_CONSTRAINT)) {
transform_event_xyz_constraint(t, EVT_XKEY, cmode, false);
transform_event_xyz_constraint(t, EVT_XKEY, false);
t->redraw |= TREDRAW_HARD;
handled = true;
}
break;
case TFM_MODAL_AXIS_Y:
if ((t->flag & T_NO_CONSTRAINT) == 0) {
transform_event_xyz_constraint(t, EVT_YKEY, cmode, false);
transform_event_xyz_constraint(t, EVT_YKEY, false);
t->redraw |= TREDRAW_HARD;
handled = true;
}
break;
case TFM_MODAL_AXIS_Z:
if ((t->flag & (T_NO_CONSTRAINT)) == 0) {
transform_event_xyz_constraint(t, EVT_ZKEY, cmode, false);
transform_event_xyz_constraint(t, EVT_ZKEY, false);
t->redraw |= TREDRAW_HARD;
handled = true;
}
break;
case TFM_MODAL_PLANE_X:
if ((t->flag & (T_NO_CONSTRAINT | T_2D_EDIT)) == 0) {
transform_event_xyz_constraint(t, EVT_XKEY, cmode, true);
transform_event_xyz_constraint(t, EVT_XKEY, true);
t->redraw |= TREDRAW_HARD;
handled = true;
}
break;
case TFM_MODAL_PLANE_Y:
if ((t->flag & (T_NO_CONSTRAINT | T_2D_EDIT)) == 0) {
transform_event_xyz_constraint(t, EVT_YKEY, cmode, true);
transform_event_xyz_constraint(t, EVT_YKEY, true);
t->redraw |= TREDRAW_HARD;
handled = true;
}
break;
case TFM_MODAL_PLANE_Z:
if ((t->flag & (T_NO_CONSTRAINT | T_2D_EDIT)) == 0) {
transform_event_xyz_constraint(t, EVT_ZKEY, cmode, true);
transform_event_xyz_constraint(t, EVT_ZKEY, true);
t->redraw |= TREDRAW_HARD;
handled = true;
}
@@ -1228,17 +1217,7 @@ int transformEvent(TransInfo *t, const wmEvent *event)
stopConstraint(t);
}
else {
if (event->shift) {
/* bit hackish... but it prevents mmb select to print the
* orientation from menu */
float mati[3][3];
strcpy(t->spacename, "global");
unit_m3(mati);
initSelectConstraint(t, mati);
}
else {
initSelectConstraint(t, t->spacemtx);
}
initSelectConstraint(t, event->shift);
postSelectConstraint(t);
}
}
@@ -1699,18 +1678,6 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
ts->prop_mode = t->prop_mode;
}
}
if (t->spacetype == SPACE_VIEW3D) {
if ((prop = RNA_struct_find_property(op->ptr, "orient_type")) &&
!RNA_property_is_set(op->ptr, prop) &&
(t->orientation.user != V3D_ORIENT_CUSTOM_MATRIX)) {
TransformOrientationSlot *orient_slot = &t->scene->orientation_slots[SCE_ORIENT_DEFAULT];
orient_slot->type = t->orientation.user;
BLI_assert(((orient_slot->index_custom == -1) && (t->orientation.custom == NULL)) ||
(BKE_scene_transform_orientation_get_index(t->scene, t->orientation.custom) ==
orient_slot->index_custom));
}
}
}
if (t->flag & T_MODAL) {
@@ -1737,34 +1704,6 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
RNA_property_boolean_set(op->ptr, prop, (t->flag & T_NO_MIRROR) == 0);
}
/* Orientation used for redo. */
const bool use_orient_axis = (t->orient_matrix_is_set &&
(RNA_struct_find_property(op->ptr, "orient_axis") != NULL));
short orientation;
if (t->con.mode & CON_APPLY) {
orientation = t->con.orientation;
if (orientation == V3D_ORIENT_CUSTOM) {
const int orientation_index_custom = BKE_scene_transform_orientation_get_index(
t->scene, t->orientation.custom);
/* Maybe we need a t->con.custom_orientation?
* Seems like it would always match t->orientation.custom. */
orientation = V3D_ORIENT_CUSTOM + orientation_index_custom;
BLI_assert(orientation >= V3D_ORIENT_CUSTOM);
}
}
else if ((t->orientation.user == V3D_ORIENT_CUSTOM_MATRIX) &&
(prop = RNA_struct_find_property(op->ptr, "orient_matrix_type"))) {
orientation = RNA_property_enum_get(op->ptr, prop);
}
else if (use_orient_axis) {
/* We're not using an orientation, use the fallback. */
orientation = t->orientation.unset;
}
else {
orientation = V3D_ORIENT_GLOBAL;
unit_m3(t->spacemtx);
}
if ((prop = RNA_struct_find_property(op->ptr, "orient_axis"))) {
if (t->flag & T_MODAL) {
if (t->con.mode & CON_APPLY) {
@@ -1784,43 +1723,34 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
}
}
if ((prop = RNA_struct_find_property(op->ptr, "orient_matrix"))) {
if (t->flag & T_MODAL) {
if (orientation != V3D_ORIENT_CUSTOM_MATRIX) {
if (t->flag & T_MODAL) {
RNA_enum_set(op->ptr, "orient_matrix_type", orientation);
}
}
if (t->con.mode & CON_APPLY) {
RNA_float_set_array(op->ptr, "orient_matrix", &t->con.mtx[0][0]);
}
else if (use_orient_axis) {
RNA_float_set_array(op->ptr, "orient_matrix", &t->orient_matrix[0][0]);
}
else {
if ((prop = RNA_struct_find_property(op->ptr, "orient_type"))) {
short orient_set, orient_cur;
orient_set = RNA_property_is_set(op->ptr, prop) ? RNA_property_enum_get(op->ptr, prop) : -1;
orient_cur = t->orientation.types[t->orientation.index];
if (!ELEM(orient_cur, orient_set, V3D_ORIENT_CUSTOM_MATRIX)) {
RNA_property_enum_set(op->ptr, prop, orient_cur);
orient_set = orient_cur;
}
if (((prop = RNA_struct_find_property(op->ptr, "orient_matrix_type")) &&
!RNA_property_is_set(op->ptr, prop))) {
/* Set the first time to register on redo. */
RNA_property_enum_set(op->ptr, prop, orient_set);
if (((prop = RNA_struct_find_property(op->ptr, "orient_matrix")) &&
!RNA_property_is_set(op->ptr, prop))) {
RNA_float_set_array(op->ptr, "orient_matrix", &t->spacemtx[0][0]);
}
}
}
if ((prop = RNA_struct_find_property(op->ptr, "orient_type"))) {
/* constraint orientation can be global, even if user selects something else
* so use the orientation in the constraint if set */
/* Use 'orient_matrix' instead. */
if (t->flag & T_MODAL) {
if (orientation != V3D_ORIENT_CUSTOM_MATRIX) {
RNA_property_enum_set(op->ptr, prop, orientation);
}
}
}
if ((prop = RNA_struct_find_property(op->ptr, "constraint_axis"))) {
bool constraint_axis[3] = {false, false, false};
if (t->flag & T_MODAL) {
/* Only set if needed, so we can hide in the UI when nothing is set.
* See 'transform_poll_property'. */
if (t->con.mode & CON_APPLY) {
if (t->con.mode & CON_APPLY) {
bool constraint_axis[3] = {false, false, false};
if (t->idx_max == 0) {
/* Only set if needed, so we can hide in the UI when nothing is set.
* See 'transform_poll_property'. */
if (t->con.mode & CON_AXIS0) {
constraint_axis[0] = true;
}
@@ -1831,9 +1761,15 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
constraint_axis[2] = true;
}
}
if (ELEM(true, UNPACK3(constraint_axis))) {
RNA_property_boolean_set_array(op->ptr, prop, constraint_axis);
else {
constraint_axis[0] = true;
constraint_axis[1] = true;
constraint_axis[2] = true;
}
RNA_property_boolean_set_array(op->ptr, prop, constraint_axis);
}
else {
RNA_property_unset(op->ptr, prop);
}
}
@@ -1959,7 +1895,10 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
unit_m3(t->spacemtx);
initTransInfo(C, t, op, event);
initTransformOrientation(C, t);
/* Although `t->orientation.index` can be different from 0, always init the
* default orientation so that in redo the contraint uses the `orient_matrix` */
initTransformOrientation(C, t, t->orientation.types[0]);
if (t->spacetype == SPACE_VIEW3D) {
t->draw_handle_apply = ED_region_draw_cb_activate(
@@ -2141,38 +2080,8 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
}
/* Constraint init from operator */
if ((t->flag & T_MODAL) ||
/* For mirror operator the constraint axes are effectively the values. */
(RNA_struct_find_property(op->ptr, "value") == NULL)) {
if ((prop = RNA_struct_find_property(op->ptr, "constraint_axis")) &&
RNA_property_is_set(op->ptr, prop)) {
bool constraint_axis[3];
RNA_property_boolean_get_array(op->ptr, prop, constraint_axis);
if (constraint_axis[0] || constraint_axis[1] || constraint_axis[2]) {
t->con.mode |= CON_APPLY;
if (constraint_axis[0]) {
t->con.mode |= CON_AXIS0;
}
if (constraint_axis[1]) {
t->con.mode |= CON_AXIS1;
}
if (constraint_axis[2]) {
t->con.mode |= CON_AXIS2;
}
setUserConstraint(t, t->orientation.user, t->con.mode, "%s");
}
}
}
else {
/* So we can adjust in non global orientation. */
if (t->orientation.user != V3D_ORIENT_GLOBAL) {
t->con.mode |= CON_APPLY | CON_AXIS0 | CON_AXIS1 | CON_AXIS2;
setUserConstraint(t, t->orientation.user, t->con.mode, "%s");
}
if (t->con.mode & CON_APPLY) {
setUserConstraint(t, t->orientation.types[t->orientation.index], t->con.mode, "%s");
}
/* Don't write into the values when non-modal because they are already set from operator redo

24
source/blender/editors/transform/transform.h
View File

@@ -531,17 +531,12 @@ typedef struct TransInfo {
bool is_launch_event_tweak;
struct {
/** Orientation type when when we're not constrained.
* nearly always global except for rotate which defaults to screen-space orientation. */
short unset;
/** Orientation to use when a key is pressed. */
short user;
/* Used when user is global. */
short user_alt;
short index;
short *types[2];
/* this gets used when custom_orientation is V3D_ORIENT_CUSTOM */
short types[3];
/* this gets used when orientation.type[x] is V3D_ORIENT_CUSTOM */
struct TransformOrientation *custom;
/* this gets used when orientation.type[0] is V3D_ORIENT_CUSTOM_MATRIX */
float custom_matrix[3][3];
} orientation;
/** backup from view3d, to restore on end. */
short gizmo_flag;
@@ -566,15 +561,6 @@ typedef struct TransInfo {
/** Secondary axis, shear uses this. */
int orient_axis_ortho;
/** Often this matrix has similar usage to #TransInfo.spacemtx however this
* is used to define extra axes to operate on, not necessarily a space.
*
* For example, by default rotation operates on the view (`orient_matrix[2]`),
* even when the current space isn't set to the view. */
float orient_matrix[3][3];
/** Don't overwrite when set by operator redo defines the orientation axis. */
bool orient_matrix_is_set;
/** remove elements if operator is canceled. */
bool remove_on_cancel;
@@ -926,7 +912,7 @@ void transform_data_ext_rotate(TransData *td, float mat[3][3], bool use_drot);
/*********************** Transform Orientations ******************************/
void initTransformOrientation(struct bContext *C, TransInfo *t);
void initTransformOrientation(struct bContext *C, TransInfo *t, short orientation);
/* Those two fill in mat and return non-zero on success */
bool createSpaceNormal(float mat[3][3], const float normal[3]);

27
source/blender/editors/transform/transform_constraints.c
View File

@@ -713,7 +713,10 @@ void setUserConstraint(TransInfo *t, short orientation, int mode, const char fte
break;
case V3D_ORIENT_VIEW:
BLI_snprintf(text, sizeof(text), ftext, TIP_("view"));
setConstraint(t, t->spacemtx, mode, text);
float mtx[3][3];
copy_m3_m3(mtx, t->spacemtx);
negate_v3(mtx[2]);
setConstraint(t, mtx, mode, text);
break;
case V3D_ORIENT_CURSOR:
BLI_snprintf(text, sizeof(text), ftext, TIP_("cursor"));
@@ -984,17 +987,23 @@ void getConstraintMatrix(TransInfo *t)
/*------------------------- MMB Select -------------------------------*/
void initSelectConstraint(TransInfo *t, float mtx[3][3])
void initSelectConstraint(TransInfo *t, bool force_global)
{
copy_m3_m3(t->con.mtx, mtx);
t->con.mode |= CON_APPLY;
t->con.mode |= CON_SELECT;
short orientation;
if (force_global) {
orientation = V3D_ORIENT_GLOBAL;
}
else {
if (t->orientation.index == 0) {
t->orientation.index = 1;
BLI_assert(t->orientation.types[0] != V3D_ORIENT_CUSTOM_MATRIX);
initTransformOrientation(t->context, t, t->orientation.types[t->orientation.index]);
}
orientation = t->orientation.types[t->orientation.index];
}
setUserConstraint(t, orientation, CON_APPLY | CON_SELECT, "");
setNearestAxis(t);
t->con.drawExtra = NULL;
t->con.applyVec = applyAxisConstraintVec;
t->con.applySize = applyAxisConstraintSize;
t->con.applyRot = applyAxisConstraintRot;
}
void selectConstraint(TransInfo *t)

2
source/blender/editors/transform/transform_constraints.h
View File

@@ -36,7 +36,7 @@ void drawPropCircle(const struct bContext *C, TransInfo *t);
void startConstraint(TransInfo *t);
void stopConstraint(TransInfo *t);
void getConstraintMatrix(TransInfo *t);
void initSelectConstraint(TransInfo *t, float mtx[3][3]);
void initSelectConstraint(TransInfo *t, bool force_global);
void selectConstraint(TransInfo *t);
void postSelectConstraint(TransInfo *t);
void setNearestAxis(TransInfo *t);

137
source/blender/editors/transform/transform_generics.c
View File

@@ -1431,11 +1431,6 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
unit_m3(t->mat);
unit_m3(t->orient_matrix);
negate_m3(t->orient_matrix);
/* Leave 't->orient_matrix_is_set' to false,
* so we overwrite it when we have a useful value. */
/* Default to rotate on the Z axis. */
t->orient_axis = 2;
t->orient_axis_ortho = 1;
@@ -1513,22 +1508,6 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
t->around = V3D_AROUND_CURSOR;
}
TransformOrientationSlot *orient_slot = &t->scene->orientation_slots[SCE_ORIENT_DEFAULT];
t->orientation.unset = V3D_ORIENT_GLOBAL;
t->orientation.user = orient_slot->type;
t->orientation.custom = BKE_scene_transform_orientation_find(t->scene,
orient_slot->index_custom);
t->orientation.index = 0;
ARRAY_SET_ITEMS(t->orientation.types, &t->orientation.user, NULL);
/* Make second orientation local if both are global. */
if (t->orientation.user == V3D_ORIENT_GLOBAL) {
t->orientation.user_alt = V3D_ORIENT_LOCAL;
t->orientation.types[0] = &t->orientation.user_alt;
SWAP(short *, t->orientation.types[0], t->orientation.types[1]);
}
/* exceptional case */
if (t->around == V3D_AROUND_LOCAL_ORIGINS) {
if (ELEM(t->mode, TFM_ROTATION, TFM_RESIZE, TFM_TRACKBALL)) {
@@ -1617,48 +1596,100 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
t->around = V3D_AROUND_CENTER_BOUNDS;
}
if (op && (prop = RNA_struct_find_property(op->ptr, "orient_axis"))) {
t->orient_axis = RNA_property_enum_get(op->ptr, prop);
}
if (op && (prop = RNA_struct_find_property(op->ptr, "orient_axis_ortho"))) {
t->orient_axis_ortho = RNA_property_enum_get(op->ptr, prop);
}
if ((prop = RNA_struct_find_property(op->ptr, "constraint_axis")) &&
RNA_property_is_set(op->ptr, prop)) {
bool constraint_axis[3];
if (op &&
((prop = RNA_struct_find_property(op->ptr, "orient_matrix")) &&
RNA_property_is_set(op->ptr, prop)) &&
((t->flag & T_MODAL) ||
/* When using redo, don't use the custom constraint matrix
* if the user selects a different orientation. */
(RNA_enum_get(op->ptr, "orient_type") == RNA_enum_get(op->ptr, "orient_matrix_type")))) {
RNA_property_float_get_array(op->ptr, prop, &t->orient_matrix[0][0]);
copy_m3_m3(t->spacemtx, t->orient_matrix);
/* Some transform modes use this to operate on an axis. */
t->orient_matrix_is_set = true;
t->orientation.user = V3D_ORIENT_CUSTOM_MATRIX;
t->orientation.custom = 0;
if (t->flag & T_MODAL) {
RNA_enum_set(op->ptr, "orient_matrix_type", RNA_enum_get(op->ptr, "orient_type"));
RNA_property_boolean_get_array(op->ptr, prop, constraint_axis);
if (constraint_axis[0] || constraint_axis[1] || constraint_axis[2]) {
t->con.mode |= CON_APPLY;
if (constraint_axis[0]) {
t->con.mode |= CON_AXIS0;
}
if (constraint_axis[1]) {
t->con.mode |= CON_AXIS1;
}
if (constraint_axis[2]) {
t->con.mode |= CON_AXIS2;
}
}
}
else if (op && ((prop = RNA_struct_find_property(op->ptr, "orient_type")) &&
RNA_property_is_set(op->ptr, prop))) {
short orientation = RNA_property_enum_get(op->ptr, prop);
TransformOrientation *custom_orientation = NULL;
if (orientation >= V3D_ORIENT_CUSTOM) {
if (orientation >= V3D_ORIENT_CUSTOM + BIF_countTransformOrientation(C)) {
orientation = V3D_ORIENT_GLOBAL;
{
TransformOrientation *custom_orientation = NULL;
short orient_type_default = V3D_ORIENT_GLOBAL;
short orient_type_set = -1;
short orient_type_matrix_set = -1;
short orient_type_constraint = -1;
if (op && (prop = RNA_struct_find_property(op->ptr, "orient_axis"))) {
t->orient_axis = RNA_property_enum_get(op->ptr, prop);
orient_type_default = V3D_ORIENT_VIEW;
}
if (op && (prop = RNA_struct_find_property(op->ptr, "orient_axis_ortho"))) {
t->orient_axis_ortho = RNA_property_enum_get(op->ptr, prop);
}
if (op && ((prop = RNA_struct_find_property(op->ptr, "orient_type")) &&
RNA_property_is_set(op->ptr, prop))) {
orient_type_set = RNA_property_enum_get(op->ptr, prop);
}
if (op && ((prop = RNA_struct_find_property(op->ptr, "orient_matrix")) &&
RNA_property_is_set(op->ptr, prop))) {
RNA_property_float_get_array(op->ptr, prop, &t->orientation.custom_matrix[0][0]);
if ((prop = RNA_struct_find_property(op->ptr, "orient_matrix_type")) &&
RNA_property_is_set(op->ptr, prop)) {
orient_type_matrix_set = RNA_property_enum_get(op->ptr, prop);
}
else {
custom_orientation = BKE_scene_transform_orientation_find(t->scene,
orientation - V3D_ORIENT_CUSTOM);
orientation = V3D_ORIENT_CUSTOM;
orient_type_matrix_set = orient_type_set;
}
if (orient_type_matrix_set == orient_type_set) {
/* When using redo, don't use the custom constraint matrix
* if the user selects a different orientation. */
orient_type_default = V3D_ORIENT_CUSTOM_MATRIX;
orient_type_constraint = orient_type_set;
}
}
t->orientation.user = orientation;
if (orient_type_constraint == -1) {
if (orient_type_set != -1) {
orient_type_default = orient_type_set;
if (orient_type_default >= V3D_ORIENT_CUSTOM) {
if (orient_type_default >= V3D_ORIENT_CUSTOM + BIF_countTransformOrientation(C)) {
orient_type_default = V3D_ORIENT_GLOBAL;
}
else {
custom_orientation = BKE_scene_transform_orientation_find(
t->scene, orient_type_default - V3D_ORIENT_CUSTOM);
orient_type_default = V3D_ORIENT_CUSTOM;
}
}
orient_type_constraint = orient_type_default;
}
else {
TransformOrientationSlot *orient_slot = &t->scene->orientation_slots[SCE_ORIENT_DEFAULT];
orient_type_constraint = orient_slot->type;
custom_orientation = BKE_scene_transform_orientation_find(t->scene,
orient_slot->index_custom);
}
}
t->orientation.types[0] = orient_type_default;
t->orientation.types[1] = orient_type_constraint;
t->orientation.types[2] = orient_type_constraint != V3D_ORIENT_GLOBAL ? V3D_ORIENT_GLOBAL :
V3D_ORIENT_LOCAL;
t->orientation.custom = custom_orientation;
if (t->con.mode & CON_APPLY) {
t->orientation.index = 1;
}
}
if (op && ((prop = RNA_struct_find_property(op->ptr, "release_confirm")) &&

2
source/blender/editors/transform/transform_gizmo_3d.c
View File

@@ -1402,7 +1402,7 @@ void drawDial3d(const TransInfo *t)
}
else {
axis_idx = MAN_AXIS_ROT_C;
negate_v3_v3(mat_basis[2], t->orient_matrix[t->orient_axis]);
negate_v3_v3(mat_basis[2], t->spacemtx[t->orient_axis]);
scale *= 1.2f;
line_with -= 1.0f;
}

2
source/blender/editors/transform/transform_mode.c
View File

@@ -529,7 +529,7 @@ void headerRotation(TransInfo *t, char str[UI_MAX_DRAW_STR], float final)
void postInputRotation(TransInfo *t, float values[3])
{
float axis_final[3];
copy_v3_v3(axis_final, t->orient_matrix[t->orient_axis]);
copy_v3_v3(axis_final, t->spacemtx[t->orient_axis]);
if ((t->con.mode & CON_APPLY) && t->con.applyRot) {
t->con.applyRot(t, NULL, NULL, axis_final, values);
}

2
source/blender/editors/transform/transform_mode_edge_rotate_normal.c
View File

@@ -81,7 +81,7 @@ static void applyNormalRotation(TransInfo *t, const int UNUSED(mval[2]))
char str[UI_MAX_DRAW_STR];
float axis_final[3];
copy_v3_v3(axis_final, t->orient_matrix[t->orient_axis]);
copy_v3_v3(axis_final, t->spacemtx[t->orient_axis]);
if ((t->con.mode & CON_APPLY) && t->con.applyRot) {
t->con.applyRot(t, NULL, NULL, axis_final, NULL);

2
source/blender/editors/transform/transform_mode_rotate.c
View File

@@ -146,7 +146,7 @@ static void applyRotation(TransInfo *t, const int UNUSED(mval[2]))
snapGridIncrement(t, &final);
float axis_final[3];
copy_v3_v3(axis_final, t->orient_matrix[t->orient_axis]);
copy_v3_v3(axis_final, t->spacemtx[t->orient_axis]);
if ((t->con.mode & CON_APPLY) && t->con.applyRot) {
t->con.applyRot(t, NULL, NULL, axis_final, NULL);

8
source/blender/editors/transform/transform_mode_shear.c
View File

@@ -53,10 +53,10 @@ static void initShear_mouseInputMode(TransInfo *t)
{
float dir[3];
bool dir_flip = false;
copy_v3_v3(dir, t->orient_matrix[t->orient_axis_ortho]);
copy_v3_v3(dir, t->spacemtx[t->orient_axis_ortho]);
/* Needed for axis aligned view gizmo. */
if (t->orientation.user == V3D_ORIENT_VIEW) {
if (t->orientation.types[t->orientation.index] == V3D_ORIENT_VIEW) {
if (t->orient_axis_ortho == 0) {
if (t->center2d[1] > t->mouse.imval[1]) {
dir_flip = !dir_flip;
@@ -154,8 +154,8 @@ static void applyShear(TransInfo *t, const int UNUSED(mval[2]))
unit_m3(smat);
smat[1][0] = value;
copy_v3_v3(axismat_inv[0], t->orient_matrix[t->orient_axis_ortho]);
copy_v3_v3(axismat_inv[2], t->orient_matrix[t->orient_axis]);
copy_v3_v3(axismat_inv[0], t->spacemtx[t->orient_axis_ortho]);
copy_v3_v3(axismat_inv[2], t->spacemtx[t->orient_axis]);
cross_v3_v3v3(axismat_inv[1], axismat_inv[0], axismat_inv[2]);
invert_m3_m3(axismat, axismat_inv);

24
source/blender/editors/transform/transform_orientations.c
View File

@@ -438,12 +438,12 @@ static int armature_bone_transflags_update_recursive(bArmature *arm,
return total;
}
void initTransformOrientation(bContext *C, TransInfo *t)
void initTransformOrientation(bContext *C, TransInfo *t, short orientation)
{
Object *ob = CTX_data_active_object(C);
Object *obedit = CTX_data_active_object(C);
switch (t->orientation.user) {
switch (orientation) {
case V3D_ORIENT_GLOBAL:
unit_m3(t->spacemtx);
BLI_strncpy(t->spacename, TIP_("global"), sizeof(t->spacename));
@@ -478,12 +478,12 @@ void initTransformOrientation(bContext *C, TransInfo *t)
case V3D_ORIENT_VIEW:
if ((t->spacetype == SPACE_VIEW3D) && (t->region->regiontype == RGN_TYPE_WINDOW)) {
RegionView3D *rv3d = t->region->regiondata;
float mat[3][3];
BLI_strncpy(t->spacename, TIP_("view"), sizeof(t->spacename));
copy_m3_m4(mat, rv3d->viewinv);
copy_m3_m4(mat, t->viewinv);
normalize_m3(mat);
negate_v3(mat[2]);
copy_m3_m3(t->spacemtx, mat);
}
else {
@@ -496,8 +496,8 @@ void initTransformOrientation(bContext *C, TransInfo *t)
break;
}
case V3D_ORIENT_CUSTOM_MATRIX:
/* Already set. */
BLI_strncpy(t->spacename, TIP_("custom"), sizeof(t->spacename));
copy_m3_m3(t->spacemtx, t->orientation.custom_matrix);
break;
case V3D_ORIENT_CUSTOM:
BLI_strncpy(t->spacename, t->orientation.custom->name, sizeof(t->spacename));
@@ -510,20 +510,6 @@ void initTransformOrientation(bContext *C, TransInfo *t)
}
break;
}
if (t->orient_matrix_is_set == false) {
t->orient_matrix_is_set = true;
if (t->flag & T_MODAL) {
/* Rotate for example defaults to operating on the view plane. */
t->orientation.unset = V3D_ORIENT_VIEW;
copy_m3_m4(t->orient_matrix, t->viewinv);
normalize_m3(t->orient_matrix);
negate_m3(t->orient_matrix);
}
else {
copy_m3_m3(t->orient_matrix, t->spacemtx);
}
}
}
/**