Differential D15494 Diff 53819 source/blender/editors/transform/transform_convert.c

Changeset View

Standalone View

source/blender/editors/transform/transform_convert.c

Show First 20 Lines • Show All 770 Lines • ▼ Show 20 Lines	void special_aftertrans_update(bContext C, TransInfo t)
* with transform's order of freeing (campbell).		* with transform's order of freeing (campbell).
* Order changed, the sequencer stuff should go back in here. */		* Order changed, the sequencer stuff should go back in here. */

/* early out when nothing happened */		/* early out when nothing happened */
if (t->data_len_all == 0 \|\| t->mode == TFM_DUMMY) {		if (t->data_len_all == 0 \|\| t->mode == TFM_DUMMY) {
return;		return;
}		}

BLI_assert(CTX_data_main(t->context) == CTX_data_main(C));		if (t->data_type->special_aftertrans_update == NULL) {
switch (t->data_type) {		return;
case TC_ACTION_DATA:
special_aftertrans_update__actedit(C, t);
break;
case TC_POSE:
special_aftertrans_update__pose(C, t);
break;
case TC_GRAPH_EDIT_DATA:
special_aftertrans_update__graph(C, t);
break;
case TC_MASKING_DATA:
special_aftertrans_update__mask(C, t);
break;
case TC_MESH_VERTS:
case TC_MESH_EDGES:
special_aftertrans_update__mesh(C, t);
break;
case TC_NLA_DATA:
special_aftertrans_update__nla(C, t);
break;
case TC_NODE_DATA:
special_aftertrans_update__node(C, t);
break;
case TC_OBJECT:
special_aftertrans_update__object(C, t);
break;
case TC_SCULPT:
special_aftertrans_update__sculpt(C, t);
break;
case TC_SEQ_DATA:
special_aftertrans_update__sequencer(C, t);
break;
case TC_SEQ_IMAGE_DATA:
special_aftertrans_update__sequencer_image(C, t);
break;
case TC_TRACKING_DATA:
special_aftertrans_update__movieclip(C, t);
break;
case TC_ARMATURE_VERTS:
case TC_CURSOR_IMAGE:
case TC_CURSOR_SEQUENCER:
case TC_CURSOR_VIEW3D:
case TC_CURVE_VERTS:
case TC_GPENCIL:
case TC_LATTICE_VERTS:
case TC_MBALL_VERTS:
case TC_MESH_VERT_CDATA:
case TC_MESH_UV:
case TC_MESH_SKIN:
case TC_OBJECT_TEXSPACE:
case TC_PAINT_CURVE_VERTS:
case TC_PARTICLE_VERTS:
case TC_NONE:
default:
break;
}		}

		BLI_assert(CTX_data_main(t->context) == CTX_data_main(C));
		t->data_type->special_aftertrans_update(C, t);
}		}

int special_transform_moving(TransInfo *t)		int special_transform_moving(TransInfo *t)
{		{
if (t->options & CTX_CURSOR) {		if (t->options & CTX_CURSOR) {
return G_TRANSFORM_CURSOR;		return G_TRANSFORM_CURSOR;
}		}
if (t->spacetype == SPACE_SEQ) {		if (t->spacetype == SPACE_SEQ) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	if (data_container_len_orig != t->data_container_len) {
t->data_container = MEM_reallocN(t->data_container,		t->data_container = MEM_reallocN(t->data_container,
sizeof(t->data_container) t->data_container_len);		sizeof(t->data_container) t->data_container_len);
}		}
return t->data_len_all;		return t->data_len_all;
}		}

static void init_proportional_edit(TransInfo *t)		static void init_proportional_edit(TransInfo *t)
{		{
eTConvertType convert_type = t->data_type;		/* NOTE: PET is not usable in pose mode yet T32444. */
switch (convert_type) {		if (!ELEM(t->data_type,
case TC_ACTION_DATA:		&TransConvertType_Action,
case TC_CURVE_VERTS:		&TransConvertType_Curve,
case TC_GRAPH_EDIT_DATA:		&TransConvertType_Graph,
case TC_GPENCIL:		&TransConvertType_GPencil,
case TC_LATTICE_VERTS:		&TransConvertType_Lattice,
case TC_MASKING_DATA:		&TransConvertType_Mask,
case TC_MBALL_VERTS:		&TransConvertType_MBall,
case TC_MESH_VERTS:		&TransConvertType_Mesh,
case TC_MESH_EDGES:		&TransConvertType_MeshEdge,
case TC_MESH_SKIN:		&TransConvertType_MeshSkin,
case TC_MESH_UV:		&TransConvertType_MeshUV,
case TC_MESH_VERT_CDATA:		&TransConvertType_MeshVertCData,
case TC_NODE_DATA:		&TransConvertType_Node,
case TC_OBJECT:		&TransConvertType_Object,
case TC_PARTICLE_VERTS:		&TransConvertType_Particle)) {
break;		/* Disable PET */
case TC_POSE: /* Disable PET, its not usable in pose mode yet T32444. */
case TC_ARMATURE_VERTS:
case TC_CURSOR_IMAGE:
case TC_CURSOR_SEQUENCER:
case TC_CURSOR_VIEW3D:
case TC_NLA_DATA:
case TC_OBJECT_TEXSPACE:
case TC_PAINT_CURVE_VERTS:
case TC_SCULPT:
case TC_SEQ_DATA:
case TC_SEQ_IMAGE_DATA:
case TC_TRACKING_DATA:
case TC_NONE:
default:
t->options \|= CTX_NO_PET;		t->options \|= CTX_NO_PET;
t->flag &= ~T_PROP_EDIT_ALL;		t->flag &= ~T_PROP_EDIT_ALL;
return;		return;
}		}

if (t->data_len_all && (t->flag & T_PROP_EDIT)) {		if (t->data_len_all && (t->flag & T_PROP_EDIT)) {
if (convert_type == TC_OBJECT) {		if (t->data_type == &TransConvertType_Object) {
/* Selected objects are already first, no need to presort. */		/* Selected objects are already first, no need to presort. */
}		}
else {		else {
sort_trans_data_selected_first(t);		sort_trans_data_selected_first(t);
}		}

if (ELEM(convert_type, TC_ACTION_DATA, TC_GRAPH_EDIT_DATA)) {		if (ELEM(t->data_type, &TransConvertType_Action, &TransConvertType_Graph)) {
/* Distance has already been set. */		/* Distance has already been set. */
}		}
else if (ELEM(convert_type, TC_MESH_VERTS, TC_MESH_SKIN, TC_MESH_VERT_CDATA)) {		else if (ELEM(t->data_type,
		&TransConvertType_Mesh,
		&TransConvertType_MeshSkin,
		&TransConvertType_MeshVertCData)) {
if (t->flag & T_PROP_CONNECTED) {		if (t->flag & T_PROP_CONNECTED) {
/* Already calculated by transform_convert_mesh_connectivity_distance. */		/* Already calculated by transform_convert_mesh_connectivity_distance. */
}		}
else {		else {
set_prop_dist(t, false);		set_prop_dist(t, false);
}		}
}		}
else if (convert_type == TC_MESH_UV && t->flag & T_PROP_CONNECTED) {		else if (t->data_type == &TransConvertType_MeshUV && t->flag & T_PROP_CONNECTED) {
/* Already calculated by uv_set_connectivity_distance. */		/* Already calculated by uv_set_connectivity_distance. */
}		}
else if (convert_type == TC_CURVE_VERTS) {		else if (t->data_type == &TransConvertType_Curve) {
BLI_assert(t->obedit_type == OB_CURVES_LEGACY);		BLI_assert(t->obedit_type == OB_CURVES_LEGACY);
set_prop_dist(t, false);		set_prop_dist(t, false);
}		}
else {		else {
set_prop_dist(t, true);		set_prop_dist(t, true);
}		}

sort_trans_data_dist(t);		sort_trans_data_dist(t);
}		}
else if (ELEM(t->obedit_type, OB_CURVES_LEGACY)) {		else if (ELEM(t->obedit_type, OB_CURVES_LEGACY)) {
/* Needed because bezier handles can be partially selected		/* Needed because bezier handles can be partially selected
* and are still added into transform data. */		* and are still added into transform data. */
sort_trans_data_selected_first(t);		sort_trans_data_selected_first(t);
}		}
}		}

/* For multi object editing. */		/* For multi object editing. */
static void init_TransDataContainers(TransInfo *t,		static void init_TransDataContainers(TransInfo *t,
Object *obact,		Object *obact,
Object **objects,		Object **objects,
uint objects_len)		uint objects_len)
{		{
switch (t->data_type) {		if (!ELEM(t->data_type,
case TC_POSE:		&TransConvertType_Pose,
case TC_ARMATURE_VERTS:		&TransConvertType_EditArmature,
case TC_CURVE_VERTS:		&TransConvertType_Curve,
case TC_GPENCIL:		&TransConvertType_GPencil,
case TC_LATTICE_VERTS:		&TransConvertType_Lattice,
case TC_MBALL_VERTS:		&TransConvertType_MBall,
case TC_MESH_VERTS:		&TransConvertType_Mesh,
case TC_MESH_EDGES:		&TransConvertType_MeshEdge,
case TC_MESH_SKIN:		&TransConvertType_MeshSkin,
case TC_MESH_UV:		&TransConvertType_MeshUV,
case TC_MESH_VERT_CDATA:		&TransConvertType_MeshVertCData)) {
break;
case TC_ACTION_DATA:
case TC_GRAPH_EDIT_DATA:
case TC_CURSOR_IMAGE:
case TC_CURSOR_SEQUENCER:
case TC_CURSOR_VIEW3D:
case TC_MASKING_DATA:
case TC_NLA_DATA:
case TC_NODE_DATA:
case TC_OBJECT:
case TC_OBJECT_TEXSPACE:
case TC_PAINT_CURVE_VERTS:
case TC_PARTICLE_VERTS:
case TC_SCULPT:
case TC_SEQ_DATA:
case TC_SEQ_IMAGE_DATA:
case TC_TRACKING_DATA:
case TC_NONE:
default:
/* Does not support Multi object editing. */		/* Does not support Multi object editing. */
return;		return;
}		}

const eObjectMode object_mode = obact ? obact->mode : OB_MODE_OBJECT;		const eObjectMode object_mode = obact ? obact->mode : OB_MODE_OBJECT;
const short object_type = obact ? obact->type : -1;		const short object_type = obact ? obact->type : -1;

if ((object_mode & OB_MODE_EDIT) \|\| (t->data_type == TC_GPENCIL) \|\|		if ((object_mode & OB_MODE_EDIT) \|\| (t->data_type == &TransConvertType_GPencil) \|\|
((object_mode & OB_MODE_POSE) && (object_type == OB_ARMATURE))) {		((object_mode & OB_MODE_POSE) && (object_type == OB_ARMATURE))) {
if (t->data_container) {		if (t->data_container) {
MEM_freeN(t->data_container);		MEM_freeN(t->data_container);
}		}

bool free_objects = false;		bool free_objects = false;
if (objects == NULL) {		if (objects == NULL) {
objects = BKE_view_layer_array_from_objects_in_mode(		objects = BKE_view_layer_array_from_objects_in_mode(
Show All 25 Lines	for (int i = 0; i < objects_len; i++) {
if ((t->flag & T_2D_EDIT) == 0) {		if ((t->flag & T_2D_EDIT) == 0) {
tc->use_local_mat = true;		tc->use_local_mat = true;
}		}
}		}
else if (object_mode & OB_MODE_POSE) {		else if (object_mode & OB_MODE_POSE) {
tc->poseobj = objects[i];		tc->poseobj = objects[i];
tc->use_local_mat = true;		tc->use_local_mat = true;
}		}
else if (t->data_type == TC_GPENCIL) {		else if (t->data_type == &TransConvertType_GPencil) {
tc->use_local_mat = true;		tc->use_local_mat = true;
}		}

if (tc->use_local_mat) {		if (tc->use_local_mat) {
BLI_assert((t->flag & T_2D_EDIT) == 0);		BLI_assert((t->flag & T_2D_EDIT) == 0);
copy_m4_m4(tc->mat, objects[i]->obmat);		copy_m4_m4(tc->mat, objects[i]->obmat);
copy_m3_m4(tc->mat3, tc->mat);		copy_m3_m4(tc->mat3, tc->mat);
/* for non-invertible scale matrices, invert_m4_m4_fallback()		/* for non-invertible scale matrices, invert_m4_m4_fallback()
* can still provide a valid pivot */		* can still provide a valid pivot */
invert_m4_m4_fallback(tc->imat, tc->mat);		invert_m4_m4_fallback(tc->imat, tc->mat);
invert_m3_m3(tc->imat3, tc->mat3);		invert_m3_m3(tc->imat3, tc->mat3);
normalize_m3_m3(tc->mat3_unit, tc->mat3);		normalize_m3_m3(tc->mat3_unit, tc->mat3);
}		}
/* Otherwise leave as zero. */		/* Otherwise leave as zero. */
}		}

if (free_objects) {		if (free_objects) {
MEM_freeN(objects);		MEM_freeN(objects);
}		}
}		}
}		}

static eTFlag flags_from_data_type(eTConvertType data_type)		static TransConvertTypeInfo convert_type_get(const TransInfo t, Object **r_obj_armature)
{
switch (data_type) {
case TC_ACTION_DATA:
case TC_GRAPH_EDIT_DATA:
case TC_MASKING_DATA:
case TC_NLA_DATA:
case TC_NODE_DATA:
case TC_PAINT_CURVE_VERTS:
case TC_SEQ_DATA:
case TC_SEQ_IMAGE_DATA:
case TC_TRACKING_DATA:
return T_POINTS \| T_2D_EDIT;
case TC_ARMATURE_VERTS:
case TC_CURVE_VERTS:
case TC_GPENCIL:
case TC_LATTICE_VERTS:
case TC_MBALL_VERTS:
case TC_MESH_VERTS:
case TC_MESH_SKIN:
case TC_MESH_VERT_CDATA:
return T_EDIT \| T_POINTS;
case TC_MESH_EDGES:
return T_EDIT;
case TC_MESH_UV:
return T_EDIT \| T_POINTS \| T_2D_EDIT;
case TC_CURSOR_IMAGE:
case TC_CURSOR_SEQUENCER:
return T_2D_EDIT;
case TC_PARTICLE_VERTS:
return T_POINTS;
case TC_POSE:
case TC_CURSOR_VIEW3D:
case TC_OBJECT:
case TC_OBJECT_TEXSPACE:
case TC_SCULPT:
case TC_NONE:
default:
break;
}
return 0;
}

static eTConvertType convert_type_get(const TransInfo t, Object *r_obj_armature)
{		{
ViewLayer *view_layer = t->view_layer;		ViewLayer *view_layer = t->view_layer;
Object *ob = OBACT(view_layer);		Object *ob = OBACT(view_layer);
eTConvertType convert_type = TC_NONE;

/* if tests must match recalcData for correct updates */		/* if tests must match recalcData for correct updates */
if (t->options & CTX_CURSOR) {		if (t->options & CTX_CURSOR) {
if (t->spacetype == SPACE_IMAGE) {		if (t->spacetype == SPACE_IMAGE) {
convert_type = TC_CURSOR_IMAGE;		return &TransConvertType_CursorImage;
}
else if (t->spacetype == SPACE_SEQ) {
convert_type = TC_CURSOR_SEQUENCER;
}		}
else {
convert_type = TC_CURSOR_VIEW3D;		if (t->spacetype == SPACE_SEQ) {
		return &TransConvertType_CursorSequencer;
}		}

		return &TransConvertType_Cursor3D;
}		}
else if (!(t->options & CTX_PAINT_CURVE) && (t->spacetype == SPACE_VIEW3D) && ob &&		if (!(t->options & CTX_PAINT_CURVE) && (t->spacetype == SPACE_VIEW3D) && ob &&
(ob->mode == OB_MODE_SCULPT) && ob->sculpt) {		(ob->mode == OB_MODE_SCULPT) && ob->sculpt) {
convert_type = TC_SCULPT;		return &TransConvertType_Sculpt;
}		}
else if (t->options & CTX_TEXTURE_SPACE) {		if (t->options & CTX_TEXTURE_SPACE) {
convert_type = TC_OBJECT_TEXSPACE;		return &TransConvertType_ObjectTexSpace;
}		}
else if (t->options & CTX_EDGE_DATA) {		if (t->options & CTX_EDGE_DATA) {
convert_type = TC_MESH_EDGES;		return &TransConvertType_MeshEdge;
}		}
else if (t->options & CTX_GPENCIL_STROKES) {		if (t->options & CTX_GPENCIL_STROKES) {
convert_type = TC_GPENCIL;		return &TransConvertType_GPencil;
}		}
else if (t->spacetype == SPACE_IMAGE) {		if (t->spacetype == SPACE_IMAGE) {
if (t->options & CTX_MASK) {		if (t->options & CTX_MASK) {
convert_type = TC_MASKING_DATA;		return &TransConvertType_Mask;
}		}
else if (t->options & CTX_PAINT_CURVE) {		if (t->options & CTX_PAINT_CURVE) {
if (!ELEM(t->mode, TFM_SHEAR, TFM_SHRINKFATTEN)) {		if (!ELEM(t->mode, TFM_SHEAR, TFM_SHRINKFATTEN)) {
convert_type = TC_PAINT_CURVE_VERTS;		return &TransConvertType_PaintCurve;
}		}
}		}
else if (t->obedit_type == OB_MESH) {		else if (t->obedit_type == OB_MESH) {
convert_type = TC_MESH_UV;		return &TransConvertType_MeshUV;
}		}
		return NULL;
}		}
else if (t->spacetype == SPACE_ACTION) {		if (t->spacetype == SPACE_ACTION) {
convert_type = TC_ACTION_DATA;		return &TransConvertType_Action;
}		}
else if (t->spacetype == SPACE_NLA) {		if (t->spacetype == SPACE_NLA) {
convert_type = TC_NLA_DATA;		return &TransConvertType_NLA;
}		}
else if (t->spacetype == SPACE_SEQ) {		if (t->spacetype == SPACE_SEQ) {
if (t->options & CTX_SEQUENCER_IMAGE) {		if (t->options & CTX_SEQUENCER_IMAGE) {
convert_type = TC_SEQ_IMAGE_DATA;		return &TransConvertType_SequencerImage;
}
else {
convert_type = TC_SEQ_DATA;
}		}
		return &TransConvertType_Sequencer;
}		}
else if (t->spacetype == SPACE_GRAPH) {		if (t->spacetype == SPACE_GRAPH) {
convert_type = TC_GRAPH_EDIT_DATA;		return &TransConvertType_Graph;
}		}
else if (t->spacetype == SPACE_NODE) {		if (t->spacetype == SPACE_NODE) {
convert_type = TC_NODE_DATA;		return &TransConvertType_Graph;
}		}
else if (t->spacetype == SPACE_CLIP) {		if (t->spacetype == SPACE_CLIP) {
if (t->options & CTX_MOVIECLIP) {		if (t->options & CTX_MOVIECLIP) {
convert_type = TC_TRACKING_DATA;		return &TransConvertType_Tracking;
}		}
else if (t->options & CTX_MASK) {		if (t->options & CTX_MASK) {
convert_type = TC_MASKING_DATA;		return &TransConvertType_Mask;
}		}
		return NULL;
}		}
else if (t->obedit_type != -1) {		if (t->obedit_type != -1) {
if (t->obedit_type == OB_MESH) {		if (t->obedit_type == OB_MESH) {
if (t->mode == TFM_SKIN_RESIZE) {		if (t->mode == TFM_SKIN_RESIZE) {
convert_type = TC_MESH_SKIN;		return &TransConvertType_MeshSkin;
}		}
else if (ELEM(t->mode, TFM_BWEIGHT, TFM_VERT_CREASE)) {		if (ELEM(t->mode, TFM_BWEIGHT, TFM_VERT_CREASE)) {
convert_type = TC_MESH_VERT_CDATA;		return &TransConvertType_MeshVertCData;
}		}
else {		return &TransConvertType_Mesh;
convert_type = TC_MESH_VERTS;
}		}
		if (ELEM(t->obedit_type, OB_CURVES_LEGACY, OB_SURF)) {
		return &TransConvertType_Curve;
}		}
else if (ELEM(t->obedit_type, OB_CURVES_LEGACY, OB_SURF)) {		if (t->obedit_type == OB_LATTICE) {
convert_type = TC_CURVE_VERTS;		return &TransConvertType_Lattice;
}		}
else if (t->obedit_type == OB_LATTICE) {		if (t->obedit_type == OB_MBALL) {
convert_type = TC_LATTICE_VERTS;		return &TransConvertType_MBall;
}		}
else if (t->obedit_type == OB_MBALL) {		if (t->obedit_type == OB_ARMATURE) {
convert_type = TC_MBALL_VERTS;		return &TransConvertType_EditArmature;
}		}
else if (t->obedit_type == OB_ARMATURE) {		return NULL;
convert_type = TC_ARMATURE_VERTS;
}		}
		if (ob && (ob->mode & OB_MODE_POSE)) {
		return &TransConvertType_Pose;
}		}
else if (ob && (ob->mode & OB_MODE_POSE)) {		if (ob && (ob->mode & OB_MODE_ALL_WEIGHT_PAINT) && !(t->options & CTX_PAINT_CURVE)) {
convert_type = TC_POSE;
}
else if (ob && (ob->mode & OB_MODE_ALL_WEIGHT_PAINT) && !(t->options & CTX_PAINT_CURVE)) {
Object *ob_armature = transform_object_deform_pose_armature_get(t, ob);		Object *ob_armature = transform_object_deform_pose_armature_get(t, ob);
if (ob_armature) {		if (ob_armature) {
*r_obj_armature = ob_armature;		*r_obj_armature = ob_armature;
convert_type = TC_POSE;		return &TransConvertType_Pose;
}		}
		return NULL;
}		}
else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT) &&		if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT) &&
PE_start_edit(PE_get_current(t->depsgraph, t->scene, ob))) {		PE_start_edit(PE_get_current(t->depsgraph, t->scene, ob))) {
convert_type = TC_PARTICLE_VERTS;		return &TransConvertType_Particle;
}		}
else if (ob && (ob->mode & OB_MODE_ALL_PAINT)) {		if (ob && (ob->mode & OB_MODE_ALL_PAINT)) {
if ((t->options & CTX_PAINT_CURVE) && !ELEM(t->mode, TFM_SHEAR, TFM_SHRINKFATTEN)) {		if ((t->options & CTX_PAINT_CURVE) && !ELEM(t->mode, TFM_SHEAR, TFM_SHRINKFATTEN)) {
convert_type = TC_PAINT_CURVE_VERTS;		return &TransConvertType_PaintCurve;
}		}
		return NULL;
}		}
else if ((ob) && (ELEM(ob->mode,		if ((ob) && (ELEM(ob->mode,
OB_MODE_PAINT_GPENCIL,		OB_MODE_PAINT_GPENCIL,
OB_MODE_SCULPT_GPENCIL,		OB_MODE_SCULPT_GPENCIL,
OB_MODE_WEIGHT_GPENCIL,		OB_MODE_WEIGHT_GPENCIL,
OB_MODE_VERTEX_GPENCIL))) {		OB_MODE_VERTEX_GPENCIL))) {
/* In grease pencil all transformations must be canceled if not Object or Edit. */		/* In grease pencil all transformations must be canceled if not Object or Edit. */
		return NULL;
}		}
else {		return &TransConvertType_Object;
convert_type = TC_OBJECT;
}

return convert_type;
}		}

void createTransData(bContext C, TransInfo t)		void createTransData(bContext C, TransInfo t)
{		{
t->data_len_all = -1;		t->data_len_all = -1;

Object *ob_armature = NULL;		Object *ob_armature = NULL;
t->data_type = convert_type_get(t, &ob_armature);		t->data_type = convert_type_get(t, &ob_armature);
t->flag \|= flags_from_data_type(t->data_type);		if (t->data_type == NULL) {
		printf("edit type not implemented!\n");
		BLI_assert(t->data_len_all == -1);
		t->data_len_all = 0;
		return;
		}

		t->flag \|= t->data_type->flags;

if (ob_armature) {		if (ob_armature) {
init_TransDataContainers(t, ob_armature, &ob_armature, 1);		init_TransDataContainers(t, ob_armature, &ob_armature, 1);
}		}
else {		else {
ViewLayer *view_layer = t->view_layer;		ViewLayer *view_layer = t->view_layer;
Object *ob = OBACT(view_layer);		Object *ob = OBACT(view_layer);
init_TransDataContainers(t, ob, NULL, 0);		init_TransDataContainers(t, ob, NULL, 0);
}		}

switch (t->data_type) {		if (t->data_type == &TransConvertType_Object) {
case TC_ACTION_DATA:
createTransActionData(C, t);
break;
case TC_POSE:
t->options \|= CTX_POSE_BONE;

/* XXX active-layer checking isn't done
* as that should probably be checked through context instead. */
createTransPose(t);
break;
case TC_ARMATURE_VERTS:
createTransArmatureVerts(t);
break;
case TC_CURSOR_IMAGE:
createTransCursor_image(t);
break;
case TC_CURSOR_SEQUENCER:
createTransCursor_sequencer(t);
break;
case TC_CURSOR_VIEW3D:
createTransCursor_view3d(t);
break;
case TC_CURVE_VERTS:
createTransCurveVerts(t);
break;
case TC_GRAPH_EDIT_DATA:
createTransGraphEditData(C, t);
break;
case TC_GPENCIL:
createTransGPencil(C, t);
break;
case TC_LATTICE_VERTS:
createTransLatticeVerts(t);
break;
case TC_MASKING_DATA:
createTransMaskingData(C, t);
break;
case TC_MBALL_VERTS:
createTransMBallVerts(t);
break;
case TC_MESH_VERTS:
createTransEditVerts(t);
break;
case TC_MESH_EDGES:
createTransEdge(t);
break;
case TC_MESH_SKIN:
createTransMeshSkin(t);
break;
case TC_MESH_UV:
createTransUVs(C, t);
break;
case TC_NLA_DATA:
createTransNlaData(C, t);
break;
case TC_MESH_VERT_CDATA:
createTransMeshVertCData(t);
break;
case TC_NODE_DATA:
createTransNodeData(t);
break;
case TC_OBJECT:
t->options \|= CTX_OBJECT;		t->options \|= CTX_OBJECT;

/* Needed for correct Object.obmat after duplication, see: T62135. */		/* Needed for correct Object.obmat after duplication, see: T62135. */
BKE_scene_graph_evaluated_ensure(t->depsgraph, CTX_data_main(t->context));		BKE_scene_graph_evaluated_ensure(t->depsgraph, CTX_data_main(t->context));

if ((t->settings->transform_flag & SCE_XFORM_DATA_ORIGIN) != 0) {		if ((t->settings->transform_flag & SCE_XFORM_DATA_ORIGIN) != 0) {
t->options \|= CTX_OBMODE_XFORM_OBDATA;		t->options \|= CTX_OBMODE_XFORM_OBDATA;
}		}
if ((t->settings->transform_flag & SCE_XFORM_SKIP_CHILDREN) != 0) {		if ((t->settings->transform_flag & SCE_XFORM_SKIP_CHILDREN) != 0) {
t->options \|= CTX_OBMODE_XFORM_SKIP_CHILDREN;		t->options \|= CTX_OBMODE_XFORM_SKIP_CHILDREN;
}		}
createTransObject(C, t);		TransConvertType_Object.createTransData(C, t);
/* Check if we're transforming the camera from the camera */		/* Check if we're transforming the camera from the camera */
if ((t->spacetype == SPACE_VIEW3D) && (t->region->regiontype == RGN_TYPE_WINDOW)) {		if ((t->spacetype == SPACE_VIEW3D) && (t->region->regiontype == RGN_TYPE_WINDOW)) {
View3D *v3d = t->view;		View3D *v3d = t->view;
RegionView3D *rv3d = t->region->regiondata;		RegionView3D *rv3d = t->region->regiondata;
if ((rv3d->persp == RV3D_CAMOB) && v3d->camera) {		if ((rv3d->persp == RV3D_CAMOB) && v3d->camera) {
/* we could have a flag to easily check an object is being transformed */		/* we could have a flag to easily check an object is being transformed */
if (v3d->camera->id.tag & LIB_TAG_DOIT) {		if (v3d->camera->id.tag & LIB_TAG_DOIT) {
t->options \|= CTX_CAMERA;		t->options \|= CTX_CAMERA;
}		}
}		}
else if (v3d->ob_center && v3d->ob_center->id.tag & LIB_TAG_DOIT) {		else if (v3d->ob_center && v3d->ob_center->id.tag & LIB_TAG_DOIT) {
t->options \|= CTX_CAMERA;		t->options \|= CTX_CAMERA;
}		}
}		}
break;		}
case TC_OBJECT_TEXSPACE:		else {
createTransTexspace(t);		if (t->data_type == &TransConvertType_Pose) {
break;		t->options \|= CTX_POSE_BONE;
case TC_PAINT_CURVE_VERTS:		}
createTransPaintCurveVerts(C, t);		else if (t->data_type == &TransConvertType_Sequencer) {
break;		/* Sequencer has no use for floating point transform. */
case TC_PARTICLE_VERTS:		t->num.flag \|= NUM_NO_FRACTION;
createTransParticleVerts(t);		}
break;		else if (t->data_type == &TransConvertType_SequencerImage) {
case TC_SCULPT:
createTransSculpt(C, t);
break;
case TC_SEQ_DATA:
t->num.flag \|= NUM_NO_FRACTION; /* sequencer has no use for floating point transform. */
createTransSeqData(t);
break;
case TC_SEQ_IMAGE_DATA:
t->obedit_type = -1;		t->obedit_type = -1;
createTransSeqImageData(t);		}
break;		t->data_type->createTransData(C, t);
case TC_TRACKING_DATA:
createTransTrackingData(C, t);
break;
case TC_NONE:
default:
printf("edit type not implemented!\n");
BLI_assert(t->data_len_all == -1);
t->data_len_all = 0;
return;
}		}

countAndCleanTransDataContainer(t);		countAndCleanTransDataContainer(t);

init_proportional_edit(t);		init_proportional_edit(t);
}		}

/** \} */		/** \} */
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines	void transform_convert_flush_handle2D(TransData td, TransData2D td2d, const float y_fac)
if ((td->flag & TD_MOVEHANDLE2) && td2d->h2) {		if ((td->flag & TD_MOVEHANDLE2) && td2d->h2) {
td2d->h2[0] = td2d->ih2[0] + delta_x;		td2d->h2[0] = td2d->ih2[0] + delta_x;
td2d->h2[1] = td2d->ih2[1] + delta_y;		td2d->h2[1] = td2d->ih2[1] + delta_y;
}		}
}		}

void recalcData(TransInfo *t)		void recalcData(TransInfo *t)
{		{
switch (t->data_type) {		if (!t->data_type->recalcData) {
case TC_ACTION_DATA:		return;
recalcData_actedit(t);
break;
case TC_POSE:
recalcData_pose(t);
break;
case TC_ARMATURE_VERTS:
recalcData_edit_armature(t);
break;
case TC_CURVE_VERTS:
recalcData_curve(t);
break;
case TC_CURSOR_IMAGE:
recalcData_cursor_image(t);
break;
case TC_CURSOR_SEQUENCER:
recalcData_cursor_sequencer(t);
break;
case TC_CURSOR_VIEW3D:
recalcData_cursor_view3d(t);
break;
case TC_GRAPH_EDIT_DATA:
recalcData_graphedit(t);
break;
case TC_GPENCIL:
recalcData_gpencil_strokes(t);
break;
case TC_MASKING_DATA:
recalcData_mask_common(t);
break;
case TC_MESH_VERTS:
recalcData_mesh(t);
break;
case TC_MESH_EDGES:
recalcData_mesh_edge(t);
break;
case TC_MESH_SKIN:
recalcData_mesh_skin(t);
break;
case TC_MESH_UV:
recalcData_uv(t);
break;
case TC_MESH_VERT_CDATA:
recalcData_mesh_cdata(t);
break;
case TC_NLA_DATA:
recalcData_nla(t);
break;
case TC_NODE_DATA:
flushTransNodes(t);
break;
case TC_OBJECT:
recalcData_objects(t);
break;
case TC_OBJECT_TEXSPACE:
recalcData_texspace(t);
break;
case TC_PAINT_CURVE_VERTS:
flushTransPaintCurve(t);
break;
case TC_SCULPT:
recalcData_sculpt(t);
break;
case TC_SEQ_DATA:
recalcData_sequencer(t);
break;
case TC_SEQ_IMAGE_DATA:
recalcData_sequencer_image(t);
break;
case TC_TRACKING_DATA:
recalcData_tracking(t);
break;
case TC_MBALL_VERTS:
recalcData_mball(t);
break;
case TC_LATTICE_VERTS:
recalcData_lattice(t);
break;
case TC_PARTICLE_VERTS:
recalcData_particles(t);
break;
case TC_NONE:
default:
break;
}		}
		t->data_type->recalcData(t);
}		}

/** \} */		/** \} */