blender
/
blender
134
399
Fork 581
Code Issues 6.2k Pull Requests 753 Projects 19 Wiki Activity

Cleanup: indentation 

Indent lines for multi object editing, no functional changes.

Also strip trailing space from indented regions.
This commit is contained in:
Campbell Barton 2018-04-16 17:54:33 +02:00
parent bfc9d426bb
commit 292a2802ad
12 changed files with 3358 additions and 3354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
source/blender/editors/armature/armature_edit.c
View File

@ -1345,33 +1345,33 @@ static int armature_delete_selected_exec(bContext *C, wmOperator *UNUSED(op))
uint objects_len = 0;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
bArmature *arm = obedit->data;
bool changed = false;
Object *obedit = objects[ob_index];
bArmature *arm = obedit->data;
bool changed = false;
armature_select_mirrored(arm);
armature_select_mirrored(arm);
BKE_pose_channels_remove(obedit, armature_delete_ebone_cb, arm);
BKE_pose_channels_remove(obedit, armature_delete_ebone_cb, arm);
for (curBone = arm->edbo->first; curBone; curBone = ebone_next) {
ebone_next = curBone->next;
if (arm->layer & curBone->layer) {
if (curBone->flag & BONE_SELECTED) {
if (curBone == arm->act_edbone) arm->act_edbone = NULL;
ED_armature_ebone_remove(arm, curBone);
changed = true;
for (curBone = arm->edbo->first; curBone; curBone = ebone_next) {
ebone_next = curBone->next;
if (arm->layer & curBone->layer) {
if (curBone->flag & BONE_SELECTED) {
if (curBone == arm->act_edbone) arm->act_edbone = NULL;
ED_armature_ebone_remove(arm, curBone);
changed = true;
}
}
}
}
if (changed) {
changed_multi = true;
if (changed) {
changed_multi = true;
ED_armature_edit_sync_selection(arm->edbo);
BKE_pose_tag_recalc(CTX_data_main(C), obedit->pose);
ED_armature_edit_sync_selection(arm->edbo);
BKE_pose_tag_recalc(CTX_data_main(C), obedit->pose);
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
}
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
}
}
if (!changed_multi) {

276
source/blender/editors/mesh/editmesh_select.c
View File

@ -2712,171 +2712,171 @@ static int edbm_select_linked_exec(bContext *C, wmOperator *op)
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
BMIter iter;
BMWalker walker;
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
BMIter iter;
BMWalker walker;
int delimit = delimit_init;
int delimit = delimit_init;
select_linked_delimit_validate(bm, &delimit);
select_linked_delimit_validate(bm, &delimit);
if (delimit) {
select_linked_delimit_begin(em->bm, delimit);
}
if (em->selectmode & SCE_SELECT_VERTEX) {
BMVert *v;
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
BM_elem_flag_set(v, BM_ELEM_TAG, BM_elem_flag_test(v, BM_ELEM_SELECT));
if (delimit) {
select_linked_delimit_begin(em->bm, delimit);
}
/* exclude all delimited verts */
if (delimit) {
if (em->selectmode & SCE_SELECT_VERTEX) {
BMVert *v;
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
BM_elem_flag_set(v, BM_ELEM_TAG, BM_elem_flag_test(v, BM_ELEM_SELECT));
}
/* exclude all delimited verts */
if (delimit) {
BMEdge *e;
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (!BMO_edge_flag_test(bm, e, BMO_ELE_TAG)) {
BM_elem_flag_disable(e->v1, BM_ELEM_TAG);
BM_elem_flag_disable(e->v2, BM_ELEM_TAG);
}
}
}
BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, BMW_MASK_NOP,
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
if (delimit) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
BMElem *ele_walk;
BMW_ITER (ele_walk, &walker, v) {
if (ele_walk->head.htype == BM_LOOP) {
BMVert *v_step = ((BMLoop *)ele_walk)->v;
BM_vert_select_set(em->bm, v_step, true);
BM_elem_flag_disable(v_step, BM_ELEM_TAG);
}
else {
BMEdge *e_step = (BMEdge *)ele_walk;
BLI_assert(ele_walk->head.htype == BM_EDGE);
BM_edge_select_set(em->bm, e_step, true);
BM_elem_flag_disable(e_step->v1, BM_ELEM_TAG);
BM_elem_flag_disable(e_step->v2, BM_ELEM_TAG);
}
}
}
}
}
else {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
BMEdge *e_walk;
BMW_ITER (e_walk, &walker, v) {
BM_edge_select_set(em->bm, e_walk, true);
BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
}
}
}
}
BMW_end(&walker);
EDBM_selectmode_flush(em);
}
else if (em->selectmode & SCE_SELECT_EDGE) {
BMEdge *e;
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (!BMO_edge_flag_test(bm, e, BMO_ELE_TAG)) {
BM_elem_flag_disable(e->v1, BM_ELEM_TAG);
BM_elem_flag_disable(e->v2, BM_ELEM_TAG);
if (delimit) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_set(
e, BM_ELEM_TAG,
(BM_elem_flag_test(e, BM_ELEM_SELECT) && BMO_edge_flag_test(bm, e, BMO_ELE_TAG)));
}
}
else {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_set(e, BM_ELEM_TAG, BM_elem_flag_test(e, BM_ELEM_SELECT));
}
}
}
BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, BMW_MASK_NOP,
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, BMW_MASK_NOP,
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
if (delimit) {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
BMElem *ele_walk;
BMW_ITER (ele_walk, &walker, v) {
if (ele_walk->head.htype == BM_LOOP) {
BMVert *v_step = ((BMLoop *)ele_walk)->v;
BM_vert_select_set(em->bm, v_step, true);
BM_elem_flag_disable(v_step, BM_ELEM_TAG);
}
else {
BMEdge *e_step = (BMEdge *)ele_walk;
BLI_assert(ele_walk->head.htype == BM_EDGE);
BM_edge_select_set(em->bm, e_step, true);
BM_elem_flag_disable(e_step->v1, BM_ELEM_TAG);
BM_elem_flag_disable(e_step->v2, BM_ELEM_TAG);
if (delimit) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BMElem *ele_walk;
BMW_ITER (ele_walk, &walker, e) {
if (ele_walk->head.htype == BM_LOOP) {
BMLoop *l_step = (BMLoop *)ele_walk;
BM_edge_select_set(em->bm, l_step->e, true);
BM_edge_select_set(em->bm, l_step->prev->e, true);
BM_elem_flag_disable(l_step->e, BM_ELEM_TAG);
}
else {
BMEdge *e_step = (BMEdge *)ele_walk;
BLI_assert(ele_walk->head.htype == BM_EDGE);
BM_edge_select_set(em->bm, e_step, true);
BM_elem_flag_disable(e_step, BM_ELEM_TAG);
}
}
}
}
}
else {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BMEdge *e_walk;
BMW_ITER (e_walk, &walker, e) {
BM_edge_select_set(em->bm, e_walk, true);
BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
}
}
}
}
BMW_end(&walker);
EDBM_selectmode_flush(em);
}
else {
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
BMEdge *e_walk;
BMW_ITER (e_walk, &walker, v) {
BM_edge_select_set(em->bm, e_walk, true);
BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
BMFace *f;
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_set(f, BM_ELEM_TAG, BM_elem_flag_test(f, BM_ELEM_SELECT));
}
BMW_init(&walker, bm, BMW_ISLAND,
BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, BMW_MASK_NOP,
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
BMFace *f_walk;
BMW_ITER (f_walk, &walker, f) {
BM_face_select_set(bm, f_walk, true);
BM_elem_flag_disable(f_walk, BM_ELEM_TAG);
}
}
}
BMW_end(&walker);
}
BMW_end(&walker);
EDBM_selectmode_flush(em);
}
else if (em->selectmode & SCE_SELECT_EDGE) {
BMEdge *e;
if (delimit) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_set(
e, BM_ELEM_TAG,
(BM_elem_flag_test(e, BM_ELEM_SELECT) && BMO_edge_flag_test(bm, e, BMO_ELE_TAG)));
}
}
else {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
BM_elem_flag_set(e, BM_ELEM_TAG, BM_elem_flag_test(e, BM_ELEM_SELECT));
}
select_linked_delimit_end(em);
}
BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE : BMW_VERT_SHELL,
BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, BMW_MASK_NOP,
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
if (delimit) {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BMElem *ele_walk;
BMW_ITER (ele_walk, &walker, e) {
if (ele_walk->head.htype == BM_LOOP) {
BMLoop *l_step = (BMLoop *)ele_walk;
BM_edge_select_set(em->bm, l_step->e, true);
BM_edge_select_set(em->bm, l_step->prev->e, true);
BM_elem_flag_disable(l_step->e, BM_ELEM_TAG);
}
else {
BMEdge *e_step = (BMEdge *)ele_walk;
BLI_assert(ele_walk->head.htype == BM_EDGE);
BM_edge_select_set(em->bm, e_step, true);
BM_elem_flag_disable(e_step, BM_ELEM_TAG);
}
}
}
}
}
else {
BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BMEdge *e_walk;
BMW_ITER (e_walk, &walker, e) {
BM_edge_select_set(em->bm, e_walk, true);
BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
}
}
}
}
BMW_end(&walker);
EDBM_selectmode_flush(em);
}
else {
BMFace *f;
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_set(f, BM_ELEM_TAG, BM_elem_flag_test(f, BM_ELEM_SELECT));
}
BMW_init(&walker, bm, BMW_ISLAND,
BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, BMW_MASK_NOP,
BMW_FLAG_TEST_HIDDEN,
BMW_NIL_LAY);
BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
BMFace *f_walk;
BMW_ITER (f_walk, &walker, f) {
BM_face_select_set(bm, f_walk, true);
BM_elem_flag_disable(f_walk, BM_ELEM_TAG);
}
}
}
BMW_end(&walker);
}
if (delimit) {
select_linked_delimit_end(em);
}
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
} /* objects */
MEM_SAFE_FREE(objects);

328
source/blender/editors/mesh/editmesh_tools.c
View File

@ -99,30 +99,30 @@ static int edbm_subdivide_exec(bContext *C, wmOperator *op)
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int cuts = RNA_int_get(op->ptr, "number_cuts");
float smooth = RNA_float_get(op->ptr, "smoothness");
const float fractal = RNA_float_get(op->ptr, "fractal") / 2.5f;
const float along_normal = RNA_float_get(op->ptr, "fractal_along_normal");
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int cuts = RNA_int_get(op->ptr, "number_cuts");
float smooth = RNA_float_get(op->ptr, "smoothness");
const float fractal = RNA_float_get(op->ptr, "fractal") / 2.5f;
const float along_normal = RNA_float_get(op->ptr, "fractal_along_normal");
if (RNA_boolean_get(op->ptr, "quadtri") &&
RNA_enum_get(op->ptr, "quadcorner") == SUBD_CORNER_STRAIGHT_CUT)
{
RNA_enum_set(op->ptr, "quadcorner", SUBD_CORNER_INNERVERT);
}
if (RNA_boolean_get(op->ptr, "quadtri") &&
RNA_enum_get(op->ptr, "quadcorner") == SUBD_CORNER_STRAIGHT_CUT)
{
RNA_enum_set(op->ptr, "quadcorner", SUBD_CORNER_INNERVERT);
}
BM_mesh_esubdivide(
em->bm, BM_ELEM_SELECT,
smooth, SUBD_FALLOFF_LIN, false,
fractal, along_normal,
cuts,
SUBDIV_SELECT_ORIG, RNA_enum_get(op->ptr, "quadcorner"),
RNA_boolean_get(op->ptr, "quadtri"), true, false,
RNA_int_get(op->ptr, "seed"));
BM_mesh_esubdivide(
em->bm, BM_ELEM_SELECT,
smooth, SUBD_FALLOFF_LIN, false,
fractal, along_normal,
cuts,
SUBDIV_SELECT_ORIG, RNA_enum_get(op->ptr, "quadcorner"),
RNA_boolean_get(op->ptr, "quadtri"), true, false,
RNA_int_get(op->ptr, "seed"));
EDBM_update_generic(em, true, true);
EDBM_update_generic(em, true, true);
}
MEM_SAFE_FREE(objects);
@ -392,44 +392,44 @@ static int edbm_delete_exec(bContext *C, wmOperator *op)
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int type = RNA_enum_get(op->ptr, "type");
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int type = RNA_enum_get(op->ptr, "type");
switch (type) {
case MESH_DELETE_VERT:
if (!EDBM_op_callf(em, op, "delete geom=%hv context=%i", BM_ELEM_SELECT, DEL_VERTS)) /* Erase Vertices */
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_EDGE:
if (!EDBM_op_callf(em, op, "delete geom=%he context=%i", BM_ELEM_SELECT, DEL_EDGES)) /* Erase Edges */
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_FACE:
if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES)) /* Erase Faces */
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_EDGE_FACE:
/* Edges and Faces */
if (!EDBM_op_callf(em, op, "delete geom=%hef context=%i", BM_ELEM_SELECT, DEL_EDGESFACES))
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_ONLY_FACE:
/* Only faces. */
if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_ONLYFACES))
return OPERATOR_CANCELLED;
break;
default:
BLI_assert(0);
break;
}
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
EDBM_update_generic(em, true, true);
switch (type) {
case MESH_DELETE_VERT:
if (!EDBM_op_callf(em, op, "delete geom=%hv context=%i", BM_ELEM_SELECT, DEL_VERTS)) /* Erase Vertices */
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_EDGE:
if (!EDBM_op_callf(em, op, "delete geom=%he context=%i", BM_ELEM_SELECT, DEL_EDGES)) /* Erase Edges */
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_FACE:
if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_FACES)) /* Erase Faces */
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_EDGE_FACE:
/* Edges and Faces */
if (!EDBM_op_callf(em, op, "delete geom=%hef context=%i", BM_ELEM_SELECT, DEL_EDGESFACES))
return OPERATOR_CANCELLED;
break;
case MESH_DELETE_ONLY_FACE:
/* Only faces. */
if (!EDBM_op_callf(em, op, "delete geom=%hf context=%i", BM_ELEM_SELECT, DEL_ONLYFACES))
return OPERATOR_CANCELLED;
break;
default:
BLI_assert(0);
break;
}
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
EDBM_update_generic(em, true, true);
} /* objects */
return OPERATOR_FINISHED;
}
@ -499,53 +499,53 @@ static int edbm_delete_loose_exec(bContext *C, wmOperator *op)
const bool use_faces = (RNA_boolean_get(op->ptr, "use_faces") && totelem_old_sel[2]);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
BMIter iter;
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
BMIter iter;
BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_TAG, false);
BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_TAG, false);
if (use_faces) {
BMFace *f;
if (use_faces) {
BMFace *f;
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
BM_elem_flag_set(f, BM_ELEM_TAG, bm_face_is_loose(f));
BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
BM_elem_flag_set(f, BM_ELEM_TAG, bm_face_is_loose(f));
}
}
BM_mesh_delete_hflag_context(bm, BM_ELEM_TAG, DEL_FACES);
}
BM_mesh_delete_hflag_context(bm, BM_ELEM_TAG, DEL_FACES);
}
if (use_edges) {
BMEdge *e;
if (use_edges) {
BMEdge *e;
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
BM_elem_flag_set(e, BM_ELEM_TAG, BM_edge_is_wire(e));
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
BM_elem_flag_set(e, BM_ELEM_TAG, BM_edge_is_wire(e));
}
}
BM_mesh_delete_hflag_context(bm, BM_ELEM_TAG, DEL_EDGES);
}
BM_mesh_delete_hflag_context(bm, BM_ELEM_TAG, DEL_EDGES);
}
if (use_verts) {
BMVert *v;
if (use_verts) {
BMVert *v;
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
BM_elem_flag_set(v, BM_ELEM_TAG, (v->e == NULL));
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
BM_elem_flag_set(v, BM_ELEM_TAG, (v->e == NULL));
}
}
BM_mesh_delete_hflag_context(bm, BM_ELEM_TAG, DEL_VERTS);
}
BM_mesh_delete_hflag_context(bm, BM_ELEM_TAG, DEL_VERTS);
}
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
EDBM_flag_disable_all(em, BM_ELEM_SELECT);
EDBM_update_generic(em, true, true);
EDBM_update_generic(em, true, true);
}
int totelem_new[3];
@ -4136,34 +4136,34 @@ static int edbm_quads_convert_to_tris_exec(bContext *C, wmOperator *op)
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMOperator bmop;
BMOIter oiter;
BMFace *f;
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMOperator bmop;
BMOIter oiter;
BMFace *f;
EDBM_op_init(em, &bmop, op, "triangulate faces=%hf quad_method=%i ngon_method=%i", BM_ELEM_SELECT, quad_method, ngon_method);
BMO_op_exec(em->bm, &bmop);
EDBM_op_init(em, &bmop, op, "triangulate faces=%hf quad_method=%i ngon_method=%i", BM_ELEM_SELECT, quad_method, ngon_method);
BMO_op_exec(em->bm, &bmop);
/* select the output */
BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
/* select the output */
BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
/* remove the doubles */
BMO_ITER (f, &oiter, bmop.slots_out, "face_map_double.out", BM_FACE) {
BM_face_kill(em->bm, f);
}
/* remove the doubles */
BMO_ITER (f, &oiter, bmop.slots_out, "face_map_double.out", BM_FACE) {
BM_face_kill(em->bm, f);
}
EDBM_selectmode_flush(em);
EDBM_selectmode_flush(em);
// XXX, TODO
#if 0
if (!EDBM_op_finish(em, &bmop, op, true)) {
return OPERATOR_CANCELLED;
}
#endif
// XXX, TODO
#if 0
if (!EDBM_op_finish(em, &bmop, op, true)) {
return OPERATOR_CANCELLED;
}
#endif
EDBM_update_generic(em, true, true);
EDBM_update_generic(em, true, true);
}
return OPERATOR_FINISHED;
@ -4212,53 +4212,53 @@ static int edbm_tris_convert_to_quads_exec(bContext *C, wmOperator *op)
}
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
bool do_seam, do_sharp, do_uvs, do_vcols, do_materials;
float angle_face_threshold, angle_shape_threshold;
PropertyRNA *prop;
BMEditMesh *em = BKE_editmesh_from_object(obedit);
bool do_seam, do_sharp, do_uvs, do_vcols, do_materials;
float angle_face_threshold, angle_shape_threshold;
PropertyRNA *prop;
/* When joining exactly 2 faces, no limit.
* this is useful for one off joins while editing. */
prop = RNA_struct_find_property(op->ptr, "face_threshold");
if (is_face_pair &&
(RNA_property_is_set(op->ptr, prop) == false))
{
angle_face_threshold = DEG2RADF(180.0f);
}
else {
angle_face_threshold = RNA_property_float_get(op->ptr, prop);
}
/* When joining exactly 2 faces, no limit.
* this is useful for one off joins while editing. */
prop = RNA_struct_find_property(op->ptr, "face_threshold");
if (is_face_pair &&
(RNA_property_is_set(op->ptr, prop) == false))
{
angle_face_threshold = DEG2RADF(180.0f);
}
else {
angle_face_threshold = RNA_property_float_get(op->ptr, prop);
}
prop = RNA_struct_find_property(op->ptr, "shape_threshold");
if (is_face_pair &&
(RNA_property_is_set(op->ptr, prop) == false))
{
angle_shape_threshold = DEG2RADF(180.0f);
}
else {
angle_shape_threshold = RNA_property_float_get(op->ptr, prop);
}
prop = RNA_struct_find_property(op->ptr, "shape_threshold");
if (is_face_pair &&
(RNA_property_is_set(op->ptr, prop) == false))
{
angle_shape_threshold = DEG2RADF(180.0f);
}
else {
angle_shape_threshold = RNA_property_float_get(op->ptr, prop);
}
do_seam = RNA_boolean_get(op->ptr, "seam");
do_sharp = RNA_boolean_get(op->ptr, "sharp");
do_uvs = RNA_boolean_get(op->ptr, "uvs");
do_vcols = RNA_boolean_get(op->ptr, "vcols");
do_materials = RNA_boolean_get(op->ptr, "materials");
do_seam = RNA_boolean_get(op->ptr, "seam");
do_sharp = RNA_boolean_get(op->ptr, "sharp");
do_uvs = RNA_boolean_get(op->ptr, "uvs");
do_vcols = RNA_boolean_get(op->ptr, "vcols");
do_materials = RNA_boolean_get(op->ptr, "materials");
if (!EDBM_op_call_and_selectf(
em, op,
"faces.out", true,
"join_triangles faces=%hf angle_face_threshold=%f angle_shape_threshold=%f "
"cmp_seam=%b cmp_sharp=%b cmp_uvs=%b cmp_vcols=%b cmp_materials=%b",
BM_ELEM_SELECT, angle_face_threshold, angle_shape_threshold,
do_seam, do_sharp, do_uvs, do_vcols, do_materials))
{
continue;
}
if (!EDBM_op_call_and_selectf(
em, op,
"faces.out", true,
"join_triangles faces=%hf angle_face_threshold=%f angle_shape_threshold=%f "
"cmp_seam=%b cmp_sharp=%b cmp_uvs=%b cmp_vcols=%b cmp_materials=%b",
BM_ELEM_SELECT, angle_face_threshold, angle_shape_threshold,
do_seam, do_sharp, do_uvs, do_vcols, do_materials))
{
continue;
}
EDBM_update_generic(em, true, true);
EDBM_update_generic(em, true, true);
}
return OPERATOR_FINISHED;
@ -4805,26 +4805,26 @@ static int edbm_dissolve_degenerate_exec(bContext *C, wmOperator *op)
const float thresh = RNA_float_get(op->ptr, "threshold");
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
if (!EDBM_op_callf(
em, op,
"dissolve_degenerate edges=%he dist=%f",
BM_ELEM_SELECT, thresh))
{
return OPERATOR_CANCELLED;
}
if (!EDBM_op_callf(
em, op,
"dissolve_degenerate edges=%he dist=%f",
BM_ELEM_SELECT, thresh))
{
return OPERATOR_CANCELLED;
}
/* tricky to maintain correct selection here, so just flush up from verts */
EDBM_select_flush(em);
/* tricky to maintain correct selection here, so just flush up from verts */
EDBM_select_flush(em);
EDBM_update_generic(em, true, true);
EDBM_update_generic(em, true, true);
totelem_new[0] += bm->totvert;
totelem_new[1] += bm->totedge;
totelem_new[2] += bm->totface;
totelem_new[0] += bm->totvert;
totelem_new[1] += bm->totedge;
totelem_new[2] += bm->totface;
}
edbm_report_delete_info(op->reports, totelem_old, totelem_new);

114
source/blender/editors/screen/screen_context.c
View File

@ -213,42 +213,42 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
uint objects_len;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint i = 0; i < objects_len; i++) {
Object *ob = objects[i];
arm = ob->data;
Object *ob = objects[i];
arm = ob->data;
/* Attention: X-Axis Mirroring is also handled here... */
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
/* first and foremost, bone must be visible and selected */
if (EBONE_VISIBLE(arm, ebone)) {
/* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
* so that most users of this data don't need to explicitly check for it themselves.
*
* We need to make sure that these mirrored copies are not selected, otherwise some
* bones will be operated on twice.
*/
if (arm->flag & ARM_MIRROR_EDIT)
flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
/* if we're filtering for editable too, use the check for that instead, as it has selection check too */
if (editable_bones) {
/* only selected + editable */
if (EBONE_EDITABLE(ebone)) {
/* Attention: X-Axis Mirroring is also handled here... */
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
/* first and foremost, bone must be visible and selected */
if (EBONE_VISIBLE(arm, ebone)) {
/* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
* so that most users of this data don't need to explicitly check for it themselves.
*
* We need to make sure that these mirrored copies are not selected, otherwise some
* bones will be operated on twice.
*/
if (arm->flag & ARM_MIRROR_EDIT)
flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
/* if we're filtering for editable too, use the check for that instead, as it has selection check too */
if (editable_bones) {
/* only selected + editable */
if (EBONE_EDITABLE(ebone)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED))
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
else {
/* only include bones if visible */
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED))
if ((flipbone) && EBONE_VISIBLE(arm, flipbone) == 0)
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
else {
/* only include bones if visible */
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && EBONE_VISIBLE(arm, flipbone) == 0)
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
}
}
MEM_freeN(objects);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
@ -264,42 +264,42 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
uint objects_len;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint i = 0; i < objects_len; i++) {
Object *ob = objects[i];
arm = ob->data;
Object *ob = objects[i];
arm = ob->data;
/* Attention: X-Axis Mirroring is also handled here... */
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
/* first and foremost, bone must be visible and selected */
if (EBONE_VISIBLE(arm, ebone) && (ebone->flag & BONE_SELECTED)) {
/* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
* so that most users of this data don't need to explicitly check for it themselves.
*
* We need to make sure that these mirrored copies are not selected, otherwise some
* bones will be operated on twice.
*/
if (arm->flag & ARM_MIRROR_EDIT)
flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
/* if we're filtering for editable too, use the check for that instead, as it has selection check too */
if (selected_editable_bones) {
/* only selected + editable */
if (EBONE_EDITABLE(ebone)) {
/* Attention: X-Axis Mirroring is also handled here... */
for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
/* first and foremost, bone must be visible and selected */
if (EBONE_VISIBLE(arm, ebone) && (ebone->flag & BONE_SELECTED)) {
/* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
* so that most users of this data don't need to explicitly check for it themselves.
*
* We need to make sure that these mirrored copies are not selected, otherwise some
* bones will be operated on twice.
*/
if (arm->flag & ARM_MIRROR_EDIT)
flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
/* if we're filtering for editable too, use the check for that instead, as it has selection check too */
if (selected_editable_bones) {
/* only selected + editable */
if (EBONE_EDITABLE(ebone)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED))
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
else {
/* only include bones if selected */
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED))
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
else {
/* only include bones if selected */
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED))
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
}
}
MEM_freeN(objects);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);

164
source/blender/editors/space_view3d/view3d_select.c
View File

@ -860,31 +860,31 @@ static void view3d_lasso_select(
else { /* Edit Mode */
FOREACH_OBJECT_IN_MODE_BEGIN (eval_ctx.view_layer, ob->mode, ob_iter) {
ED_view3d_viewcontext_init_object(vc, ob_iter);
ED_view3d_viewcontext_init_object(vc, ob_iter);
switch (vc->obedit->type) {
case OB_MESH:
do_lasso_select_mesh(&eval_ctx, vc, mcords, moves, extend, select);
break;
case OB_CURVE:
case OB_SURF:
do_lasso_select_curve(vc, mcords, moves, extend, select);
break;
case OB_LATTICE:
do_lasso_select_lattice(vc, mcords, moves, extend, select);
break;
case OB_ARMATURE:
do_lasso_select_armature(vc, mcords, moves, extend, select);
break;
case OB_MBALL:
do_lasso_select_meta(vc, mcords, moves, extend, select);
break;
default:
assert(!"lasso select on incorrect object type");
break;
}
switch (vc->obedit->type) {
case OB_MESH:
do_lasso_select_mesh(&eval_ctx, vc, mcords, moves, extend, select);
break;
case OB_CURVE:
case OB_SURF:
do_lasso_select_curve(vc, mcords, moves, extend, select);
break;
case OB_LATTICE:
do_lasso_select_lattice(vc, mcords, moves, extend, select);
break;
case OB_ARMATURE:
do_lasso_select_armature(vc, mcords, moves, extend, select);
break;
case OB_MBALL:
do_lasso_select_meta(vc, mcords, moves, extend, select);
break;
default:
assert(!"lasso select on incorrect object type");
break;
}
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc->obedit->data);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc->obedit->data);
}
FOREACH_OBJECT_IN_MODE_END;
}
@ -2209,45 +2209,45 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
if (vc.obedit) {
FOREACH_OBJECT_IN_MODE_BEGIN (eval_ctx.view_layer, vc.obedit->mode, ob_iter) {
ED_view3d_viewcontext_init_object(&vc, ob_iter);
ED_view3d_viewcontext_init_object(&vc, ob_iter);
switch (vc.obedit->type) {
case OB_MESH:
vc.em = BKE_editmesh_from_object(vc.obedit);
ret |= do_mesh_box_select(&eval_ctx, &vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
case OB_CURVE:
case OB_SURF:
ret |= do_nurbs_box_select(&vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
case OB_MBALL:
ret |= do_meta_box_select(&eval_ctx, &vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
case OB_ARMATURE:
ret |= do_armature_box_select(&eval_ctx, &vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, vc.obedit);
}
break;
case OB_LATTICE:
ret |= do_lattice_box_select(&vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
default:
assert(!"border select on incorrect object type");
break;
}
switch (vc.obedit->type) {
case OB_MESH:
vc.em = BKE_editmesh_from_object(vc.obedit);
ret |= do_mesh_box_select(&eval_ctx, &vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
case OB_CURVE:
case OB_SURF:
ret |= do_nurbs_box_select(&vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
case OB_MBALL:
ret |= do_meta_box_select(&eval_ctx, &vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
case OB_ARMATURE:
ret |= do_armature_box_select(&eval_ctx, &vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, vc.obedit);
}
break;
case OB_LATTICE:
ret |= do_lattice_box_select(&vc, &rect, select, extend);
if (ret & OPERATOR_FINISHED) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit->data);
}
break;
default:
assert(!"border select on incorrect object type");
break;
}
}
FOREACH_OBJECT_IN_MODE_END;
}
@ -2936,29 +2936,29 @@ static int view3d_circle_select_exec(bContext *C, wmOperator *op)
view3d_operator_needs_opengl(C);
FOREACH_OBJECT_IN_MODE_BEGIN (eval_ctx.view_layer, obact->mode, ob_iter) {
ED_view3d_viewcontext_init_object(&vc, ob_iter);
ED_view3d_viewcontext_init_object(&vc, ob_iter);
obact = vc.obact;
obedit = vc.obedit;
obact = vc.obact;
obedit = vc.obedit;
if (CTX_data_edit_object(C)) {
obedit_circle_select(&eval_ctx, &vc, select, mval, (float)radius);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obact->data);
}
else if (BKE_paint_select_face_test(obact)) {
paint_facesel_circle_select(&eval_ctx, &vc, select, mval, (float)radius);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obact->data);
}
else if (BKE_paint_select_vert_test(obact)) {
paint_vertsel_circle_select(&eval_ctx, &vc, select, mval, (float)radius);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obact->data);
}
else if (obact->mode & OB_MODE_POSE) {
pose_circle_select(&vc, select, mval, (float)radius);
}
else {
return PE_circle_select(C, select, mval, (float)radius);
}
if (CTX_data_edit_object(C)) {
obedit_circle_select(&eval_ctx, &vc, select, mval, (float)radius);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obact->data);
}
else if (BKE_paint_select_face_test(obact)) {
paint_facesel_circle_select(&eval_ctx, &vc, select, mval, (float)radius);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obact->data);
}
else if (BKE_paint_select_vert_test(obact)) {
paint_vertsel_circle_select(&eval_ctx, &vc, select, mval, (float)radius);
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obact->data);
}
else if (obact->mode & OB_MODE_POSE) {
pose_circle_select(&vc, select, mval, (float)radius);
}
else {
return PE_circle_select(C, select, mval, (float)radius);
}
}
FOREACH_OBJECT_IN_MODE_END;
}

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

File diff suppressed because it is too large Load Diff

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

@ -848,55 +848,55 @@ static void drawObjectConstraint(TransInfo *t)
float tmp_axismtx[3][3];
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
float co[3];
float (*axismtx)[3];
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
float co[3];
float (*axismtx)[3];
if (t->flag & T_PROP_EDIT) {
/* we're sorted, so skip the rest */
if (td->factor == 0.0f) {
break;
if (t->flag & T_PROP_EDIT) {
/* we're sorted, so skip the rest */
if (td->factor == 0.0f) {
break;
}
}
}
if (t->options & CTX_GPENCIL_STROKES) {
/* only draw a constraint line for one point, otherwise we can't see anything */
if ((options & DRAWLIGHT) == 0) {
break;
if (t->options & CTX_GPENCIL_STROKES) {
/* only draw a constraint line for one point, otherwise we can't see anything */
if ((options & DRAWLIGHT) == 0) {
break;
}
}
}
if (t->flag & T_OBJECT) {
copy_v3_v3(co, td->ob->obmat[3]);
axismtx = td->axismtx;
}
else if (t->flag & T_EDIT) {
mul_v3_m4v3(co, tc->obedit->obmat, td->center);
if (t->flag & T_OBJECT) {
copy_v3_v3(co, td->ob->obmat[3]);
axismtx = td->axismtx;
}
else if (t->flag & T_EDIT) {
mul_v3_m4v3(co, tc->obedit->obmat, td->center);
mul_m3_m3m3(tmp_axismtx, tc->obedit_mat, td->axismtx);
axismtx = tmp_axismtx;
}
else if (t->flag & T_POSE) {
mul_v3_m4v3(co, tc->poseobj->obmat, td->center);
axismtx = td->axismtx;
}
else {
copy_v3_v3(co, td->center);
axismtx = td->axismtx;
}
mul_m3_m3m3(tmp_axismtx, tc->obedit_mat, td->axismtx);
axismtx = tmp_axismtx;
}
else if (t->flag & T_POSE) {
mul_v3_m4v3(co, tc->poseobj->obmat, td->center);
axismtx = td->axismtx;
}
else {
copy_v3_v3(co, td->center);
axismtx = td->axismtx;
}
if (t->con.mode & CON_AXIS0) {
drawLine(t, co, axismtx[0], 'X', options);
if (t->con.mode & CON_AXIS0) {
drawLine(t, co, axismtx[0], 'X', options);
}
if (t->con.mode & CON_AXIS1) {
drawLine(t, co, axismtx[1], 'Y', options);
}
if (t->con.mode & CON_AXIS2) {
drawLine(t, co, axismtx[2], 'Z', options);
}
options &= ~DRAWLIGHT;
}
if (t->con.mode & CON_AXIS1) {
drawLine(t, co, axismtx[1], 'Y', options);
}
if (t->con.mode & CON_AXIS2) {
drawLine(t, co, axismtx[2], 'Z', options);
}
options &= ~DRAWLIGHT;
}
}
}

2746
source/blender/editors/transform/transform_conversions.c
View File

File diff suppressed because it is too large Load Diff

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

@ -131,130 +131,130 @@ void getViewVector(TransInfo *t, float coord[3], float vec[3])
static void clipMirrorModifier(TransInfo *t)
{
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
Object *ob = tc->obedit;
ModifierData *md = ob->modifiers.first;
float tolerance[3] = {0.0f, 0.0f, 0.0f};
int axis = 0;
for (; md; md = md->next) {
if ((md->type == eModifierType_Mirror) && (md->mode & eModifierMode_Realtime)) {
MirrorModifierData *mmd = (MirrorModifierData *) md;
if (mmd->flag & MOD_MIR_CLIPPING) {
axis = 0;
if (mmd->flag & MOD_MIR_AXIS_X) {
axis |= 1;
tolerance[0] = mmd->tolerance;
}
if (mmd->flag & MOD_MIR_AXIS_Y) {
axis |= 2;
tolerance[1] = mmd->tolerance;
}
if (mmd->flag & MOD_MIR_AXIS_Z) {
axis |= 4;
tolerance[2] = mmd->tolerance;
}
if (axis) {
float mtx[4][4], imtx[4][4];
int i;
if (mmd->mirror_ob) {
float obinv[4][4];
invert_m4_m4(obinv, mmd->mirror_ob->obmat);
mul_m4_m4m4(mtx, obinv, ob->obmat);
invert_m4_m4(imtx, mtx);
Object *ob = tc->obedit;
ModifierData *md = ob->modifiers.first;
float tolerance[3] = {0.0f, 0.0f, 0.0f};
int axis = 0;
for (; md; md = md->next) {
if ((md->type == eModifierType_Mirror) && (md->mode & eModifierMode_Realtime)) {
MirrorModifierData *mmd = (MirrorModifierData *) md;
if (mmd->flag & MOD_MIR_CLIPPING) {
axis = 0;
if (mmd->flag & MOD_MIR_AXIS_X) {
axis |= 1;
tolerance[0] = mmd->tolerance;
}
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
int clip;
float loc[3], iloc[3];
if (td->flag & TD_NOACTION)
break;
if (td->loc == NULL)
break;
if (td->flag & TD_SKIP)
continue;
copy_v3_v3(loc, td->loc);
copy_v3_v3(iloc, td->iloc);
if (mmd->flag & MOD_MIR_AXIS_Y) {
axis |= 2;
tolerance[1] = mmd->tolerance;
}
if (mmd->flag & MOD_MIR_AXIS_Z) {
axis |= 4;
tolerance[2] = mmd->tolerance;
}
if (axis) {
float mtx[4][4], imtx[4][4];
int i;
if (mmd->mirror_ob) {
mul_m4_v3(mtx, loc);
mul_m4_v3(mtx, iloc);
float obinv[4][4];
invert_m4_m4(obinv, mmd->mirror_ob->obmat);
mul_m4_m4m4(mtx, obinv, ob->obmat);
invert_m4_m4(imtx, mtx);
}
clip = 0;
if (axis & 1) {
if (fabsf(iloc[0]) <= tolerance[0] ||
loc[0] * iloc[0] < 0.0f)
{
loc[0] = 0.0f;
clip = 1;
}
}
if (axis & 2) {
if (fabsf(iloc[1]) <= tolerance[1] ||
loc[1] * iloc[1] < 0.0f)
{
loc[1] = 0.0f;
clip = 1;
}
}
if (axis & 4) {
if (fabsf(iloc[2]) <= tolerance[2] ||
loc[2] * iloc[2] < 0.0f)
{
loc[2] = 0.0f;
clip = 1;
}
}
if (clip) {
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
int clip;
float loc[3], iloc[3];
if (td->flag & TD_NOACTION)
break;
if (td->loc == NULL)
break;
if (td->flag & TD_SKIP)
continue;
copy_v3_v3(loc, td->loc);
copy_v3_v3(iloc, td->iloc);
if (mmd->mirror_ob) {
mul_m4_v3(imtx, loc);
mul_m4_v3(mtx, loc);
mul_m4_v3(mtx, iloc);
}
clip = 0;
if (axis & 1) {
if (fabsf(iloc[0]) <= tolerance[0] ||
loc[0] * iloc[0] < 0.0f)
{
loc[0] = 0.0f;
clip = 1;
}
}
if (axis & 2) {
if (fabsf(iloc[1]) <= tolerance[1] ||
loc[1] * iloc[1] < 0.0f)
{
loc[1] = 0.0f;
clip = 1;
}
}
if (axis & 4) {
if (fabsf(iloc[2]) <= tolerance[2] ||
loc[2] * iloc[2] < 0.0f)
{
loc[2] = 0.0f;
clip = 1;
}
}
if (clip) {
if (mmd->mirror_ob) {
mul_m4_v3(imtx, loc);
}
copy_v3_v3(td->loc, loc);
}
copy_v3_v3(td->loc, loc);
}
}
}
}
}
}
}
}
/* assumes obedit set to mesh object */
static void editbmesh_apply_to_mirror(TransInfo *t)
{
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
TransData *td = tc->data;
BMVert *eve;
int i;
TransData *td = tc->data;
BMVert *eve;
int i;
for (i = 0; i < tc->data_len; i++, td++) {
if (td->flag & TD_NOACTION)
break;
if (td->loc == NULL)
break;
if (td->flag & TD_SKIP)
continue;
eve = td->extra;
if (eve) {
eve->co[0] = -td->loc[0];
eve->co[1] = td->loc[1];
eve->co[2] = td->loc[2];
for (i = 0; i < tc->data_len; i++, td++) {
if (td->flag & TD_NOACTION)
break;
if (td->loc == NULL)
break;
if (td->flag & TD_SKIP)
continue;
eve = td->extra;
if (eve) {
eve->co[0] = -td->loc[0];
eve->co[1] = td->loc[1];
eve->co[2] = td->loc[2];
}
if (td->flag & TD_MIRROR_EDGE) {
td->loc[0] = 0;
}
}
if (td->flag & TD_MIRROR_EDGE) {
td->loc[0] = 0;
}
}
}
}
@ -737,27 +737,27 @@ static void recalcData_objects(TransInfo *t)
}
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
Curve *cu = tc->obedit->data;
ListBase *nurbs = BKE_curve_editNurbs_get(cu);
Nurb *nu = nurbs->first;
Curve *cu = tc->obedit->data;
ListBase *nurbs = BKE_curve_editNurbs_get(cu);
Nurb *nu = nurbs->first;
DEG_id_tag_update(tc->obedit->data, 0); /* sets recalc flags */
DEG_id_tag_update(tc->obedit->data, 0); /* sets recalc flags */
if (t->state == TRANS_CANCEL) {
while (nu) {
BKE_nurb_handles_calc(nu); /* Cant do testhandlesNurb here, it messes up the h1 and h2 flags */
nu = nu->next;
if (t->state == TRANS_CANCEL) {
while (nu) {
BKE_nurb_handles_calc(nu); /* Cant do testhandlesNurb here, it messes up the h1 and h2 flags */
nu = nu->next;
}
}
}
else {
/* Normal updating */
while (nu) {
BKE_nurb_test2D(nu);
BKE_nurb_handles_calc(nu);
nu = nu->next;
else {
/* Normal updating */
while (nu) {
BKE_nurb_test2D(nu);
BKE_nurb_handles_calc(nu);
nu = nu->next;
}
}
}
}
}
else if (t->obedit_type == OB_LATTICE) {
@ -766,11 +766,11 @@ static void recalcData_objects(TransInfo *t)
}
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
Lattice *la = tc->obedit->data;
DEG_id_tag_update(tc->obedit->data, 0); /* sets recalc flags */
if (la->editlatt->latt->flag & LT_OUTSIDE) {
outside_lattice(la->editlatt->latt);
}
Lattice *la = tc->obedit->data;
DEG_id_tag_update(tc->obedit->data, 0); /* sets recalc flags */
if (la->editlatt->latt->flag & LT_OUTSIDE) {
outside_lattice(la->editlatt->latt);
}
}
}
else if (t->obedit_type == OB_MESH) {
@ -791,10 +791,10 @@ static void recalcData_objects(TransInfo *t)
}
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
DEG_id_tag_update(tc->obedit->data, 0); /* sets recalc flags */
BMEditMesh *em = BKE_editmesh_from_object(tc->obedit);
EDBM_mesh_normals_update(em);
BKE_editmesh_tessface_calc(em);
DEG_id_tag_update(tc->obedit->data, 0); /* sets recalc flags */
BMEditMesh *em = BKE_editmesh_from_object(tc->obedit);
EDBM_mesh_normals_update(em);
BKE_editmesh_tessface_calc(em);
}
}
else if (t->obedit_type == OB_ARMATURE) { /* no recalc flag, does pose */
@ -804,92 +804,92 @@ static void recalcData_objects(TransInfo *t)
}
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
bArmature *arm = tc->obedit->data;
ListBase *edbo = arm->edbo;
EditBone *ebo, *ebo_parent;
TransData *td = tc->data;
int i;
bArmature *arm = tc->obedit->data;
ListBase *edbo = arm->edbo;
EditBone *ebo, *ebo_parent;
TransData *td = tc->data;
int i;
/* Ensure all bones are correctly adjusted */
for (ebo = edbo->first; ebo; ebo = ebo->next) {
ebo_parent = (ebo->flag & BONE_CONNECTED) ? ebo->parent : NULL;
if (ebo_parent) {
/* If this bone has a parent tip that has been moved */
if (ebo_parent->flag & BONE_TIPSEL) {
copy_v3_v3(ebo->head, ebo_parent->tail);
if (t->mode == TFM_BONE_ENVELOPE) ebo->rad_head = ebo_parent->rad_tail;
}
/* If this bone has a parent tip that has NOT been moved */
else {
copy_v3_v3(ebo_parent->tail, ebo->head);
if (t->mode == TFM_BONE_ENVELOPE) ebo_parent->rad_tail = ebo->rad_head;
}
}
/* on extrude bones, oldlength==0.0f, so we scale radius of points */
ebo->length = len_v3v3(ebo->head, ebo->tail);
if (ebo->oldlength == 0.0f) {
ebo->rad_head = 0.25f * ebo->length;
ebo->rad_tail = 0.10f * ebo->length;
ebo->dist = 0.25f * ebo->length;
if (ebo->parent) {
if (ebo->rad_head > ebo->parent->rad_tail)
ebo->rad_head = ebo->parent->rad_tail;
}
}
else if (t->mode != TFM_BONE_ENVELOPE) {
/* if bones change length, lets do that for the deform distance as well */
ebo->dist *= ebo->length / ebo->oldlength;
ebo->rad_head *= ebo->length / ebo->oldlength;
ebo->rad_tail *= ebo->length / ebo->oldlength;
ebo->oldlength = ebo->length;
/* Ensure all bones are correctly adjusted */
for (ebo = edbo->first; ebo; ebo = ebo->next) {
ebo_parent = (ebo->flag & BONE_CONNECTED) ? ebo->parent : NULL;
if (ebo_parent) {
ebo_parent->rad_tail = ebo->rad_head;
}
}
}
if (!ELEM(t->mode, TFM_BONE_ROLL, TFM_BONE_ENVELOPE, TFM_BONE_ENVELOPE_DIST, TFM_BONESIZE)) {
/* fix roll */
for (i = 0; i < tc->data_len; i++, td++) {
if (td->extra) {
float vec[3], up_axis[3];
float qrot[4];
float roll;
ebo = td->extra;
if (t->state == TRANS_CANCEL) {
/* restore roll */
ebo->roll = td->ival;
/* If this bone has a parent tip that has been moved */
if (ebo_parent->flag & BONE_TIPSEL) {
copy_v3_v3(ebo->head, ebo_parent->tail);
if (t->mode == TFM_BONE_ENVELOPE) ebo->rad_head = ebo_parent->rad_tail;
}
/* If this bone has a parent tip that has NOT been moved */
else {
copy_v3_v3(up_axis, td->axismtx[2]);
copy_v3_v3(ebo_parent->tail, ebo->head);
if (t->mode == TFM_BONE_ENVELOPE) ebo_parent->rad_tail = ebo->rad_head;
}
}
sub_v3_v3v3(vec, ebo->tail, ebo->head);
normalize_v3(vec);
rotation_between_vecs_to_quat(qrot, td->axismtx[1], vec);
mul_qt_v3(qrot, up_axis);
/* on extrude bones, oldlength==0.0f, so we scale radius of points */
ebo->length = len_v3v3(ebo->head, ebo->tail);
if (ebo->oldlength == 0.0f) {
ebo->rad_head = 0.25f * ebo->length;
ebo->rad_tail = 0.10f * ebo->length;
ebo->dist = 0.25f * ebo->length;
if (ebo->parent) {
if (ebo->rad_head > ebo->parent->rad_tail)
ebo->rad_head = ebo->parent->rad_tail;
}
}
else if (t->mode != TFM_BONE_ENVELOPE) {
/* if bones change length, lets do that for the deform distance as well */
ebo->dist *= ebo->length / ebo->oldlength;
ebo->rad_head *= ebo->length / ebo->oldlength;
ebo->rad_tail *= ebo->length / ebo->oldlength;
ebo->oldlength = ebo->length;
/* roll has a tendency to flip in certain orientations - [#34283], [#33974] */
roll = ED_armature_ebone_roll_to_vector(ebo, up_axis, false);
ebo->roll = angle_compat_rad(roll, td->ival);
if (ebo_parent) {
ebo_parent->rad_tail = ebo->rad_head;
}
}
}
}
if (arm->flag & ARM_MIRROR_EDIT) {
if (t->state != TRANS_CANCEL) {
ED_armature_edit_transform_mirror_update(tc->obedit);
if (!ELEM(t->mode, TFM_BONE_ROLL, TFM_BONE_ENVELOPE, TFM_BONE_ENVELOPE_DIST, TFM_BONESIZE)) {
/* fix roll */
for (i = 0; i < tc->data_len; i++, td++) {
if (td->extra) {
float vec[3], up_axis[3];
float qrot[4];
float roll;
ebo = td->extra;
if (t->state == TRANS_CANCEL) {
/* restore roll */
ebo->roll = td->ival;
}
else {
copy_v3_v3(up_axis, td->axismtx[2]);
sub_v3_v3v3(vec, ebo->tail, ebo->head);
normalize_v3(vec);
rotation_between_vecs_to_quat(qrot, td->axismtx[1], vec);
mul_qt_v3(qrot, up_axis);
/* roll has a tendency to flip in certain orientations - [#34283], [#33974] */
roll = ED_armature_ebone_roll_to_vector(ebo, up_axis, false);
ebo->roll = angle_compat_rad(roll, td->ival);
}
}
}
}
else {
restoreBones(tc);
if (arm->flag & ARM_MIRROR_EDIT) {
if (t->state != TRANS_CANCEL) {
ED_armature_edit_transform_mirror_update(tc->obedit);
}
else {
restoreBones(tc);
}
}
}
}
}
else {
if (t->state != TRANS_CANCEL) {
@ -905,31 +905,32 @@ static void recalcData_objects(TransInfo *t)
}
else if (t->flag & T_POSE) {
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
Object *ob = tc->poseobj;
bArmature *arm = ob->data;
/* if animtimer is running, and the object already has animation data,
* check if the auto-record feature means that we should record 'samples'
* (i.e. uneditable animation values)
*
* context is needed for keying set poll() functions.
*/
// TODO: autokeyframe calls need some setting to specify to add samples (FPoints) instead of keyframes?
if ((t->animtimer) && (t->context) && IS_AUTOKEY_ON(t->scene)) {
int targetless_ik = (t->flag & T_AUTOIK); // XXX this currently doesn't work, since flags aren't set yet!
animrecord_check_state(t->scene, &ob->id, t->animtimer);
autokeyframe_pose_cb_func(t->context, t->scene, (View3D *)t->view, ob, t->mode, targetless_ik);
}
/* old optimize trick... this enforces to bypass the depgraph */
if (!(arm->flag & ARM_DELAYDEFORM)) {
DEG_id_tag_update(&ob->id, OB_RECALC_DATA); /* sets recalc flags */
/* transformation of pose may affect IK tree, make sure it is rebuilt */
BIK_clear_data(ob->pose);
}
else
BKE_pose_where_is(&t->eval_ctx, t->scene, ob);
Object *ob = tc->poseobj;
bArmature *arm = ob->data;
/* if animtimer is running, and the object already has animation data,
* check if the auto-record feature means that we should record 'samples'
* (i.e. uneditable animation values)
*
* context is needed for keying set poll() functions.
*/
// TODO: autokeyframe calls need some setting to specify to add samples (FPoints) instead of keyframes?
if ((t->animtimer) && (t->context) && IS_AUTOKEY_ON(t->scene)) {
int targetless_ik = (t->flag & T_AUTOIK); // XXX this currently doesn't work, since flags aren't set yet!
animrecord_check_state(t->scene, &ob->id, t->animtimer);
autokeyframe_pose_cb_func(t->context, t->scene, (View3D *)t->view, ob, t->mode, targetless_ik);
}
/* old optimize trick... this enforces to bypass the depgraph */
if (!(arm->flag & ARM_DELAYDEFORM)) {
DEG_id_tag_update(&ob->id, OB_RECALC_DATA); /* sets recalc flags */
/* transformation of pose may affect IK tree, make sure it is rebuilt */
BIK_clear_data(ob->pose);
}
else {
BKE_pose_where_is(&t->eval_ctx, t->scene, ob);
}
}
}
else if (base && (base->object->mode & OB_MODE_PARTICLE_EDIT) &&
@ -948,35 +949,35 @@ static void recalcData_objects(TransInfo *t)
}
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
TransData *td = tc->data;
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
Object *ob = td->ob;
if (td->flag & TD_NOACTION)
break;
if (td->flag & TD_SKIP)
continue;
/* if animtimer is running, and the object already has animation data,
* check if the auto-record feature means that we should record 'samples'
* (i.e. uneditable animation values)
*/
// TODO: autokeyframe calls need some setting to specify to add samples (FPoints) instead of keyframes?
if ((t->animtimer) && IS_AUTOKEY_ON(t->scene)) {
animrecord_check_state(t->scene, &ob->id, t->animtimer);
autokeyframe_ob_cb_func(t->context, t->scene, t->view_layer, (View3D *)t->view, ob, t->mode);
for (i = 0; i < tc->data_len; i++, td++) {
Object *ob = td->ob;
if (td->flag & TD_NOACTION)
break;
if (td->flag & TD_SKIP)
continue;
/* if animtimer is running, and the object already has animation data,
* check if the auto-record feature means that we should record 'samples'
* (i.e. uneditable animation values)
*/
// TODO: autokeyframe calls need some setting to specify to add samples (FPoints) instead of keyframes?
if ((t->animtimer) && IS_AUTOKEY_ON(t->scene)) {
animrecord_check_state(t->scene, &ob->id, t->animtimer);
autokeyframe_ob_cb_func(t->context, t->scene, t->view_layer, (View3D *)t->view, ob, t->mode);
}
/* sets recalc flags fully, instead of flushing existing ones
* otherwise proxies don't function correctly
*/
DEG_id_tag_update(&ob->id, OB_RECALC_OB);
if (t->flag & T_TEXTURE)
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
}
/* sets recalc flags fully, instead of flushing existing ones
* otherwise proxies don't function correctly
*/
DEG_id_tag_update(&ob->id, OB_RECALC_OB);
if (t->flag & T_TEXTURE)
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
}
}
}
}
@ -1117,16 +1118,16 @@ void drawLine(TransInfo *t, const float center[3], const float dir[3], char axis
void resetTransModal(TransInfo *t)
{
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
if (t->mode == TFM_EDGE_SLIDE) {
freeEdgeSlideVerts(t, tc, &tc->custom.mode);
}
else if (t->mode == TFM_VERT_SLIDE) {
freeVertSlideVerts(t, tc, &tc->custom.mode);
}
else {
/* no need to keep looping... */
break;
}
if (t->mode == TFM_EDGE_SLIDE) {
freeEdgeSlideVerts(t, tc, &tc->custom.mode);
}
else if (t->mode == TFM_VERT_SLIDE) {
freeVertSlideVerts(t, tc, &tc->custom.mode);
}
else {
/* no need to keep looping... */
break;
}
}
}
@ -1696,25 +1697,25 @@ void restoreTransObjects(TransInfo *t)
{
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
TransData *td;
TransData2D *td2d;
TransData *td;
TransData2D *td2d;
for (td = tc->data; td < tc->data + tc->data_len; td++) {
restoreElement(td);
}
for (td2d = tc->data_2d; tc->data_2d && td2d < tc->data_2d + tc->data_len; td2d++) {
if (td2d->h1) {
td2d->h1[0] = td2d->ih1[0];
td2d->h1[1] = td2d->ih1[1];
for (td = tc->data; td < tc->data + tc->data_len; td++) {
restoreElement(td);
}
if (td2d->h2) {
td2d->h2[0] = td2d->ih2[0];
td2d->h2[1] = td2d->ih2[1];
}
}
unit_m3(t->mat);
for (td2d = tc->data_2d; tc->data_2d && td2d < tc->data_2d + tc->data_len; td2d++) {
if (td2d->h1) {
td2d->h1[0] = td2d->ih1[0];
td2d->h1[1] = td2d->ih1[1];
}
if (td2d->h2) {
td2d->h2[0] = td2d->ih2[0];
td2d->h2[1] = td2d->ih2[1];
}
}
unit_m3(t->mat);
}
@ -1831,24 +1832,24 @@ void calculateCenterMedian(TransInfo *t, float r_center[3])
int total = 0;
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
Object *ob_xform = tc->obedit ? tc->obedit : tc->poseobj;
int i;
for (i = 0; i < tc->data_len; i++) {
if (tc->data[i].flag & TD_SELECTED) {
if (!(tc->data[i].flag & TD_NOCENTER)) {
if (ob_xform) {
float v[3];
mul_v3_m4v3(v, ob_xform->obmat, tc->data[i].center);
add_v3_v3(partial, v);
Object *ob_xform = tc->obedit ? tc->obedit : tc->poseobj;
int i;
for (i = 0; i < tc->data_len; i++) {
if (tc->data[i].flag & TD_SELECTED) {
if (!(tc->data[i].flag & TD_NOCENTER)) {
if (ob_xform) {
float v[3];
mul_v3_m4v3(v, ob_xform->obmat, tc->data[i].center);
add_v3_v3(partial, v);
}
else {
add_v3_v3(partial, tc->data[i].center);
}
total++;
}
else {
add_v3_v3(partial, tc->data[i].center);
}
total++;
}
}
}
}
if (total) {
mul_v3_fl(partial, 1.0f / (float)total);
}
@ -1862,28 +1863,28 @@ void calculateCenterBound(TransInfo *t, float r_center[3])
int i;
bool is_first = true;
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
Object *ob_xform = tc->obedit ? tc->obedit : tc->poseobj;
for (i = 0; i < tc->data_len; i++) {
if (is_first == false) {
if (tc->data[i].flag & TD_SELECTED) {
if (!(tc->data[i].flag & TD_NOCENTER)) {
if (ob_xform) {
float v[3];
mul_v3_m4v3(v, ob_xform->obmat, tc->data[i].center);
minmax_v3v3_v3(min, max, v);
}
else {
minmax_v3v3_v3(min, max, tc->data[i].center);
Object *ob_xform = tc->obedit ? tc->obedit : tc->poseobj;
for (i = 0; i < tc->data_len; i++) {
if (is_first == false) {
if (tc->data[i].flag & TD_SELECTED) {
if (!(tc->data[i].flag & TD_NOCENTER)) {
if (ob_xform) {
float v[3];
mul_v3_m4v3(v, ob_xform->obmat, tc->data[i].center);
minmax_v3v3_v3(min, max, v);
}
else {
minmax_v3v3_v3(min, max, tc->data[i].center);
}
}
}
is_first = false;
}
else {
copy_v3_v3(max, tc->data[i].center);
copy_v3_v3(min, tc->data[i].center);
}
is_first = false;
}
else {
copy_v3_v3(max, tc->data[i].center);
copy_v3_v3(min, tc->data[i].center);
}
}
}
mid_v3_v3v3(r_center, min, max);
}
@ -2058,77 +2059,77 @@ void calculatePropRatio(TransInfo *t)
if (t->flag & T_PROP_EDIT) {
const char *pet_id = NULL;
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
if (td->flag & TD_SELECTED) {
td->factor = 1.0f;
}
else if (t->flag & T_MIRROR && td->loc[0] * t->mirror < -0.00001f) {
td->flag |= TD_SKIP;
td->factor = 0.0f;
restoreElement(td);
}
else if ((connected && (td->flag & TD_NOTCONNECTED || td->dist > t->prop_size)) ||
(connected == 0 && td->rdist > t->prop_size))
{
/*
* The elements are sorted according to their dist member in the array,
* that means we can stop when it finds one element outside of the propsize.
* do not set 'td->flag |= TD_NOACTION', the prop circle is being changed.
*/
td->factor = 0.0f;
restoreElement(td);
}
else {
/* Use rdist for falloff calculations, it is the real distance */
td->flag &= ~TD_NOACTION;
if (connected)
dist = (t->prop_size - td->dist) / t->prop_size;
else
dist = (t->prop_size - td->rdist) / t->prop_size;
TransData *td = tc->data;
for (i = 0; i < tc->data_len; i++, td++) {
if (td->flag & TD_SELECTED) {
td->factor = 1.0f;
}
else if (t->flag & T_MIRROR && td->loc[0] * t->mirror < -0.00001f) {
td->flag |= TD_SKIP;
td->factor = 0.0f;
restoreElement(td);
}
else if ((connected && (td->flag & TD_NOTCONNECTED || td->dist > t->prop_size)) ||
(connected == 0 && td->rdist > t->prop_size))
{
/*
* The elements are sorted according to their dist member in the array,
* that means we can stop when it finds one element outside of the propsize.
* do not set 'td->flag |= TD_NOACTION', the prop circle is being changed.
*/
/*
* Clamp to positive numbers.
* Certain corner cases with connectivity and individual centers
* can give values of rdist larger than propsize.
*/
if (dist < 0.0f)
dist = 0.0f;
switch (t->prop_mode) {
case PROP_SHARP:
td->factor = dist * dist;
break;
case PROP_SMOOTH:
td->factor = 3.0f * dist * dist - 2.0f * dist * dist * dist;
break;
case PROP_ROOT:
td->factor = sqrtf(dist);
break;
case PROP_LIN:
td->factor = dist;
break;
case PROP_CONST:
td->factor = 1.0f;
break;
case PROP_SPHERE:
td->factor = sqrtf(2 * dist - dist * dist);
break;
case PROP_RANDOM:
td->factor = BLI_frand() * dist;
break;
case PROP_INVSQUARE:
td->factor = dist * (2.0f - dist);
break;
default:
td->factor = 1;
break;
td->factor = 0.0f;
restoreElement(td);
}
else {
/* Use rdist for falloff calculations, it is the real distance */
td->flag &= ~TD_NOACTION;
if (connected)
dist = (t->prop_size - td->dist) / t->prop_size;
else
dist = (t->prop_size - td->rdist) / t->prop_size;
/*
* Clamp to positive numbers.
* Certain corner cases with connectivity and individual centers
* can give values of rdist larger than propsize.
*/
if (dist < 0.0f)
dist = 0.0f;
switch (t->prop_mode) {
case PROP_SHARP:
td->factor = dist * dist;
break;
case PROP_SMOOTH:
td->factor = 3.0f * dist * dist - 2.0f * dist * dist * dist;
break;
case PROP_ROOT:
td->factor = sqrtf(dist);
break;
case PROP_LIN:
td->factor = dist;
break;
case PROP_CONST:
td->factor = 1.0f;
break;
case PROP_SPHERE:
td->factor = sqrtf(2 * dist - dist * dist);
break;
case PROP_RANDOM:
td->factor = BLI_frand() * dist;
break;
case PROP_INVSQUARE:
td->factor = dist * (2.0f - dist);
break;
default:
td->factor = 1;
break;
}
}
}
}
}
switch (t->prop_mode) {
case PROP_SHARP:

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

@ -276,72 +276,74 @@ void applyProject(TransInfo *t)
int i;
FOREACH_TRANS_DATA_CONTAINER(t, tc) {
TransData *td = tc->data;
TransData *td = tc->data;
float imat[4][4];
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
invert_m4_m4(imat, ob->obmat);
}
for (i = 0; i < tc->data_len; i++, td++) {
float iloc[3], loc[3], no[3];
float mval_fl[2];
float dist_px = TRANSFORM_DIST_MAX_PX;
if (td->flag & TD_NOACTION)
break;
if (td->flag & TD_SKIP)
continue;
if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f))
continue;
copy_v3_v3(iloc, td->loc);
float imat[4][4];
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
mul_m4_v3(ob->obmat, iloc);
invert_m4_m4(imat, ob->obmat);
}
else if (t->flag & T_OBJECT) {
BKE_object_eval_transform_all(G.main->eval_ctx, t->scene, td->ob);
copy_v3_v3(iloc, td->ob->obmat[3]);
}
if (ED_view3d_project_float_global(t->ar, iloc, mval_fl, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
if (snapObjectsTransform(
t, mval_fl, &dist_px,
loc, no))
{
// if (t->flag & (T_EDIT|T_POSE)) {
// mul_m4_v3(imat, loc);
// }
sub_v3_v3v3(tvec, loc, iloc);
for (i = 0; i < tc->data_len; i++, td++) {
float iloc[3], loc[3], no[3];
float mval_fl[2];
float dist_px = TRANSFORM_DIST_MAX_PX;
mul_m3_v3(td->smtx, tvec);
if (td->flag & TD_NOACTION)
break;
add_v3_v3(td->loc, tvec);
if (td->flag & TD_SKIP)
continue;
if (t->tsnap.align && (t->flag & T_OBJECT)) {
/* handle alignment as well */
const float *original_normal;
float mat[3][3];
if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f))
continue;
/* In pose mode, we want to align normals with Y axis of bones... */
original_normal = td->axismtx[2];
copy_v3_v3(iloc, td->loc);
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
mul_m4_v3(ob->obmat, iloc);
}
else if (t->flag & T_OBJECT) {
BKE_object_eval_transform_all(G.main->eval_ctx, t->scene, td->ob);
copy_v3_v3(iloc, td->ob->obmat[3]);
}
rotation_between_vecs_to_mat3(mat, original_normal, no);
if (ED_view3d_project_float_global(t->ar, iloc, mval_fl, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
if (snapObjectsTransform(
t, mval_fl, &dist_px,
loc, no))
{
#if 0
if (t->flag & (T_EDIT | T_POSE)) {
mul_m4_v3(imat, loc);
}
#endif
transform_data_ext_rotate(td, mat, true);
sub_v3_v3v3(tvec, loc, iloc);
/* TODO support constraints for rotation too? see ElementRotation */
mul_m3_v3(td->smtx, tvec);
add_v3_v3(td->loc, tvec);
if (t->tsnap.align && (t->flag & T_OBJECT)) {
/* handle alignment as well */
const float *original_normal;
float mat[3][3];
/* In pose mode, we want to align normals with Y axis of bones... */
original_normal = td->axismtx[2];
rotation_between_vecs_to_mat3(mat, original_normal, no);
transform_data_ext_rotate(td, mat, true);
/* TODO support constraints for rotation too? see ElementRotation */
}
}
}
//XXX constraintTransLim(t, td);
}
//XXX constraintTransLim(t, td);
}
}
}
}
@ -371,45 +373,45 @@ void applyGridAbsolute(TransInfo *t)
return;
FOREACH_TRANS_DATA_CONTAINER(t, tc) {
TransData *td;
TransData *td;
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
obmat = ob->obmat;
use_obmat = true;
}
for (i = 0, td = tc->data; i < tc->data_len; i++, td++) {
float iloc[3], loc[3], tvec[3];
if (td->flag & TD_NOACTION)
break;
if (td->flag & TD_SKIP)
continue;
if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f))
continue;
copy_v3_v3(iloc, td->loc);
if (use_obmat) {
mul_m4_v3(obmat, iloc);
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
obmat = ob->obmat;
use_obmat = true;
}
else if (t->flag & T_OBJECT) {
BKE_object_eval_transform_all(G.main->eval_ctx, t->scene, td->ob);
copy_v3_v3(iloc, td->ob->obmat[3]);
}
mul_v3_v3fl(loc, iloc, 1.0f / grid_size);
loc[0] = roundf(loc[0]);
loc[1] = roundf(loc[1]);
loc[2] = roundf(loc[2]);
mul_v3_fl(loc, grid_size);
sub_v3_v3v3(tvec, loc, iloc);
mul_m3_v3(td->smtx, tvec);
add_v3_v3(td->loc, tvec);
}
for (i = 0, td = tc->data; i < tc->data_len; i++, td++) {
float iloc[3], loc[3], tvec[3];
if (td->flag & TD_NOACTION)
break;
if (td->flag & TD_SKIP)
continue;
if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f))
continue;
copy_v3_v3(iloc, td->loc);
if (use_obmat) {
mul_m4_v3(obmat, iloc);
}
else if (t->flag & T_OBJECT) {
BKE_object_eval_transform_all(G.main->eval_ctx, t->scene, td->ob);
copy_v3_v3(iloc, td->ob->obmat[3]);
}
mul_v3_v3fl(loc, iloc, 1.0f / grid_size);
loc[0] = roundf(loc[0]);
loc[1] = roundf(loc[1]);
loc[2] = roundf(loc[2]);
mul_v3_fl(loc, grid_size);
sub_v3_v3v3(tvec, loc, iloc);
mul_m3_v3(td->smtx, tvec);
add_v3_v3(td->loc, tvec);
}
}
}
@ -1130,21 +1132,39 @@ static void TargetSnapClosest(TransInfo *t)
if (t->flag & T_OBJECT) {
int i;
FOREACH_TRANS_DATA_CONTAINER(t, tc) {
TransData *td = tc->data;
for (td = tc->data, i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
struct BoundBox *bb = BKE_object_boundbox_get(td->ob);
/* use boundbox if possible */
if (bb) {
int j;
for (j = 0; j < 8; j++) {
TransData *td = tc->data;
for (td = tc->data, i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
struct BoundBox *bb = BKE_object_boundbox_get(td->ob);
/* use boundbox if possible */
if (bb) {
int j;
for (j = 0; j < 8; j++) {
float loc[3];
float dist;
copy_v3_v3(loc, bb->vec[j]);
mul_m4_v3(td->ext->obmat, loc);
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
if ((dist != TRANSFORM_DIST_INVALID) &&
(closest == NULL || fabsf(dist) < fabsf(dist_closest)))
{
copy_v3_v3(t->tsnap.snapTarget, loc);
closest = td;
dist_closest = dist;
}
}
}
/* use element center otherwise */
else {
float loc[3];
float dist;
copy_v3_v3(loc, bb->vec[j]);
mul_m4_v3(td->ext->obmat, loc);
copy_v3_v3(loc, td->center);
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
if ((dist != TRANSFORM_DIST_INVALID) &&
@ -1152,17 +1172,26 @@ static void TargetSnapClosest(TransInfo *t)
{
copy_v3_v3(t->tsnap.snapTarget, loc);
closest = td;
dist_closest = dist;
}
}
}
/* use element center otherwise */
else {
}
}
else {
FOREACH_TRANS_DATA_CONTAINER(t, tc) {
TransData *td = tc->data;
int i;
for (i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
float loc[3];
float dist;
copy_v3_v3(loc, td->center);
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
mul_m4_v3(ob->obmat, loc);
}
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
if ((dist != TRANSFORM_DIST_INVALID) &&
@ -1170,37 +1199,10 @@ static void TargetSnapClosest(TransInfo *t)
{
copy_v3_v3(t->tsnap.snapTarget, loc);
closest = td;
dist_closest = dist;
}
}
}
}
}
else {
FOREACH_TRANS_DATA_CONTAINER(t, tc) {
TransData *td = tc->data;
int i;
for (i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
float loc[3];
float dist;
copy_v3_v3(loc, td->center);
if (t->flag & (T_EDIT | T_POSE)) {
Object *ob = tc->obedit ? tc->obedit : tc->poseobj;
mul_m4_v3(ob->obmat, loc);
}
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
if ((dist != TRANSFORM_DIST_INVALID) &&
(closest == NULL || fabsf(dist) < fabsf(dist_closest)))
{
copy_v3_v3(t->tsnap.snapTarget, loc);
closest = td;
dist_closest = dist;
}
}
}
}
TargetSnapOffset(t, closest);

506
source/blender/editors/uvedit/uvedit_ops.c
View File

@ -1203,170 +1203,127 @@ static void uv_select_linked_multi(
{
/* loop over objects, or just use hit_final->ob */
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
if (hit_final && ob_index != 0) {
break;
}
Object *obedit = hit_final ? hit_final->ob : objects[ob_index];
if (hit_final && ob_index != 0) {
break;
}
Object *obedit = hit_final ? hit_final->ob : objects[ob_index];
BMFace *efa;
BMLoop *l;
BMIter iter, liter;
MLoopUV *luv;
UvVertMap *vmap;
UvMapVert *vlist, *iterv, *startv;
int i, stacksize = 0, *stack;
unsigned int a;
char *flag;
BMFace *efa;
BMLoop *l;
BMIter iter, liter;
MLoopUV *luv;
UvVertMap *vmap;
UvMapVert *vlist, *iterv, *startv;
int i, stacksize = 0, *stack;
unsigned int a;
char *flag;
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
BM_mesh_elem_table_ensure(em->bm, BM_FACE); /* we can use this too */
BM_mesh_elem_table_ensure(em->bm, BM_FACE); /* we can use this too */
/* Note, we had 'use winding' so we don't consider overlapping islands as connected, see T44320
* this made *every* projection split the island into front/back islands.
* Keep 'use_winding' to false, see: T50970.
*
* Better solve this by having a delimit option for select-linked operator,
* keeping island-select working as is. */
vmap = BM_uv_vert_map_create(em->bm, limit, !select_faces, false);
/* Note, we had 'use winding' so we don't consider overlapping islands as connected, see T44320
* this made *every* projection split the island into front/back islands.
* Keep 'use_winding' to false, see: T50970.
*
* Better solve this by having a delimit option for select-linked operator,
* keeping island-select working as is. */
vmap = BM_uv_vert_map_create(em->bm, limit, !select_faces, false);
if (vmap == NULL)
return;
if (vmap == NULL)
return;
stack = MEM_mallocN(sizeof(*stack) * (em->bm->totface + 1), "UvLinkStack");
flag = MEM_callocN(sizeof(*flag) * em->bm->totface, "UvLinkFlag");
stack = MEM_mallocN(sizeof(*stack) * (em->bm->totface + 1), "UvLinkStack");
flag = MEM_callocN(sizeof(*flag) * em->bm->totface, "UvLinkFlag");
if (hit_final == NULL) {
/* Use existing selection */
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (uvedit_face_visible_test(scene, obedit, ima, efa)) {
if (select_faces) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
stack[stacksize] = a;
stacksize++;
flag[a] = 1;
}
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (luv->flag & MLOOPUV_VERTSEL) {
if (hit_final == NULL) {
/* Use existing selection */
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (uvedit_face_visible_test(scene, obedit, ima, efa)) {
if (select_faces) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
stack[stacksize] = a;
stacksize++;
flag[a] = 1;
}
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
break;
if (luv->flag & MLOOPUV_VERTSEL) {
stack[stacksize] = a;
stacksize++;
flag[a] = 1;
break;
}
}
}
}
}
}
}
else {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (efa == hit_final->efa) {
stack[stacksize] = a;
stacksize++;
flag[a] = 1;
break;
}
}
}
while (stacksize > 0) {
stacksize--;
a = stack[stacksize];
efa = BM_face_at_index(em->bm, a);
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
/* make_uv_vert_map_EM sets verts tmp.l to the indices */
vlist = BM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
startv = vlist;
for (iterv = vlist; iterv; iterv = iterv->next) {
if (iterv->separate)
startv = iterv;
if (iterv->f == a)
break;
}
for (iterv = startv; iterv; iterv = iterv->next) {
if ((startv != iterv) && (iterv->separate))
break;
else if (!flag[iterv->f]) {
flag[iterv->f] = 1;
stack[stacksize] = iterv->f;
else {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (efa == hit_final->efa) {
stack[stacksize] = a;
stacksize++;
}
}
}
}
if (!extend) {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (select_faces) {
if (flag[a])
BM_face_select_set(em->bm, efa, true);
else
BM_face_select_set(em->bm, efa, false);
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (flag[a])
luv->flag |= MLOOPUV_VERTSEL;
else
luv->flag &= ~MLOOPUV_VERTSEL;
}
}
}
}
else {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (!flag[a]) {
continue;
}
if (select_faces) {
if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
flag[a] = 1;
break;
}
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
}
if (luv->flag & MLOOPUV_VERTSEL) {
while (stacksize > 0) {
stacksize--;
a = stack[stacksize];
efa = BM_face_at_index(em->bm, a);
BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, i) {
/* make_uv_vert_map_EM sets verts tmp.l to the indices */
vlist = BM_uv_vert_map_at_index(vmap, BM_elem_index_get(l->v));
startv = vlist;
for (iterv = vlist; iterv; iterv = iterv->next) {
if (iterv->separate)
startv = iterv;
if (iterv->f == a)
break;
}
for (iterv = startv; iterv; iterv = iterv->next) {
if ((startv != iterv) && (iterv->separate))
break;
else if (!flag[iterv->f]) {
flag[iterv->f] = 1;
stack[stacksize] = iterv->f;
stacksize++;
}
}
if (l) {
break;
}
}
}
if (efa) {
if (!extend) {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (!flag[a]) {
continue;
}
if (select_faces) {
BM_face_select_set(em->bm, efa, false);
if (flag[a])
BM_face_select_set(em->bm, efa, true);
else
BM_face_select_set(em->bm, efa, false);
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
luv->flag &= ~MLOOPUV_VERTSEL;
if (flag[a])
luv->flag |= MLOOPUV_VERTSEL;
else
luv->flag &= ~MLOOPUV_VERTSEL;
}
}
}
@ -1378,22 +1335,65 @@ static void uv_select_linked_multi(
}
if (select_faces) {
BM_face_select_set(em->bm, efa, true);
if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
break;
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
luv->flag |= MLOOPUV_VERTSEL;
if (luv->flag & MLOOPUV_VERTSEL) {
break;
}
}
if (l) {
break;
}
}
}
if (efa) {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (!flag[a]) {
continue;
}
if (select_faces) {
BM_face_select_set(em->bm, efa, false);
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
luv->flag &= ~MLOOPUV_VERTSEL;
}
}
}
}
else {
BM_ITER_MESH_INDEX (efa, &iter, em->bm, BM_FACES_OF_MESH, a) {
if (!flag[a]) {
continue;
}
if (select_faces) {
BM_face_select_set(em->bm, efa, true);
}
else {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
luv->flag |= MLOOPUV_VERTSEL;
}
}
}
}
}
}
MEM_freeN(stack);
MEM_freeN(flag);
BM_uv_vert_map_free(vmap);
MEM_freeN(stack);
MEM_freeN(flag);
BM_uv_vert_map_free(vmap);
}
}
@ -3058,82 +3058,82 @@ static int uv_border_select_exec(bContext *C, wmOperator *op)
/* don't indent to avoid diff noise! */
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
bool changed = false;
bool changed = false;
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
if (!extend)
uv_select_all_perform_multi(scene, ima, objects, objects_len, SEL_DESELECT);
if (!extend)
uv_select_all_perform_multi(scene, ima, objects, objects_len, SEL_DESELECT);
/* do actual selection */
if (use_face_center && !pinned) {
/* handle face selection mode */
float cent[2];
/* do actual selection */
if (use_face_center && !pinned) {
/* handle face selection mode */
float cent[2];
changed = false;
changed = false;
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
/* assume not touched */
BM_elem_flag_disable(efa, BM_ELEM_TAG);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
/* assume not touched */
BM_elem_flag_disable(efa, BM_ELEM_TAG);
if (uvedit_face_visible_test(scene, obedit, ima, efa)) {
uv_poly_center(efa, cent, cd_loop_uv_offset);
if (BLI_rctf_isect_pt_v(&rectf, cent)) {
BM_elem_flag_enable(efa, BM_ELEM_TAG);
changed = true;
if (uvedit_face_visible_test(scene, obedit, ima, efa)) {
uv_poly_center(efa, cent, cd_loop_uv_offset);
if (BLI_rctf_isect_pt_v(&rectf, cent)) {
BM_elem_flag_enable(efa, BM_ELEM_TAG);
changed = true;
}
}
}
/* (de)selects all tagged faces and deals with sticky modes */
if (changed) {
uv_select_flush_from_tag_face(sima, scene, obedit, select);
}
}
else {
/* other selection modes */
changed = true;
BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT, BM_ELEM_TAG, false);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!uvedit_face_visible_test(scene, obedit, ima, efa))
continue;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (!pinned || (ts->uv_flag & UV_SYNC_SELECTION)) {
/* UV_SYNC_SELECTION - can't do pinned selection */
if (BLI_rctf_isect_pt_v(&rectf, luv->uv)) {
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
}
}
else if (pinned) {
if ((luv->flag & MLOOPUV_PINNED) && BLI_rctf_isect_pt_v(&rectf, luv->uv)) {
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
}
}
}
}
if (sima->sticky == SI_STICKY_VERTEX) {
uvedit_vertex_select_tagged(em, scene, select, cd_loop_uv_offset);
}
}
/* (de)selects all tagged faces and deals with sticky modes */
if (changed) {
uv_select_flush_from_tag_face(sima, scene, obedit, select);
}
}
else {
/* other selection modes */
changed = true;
BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT, BM_ELEM_TAG, false);
uv_select_sync_flush(ts, em, select);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!uvedit_face_visible_test(scene, obedit, ima, efa))
continue;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (!pinned || (ts->uv_flag & UV_SYNC_SELECTION)) {
/* UV_SYNC_SELECTION - can't do pinned selection */
if (BLI_rctf_isect_pt_v(&rectf, luv->uv)) {
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
}
}
else if (pinned) {
if ((luv->flag & MLOOPUV_PINNED) && BLI_rctf_isect_pt_v(&rectf, luv->uv)) {
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
}
}
if (ts->uv_flag & UV_SYNC_SELECTION) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
}
}
if (sima->sticky == SI_STICKY_VERTEX) {
uvedit_vertex_select_tagged(em, scene, select, cd_loop_uv_offset);
}
}
if (changed) {
uv_select_sync_flush(ts, em, select);
if (ts->uv_flag & UV_SYNC_SELECTION) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
}
}
changed_multi |= changed;
changed_multi |= changed;
}
MEM_SAFE_FREE(objects);
@ -3326,79 +3326,79 @@ static bool do_lasso_select_mesh_uv(bContext *C, const int mcords[][2], short mo
/* don't indent to avoid diff noise! */
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
Object *obedit = objects[ob_index];
bool changed = false;
bool changed = false;
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMEditMesh *em = BKE_editmesh_from_object(obedit);
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
if (!extend && select) {
uv_select_all_perform_multi(scene, ima, objects, objects_len, SEL_DESELECT);
}
if (!extend && select) {
uv_select_all_perform_multi(scene, ima, objects, objects_len, SEL_DESELECT);
}
if (use_face_center) { /* Face Center Sel */
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
/* assume not touched */
if (select != uvedit_face_select_test(scene, efa, cd_loop_uv_offset)) {
float cent[2];
uv_poly_center(efa, cent, cd_loop_uv_offset);
if (use_face_center) { /* Face Center Sel */
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
BM_elem_flag_disable(efa, BM_ELEM_TAG);
/* assume not touched */
if (select != uvedit_face_select_test(scene, efa, cd_loop_uv_offset)) {
float cent[2];
uv_poly_center(efa, cent, cd_loop_uv_offset);
if (UI_view2d_view_to_region_clip(&ar->v2d, cent[0], cent[1], &screen_uv[0], &screen_uv[1]) &&
BLI_rcti_isect_pt_v(&rect, screen_uv) &&
BLI_lasso_is_point_inside(mcords, moves, screen_uv[0], screen_uv[1], V2D_IS_CLIPPED))
{
BM_elem_flag_enable(efa, BM_ELEM_TAG);
changed = true;
if (UI_view2d_view_to_region_clip(&ar->v2d, cent[0], cent[1], &screen_uv[0], &screen_uv[1]) &&
BLI_rcti_isect_pt_v(&rect, screen_uv) &&
BLI_lasso_is_point_inside(mcords, moves, screen_uv[0], screen_uv[1], V2D_IS_CLIPPED))
{
BM_elem_flag_enable(efa, BM_ELEM_TAG);
changed = true;
}
}
}
}
/* (de)selects all tagged faces and deals with sticky modes */
if (changed) {
uv_select_flush_from_tag_face(sima, scene, obedit, select);
/* (de)selects all tagged faces and deals with sticky modes */
if (changed) {
uv_select_flush_from_tag_face(sima, scene, obedit, select);
}
}
}
else { /* Vert Sel */
BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT, BM_ELEM_TAG, false);
else { /* Vert Sel */
BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT, BM_ELEM_TAG, false);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (uvedit_face_visible_test(scene, obedit, ima, efa)) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if ((select) != (uvedit_uv_select_test(scene, l, cd_loop_uv_offset))) {
MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (UI_view2d_view_to_region_clip(
&ar->v2d,
luv->uv[0], luv->uv[1],
&screen_uv[0], &screen_uv[1]) &&
BLI_rcti_isect_pt_v(&rect, screen_uv) &&
BLI_lasso_is_point_inside(mcords, moves, screen_uv[0], screen_uv[1], V2D_IS_CLIPPED))
{
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
changed = true;
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (uvedit_face_visible_test(scene, obedit, ima, efa)) {
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if ((select) != (uvedit_uv_select_test(scene, l, cd_loop_uv_offset))) {
MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (UI_view2d_view_to_region_clip(
&ar->v2d,
luv->uv[0], luv->uv[1],
&screen_uv[0], &screen_uv[1]) &&
BLI_rcti_isect_pt_v(&rect, screen_uv) &&
BLI_lasso_is_point_inside(mcords, moves, screen_uv[0], screen_uv[1], V2D_IS_CLIPPED))
{
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
changed = true;
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
}
}
}
}
}
if (sima->sticky == SI_STICKY_VERTEX) {
uvedit_vertex_select_tagged(em, scene, select, cd_loop_uv_offset);
}
}
if (sima->sticky == SI_STICKY_VERTEX) {
uvedit_vertex_select_tagged(em, scene, select, cd_loop_uv_offset);
if (changed) {
uv_select_sync_flush(scene->toolsettings, em, select);
if (ts->uv_flag & UV_SYNC_SELECTION) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
}
}
}
if (changed) {
uv_select_sync_flush(scene->toolsettings, em, select);
if (ts->uv_flag & UV_SYNC_SELECTION) {
WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit->data);
}
}
changed_multi |= changed;
changed_multi |= changed;
}
return changed_multi;

161
source/blender/editors/uvedit/uvedit_unwrap_ops.c
View File

@ -378,46 +378,46 @@ static ParamHandle *construct_param_handle_multi(
int offset = 0;
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
BMesh *bm = em->bm;
const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV);
BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
if ((BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) || (sel && BM_elem_flag_test(efa, BM_ELEM_SELECT) == 0)) {
continue;
}
if (implicit) {
bool is_loopsel = false;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_select_test(scene, l, cd_loop_uv_offset)) {
is_loopsel = true;
break;
}
}
if (is_loopsel == false) {
if ((BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) || (sel && BM_elem_flag_test(efa, BM_ELEM_SELECT) == 0)) {
continue;
}
if (implicit) {
bool is_loopsel = false;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if (uvedit_uv_select_test(scene, l, cd_loop_uv_offset)) {
is_loopsel = true;
break;
}
}
if (is_loopsel == false) {
continue;
}
}
construct_param_handle_face_add(handle, scene, efa, i + offset, cd_loop_uv_offset);
}
construct_param_handle_face_add(handle, scene, efa, i + offset, cd_loop_uv_offset);
}
if (!implicit) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) {
ParamKey vkeys[2];
vkeys[0] = (ParamKey)BM_elem_index_get(eed->v1);
vkeys[1] = (ParamKey)BM_elem_index_get(eed->v2);
param_edge_set_seam(handle, vkeys);
if (!implicit) {
BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) {
ParamKey vkeys[2];
vkeys[0] = (ParamKey)BM_elem_index_get(eed->v1);
vkeys[1] = (ParamKey)BM_elem_index_get(eed->v2);
param_edge_set_seam(handle, vkeys);
}
}
}
}
offset += bm->totface;
offset += bm->totface;
}
param_construct_end(handle, fill, implicit);
@ -1479,74 +1479,75 @@ static int uv_from_view_exec(bContext *C, wmOperator *op)
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, &objects_len);
for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
bool changed = false;
Object *obedit = objects[ob_index];
BMEditMesh *em = BKE_editmesh_from_object(obedit);
bool changed = false;
/* add uvs if they don't exist yet */
if (!ED_uvedit_ensure_uvs(C, scene, obedit)) {
continue;
}
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
if (RNA_boolean_get(op->ptr, "orthographic")) {
uv_map_rotation_matrix(rotmat, rv3d, obedit, 90.0f, 0.0f, 1.0f);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
BLI_uvproject_from_view_ortho(luv->uv, l->v->co, rotmat);
}
changed = true;
/* add uvs if they don't exist yet */
if (!ED_uvedit_ensure_uvs(C, scene, obedit)) {
continue;
}
}
else if (camera) {
const bool camera_bounds = RNA_boolean_get(op->ptr, "camera_bounds");
struct ProjCameraInfo *uci = BLI_uvproject_camera_info(v3d->camera, obedit->obmat,
camera_bounds ? (scene->r.xsch * scene->r.xasp) : 1.0f,
camera_bounds ? (scene->r.ysch * scene->r.yasp) : 1.0f);
if (uci) {
const int cd_loop_uv_offset = CustomData_get_offset(&em->bm->ldata, CD_MLOOPUV);
if (RNA_boolean_get(op->ptr, "orthographic")) {
uv_map_rotation_matrix(rotmat, rv3d, obedit, 90.0f, 0.0f, 1.0f);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
BLI_uvproject_from_camera(luv->uv, l->v->co, uci);
BLI_uvproject_from_view_ortho(luv->uv, l->v->co, rotmat);
}
changed = true;
}
MEM_freeN(uci);
}
}
else {
copy_m4_m4(rotmat, obedit->obmat);
else if (camera) {
const bool camera_bounds = RNA_boolean_get(op->ptr, "camera_bounds");
struct ProjCameraInfo *uci = BLI_uvproject_camera_info(
v3d->camera, obedit->obmat,
camera_bounds ? (scene->r.xsch * scene->r.xasp) : 1.0f,
camera_bounds ? (scene->r.ysch * scene->r.yasp) : 1.0f);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
if (uci) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
BLI_uvproject_from_view(luv->uv, l->v->co, rv3d->persmat, rotmat, ar->winx, ar->winy);
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
BLI_uvproject_from_camera(luv->uv, l->v->co, uci);
}
changed = true;
}
MEM_freeN(uci);
}
changed = true;
}
}
else {
copy_m4_m4(rotmat, obedit->obmat);
if (changed) {
uv_map_clip_correct(scene, obedit, em, op);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
if (!BM_elem_flag_test(efa, BM_ELEM_SELECT))
continue;
DEG_id_tag_update(obedit->data, 0);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
changed_multi = true;
}
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
BLI_uvproject_from_view(luv->uv, l->v->co, rv3d->persmat, rotmat, ar->winx, ar->winy);
}
changed = true;
}
}
if (changed) {
uv_map_clip_correct(scene, obedit, em, op);
DEG_id_tag_update(obedit->data, 0);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
changed_multi = true;
}
}
MEM_SAFE_FREE(objects);