2 * ***** BEGIN GPL LICENSE BLOCK *****
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 * The Original Code is Copyright (C) 2004 by Blender Foundation.
19 * All rights reserved.
21 * The Original Code is: all of this file.
23 * Contributor(s): Joseph Eagar
25 * ***** END GPL LICENSE BLOCK *****
33 #include "MEM_guardedalloc.h"
36 #include "BLO_sys_types.h" // for intptr_t support
38 #include "DNA_mesh_types.h"
39 #include "DNA_material_types.h"
40 #include "DNA_meshdata_types.h"
41 #include "DNA_modifier_types.h"
42 #include "DNA_object_types.h"
43 #include "DNA_scene_types.h"
44 #include "DNA_screen_types.h"
45 #include "DNA_view3d_types.h"
46 #include "DNA_key_types.h"
48 #include "RNA_types.h"
49 #include "RNA_define.h"
50 #include "RNA_access.h"
52 #include "BLI_utildefines.h"
53 #include "BLI_blenlib.h"
55 #include "BLI_editVert.h"
57 #include "BLI_ghash.h"
58 #include "BLI_linklist.h"
60 #include "BLI_array.h"
62 #include "BKE_context.h"
63 #include "BKE_customdata.h"
64 #include "BKE_depsgraph.h"
65 #include "BKE_global.h"
66 #include "BKE_library.h"
69 #include "BKE_object.h"
70 #include "BKE_bmesh.h"
71 #include "BKE_report.h"
72 #include "BKE_tessmesh.h"
77 #include "BIF_glutil.h"
83 #include "ED_view3d.h"
85 #include "ED_screen.h"
87 #include "UI_interface.h"
89 #include "editbmesh_bvh.h"
90 #include "mesh_intern.h"
92 void EDBM_RecalcNormals(BMEditMesh *em)
94 BM_Compute_Normals(em->bm);
97 void EDBM_ClearMesh(BMEditMesh *em)
100 BM_Clear_Mesh(em->bm);
102 /* free derived meshes */
103 if (em->derivedCage) {
104 em->derivedCage->needsFree = 1;
105 em->derivedCage->release(em->derivedCage);
107 if (em->derivedFinal && em->derivedFinal != em->derivedCage) {
108 em->derivedFinal->needsFree = 1;
109 em->derivedFinal->release(em->derivedFinal);
112 em->derivedCage = em->derivedFinal = NULL;
114 /* free tesselation data */
117 MEM_freeN(em->looptris);
120 void EDBM_stats_update(BMEditMesh *em)
122 const char iter_types[3] = {BM_VERTS_OF_MESH,
131 tots[0] = &em->bm->totvertsel;
132 tots[1] = &em->bm->totedgesel;
133 tots[2] = &em->bm->totfacesel;
135 em->bm->totvertsel = em->bm->totedgesel = em->bm->totfacesel = 0;
137 for (i = 0; i < 3; i++) {
138 ele = BMIter_New(&iter, em->bm, iter_types[i], NULL);
139 for ( ; ele; ele = BMIter_Step(&iter)) {
140 if (BM_TestHFlag(ele, BM_SELECT)) {
147 int EDBM_InitOpf(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const char *fmt, ...)
154 if (!BMO_VInitOpf(bm, bmop, fmt, list)) {
155 BKE_report(op->reports, RPT_ERROR,
156 "Parse error in EDBM_CallOpf");
162 em->emcopy = BMEdit_Copy(em);
171 /* returns 0 on error, 1 on success. executes and finishes a bmesh operator */
172 int EDBM_FinishOp(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const int report)
176 BMO_Finish_Op(em->bm, bmop);
178 if (BMO_GetError(em->bm, &errmsg, NULL)) {
179 BMEditMesh *emcopy = em->emcopy;
181 if (report) BKE_report(op->reports, RPT_ERROR, errmsg);
185 BMEdit_RecalcTesselation(em);
194 if (em->emcopyusers < 0) {
195 printf("warning: em->emcopyusers was less then zero.\n");
198 if (em->emcopyusers <= 0) {
199 BMEdit_Free(em->emcopy);
200 MEM_freeN(em->emcopy);
208 int EDBM_CallOpf(BMEditMesh *em, wmOperator *op, const char *fmt, ...)
216 if (!BMO_VInitOpf(bm, &bmop, fmt, list)) {
217 BKE_report(op->reports, RPT_ERROR,
218 "Parse error in EDBM_CallOpf");
224 em->emcopy = BMEdit_Copy(em);
227 BMO_Exec_Op(bm, &bmop);
230 return EDBM_FinishOp(em, &bmop, op, TRUE);
233 int EDBM_CallAndSelectOpf(BMEditMesh *em, wmOperator *op, const char *selectslot, const char *fmt, ...)
241 if (!BMO_VInitOpf(bm, &bmop, fmt, list)) {
242 BKE_report(op->reports, RPT_ERROR,
243 "Parse error in EDBM_CallOpf");
249 em->emcopy = BMEdit_Copy(em);
252 BMO_Exec_Op(bm, &bmop);
253 BMO_HeaderFlag_Buffer(em->bm, &bmop, selectslot, BM_SELECT, BM_ALL);
256 return EDBM_FinishOp(em, &bmop, op, TRUE);
259 int EDBM_CallOpfSilent(BMEditMesh *em, const char *fmt, ...)
267 if (!BMO_VInitOpf(bm, &bmop, fmt, list)) {
273 em->emcopy = BMEdit_Copy(em);
276 BMO_Exec_Op(bm, &bmop);
279 return EDBM_FinishOp(em, &bmop, NULL, FALSE);
282 void EDBM_selectmode_to_scene(bContext *C)
284 Scene *scene = CTX_data_scene(C);
285 Object *obedit = CTX_data_edit_object(C);
286 BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
291 scene->toolsettings->selectmode = em->selectmode;
293 /* Request redraw of header buttons (to show new select mode) */
294 WM_event_add_notifier(C, NC_SCENE|ND_TOOLSETTINGS, scene);
297 void EDBM_MakeEditBMesh(ToolSettings *ts, Scene *UNUSED(scene), Object *ob)
302 if (!me->mpoly && me->totface) {
303 fprintf(stderr, "%s: bmesh conversion issue! may lose lots of geometry! (bmesh internal error)\n", __func__);
305 /* BMESH_TODO need to write smarter code here */
306 bm = BKE_mesh_to_bmesh(me, ob);
309 bm = BKE_mesh_to_bmesh(me, ob);
312 if (me->edit_btmesh) {
313 /* this happens when switching shape keys */
314 BMEdit_Free(me->edit_btmesh);
315 MEM_freeN(me->edit_btmesh);
318 /* currently executing operators re-tesselates, so we can avoid doing here
319 * but at some point it may need to be added back. */
321 me->edit_btmesh = BMEdit_Create(bm, TRUE);
323 me->edit_btmesh = BMEdit_Create(bm, FALSE);
326 me->edit_btmesh->selectmode = me->edit_btmesh->bm->selectmode = ts->selectmode;
327 me->edit_btmesh->me = me;
328 me->edit_btmesh->ob = ob;
331 void EDBM_LoadEditBMesh(Scene *scene, Object *ob)
334 BMesh *bm = me->edit_btmesh->bm;
336 BMO_CallOpf(bm, "object_load_bmesh scene=%p object=%p", scene, ob);
339 void EDBM_FreeEditBMesh(BMEditMesh *tm)
344 void EDBM_init_index_arrays(BMEditMesh *tm, int forvert, int foredge, int forface)
346 EDBM_free_index_arrays(tm);
353 tm->vert_index = MEM_mallocN(sizeof(void **) * tm->bm->totvert, "tm->vert_index");
355 ele = BMIter_New(&iter, tm->bm, BM_VERTS_OF_MESH, NULL);
356 for ( ; ele; ele = BMIter_Step(&iter)) {
357 tm->vert_index[i++] = ele;
366 tm->edge_index = MEM_mallocN(sizeof(void **) * tm->bm->totedge, "tm->edge_index");
368 ele = BMIter_New(&iter, tm->bm, BM_EDGES_OF_MESH, NULL);
369 for ( ; ele; ele = BMIter_Step(&iter)) {
370 tm->edge_index[i++] = ele;
379 tm->face_index = MEM_mallocN(sizeof(void **) * tm->bm->totface, "tm->face_index");
381 ele = BMIter_New(&iter, tm->bm, BM_FACES_OF_MESH, NULL);
382 for ( ; ele; ele = BMIter_Step(&iter)) {
383 tm->face_index[i++] = ele;
388 void EDBM_free_index_arrays(BMEditMesh *tm)
390 if (tm->vert_index) {
391 MEM_freeN(tm->vert_index);
392 tm->vert_index = NULL;
395 if (tm->edge_index) {
396 MEM_freeN(tm->edge_index);
397 tm->edge_index = NULL;
400 if (tm->face_index) {
401 MEM_freeN(tm->face_index);
402 tm->face_index = NULL;
406 BMVert *EDBM_get_vert_for_index(BMEditMesh *tm, int index)
408 return tm->vert_index && index < tm->bm->totvert ?tm->vert_index[index]:NULL;
411 BMEdge *EDBM_get_edge_for_index(BMEditMesh *tm, int index)
413 return tm->edge_index && index < tm->bm->totedge ?tm->edge_index[index]:NULL;
416 BMFace *EDBM_get_face_for_index(BMEditMesh *tm, int index)
418 return (tm->face_index && index < tm->bm->totface && index >= 0) ? tm->face_index[index] : NULL;
421 void EDBM_selectmode_flush_ex(BMEditMesh *em, int selectmode)
423 em->bm->selectmode = selectmode;
424 BM_SelectMode_Flush(em->bm);
425 em->bm->selectmode = em->selectmode;
428 void EDBM_selectmode_flush(BMEditMesh *em)
430 EDBM_selectmode_flush_ex(em, em->selectmode);
433 void EDBM_deselect_flush(BMEditMesh *em)
435 /* function below doesnt use. just do this to keep the values in sync */
436 em->bm->selectmode = em->selectmode;
437 BM_DeSelect_Flush(em->bm);
441 void EDBM_select_flush(BMEditMesh *em)
443 /* function below doesnt use. just do this to keep the values in sync */
444 em->bm->selectmode = em->selectmode;
445 BM_Select_Flush(em->bm);
448 void EDBM_select_more(BMEditMesh *em)
451 int usefaces = em->selectmode > SCE_SELECT_EDGE;
453 BMO_InitOpf(em->bm, &bmop,
454 "regionextend geom=%hvef constrict=%d usefaces=%d",
455 BM_SELECT, 0, usefaces);
456 BMO_Exec_Op(em->bm, &bmop);
457 BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_SELECT, BM_ALL);
458 BMO_Finish_Op(em->bm, &bmop);
460 EDBM_selectmode_flush(em);
463 void EDBM_select_less(BMEditMesh *em)
466 int usefaces = em->selectmode > SCE_SELECT_EDGE;
468 BMO_InitOpf(em->bm, &bmop,
469 "regionextend geom=%hvef constrict=%d usefaces=%d",
470 BM_SELECT, 0, usefaces);
471 BMO_Exec_Op(em->bm, &bmop);
472 BMO_HeaderFlag_Buffer(em->bm, &bmop, "geomout", BM_SELECT, BM_ALL);
473 BMO_Finish_Op(em->bm, &bmop);
475 EDBM_selectmode_flush(em);
478 int EDBM_get_actSelection(BMEditMesh *em, BMEditSelection *ese)
480 BMEditSelection *ese_last = em->bm->selected.last;
481 BMFace *efa = BM_get_actFace(em->bm, FALSE);
483 ese->next = ese->prev = NULL;
486 if (ese_last->htype == BM_FACE) { /* if there is an active face, use it over the last selected face */
488 ese->data = (void *)efa;
491 ese->data = ese_last->data;
493 ese->htype = BM_FACE;
496 ese->data = ese_last->data;
497 ese->htype = ese_last->htype;
500 else if (efa) { /* no */
501 ese->data = (void *)efa;
502 ese->htype = BM_FACE;
511 void EDBM_clear_flag_all(BMEditMesh *em, const char hflag)
513 const char iter_types[3] = {BM_VERTS_OF_MESH,
520 if (hflag & BM_SELECT)
521 BM_clear_selection_history(em->bm);
523 for (i = 0; i < 3; i++) {
524 BM_ITER(ele, &iter, em->bm, iter_types[i], NULL) {
525 if (hflag & BM_SELECT) BM_Select(em->bm, ele, FALSE);
526 BM_ClearHFlag(ele, hflag);
531 void EDBM_set_flag_all(BMEditMesh *em, const char hflag)
533 const char iter_types[3] = {BM_VERTS_OF_MESH,
540 for (i = 0; i < 3; i++) {
541 ele = BMIter_New(&iter, em->bm, iter_types[i], NULL);
542 for ( ; ele; ele = BMIter_Step(&iter)) {
543 if (hflag & BM_SELECT) {
544 BM_Select(em->bm, ele, TRUE);
547 BM_SetHFlag(ele, hflag);
553 /**************-------------- Undo ------------*****************/
557 static void *getEditMesh(bContext *C)
559 Object *obedit = CTX_data_edit_object(C);
560 if (obedit && obedit->type == OB_MESH) {
561 Mesh *me = obedit->data;
562 return me->edit_btmesh;
567 typedef struct undomesh {
570 char obname[MAX_ID_NAME - 2];
573 /* undo simply makes copies of a bmesh */
574 static void *editbtMesh_to_undoMesh(void *emv, void *obdata)
576 BMEditMesh *em = emv;
579 undomesh *um = MEM_callocN(sizeof(undomesh), "undo Mesh");
580 BLI_strncpy(um->obname, em->bm->ob->id.name + 2, sizeof(um->obname));
582 /* make sure shape keys work */
583 um->me.key = obme->key ? copy_key_nolib(obme->key) : NULL;
585 #ifdef BMESH_EM_UNDO_RECALC_TESSFACE_WORKAROUND
587 /* we recalc the tesselation here, to avoid seeding calls to
588 * BMEdit_RecalcTesselation throughout the code. */
589 BMEdit_RecalcTesselation(em);
593 BMO_CallOpf(em->bm, "bmesh_to_mesh mesh=%p notesselation=%i", &um->me, 1);
594 um->selectmode = em->selectmode;
599 static void undoMesh_to_editbtMesh(void *umv, void *emv, void *UNUSED(obdata))
601 BMEditMesh *em = emv, *em2;
605 int allocsize[4] = {512, 512, 2048, 512};
607 ob = (Object *)find_id("OB", um->obname);
608 ob->shapenr = em->bm->shapenr;
612 bm = BM_Make_Mesh(ob, allocsize);
613 BMO_CallOpf(bm, "mesh_to_bmesh mesh=%p object=%p set_shapekey=%i", &um->me, ob, 0);
615 em2 = BMEdit_Create(bm, TRUE);
618 em->selectmode = um->selectmode;
624 static void free_undo(void *umv)
626 if (((Mesh *)umv)->key) {
627 free_key(((Mesh *)umv)->key);
628 MEM_freeN(((Mesh *)umv)->key);
635 /* and this is all the undo system needs to know */
636 void undo_push_mesh(bContext *C, const char *name)
638 undo_editmode_push(C, name, getEditMesh, free_undo, undoMesh_to_editbtMesh, editbtMesh_to_undoMesh, NULL);
641 /* write comment here */
642 UvVertMap *EDBM_make_uv_vert_map(BMEditMesh *em, int selected, int do_face_idx_array, float *limit)
648 /* vars from original func */
651 /* MTexPoly *tf; */ /* UNUSED */
654 int totverts, i, totuv;
656 if (do_face_idx_array)
657 EDBM_init_index_arrays(em, 0, 0, 1);
659 BM_ElemIndex_Ensure(em->bm, BM_VERT);
661 totverts = em->bm->totvert;
664 /* generate UvMapVert array */
665 BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
666 if (!selected || ((!BM_TestHFlag(efa, BM_HIDDEN)) && BM_TestHFlag(efa, BM_SELECT)))
671 if (do_face_idx_array)
672 EDBM_free_index_arrays(em);
675 vmap = (UvVertMap *)MEM_callocN(sizeof(*vmap), "UvVertMap");
677 if (do_face_idx_array)
678 EDBM_free_index_arrays(em);
682 vmap->vert = (UvMapVert **)MEM_callocN(sizeof(*vmap->vert)*totverts, "UvMapVert_pt");
683 buf = vmap->buf = (UvMapVert *)MEM_callocN(sizeof(*vmap->buf)*totuv, "UvMapVert");
685 if (!vmap->vert || !vmap->buf) {
686 free_uv_vert_map(vmap);
687 if (do_face_idx_array)
688 EDBM_free_index_arrays(em);
693 BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
694 if (!selected || ((!BM_TestHFlag(efa, BM_HIDDEN)) && BM_TestHFlag(efa, BM_SELECT))) {
696 BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
701 buf->next = vmap->vert[BM_GetIndex(l->v)];
702 vmap->vert[BM_GetIndex(l->v)] = buf;
712 /* sort individual uvs for each vert */
714 BM_ITER(ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
715 UvMapVert *newvlist = NULL, *vlist = vmap->vert[a];
716 UvMapVert *iterv, *v, *lastv, *next;
717 float *uv, *uv2, uvdiff[2];
725 efa = EDBM_get_face_for_index(em, v->f);
726 /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
728 l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex);
729 luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
737 efa = EDBM_get_face_for_index(em, iterv->f);
738 /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
740 l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex);
741 luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
744 sub_v2_v2v2(uvdiff, uv2, uv);
746 if (fabs(uvdiff[0]) < limit[0] && fabs(uvdiff[1]) < limit[1]) {
747 if (lastv) lastv->next = next;
749 iterv->next = newvlist;
758 newvlist->separate = 1;
761 vmap->vert[a] = newvlist;
765 if (do_face_idx_array)
766 EDBM_free_index_arrays(em);
772 UvMapVert *EDBM_get_uv_map_vert(UvVertMap *vmap, unsigned int v)
774 return vmap->vert[v];
777 /* from editmesh_lib.c in trunk */
780 /* A specialized vert map used by stitch operator */
781 UvElementMap *EDBM_make_uv_element_map(BMEditMesh *em, int selected, int do_islands)
787 /* vars from original func */
788 UvElementMap *element_map;
790 UvElement *islandbuf;
793 int totverts, i, totuv, j, nislands = 0, islandbufsize = 0;
799 BM_ElemIndex_Ensure(em->bm, BM_VERT | BM_FACE);
801 totverts = em->bm->totvert;
804 /* generate UvElement array */
805 BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
806 if (!selected || ((!BM_TestHFlag(efa, BM_HIDDEN)) && BM_TestHFlag(efa, BM_SELECT)))
813 element_map = (UvElementMap *)MEM_callocN(sizeof(*element_map), "UvElementMap");
817 element_map->totalUVs = totuv;
818 element_map->vert = (UvElement **)MEM_callocN(sizeof(*element_map->vert) * totverts, "UvElementVerts");
819 buf = element_map->buf = (UvElement *)MEM_callocN(sizeof(*element_map->buf) * totuv, "UvElement");
821 if (!element_map->vert || !element_map->buf) {
822 EDBM_free_uv_element_map(element_map);
826 BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
827 if (!selected || ((!BM_TestHFlag(efa, BM_HIDDEN)) && BM_TestHFlag(efa, BM_SELECT))) {
829 BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
833 buf->island = INVALID_ISLAND;
835 buf->next = element_map->vert[BM_GetIndex(l->v)];
836 element_map->vert[BM_GetIndex(l->v)] = buf;
844 /* sort individual uvs for each vert */
846 BM_ITER(ev, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
847 UvElement *newvlist = NULL, *vlist = element_map->vert[i];
848 UvElement *iterv, *v, *lastv, *next;
849 float *uv, *uv2, uvdiff[2];
858 /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
860 l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, v->tfindex);
861 luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
870 /* tf = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY); */ /* UNUSED */
872 l = BMIter_AtIndex(em->bm, BM_LOOPS_OF_FACE, efa, iterv->tfindex);
873 luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
876 sub_v2_v2v2(uvdiff, uv2, uv);
878 if (fabsf(uvdiff[0]) < STD_UV_CONNECT_LIMIT && fabsf(uvdiff[1]) < STD_UV_CONNECT_LIMIT) {
879 if (lastv) lastv->next = next;
881 iterv->next = newvlist;
891 newvlist->separate = 1;
894 element_map->vert[i] = newvlist;
899 /* at this point, every UvElement in vert points to a UvElement sharing the same vertex. Now we should sort uv's in islands. */
901 /* map holds the map from current vmap->buf to the new, sorted map */
902 map = MEM_mallocN(sizeof(*map)*totuv, "uvelement_remap");
903 stack = MEM_mallocN(sizeof(*stack)*em->bm->totface, "uv_island_face_stack");
904 islandbuf = MEM_callocN(sizeof(*islandbuf)*totuv, "uvelement_island_buffer");
905 island_number = MEM_mallocN(sizeof(*stack)*em->bm->totface, "uv_island_number_face");
907 for (i = 0; i < totuv; i++) {
908 if (element_map->buf[i].island == INVALID_ISLAND) {
909 element_map->buf[i].island = nislands;
910 stack[0] = element_map->buf[i].face;
911 island_number[BM_GetIndex(stack[0])] = nislands;
914 while (stacksize > 0) {
915 efa = stack[--stacksize];
917 BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
918 UvElement *element, *initelement = element_map->vert[BM_GetIndex(l->v)];
920 for (element = initelement; element; element = element->next) {
921 if (element->separate)
922 initelement = element;
924 if (element->face == efa) {
925 /* found the uv corresponding to our face and vertex. Now fill it to the buffer */
926 element->island = nislands;
927 map[element - element_map->buf] = islandbufsize;
928 islandbuf[islandbufsize].tfindex = element->tfindex;
929 islandbuf[islandbufsize].face = element->face;
930 islandbuf[islandbufsize].separate = element->separate;
931 islandbuf[islandbufsize].island = nislands;
934 for (element = initelement; element; element = element->next) {
935 if (element->separate && element != initelement)
938 if (island_number[BM_GetIndex(element->face)] == INVALID_ISLAND) {
939 stack[stacksize++] = element->face;
940 island_number[BM_GetIndex(element->face)] = nislands;
954 for (i = 0; i < em->bm->totvert; i++) {
955 /* important since we may do selection only. Some of these may be NULL */
956 if (element_map->vert[i])
957 element_map->vert[i] = &islandbuf[map[element_map->vert[i] - element_map->buf]];
960 element_map->islandIndices = MEM_callocN(sizeof(*element_map->islandIndices)*nislands,"UvElementMap_island_indices");
961 if (!element_map->islandIndices) {
962 MEM_freeN(islandbuf);
965 EDBM_free_uv_element_map(element_map);
966 MEM_freeN(island_number);
970 for (i = 0; i < totuv; i++) {
971 UvElement *element = element_map->buf[i].next;
973 islandbuf[map[i]].next = NULL;
975 islandbuf[map[i]].next = &islandbuf[map[element - element_map->buf]];
977 if (islandbuf[i].island != j) {
979 element_map->islandIndices[j] = i;
983 MEM_freeN(element_map->buf);
985 element_map->buf = islandbuf;
986 element_map->totalIslands = nislands;
989 MEM_freeN(island_number);
996 UvMapVert *EM_get_uv_map_vert(UvVertMap *vmap, unsigned int v)
998 return vmap->vert[v];
1001 void EDBM_free_uv_vert_map(UvVertMap *vmap)
1004 if (vmap->vert) MEM_freeN(vmap->vert);
1005 if (vmap->buf) MEM_freeN(vmap->buf);
1010 void EDBM_free_uv_element_map(UvElementMap *element_map)
1013 if (element_map->vert) MEM_freeN(element_map->vert);
1014 if (element_map->buf) MEM_freeN(element_map->buf);
1015 if (element_map->islandIndices) MEM_freeN(element_map->islandIndices);
1016 MEM_freeN(element_map);
1020 /* last_sel, use em->act_face otherwise get the last selected face in the editselections
1021 * at the moment, last_sel is mainly useful for gaking sure the space image dosnt flicker */
1022 MTexPoly *EDBM_get_active_mtexpoly(BMEditMesh *em, BMFace **act_efa, int sloppy)
1026 if (!EDBM_texFaceCheck(em))
1029 efa = BM_get_actFace(em->bm, sloppy);
1032 if (act_efa) *act_efa = efa;
1033 return CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
1036 if (act_efa) *act_efa = NULL;
1040 /* can we edit UV's for this mesh?*/
1041 int EDBM_texFaceCheck(BMEditMesh *em)
1043 /* some of these checks could be a touch overkill */
1044 return em && em->bm->totface && CustomData_has_layer(&em->bm->pdata, CD_MTEXPOLY) &&
1045 CustomData_has_layer(&em->bm->ldata, CD_MLOOPUV);
1048 int EDBM_vertColorCheck(BMEditMesh *em)
1050 /* some of these checks could be a touch overkill */
1051 return em && em->bm->totface && CustomData_has_layer(&em->bm->ldata, CD_MLOOPCOL);
1054 static BMVert *cache_mirr_intptr_as_bmvert(intptr_t *index_lookup, int index)
1056 intptr_t eve_i = index_lookup[index];
1057 return (eve_i == -1) ? NULL : (BMVert *)eve_i;
1060 /* BM_SEARCH_MAXDIST is too big, copied from 2.6x MOC_THRESH, should become a
1062 #define BM_SEARCH_MAXDIST_MIRR 0.00002f
1063 #define BM_CD_LAYER_ID "__mirror_index"
1064 void EDBM_CacheMirrorVerts(BMEditMesh *em, const short use_select)
1072 /* one or the other is used depending if topo is enabled */
1073 BMBVHTree *tree = NULL;
1074 MirrTopoStore_t mesh_topo_store = {NULL, -1, -1, -1};
1076 if (me && (me->editflag & ME_EDIT_MIRROR_TOPO)) {
1080 if (!em->vert_index) {
1081 EDBM_init_index_arrays(em, 1, 0, 0);
1082 em->mirr_free_arrays = 1;
1085 if (!CustomData_get_layer_named(&bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID)) {
1086 BM_add_data_layer_named(bm, &bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID);
1089 li = CustomData_get_named_layer_index(&bm->vdata, CD_PROP_INT, BM_CD_LAYER_ID);
1091 bm->vdata.layers[li].flag |= CD_FLAG_TEMPORARY;
1093 BM_ElemIndex_Ensure(bm, BM_VERT);
1096 ED_mesh_mirrtopo_init(me, -1, &mesh_topo_store, TRUE);
1099 tree = BMBVH_NewBVH(em, 0, NULL, NULL);
1102 BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
1104 /* temporary for testing, check for selection */
1105 if (use_select && !BM_TestHFlag(v, BM_SELECT)) {
1110 int *idx = CustomData_bmesh_get_layer_n(&bm->vdata, v->head.data, li);
1113 mirr = cache_mirr_intptr_as_bmvert(mesh_topo_store.index_lookup, BM_GetIndex(v));
1116 float co[3] = {-v->co[0], v->co[1], v->co[2]};
1117 mirr = BMBVH_FindClosestVert(tree, co, BM_SEARCH_MAXDIST_MIRR);
1120 if (mirr && mirr != v) {
1121 *idx = BM_GetIndex(mirr);
1122 idx = CustomData_bmesh_get_layer_n(&bm->vdata, mirr->head.data, li);
1123 *idx = BM_GetIndex(v);
1134 ED_mesh_mirrtopo_free(&mesh_topo_store);
1137 BMBVH_FreeBVH(tree);
1140 em->mirror_cdlayer = li;
1143 BMVert *EDBM_GetMirrorVert(BMEditMesh *em, BMVert *v)
1145 int *mirr = CustomData_bmesh_get_layer_n(&em->bm->vdata, v->head.data, em->mirror_cdlayer);
1147 BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
1149 if (mirr && *mirr >= 0 && *mirr < em->bm->totvert) {
1150 if (!em->vert_index) {
1151 printf("err: should only be called between "
1152 "EDBM_CacheMirrorVerts and EDBM_EndMirrorCache");
1156 return em->vert_index[*mirr];
1162 void EDBM_ClearMirrorVert(BMEditMesh *em, BMVert *v)
1164 int *mirr = CustomData_bmesh_get_layer_n(&em->bm->vdata, v->head.data, em->mirror_cdlayer);
1166 BLI_assert(em->mirror_cdlayer != -1); /* invalid use */
1173 void EDBM_EndMirrorCache(BMEditMesh *em)
1175 if (em->mirr_free_arrays) {
1176 MEM_freeN(em->vert_index);
1177 em->vert_index = NULL;
1180 em->mirror_cdlayer = -1;
1183 void EDBM_ApplyMirrorCache(BMEditMesh *em, const int sel_from, const int sel_to)
1188 BLI_assert(em->vert_index != NULL);
1190 BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
1191 if (BM_TestHFlag(v, BM_SELECT) == sel_from) {
1192 BMVert *mirr = EDBM_GetMirrorVert(em, v);
1194 if (BM_TestHFlag(mirr, BM_SELECT) == sel_to) {
1195 copy_v3_v3(mirr->co, v->co);
1196 mirr->co[0] *= -1.0f;