Revision: 44248 http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=44248 Author: campbellbarton Date: 2012-02-19 17:11:40 +0000 (Sun, 19 Feb 2012) Log Message: ----------- sync some changes with trunk and rename bmeshutils.c
Modified Paths: -------------- branches/bmesh/blender/source/blender/editors/mesh/CMakeLists.txt branches/bmesh/blender/source/blender/editors/mesh/editmesh_add.c Added Paths: ----------- branches/bmesh/blender/source/blender/editors/mesh/bmesh_utils.c Removed Paths: ------------- branches/bmesh/blender/source/blender/editors/mesh/bmeshutils.c Modified: branches/bmesh/blender/source/blender/editors/mesh/CMakeLists.txt =================================================================== --- branches/bmesh/blender/source/blender/editors/mesh/CMakeLists.txt 2012-02-19 16:54:53 UTC (rev 44247) +++ branches/bmesh/blender/source/blender/editors/mesh/CMakeLists.txt 2012-02-19 17:11:40 UTC (rev 44248) @@ -43,9 +43,9 @@ mesh_ops.c editmesh_bvh.c editmesh_add.c - bmeshutils.c bmesh_selecthistory.c bmesh_select.c + bmesh_utils.c mesh_data.c bmesh_tools.c knifetool.c Copied: branches/bmesh/blender/source/blender/editors/mesh/bmesh_utils.c (from rev 44246, branches/bmesh/blender/source/blender/editors/mesh/bmeshutils.c) =================================================================== --- branches/bmesh/blender/source/blender/editors/mesh/bmesh_utils.c (rev 0) +++ branches/bmesh/blender/source/blender/editors/mesh/bmesh_utils.c 2012-02-19 17:11:40 UTC (rev 44248) @@ -0,0 +1,1139 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2004 by Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Joseph Eagar + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include "MEM_guardedalloc.h" + +#include "DNA_object_types.h" +#include "DNA_scene_types.h" + +#include "BLI_blenlib.h" +#include "BLI_math.h" + +#include "BKE_context.h" +#include "BKE_library.h" +#include "BKE_key.h" +#include "BKE_mesh.h" +#include "BKE_bmesh.h" +#include "BKE_report.h" +#include "BKE_tessmesh.h" + +#include "WM_api.h" +#include "WM_types.h" + +#include "ED_mesh.h" +#include "ED_util.h" + +void EDBM_RecalcNormals(BMEditMesh *em) +{ + BM_mesh_normals_update(em->bm); +} + +void EDBM_ClearMesh(BMEditMesh *em) +{ + /* clear bmesh */ + BM_mesh_clear(em->bm); + + /* free derived meshes */ + if (em->derivedCage) { + em->derivedCage->needsFree = 1; + em->derivedCage->release(em->derivedCage); + } + if (em->derivedFinal && em->derivedFinal != em->derivedCage) { + em->derivedFinal->needsFree = 1; + em->derivedFinal->release(em->derivedFinal); + } + + em->derivedCage = em->derivedFinal = NULL; + + /* free tesselation data */ + em->tottri = 0; + if (em->looptris) + MEM_freeN(em->looptris); +} + +void EDBM_stats_update(BMEditMesh *em) +{ + const char iter_types[3] = {BM_VERTS_OF_MESH, + BM_EDGES_OF_MESH, + BM_FACES_OF_MESH}; + + BMIter iter; + BMHeader *ele; + int *tots[3]; + int i; + + tots[0] = &em->bm->totvertsel; + tots[1] = &em->bm->totedgesel; + tots[2] = &em->bm->totfacesel; + + em->bm->totvertsel = em->bm->totedgesel = em->bm->totfacesel = 0; + + for (i = 0; i < 3; i++) { + ele = BM_iter_new(&iter, em->bm, iter_types[i], NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) { + (*tots[i])++; + } + } + } +} + +int EDBM_InitOpf(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const char *fmt, ...) +{ + BMesh *bm = em->bm; + va_list list; + + va_start(list, fmt); + + if (!BMO_op_vinitf(bm, bmop, fmt, list)) { + BKE_report(op->reports, RPT_ERROR, + "Parse error in EDBM_CallOpf"); + va_end(list); + return 0; + } + + if (!em->emcopy) + em->emcopy = BMEdit_Copy(em); + em->emcopyusers++; + + va_end(list); + + return 1; +} + + +/* returns 0 on error, 1 on success. executes and finishes a bmesh operator */ +int EDBM_FinishOp(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const int report) +{ + const char *errmsg; + + BMO_op_finish(em->bm, bmop); + + if (BMO_error_get(em->bm, &errmsg, NULL)) { + BMEditMesh *emcopy = em->emcopy; + + if (report) BKE_report(op->reports, RPT_ERROR, errmsg); + + BMEdit_Free(em); + *em = *emcopy; + BMEdit_RecalcTesselation(em); + + MEM_freeN(emcopy); + em->emcopyusers = 0; + em->emcopy = NULL; + return 0; + } + else { + em->emcopyusers--; + if (em->emcopyusers < 0) { + printf("warning: em->emcopyusers was less then zero.\n"); + } + + if (em->emcopyusers <= 0) { + BMEdit_Free(em->emcopy); + MEM_freeN(em->emcopy); + em->emcopy = NULL; + } + } + + return 1; +} + +int EDBM_CallOpf(BMEditMesh *em, wmOperator *op, const char *fmt, ...) +{ + BMesh *bm = em->bm; + BMOperator bmop; + va_list list; + + va_start(list, fmt); + + if (!BMO_op_vinitf(bm, &bmop, fmt, list)) { + BKE_report(op->reports, RPT_ERROR, + "Parse error in EDBM_CallOpf"); + va_end(list); + return 0; + } + + if (!em->emcopy) + em->emcopy = BMEdit_Copy(em); + em->emcopyusers++; + + BMO_op_exec(bm, &bmop); + + va_end(list); + return EDBM_FinishOp(em, &bmop, op, TRUE); +} + +int EDBM_CallAndSelectOpf(BMEditMesh *em, wmOperator *op, const char *selectslot, const char *fmt, ...) +{ + BMesh *bm = em->bm; + BMOperator bmop; + va_list list; + + va_start(list, fmt); + + if (!BMO_op_vinitf(bm, &bmop, fmt, list)) { + BKE_report(op->reports, RPT_ERROR, + "Parse error in EDBM_CallOpf"); + va_end(list); + return 0; + } + + if (!em->emcopy) + em->emcopy = BMEdit_Copy(em); + em->emcopyusers++; + + BMO_op_exec(bm, &bmop); + + BM_mesh_elem_flag_disable_all(em->bm, BM_VERT|BM_EDGE|BM_FACE, BM_ELEM_SELECT); + + BMO_slot_buffer_hflag_enable(em->bm, &bmop, selectslot, BM_ELEM_SELECT, BM_ALL); + + va_end(list); + return EDBM_FinishOp(em, &bmop, op, TRUE); +} + +int EDBM_CallOpfSilent(BMEditMesh *em, const char *fmt, ...) +{ + BMesh *bm = em->bm; + BMOperator bmop; + va_list list; + + va_start(list, fmt); + + if (!BMO_op_vinitf(bm, &bmop, fmt, list)) { + va_end(list); + return 0; + } + + if (!em->emcopy) + em->emcopy = BMEdit_Copy(em); + em->emcopyusers++; + + BMO_op_exec(bm, &bmop); + + va_end(list); + return EDBM_FinishOp(em, &bmop, NULL, FALSE); +} + +void EDBM_selectmode_to_scene(bContext *C) +{ + Scene *scene = CTX_data_scene(C); + Object *obedit = CTX_data_edit_object(C); + BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh; + + if (!em) + return; + + scene->toolsettings->selectmode = em->selectmode; + + /* Request redraw of header buttons (to show new select mode) */ + WM_event_add_notifier(C, NC_SCENE|ND_TOOLSETTINGS, scene); +} + +void EDBM_MakeEditBMesh(ToolSettings *ts, Scene *UNUSED(scene), Object *ob) +{ + Mesh *me = ob->data; + BMesh *bm; + + if (!me->mpoly && me->totface) { + fprintf(stderr, "%s: bmesh conversion issue! may lose lots of geometry! (bmesh internal error)\n", __func__); + + /* BMESH_TODO need to write smarter code here */ + bm = BKE_mesh_to_bmesh(me, ob); + } + else { + bm = BKE_mesh_to_bmesh(me, ob); + } + + if (me->edit_btmesh) { + /* this happens when switching shape keys */ + BMEdit_Free(me->edit_btmesh); + MEM_freeN(me->edit_btmesh); + } + + /* currently executing operators re-tesselates, so we can avoid doing here + * but at some point it may need to be added back. */ +#if 0 + me->edit_btmesh = BMEdit_Create(bm, TRUE); +#else + me->edit_btmesh = BMEdit_Create(bm, FALSE); +#endif + + me->edit_btmesh->selectmode = me->edit_btmesh->bm->selectmode = ts->selectmode; + me->edit_btmesh->me = me; + me->edit_btmesh->ob = ob; +} + +void EDBM_LoadEditBMesh(Scene *scene, Object *ob) +{ + Mesh *me = ob->data; + BMesh *bm = me->edit_btmesh->bm; + + BMO_op_callf(bm, "object_load_bmesh scene=%p object=%p", scene, ob); +} + +void EDBM_FreeEditBMesh(BMEditMesh *tm) +{ + BMEdit_Free(tm); +} + +void EDBM_init_index_arrays(BMEditMesh *tm, int forvert, int foredge, int forface) +{ + EDBM_free_index_arrays(tm); + + if (forvert) { + BMIter iter; + BMVert *ele; + int i = 0; + + tm->vert_index = MEM_mallocN(sizeof(void **) * tm->bm->totvert, "tm->vert_index"); + + ele = BM_iter_new(&iter, tm->bm, BM_VERTS_OF_MESH, NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + tm->vert_index[i++] = ele; + } + } + + if (foredge) { + BMIter iter; + BMEdge *ele; + int i = 0; + + tm->edge_index = MEM_mallocN(sizeof(void **) * tm->bm->totedge, "tm->edge_index"); + + ele = BM_iter_new(&iter, tm->bm, BM_EDGES_OF_MESH, NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + tm->edge_index[i++] = ele; + } + } + + if (forface) { + BMIter iter; + BMFace *ele; + int i = 0; + + tm->face_index = MEM_mallocN(sizeof(void **) * tm->bm->totface, "tm->face_index"); + + ele = BM_iter_new(&iter, tm->bm, BM_FACES_OF_MESH, NULL); + for ( ; ele; ele = BM_iter_step(&iter)) { + tm->face_index[i++] = ele; + } + } +} + +void EDBM_free_index_arrays(BMEditMesh *tm) +{ + if (tm->vert_index) { + MEM_freeN(tm->vert_index); + tm->vert_index = NULL; + } + + if (tm->edge_index) { + MEM_freeN(tm->edge_index); + tm->edge_index = NULL; + } + + if (tm->face_index) { + MEM_freeN(tm->face_index); + tm->face_index = NULL; + } +} + +BMVert *EDBM_get_vert_for_index(BMEditMesh *tm, int index) +{ + return tm->vert_index && index < tm->bm->totvert ?tm->vert_index[index]:NULL; +} + +BMEdge *EDBM_get_edge_for_index(BMEditMesh *tm, int index) +{ + return tm->edge_index && index < tm->bm->totedge ?tm->edge_index[index]:NULL; +} + +BMFace *EDBM_get_face_for_index(BMEditMesh *tm, int index) +{ + return (tm->face_index && index < tm->bm->totface && index >= 0) ? tm->face_index[index] : NULL; +} + +void EDBM_selectmode_flush_ex(BMEditMesh *em, int selectmode) +{ + em->bm->selectmode = selectmode; + BM_mesh_select_mode_flush(em->bm); + em->bm->selectmode = em->selectmode; +} + +void EDBM_selectmode_flush(BMEditMesh *em) +{ + EDBM_selectmode_flush_ex(em, em->selectmode); +} + +void EDBM_deselect_flush(BMEditMesh *em) +{ + /* function below doesnt use. just do this to keep the values in sync */ + em->bm->selectmode = em->selectmode; + BM_mesh_deselect_flush(em->bm); +} + + +void EDBM_select_flush(BMEditMesh *em) +{ + /* function below doesnt use. just do this to keep the values in sync */ + em->bm->selectmode = em->selectmode; + BM_mesh_select_flush(em->bm); +} + +void EDBM_select_more(BMEditMesh *em) +{ + BMOperator bmop; + int usefaces = em->selectmode > SCE_SELECT_EDGE; + @@ Diff output truncated at 10240 characters. @@ _______________________________________________ Bf-blender-cvs mailing list Bf-blender-cvs@blender.org http://lists.blender.org/mailman/listinfo/bf-blender-cvs