tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Transform: refactoring - unify constraint and default orientation

This commit is contained in:
Germano Cavalcante 2020-05-22 12:34:29 -03:00
parent 06860ba29b
commit c75a665c44
9 changed files with 288 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -825,17 +825,17 @@ static void transform_event_xyz_constraint(TransInfo *t, short key_type, bool is
}
}
else if (!edit_2d) {
if (t->orientation.index == 0 || ELEM(cmode, '\0', axis)) {
if (t->orient_curr == 0 || ELEM(cmode, '\0', axis)) {
/* Successive presses on existing axis, cycle orientation modes. */
t->orientation.index = (t->orientation.index + 1) % ARRAY_SIZE(t->orientation.types);
initTransformOrientation(t->context, t, t->orientation.types[t->orientation.index]);
t->orient_curr = (short)((t->orient_curr + 1) % (int)ARRAY_SIZE(t->orient));
transform_orientations_current_set(t, t->orient_curr);
}
if (t->orientation.index == 0) {
if (t->orient_curr == 0) {
stopConstraint(t);
}
else {
const short orientation = t->orientation.types[t->orientation.index];
const short orientation = t->orient[t->orient_curr].type;
if (is_plane == false) {
setUserConstraint(t, orientation, constraint_axis, msg2);
}
@ -983,7 +983,7 @@ int transformEvent(TransInfo *t, const wmEvent *event)
}
else if (transform_mode_is_changeable(t->mode)) {
/* Scale isn't normally very useful after extrude along normals, see T39756 */
if ((t->con.mode & CON_APPLY) && (t->con.orientation == V3D_ORIENT_NORMAL)) {
if ((t->con.mode & CON_APPLY) && (t->orient[t->orient_curr].type == V3D_ORIENT_NORMAL)) {
stopConstraint(t);
}
@ -1601,8 +1601,8 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
mul_m3_v3(t->spacemtx, t->values_final);
unit_m3(t->spacemtx);
BLI_assert(t->orientation.index == 0);
t->orientation.types[0] = V3D_ORIENT_GLOBAL;
BLI_assert(t->orient_curr == 0);
t->orient[0].type = V3D_ORIENT_GLOBAL;
}
// Save back mode in case we're in the generic operator
@ -1713,19 +1713,20 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
}
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];
short orient_type_set, orient_type_curr;
orient_type_set = RNA_property_is_set(op->ptr, prop) ? RNA_property_enum_get(op->ptr, prop) :
-1;
orient_type_curr = t->orient[t->orient_curr].type;
if (!ELEM(orient_cur, orient_set, V3D_ORIENT_CUSTOM_MATRIX)) {
RNA_property_enum_set(op->ptr, prop, orient_cur);
orient_set = orient_cur;
if (!ELEM(orient_type_curr, orient_type_set, V3D_ORIENT_CUSTOM_MATRIX)) {
RNA_property_enum_set(op->ptr, prop, orient_type_curr);
orient_type_set = orient_type_curr;
}
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);
RNA_property_enum_set(op->ptr, prop, orient_type_set);
RNA_float_set_array(op->ptr, "orient_matrix", &t->spacemtx[0][0]);
}
}
@ -1873,11 +1874,8 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
initTransInfo(C, t, op, event);
/* Use the custom orientation when it is set. */
short orientation = t->orientation.types[0] == V3D_ORIENT_CUSTOM_MATRIX ?
V3D_ORIENT_CUSTOM_MATRIX :
t->orientation.types[t->orientation.index];
initTransformOrientation(C, t, orientation);
short orient_index = t->orient[0].type == V3D_ORIENT_CUSTOM_MATRIX ? 0 : t->orient_curr;
transform_orientations_current_set(t, orient_index);
if (t->spacetype == SPACE_VIEW3D) {
t->draw_handle_apply = ED_region_draw_cb_activate(
@ -2033,7 +2031,7 @@ bool initTransform(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
/* Constraint init from operator */
if (t->con.mode & CON_APPLY) {
setUserConstraint(t, t->orientation.types[t->orientation.index], t->con.mode, "%s");
setUserConstraint(t, t->orient[t->orient_curr].type, t->con.mode, "%s");
}
/* Don't write into the values when non-modal because they are already set from operator redo

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

@ -113,13 +113,8 @@ typedef struct TransSnap {
} TransSnap;
typedef struct TransCon {
short orientation;
/** Description of the constraint for header_print. */
char text[50];
/** Matrix of the constraint space. */
float mtx[3][3];
/** Inverse matrix of the constraint space. */
float imtx[3][3];
/** Projection constraint matrix (same as #imtx with some axis == 0). */
float pmtx[3][3];
/** Initial mouse value for visual calculation
@ -531,13 +526,11 @@ typedef struct TransInfo {
bool is_launch_event_tweak;
struct {
short index;
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;
short type;
float matrix[3][3];
} orient[3];
short orient_curr;
/** backup from view3d, to restore on end. */
short gizmo_flag;
@ -911,8 +904,13 @@ void getViewVector(const TransInfo *t, const float coord[3], float vec[3]);
void transform_data_ext_rotate(TransData *td, float mat[3][3], bool use_drot);
/*********************** Transform Orientations ******************************/
void initTransformOrientation(struct bContext *C, TransInfo *t, short orientation);
short transform_orientation_matrix_get(struct bContext *C,
TransInfo *t,
const short orientation,
const float custom[3][3],
float r_spacemtx[3][3]);
const char *transform_orientations_spacename_get(TransInfo *t, const short orient_type);
void transform_orientations_current_set(struct TransInfo *t, const short orient_index);
/* Those two fill in mat and return non-zero on success */
bool createSpaceNormal(float mat[3][3], const float normal[3]);

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

@ -42,6 +42,7 @@
#include "BLI_utildefines.h"
#include "BKE_context.h"
#include "BKE_scene.h"
#include "ED_view3d.h"
@ -57,6 +58,27 @@
static void drawObjectConstraint(TransInfo *t);
static void projection_matrix_calc(const TransInfo *t, float r_pmtx[3][3])
{
unit_m3(r_pmtx);
if (!(t->con.mode & CON_AXIS0)) {
zero_v3(r_pmtx[0]);
}
if (!(t->con.mode & CON_AXIS1)) {
zero_v3(r_pmtx[1]);
}
if (!(t->con.mode & CON_AXIS2)) {
zero_v3(r_pmtx[2]);
}
float mat[3][3];
mul_m3_m3m3(mat, r_pmtx, t->spacemtx_inv);
mul_m3_m3m3(r_pmtx, t->spacemtx, mat);
}
/* ************************** CONSTRAINTS ************************* */
static void constraintValuesFinal(TransInfo *t, float vec[3])
{
@ -123,7 +145,7 @@ void constraintNumInput(TransInfo *t, float vec[3])
static void postConstraintChecks(TransInfo *t, float vec[3])
{
mul_m3_v3(t->con.imtx, vec);
mul_m3_v3(t->spacemtx_inv, vec);
snapGridIncrement(t, vec);
@ -153,7 +175,7 @@ static void postConstraintChecks(TransInfo *t, float vec[3])
/* inverse transformation at the end */
}
mul_m3_v3(t->con.mtx, vec);
mul_m3_v3(t->spacemtx, vec);
}
static void viewAxisCorrectCenter(const TransInfo *t, float t_con_center[3])
@ -286,7 +308,7 @@ static bool isPlaneProjectionViewAligned(const TransInfo *t)
int n = 0;
for (int i = 0; i < 3; i++) {
if (t->con.mode & (CON_AXIS0 << i)) {
constraint_vector[n++] = t->con.mtx[i];
constraint_vector[n++] = t->spacemtx[i];
if (n == 2) {
break;
}
@ -326,6 +348,39 @@ static void planeProjection(const TransInfo *t, const float in[3], float out[3])
add_v3_v3v3(out, in, vec);
}
static void applyAxisConstraintVec_impl(
TransInfo *t, float space_mat[3][3], float proj_mat[3][3], const float in[3], float out[3])
{
mul_m3_v3(proj_mat, out);
// With snap, a projection is alright, no need to correct for view alignment
if (!validSnap(t)) {
const int dims = getConstraintSpaceDimension(t);
if (dims == 2) {
if (!is_zero_v3(out)) {
if (!isPlaneProjectionViewAligned(t)) {
planeProjection(t, in, out);
}
}
}
else if (dims == 1) {
float c[3];
if (t->con.mode & CON_AXIS0) {
copy_v3_v3(c, space_mat[0]);
}
else if (t->con.mode & CON_AXIS1) {
copy_v3_v3(c, space_mat[1]);
}
else if (t->con.mode & CON_AXIS2) {
copy_v3_v3(c, space_mat[2]);
}
axisProjection(t, c, in, out);
}
}
postConstraintChecks(t, out);
}
/*
* Generic callback for constant spatial constraints applied to linear motion
*
@ -339,41 +394,14 @@ static void applyAxisConstraintVec(
{
copy_v3_v3(out, in);
if (!td && t->con.mode & CON_APPLY) {
mul_m3_v3(t->con.pmtx, out);
// With snap, a projection is alright, no need to correct for view alignment
if (!validSnap(t)) {
const int dims = getConstraintSpaceDimension(t);
if (dims == 2) {
if (!is_zero_v3(out)) {
if (!isPlaneProjectionViewAligned(t)) {
planeProjection(t, in, out);
}
}
}
else if (dims == 1) {
float c[3];
if (t->con.mode & CON_AXIS0) {
copy_v3_v3(c, t->con.mtx[0]);
}
else if (t->con.mode & CON_AXIS1) {
copy_v3_v3(c, t->con.mtx[1]);
}
else if (t->con.mode & CON_AXIS2) {
copy_v3_v3(c, t->con.mtx[2]);
}
axisProjection(t, c, in, out);
}
}
postConstraintChecks(t, out);
applyAxisConstraintVec_impl(t, t->spacemtx, t->con.pmtx, in, out);
}
}
/*
* Generic callback for object based spatial constraints applied to linear motion
*
* At first, the following is applied to the first data in the array
* At first, the following is applied without orientation
* The IN vector in projected into the constrained space and then further
* projected along the view vector.
* (in perspective mode, the view vector is relative to the position on screen)
@ -387,33 +415,22 @@ static void applyObjectConstraintVec(
copy_v3_v3(out, in);
if (t->con.mode & CON_APPLY) {
if (!td) {
mul_m3_v3(t->con.pmtx, out);
const int dims = getConstraintSpaceDimension(t);
if (dims == 2) {
if (!is_zero_v3(out)) {
if (!isPlaneProjectionViewAligned(t)) {
planeProjection(t, in, out);
}
}
/* No specific orientation. */
float spacemtx[3][3], pmtx[3][3] = {{0.0f}};
unit_m3(spacemtx);
if (!(t->con.mode & CON_AXIS0)) {
pmtx[0][0] = 1.0f;
}
else if (dims == 1) {
float c[3];
if (t->con.mode & CON_AXIS0) {
copy_v3_v3(c, t->con.mtx[0]);
}
else if (t->con.mode & CON_AXIS1) {
copy_v3_v3(c, t->con.mtx[1]);
}
else if (t->con.mode & CON_AXIS2) {
copy_v3_v3(c, t->con.mtx[2]);
}
axisProjection(t, c, in, out);
if (!(t->con.mode & CON_AXIS1)) {
pmtx[1][1] = 1.0f;
}
postConstraintChecks(t, out);
if (!(t->con.mode & CON_AXIS2)) {
pmtx[2][2] = 1.0f;
}
applyAxisConstraintVec_impl(t, spacemtx, pmtx, in, out);
}
else {
/* Specific TransData's space, use axismtx. */
mul_m3_v3(td->axismtx, out);
if (t->flag & T_EDIT) {
mul_m3_v3(tc->mat3_unit, out);
@ -444,8 +461,8 @@ static void applyAxisConstraintSize(TransInfo *t,
smat[2][2] = 1.0f;
}
mul_m3_m3m3(tmat, smat, t->con.imtx);
mul_m3_m3m3(smat, t->con.mtx, tmat);
mul_m3_m3m3(tmat, smat, t->spacemtx_inv);
mul_m3_m3m3(smat, t->spacemtx, tmat);
}
}
@ -505,15 +522,15 @@ static void applyAxisConstraintRot(
switch (mode) {
case CON_AXIS0:
case (CON_AXIS1 | CON_AXIS2):
copy_v3_v3(vec, t->con.mtx[0]);
copy_v3_v3(vec, t->spacemtx[0]);
break;
case CON_AXIS1:
case (CON_AXIS0 | CON_AXIS2):
copy_v3_v3(vec, t->con.mtx[1]);
copy_v3_v3(vec, t->spacemtx[1]);
break;
case CON_AXIS2:
case (CON_AXIS0 | CON_AXIS1):
copy_v3_v3(vec, t->con.mtx[2]);
copy_v3_v3(vec, t->spacemtx[2]);
break;
}
/* don't flip axis if asked to or if num input */
@ -586,12 +603,11 @@ static void applyObjectConstraintRot(
/*--------------------- INTERNAL SETUP CALLS ------------------*/
void setConstraint(TransInfo *t, float space[3][3], int mode, const char text[])
void setConstraint(TransInfo *t, int mode, const char text[])
{
BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
copy_m3_m3(t->con.mtx, space);
t->con.mode = mode;
getConstraintMatrix(t);
projection_matrix_calc(t, t->con.pmtx);
startConstraint(t);
@ -605,41 +621,25 @@ void setConstraint(TransInfo *t, float space[3][3], int mode, const char text[])
/* applies individual td->axismtx constraints */
void setAxisMatrixConstraint(TransInfo *t, int mode, const char text[])
{
TransDataContainer *tc = t->data_container;
if (t->data_len_all == 1) {
float axismtx[3][3];
if (t->flag & T_EDIT) {
mul_m3_m3m3(axismtx, tc->mat3_unit, tc->data->axismtx);
}
else {
copy_m3_m3(axismtx, tc->data->axismtx);
}
BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
t->con.mode = mode;
projection_matrix_calc(t, t->con.pmtx);
setConstraint(t, axismtx, mode, text);
}
else {
BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
unit_m3(t->con.mtx);
t->con.mode = mode;
getConstraintMatrix(t);
startConstraint(t);
startConstraint(t);
t->con.drawExtra = drawObjectConstraint;
t->con.applyVec = applyObjectConstraintVec;
t->con.applySize = applyObjectConstraintSize;
t->con.applyRot = applyObjectConstraintRot;
t->redraw = TREDRAW_HARD;
}
t->con.drawExtra = drawObjectConstraint;
t->con.applyVec = applyObjectConstraintVec;
t->con.applySize = applyObjectConstraintSize;
t->con.applyRot = applyObjectConstraintRot;
t->redraw = TREDRAW_HARD;
}
void setLocalConstraint(TransInfo *t, int mode, const char text[])
{
/* edit-mode now allows local transforms too */
if (t->flag & T_EDIT) {
/* Use the active (first) edit object. */
TransDataContainer *tc = t->data_container;
setConstraint(t, tc->mat3_unit, mode, text);
/* Although in edit-mode each object has its local space, use the
* orientation of the active object. */
setConstraint(t, mode, text);
}
else {
setAxisMatrixConstraint(t, mode, text);
@ -654,62 +654,43 @@ void setLocalConstraint(TransInfo *t, int mode, const char text[])
*/
void setUserConstraint(TransInfo *t, short orientation, int mode, const char ftext[])
{
char text[256];
const char *spacename = transform_orientations_spacename_get(t, orientation);
switch (orientation) {
case V3D_ORIENT_GLOBAL: {
float mtx[3][3];
BLI_snprintf(text, sizeof(text), ftext, TIP_("global"));
unit_m3(mtx);
setConstraint(t, mtx, mode, text);
setConstraint(t, mode, spacename);
break;
}
case V3D_ORIENT_LOCAL:
BLI_snprintf(text, sizeof(text), ftext, TIP_("local"));
setLocalConstraint(t, mode, text);
setLocalConstraint(t, mode, spacename);
break;
case V3D_ORIENT_NORMAL:
BLI_snprintf(text, sizeof(text), ftext, TIP_("normal"));
if (checkUseAxisMatrix(t)) {
setAxisMatrixConstraint(t, mode, text);
setAxisMatrixConstraint(t, mode, spacename);
}
else {
setConstraint(t, t->spacemtx, mode, text);
setConstraint(t, mode, spacename);
}
break;
case V3D_ORIENT_VIEW:
BLI_snprintf(text, sizeof(text), ftext, TIP_("view"));
setConstraint(t, t->spacemtx, mode, text);
setConstraint(t, mode, spacename);
break;
case V3D_ORIENT_CURSOR:
BLI_snprintf(text, sizeof(text), ftext, TIP_("cursor"));
setConstraint(t, t->spacemtx, mode, text);
setConstraint(t, mode, spacename);
break;
case V3D_ORIENT_GIMBAL:
BLI_snprintf(text, sizeof(text), ftext, TIP_("gimbal"));
setConstraint(t, t->spacemtx, mode, text);
setConstraint(t, mode, spacename);
break;
case V3D_ORIENT_CUSTOM_MATRIX:
BLI_snprintf(text, sizeof(text), ftext, TIP_("custom matrix"));
setConstraint(t, t->spacemtx, mode, text);
setConstraint(t, mode, spacename);
break;
case V3D_ORIENT_CUSTOM:
default: {
BLI_assert(orientation >= V3D_ORIENT_CUSTOM);
char orientation_str[128];
BLI_snprintf(orientation_str,
sizeof(orientation_str),
"%s \"%s\"",
TIP_("custom orientation"),
t->orientation.custom->name);
BLI_snprintf(text, sizeof(text), ftext, orientation_str);
setConstraint(t, t->spacemtx, mode, text);
setConstraint(t, mode, spacename);
break;
}
}
t->con.orientation = orientation;
t->con.mode |= CON_USER;
}
@ -740,9 +721,9 @@ void drawConstraint(TransInfo *t)
convertViewVec(t, vec, (t->mval[0] - t->con.imval[0]), (t->mval[1] - t->con.imval[1]));
add_v3_v3(vec, t->center_global);
drawLine(t, t->center_global, tc->mtx[0], 'X', 0);
drawLine(t, t->center_global, tc->mtx[1], 'Y', 0);
drawLine(t, t->center_global, tc->mtx[2], 'Z', 0);
drawLine(t, t->center_global, t->spacemtx[0], 'X', 0);
drawLine(t, t->center_global, t->spacemtx[1], 'Y', 0);
drawLine(t, t->center_global, t->spacemtx[2], 'Z', 0);
depth_test_enabled = GPU_depth_test_enabled();
if (depth_test_enabled) {
@ -776,13 +757,13 @@ void drawConstraint(TransInfo *t)
}
if (tc->mode & CON_AXIS0) {
drawLine(t, t->center_global, tc->mtx[0], 'X', DRAWLIGHT);
drawLine(t, t->center_global, t->spacemtx[0], 'X', DRAWLIGHT);
}
if (tc->mode & CON_AXIS1) {
drawLine(t, t->center_global, tc->mtx[1], 'Y', DRAWLIGHT);
drawLine(t, t->center_global, t->spacemtx[1], 'Y', DRAWLIGHT);
}
if (tc->mode & CON_AXIS2) {
drawLine(t, t->center_global, tc->mtx[2], 'Z', DRAWLIGHT);
drawLine(t, t->center_global, t->spacemtx[2], 'Z', DRAWLIGHT);
}
}
}
@ -928,28 +909,6 @@ void stopConstraint(TransInfo *t)
t->num.idx_max = t->idx_max;
}
void getConstraintMatrix(TransInfo *t)
{
float mat[3][3];
invert_m3_m3(t->con.imtx, t->con.mtx);
unit_m3(t->con.pmtx);
if (!(t->con.mode & CON_AXIS0)) {
zero_v3(t->con.pmtx[0]);
}
if (!(t->con.mode & CON_AXIS1)) {
zero_v3(t->con.pmtx[1]);
}
if (!(t->con.mode & CON_AXIS2)) {
zero_v3(t->con.pmtx[2]);
}
mul_m3_m3m3(mat, t->con.pmtx, t->con.imtx);
mul_m3_m3m3(t->con.pmtx, t->con.mtx, mat);
}
/*------------------------- MMB Select -------------------------------*/
void initSelectConstraint(TransInfo *t, bool force_global)
@ -959,11 +918,11 @@ void initSelectConstraint(TransInfo *t, bool force_global)
orientation = V3D_ORIENT_GLOBAL;
}
else {
if (t->orientation.index == 0) {
t->orientation.index = 1;
initTransformOrientation(t->context, t, t->orientation.types[t->orientation.index]);
if (t->orient_curr == 0) {
t->orient_curr = 1;
transform_orientations_current_set(t, t->orient_curr);
}
orientation = t->orientation.types[t->orientation.index];
orientation = t->orient[t->orient_curr].type;
}
setUserConstraint(t, orientation, CON_APPLY | CON_SELECT, "");
@ -1033,7 +992,7 @@ static void setNearestAxis3d(TransInfo *t)
for (i = 0; i < 3; i++) {
float axis[3], axis_2d[2];
copy_v3_v3(axis, t->con.mtx[i]);
copy_v3_v3(axis, t->spacemtx[i]);
mul_v3_fl(axis, zfac);
/* now we can project to get window coordinate */
@ -1102,7 +1061,7 @@ void setNearestAxis(TransInfo *t)
setNearestAxis2d(t);
}
getConstraintMatrix(t);
projection_matrix_calc(t, t->con.pmtx);
}
/*-------------- HELPER FUNCTIONS ----------------*/

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

@ -27,7 +27,7 @@
struct TransInfo;
void constraintNumInput(TransInfo *t, float vec[3]);
void setConstraint(TransInfo *t, float space[3][3], int mode, const char text[]);
void setConstraint(TransInfo *t, int mode, const char text[]);
void setAxisMatrixConstraint(TransInfo *t, int mode, const char text[]);
void setLocalConstraint(TransInfo *t, int mode, const char text[]);
void setUserConstraint(TransInfo *t, short orientation, int mode, const char text[]);
@ -35,7 +35,6 @@ void drawConstraint(TransInfo *t);
void drawPropCircle(const struct bContext *C, TransInfo *t);
void startConstraint(TransInfo *t);
void stopConstraint(TransInfo *t);
void getConstraintMatrix(TransInfo *t);
void initSelectConstraint(TransInfo *t, bool force_global);
void selectConstraint(TransInfo *t);
void postSelectConstraint(TransInfo *t);

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

@ -1650,25 +1650,16 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
{
TransformOrientationSlot *orient_slot = &t->scene->orientation_slots[SCE_ORIENT_DEFAULT];
TransformOrientation *custom_orientation = NULL;
short orient_type_set = -1;
short orient_type_matrix_set = -1;
short orient_type_scene = orient_slot->type;
if (orient_type_scene == V3D_ORIENT_CUSTOM) {
const int index_custom = orient_slot->index_custom;
custom_orientation = BKE_scene_transform_orientation_find(t->scene, index_custom);
orient_type_scene += index_custom;
}
short orient_type_default;
short orient_type_constraint[2];
if ((t->flag & T_MODAL) && transform_mode_is_changeable(t->mode)) {
/* During modal, rotation starts with the View orientation. */
orient_type_default = V3D_ORIENT_VIEW;
}
else {
orient_type_default = orient_type_scene;
}
short orient_types[3];
float custom_matrix[3][3];
if (op && (prop = RNA_struct_find_property(op->ptr, "orient_axis"))) {
t->orient_axis = RNA_property_enum_get(op->ptr, prop);
@ -1684,26 +1675,28 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
if (orient_type_set >= V3D_ORIENT_CUSTOM + BIF_countTransformOrientation(C)) {
orient_type_set = V3D_ORIENT_GLOBAL;
}
else {
custom_orientation = BKE_scene_transform_orientation_find(
t->scene, orient_type_set - V3D_ORIENT_CUSTOM);
}
}
/* Change the default orientation to be used when redoing. */
orient_type_default = orient_type_set;
orient_type_constraint[0] = orient_type_set;
orient_type_constraint[1] = orient_type_scene;
orient_types[0] = orient_type_set;
orient_types[1] = orient_type_set;
orient_types[2] = orient_type_scene;
}
else {
orient_type_constraint[0] = orient_type_scene;
orient_type_constraint[1] = orient_type_scene != V3D_ORIENT_GLOBAL ? V3D_ORIENT_GLOBAL :
V3D_ORIENT_LOCAL;
if ((t->flag & T_MODAL) && transform_mode_is_changeable(t->mode)) {
orient_types[0] = V3D_ORIENT_VIEW;
}
else {
orient_types[0] = orient_type_scene;
}
orient_types[1] = orient_type_scene;
orient_types[2] = orient_type_scene != V3D_ORIENT_GLOBAL ? V3D_ORIENT_GLOBAL :
V3D_ORIENT_LOCAL;
}
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]);
RNA_property_float_get_array(op->ptr, prop, &custom_matrix[0][0]);
if ((prop = RNA_struct_find_property(op->ptr, "orient_matrix_type")) &&
RNA_property_is_set(op->ptr, prop)) {
@ -1718,18 +1711,30 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
if (orient_type_matrix_set == orient_type_set) {
/* Constraints are forced to use the custom matrix when redoing. */
orient_type_default = V3D_ORIENT_CUSTOM_MATRIX;
orient_types[0] = V3D_ORIENT_CUSTOM_MATRIX;
}
}
t->orientation.types[0] = orient_type_default;
t->orientation.types[1] = orient_type_constraint[0];
t->orientation.types[2] = orient_type_constraint[1];
t->orientation.custom = custom_orientation;
if (t->con.mode & CON_APPLY) {
t->orientation.index = 1;
t->orient_curr = 1;
}
/* For efficiency, avoid calculating the same orientation twice. */
for (int i = 1; i < 3; i++) {
t->orient[i].type = transform_orientation_matrix_get(
C, t, orient_types[i], custom_matrix, t->orient[i].matrix);
}
if (orient_types[0] != orient_types[1]) {
t->orient[0].type = transform_orientation_matrix_get(
C, t, orient_types[0], custom_matrix, t->orient[0].matrix);
}
else {
memcpy(&t->orient[0], &t->orient[1], sizeof(t->orient[0]));
}
const char *spacename = transform_orientations_spacename_get(t, orient_types[0]);
BLI_strncpy(t->spacename, spacename, sizeof(t->spacename));
}
if (op && ((prop = RNA_struct_find_property(op->ptr, "release_confirm")) &&

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

@ -1390,16 +1390,16 @@ void drawDial3d(const TransInfo *t)
if (tc->mode & CON_APPLY) {
if (tc->mode & CON_AXIS0) {
axis_idx = MAN_AXIS_ROT_X;
negate_v3_v3(mat_basis[2], tc->mtx[0]);
negate_v3_v3(mat_basis[2], t->spacemtx[0]);
}
else if (tc->mode & CON_AXIS1) {
axis_idx = MAN_AXIS_ROT_Y;
negate_v3_v3(mat_basis[2], tc->mtx[1]);
negate_v3_v3(mat_basis[2], t->spacemtx[1]);
}
else {
BLI_assert((tc->mode & CON_AXIS2) != 0);
axis_idx = MAN_AXIS_ROT_Z;
negate_v3_v3(mat_basis[2], tc->mtx[2]);
negate_v3_v3(mat_basis[2], t->spacemtx[2]);
}
}
else {

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

@ -56,7 +56,7 @@ static void initShear_mouseInputMode(TransInfo *t)
copy_v3_v3(dir, t->spacemtx[t->orient_axis_ortho]);
/* Needed for axis aligned view gizmo. */
if (t->orientation.types[t->orientation.index] == V3D_ORIENT_VIEW) {
if (t->orient[t->orient_curr].type == V3D_ORIENT_VIEW) {
if (t->orient_axis_ortho == 0) {
if (t->center2d[1] > t->mouse.imval[1]) {
dir_flip = !dir_flip;

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

@ -438,79 +438,147 @@ static int armature_bone_transflags_update_recursive(bArmature *arm,
return total;
}
void initTransformOrientation(bContext *C, TransInfo *t, short orientation)
/* Sets the matrix of the specified space orientation.
* If the matrix cannot be obtained, an orientation different from the one
* informed is returned */
short transform_orientation_matrix_get(bContext *C,
TransInfo *t,
const short orientation,
const float custom[3][3],
float r_spacemtx[3][3])
{
Object *ob = CTX_data_active_object(C);
Object *obedit = CTX_data_active_object(C);
switch (orientation) {
case V3D_ORIENT_GLOBAL:
unit_m3(t->spacemtx);
BLI_strncpy(t->spacename, TIP_("global"), sizeof(t->spacename));
break;
unit_m3(r_spacemtx);
return V3D_ORIENT_GLOBAL;
case V3D_ORIENT_GIMBAL:
unit_m3(t->spacemtx);
if (ob && gimbal_axis(ob, t->spacemtx)) {
BLI_strncpy(t->spacename, TIP_("gimbal"), sizeof(t->spacename));
break;
unit_m3(r_spacemtx);
if (ob && gimbal_axis(ob, r_spacemtx)) {
return V3D_ORIENT_GIMBAL;
}
ATTR_FALLTHROUGH; /* no gimbal fallthrough to normal */
case V3D_ORIENT_NORMAL:
if (obedit || (ob && ob->mode & OB_MODE_POSE)) {
BLI_strncpy(t->spacename, TIP_("normal"), sizeof(t->spacename));
ED_getTransformOrientationMatrix(C, t->spacemtx, t->around);
break;
ED_getTransformOrientationMatrix(C, r_spacemtx, t->around);
return V3D_ORIENT_NORMAL;
}
ATTR_FALLTHROUGH; /* we define 'normal' as 'local' in Object mode */
case V3D_ORIENT_LOCAL:
BLI_strncpy(t->spacename, TIP_("local"), sizeof(t->spacename));
if (ob) {
copy_m3_m4(t->spacemtx, ob->obmat);
normalize_m3(t->spacemtx);
copy_m3_m4(r_spacemtx, ob->obmat);
normalize_m3(r_spacemtx);
return V3D_ORIENT_LOCAL;
}
else {
unit_m3(t->spacemtx);
}
break;
unit_m3(r_spacemtx);
return V3D_ORIENT_GLOBAL;
case V3D_ORIENT_VIEW: {
float mat[3][3];
if ((t->spacetype == SPACE_VIEW3D) && (t->region->regiontype == RGN_TYPE_WINDOW)) {
BLI_strncpy(t->spacename, TIP_("view"), sizeof(t->spacename));
copy_m3_m4(mat, t->viewinv);
RegionView3D *rv3d = t->region->regiondata;
copy_m3_m4(mat, rv3d->viewinv);
normalize_m3(mat);
}
else {
unit_m3(mat);
}
copy_m3_m3(t->spacemtx, mat);
break;
}
case V3D_ORIENT_CURSOR: {
BLI_strncpy(t->spacename, TIP_("cursor"), sizeof(t->spacename));
BKE_scene_cursor_rot_to_mat3(&t->scene->cursor, t->spacemtx);
break;
copy_m3_m3(r_spacemtx, mat);
return V3D_ORIENT_VIEW;
}
case V3D_ORIENT_CURSOR:
BKE_scene_cursor_rot_to_mat3(&t->scene->cursor, r_spacemtx);
return V3D_ORIENT_CURSOR;
case V3D_ORIENT_CUSTOM_MATRIX:
BLI_strncpy(t->spacename, TIP_("custom"), sizeof(t->spacename));
copy_m3_m3(t->spacemtx, t->orientation.custom_matrix);
break;
copy_m3_m3(r_spacemtx, custom);
return V3D_ORIENT_CUSTOM_MATRIX;
case V3D_ORIENT_CUSTOM:
default:
BLI_assert(orientation >= V3D_ORIENT_CUSTOM);
BLI_strncpy(t->spacename, t->orientation.custom->name, sizeof(t->spacename));
if (applyTransformOrientation(t->orientation.custom, t->spacemtx, t->spacename)) {
TransformOrientation *ts = BKE_scene_transform_orientation_find(
t->scene, orientation - V3D_ORIENT_CUSTOM);
if (applyTransformOrientation(ts, r_spacemtx, t->spacename)) {
/* pass */
}
else {
unit_m3(t->spacemtx);
unit_m3(r_spacemtx);
}
break;
}
return orientation;
}
const char *transform_orientations_spacename_get(TransInfo *t, const short orient_type)
{
switch (orient_type) {
case V3D_ORIENT_GLOBAL:
return TIP_("global");
case V3D_ORIENT_GIMBAL:
return TIP_("gimbal");
case V3D_ORIENT_NORMAL:
return TIP_("normal");
case V3D_ORIENT_LOCAL:
return TIP_("local");
case V3D_ORIENT_VIEW:
return TIP_("view");
case V3D_ORIENT_CURSOR:
return TIP_("cursor");
case V3D_ORIENT_CUSTOM_MATRIX:
return TIP_("custom");
case V3D_ORIENT_CUSTOM:
default:
BLI_assert(orient_type >= V3D_ORIENT_CUSTOM);
TransformOrientation *ts = BKE_scene_transform_orientation_find(
t->scene, orient_type - V3D_ORIENT_CUSTOM);
return ts->name;
}
}
void transform_orientations_current_set(TransInfo *t, const short orient_index)
{
const short orientation = t->orient[orient_index].type;
const char *spacename;
switch (orientation) {
case V3D_ORIENT_GLOBAL:
spacename = TIP_("global");
break;
case V3D_ORIENT_GIMBAL:
spacename = TIP_("gimbal");
break;
case V3D_ORIENT_NORMAL:
spacename = TIP_("normal");
break;
case V3D_ORIENT_LOCAL:
spacename = TIP_("local");
break;
case V3D_ORIENT_VIEW:
spacename = TIP_("view");
break;
case V3D_ORIENT_CURSOR:
spacename = TIP_("cursor");
break;
case V3D_ORIENT_CUSTOM_MATRIX:
spacename = TIP_("custom");
break;
case V3D_ORIENT_CUSTOM:
default:
BLI_assert(orientation >= V3D_ORIENT_CUSTOM);
TransformOrientation *ts = BKE_scene_transform_orientation_find(
t->scene, orientation - V3D_ORIENT_CUSTOM);
spacename = ts->name;
break;
}
BLI_strncpy(t->spacename, spacename, sizeof(t->spacename));
copy_m3_m3(t->spacemtx, t->orient[orient_index].matrix);
invert_m3_m3(t->spacemtx_inv, t->spacemtx);
}

4
source/blender/editors/transform/transform_snap.c
View File

@ -1749,8 +1749,8 @@ static void applyGridIncrement(
float local_axis[3];
float pos_on_axis[3];
copy_v3_v3(local_axis, t->con.mtx[i]);
copy_v3_v3(pos_on_axis, t->con.mtx[i]);
copy_v3_v3(local_axis, t->spacemtx[i]);
copy_v3_v3(pos_on_axis, t->spacemtx[i]);
/* amount of movement on axis from initial pos */
mul_v3_fl(pos_on_axis, val[i]);