Merged changes in the trunk up to revision 45383.
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Wed, 4 Apr 2012 00:50:41 +0000 (00:50 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Wed, 4 Apr 2012 00:50:41 +0000 (00:50 +0000)
85 files changed:
release/scripts/presets/keyconfig/maya.py
release/scripts/startup/bl_operators/image.py
release/scripts/startup/bl_operators/mesh.py
release/scripts/startup/bl_ui/properties_object_constraint.py
release/scripts/startup/bl_ui/space_view3d.py
release/scripts/startup/bl_ui/space_view3d_toolbar.py
source/blender/blenkernel/BKE_context.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/context.c
source/blender/blenkernel/intern/displist.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenlib/BLI_math_matrix.h
source/blender/blenlib/intern/math_matrix.c
source/blender/blenlib/intern/math_rotation.c
source/blender/blenloader/intern/readfile.c
source/blender/bmesh/intern/bmesh_construct.c
source/blender/bmesh/intern/bmesh_inline.h
source/blender/bmesh/intern/bmesh_marking.c
source/blender/bmesh/intern/bmesh_marking.h
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/bmesh/intern/bmesh_mesh_conv.c
source/blender/bmesh/intern/bmesh_mesh_validate.c
source/blender/bmesh/intern/bmesh_operator_api.h
source/blender/bmesh/intern/bmesh_operator_api_inline.h
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_queries.c
source/blender/bmesh/intern/bmesh_walkers_impl.c
source/blender/bmesh/operators/bmo_dupe.c
source/blender/bmesh/operators/bmo_extrude.c
source/blender/bmesh/operators/bmo_inset.c
source/blender/bmesh/operators/bmo_subdivide.c
source/blender/bmesh/tools/BME_bevel.c
source/blender/editors/animation/anim_filter.c
source/blender/editors/armature/poseobject.c
source/blender/editors/curve/editcurve.c
source/blender/editors/include/UI_interface.h
source/blender/editors/interface/interface_layout.c
source/blender/editors/interface/interface_regions.c
source/blender/editors/mesh/editface.c
source/blender/editors/mesh/editmesh_loopcut.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/editmesh_utils.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/render/render_opengl.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt_undo.c
source/blender/editors/space_console/console_intern.h
source/blender/editors/space_console/console_ops.c
source/blender/editors/space_console/space_console.c
source/blender/editors/space_graph/graph_draw.c
source/blender/editors/space_image/image_ops.c
source/blender/editors/space_image/space_image.c
source/blender/editors/space_view3d/drawmesh.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_fly.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_manipulator.c
source/blender/editors/transform/transform_orientations.c
source/blender/editors/uvedit/uvedit_buttons.c
source/blender/editors/uvedit/uvedit_draw.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/gpu/intern/gpu_buffers.c
source/blender/imbuf/intern/anim_movie.c
source/blender/imbuf/intern/filetype.c
source/blender/imbuf/intern/openexr/SConscript
source/blender/imbuf/intern/openexr/openexr_api.cpp
source/blender/imbuf/intern/openexr/openexr_api.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_test.c
source/blender/makesrna/intern/rna_timeline.c
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_boolean_util.c
source/blender/modifiers/intern/MOD_explode.c
source/blender/nodes/composite/nodes/node_composite_bilateralblur.c
source/blender/python/intern/bpy_rna.c
source/blender/python/mathutils/mathutils_Matrix.c
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/volumetric.c

index d9228514a72f562a72915faa112159b65da4fb9e..4a869c3c1c833373e566fdabb7e63b7f1e93c81d 100644 (file)
@@ -164,7 +164,7 @@ kmi = km.keymap_items.new('view3d.zoom_border', 'B', 'PRESS', shift=True)
 kmi = km.keymap_items.new('view3d.render_border', 'B', 'PRESS', shift=True)
 kmi = km.keymap_items.new('view3d.camera_to_view', 'NUMPAD_0', 'PRESS', ctrl=True, alt=True)
 kmi = km.keymap_items.new('view3d.object_as_camera', 'NUMPAD_0', 'PRESS', ctrl=True)
-kmi = km.keymap_items.new('wm.call_menu', 'S', 'PRESS', shift=True)
+kmi = km.keymap_items.new('wm.call_menu', 'S', 'PRESS', shift=True, ctrl=True)
 kmi.properties.name = 'VIEW3D_MT_snap'
 kmi = km.keymap_items.new('wm.context_set_enum', 'COMMA', 'PRESS')
 kmi.properties.data_path = 'space_data.pivot_point'
index 754e993dacbb0749aba564aaef3c14455e3f7255..1b7d5e3a40d059ea2f97643e73b0827cb58d8dcc 100644 (file)
@@ -96,6 +96,10 @@ class EditExternally(Operator):
             self.report({'ERROR'}, "Context incorrect, image not found")
             return {'CANCELLED'}
 
+        if image.packed_file:
+            self.report({'ERROR'}, "Image is packed, unpack before editing")
+            return {'CANCELLED'}
+
         filepath = bpy.path.abspath(image.filepath, library=image.library)
 
         self.filepath = os.path.normpath(filepath)
index cc5442d41aacc63302ed84f306870fdd569f1943..2d4c703dbf23a5f5b72ec2457601b6d5460437eb 100644 (file)
@@ -55,7 +55,7 @@ class MeshMirrorUV(Operator):
         mirror_gt = {}
         mirror_lt = {}
 
-        vcos = [v.co.to_tuple(5) for v in mesh.vertices]
+        vcos = (v.co.to_tuple(5) for v in mesh.vertices)
 
         for i, co in enumerate(vcos):
             if co[0] > 0.0:
@@ -76,51 +76,60 @@ class MeshMirrorUV(Operator):
                 if j is not None:
                     vmap[i] = j
 
-        active_uv_layer = mesh.uv_textures.active.data
-        fuvs = [(uv.uv1, uv.uv2, uv.uv3, uv.uv4) for uv in active_uv_layer]
-        fuvs_cpy = [(uv[0].copy(), uv[1].copy(), uv[2].copy(), uv[3].copy())
-                    for uv in fuvs]
-
-        # as a list
-        # BMESH_TODO - use polygons
-        faces = mesh.faces[:]
-
-        fuvsel = [(False not in uv.select_uv) for uv in active_uv_layer]
-        fcents = [f.center for f in faces]
-
-        # find mirror faces
-        mirror_fm = {}
-        for i, f in enumerate(faces):
-            verts = list(f.vertices)
-            verts.sort()
-            verts = tuple(verts)
-            mirror_fm[verts] = i
-
-        fmap = {}
-        for i, f in enumerate(faces):
-            verts = [vmap.get(j) for j in f.vertices]
-            if None not in verts:
-                verts.sort()
-                j = mirror_fm.get(tuple(verts))
+        polys = mesh.polygons
+        loops = mesh.loops
+        verts = mesh.vertices
+        uv_loops = mesh.uv_loop_layers.active.data
+        nbr_polys = len(polys)
+
+        mirror_pm = {}
+        pmap = {}
+        puvs = [None] * nbr_polys
+        puvs_cpy = [None] * nbr_polys
+        puvsel = [None] * nbr_polys
+        pcents = [None] * nbr_polys
+        vidxs = [None] * nbr_polys
+        for i, p in enumerate(polys):
+            lstart = lend = p.loop_start
+            lend += p.loop_total
+            puvs[i] = tuple(uv.uv for uv in uv_loops[lstart:lend])
+            puvs_cpy[i] = tuple(uv.copy() for uv in puvs[i])
+            puvsel[i] = (False not in
+                               (uv.select for uv in uv_loops[lstart:lend]))
+            # Vert idx of the poly.
+            vidxs[i] = tuple(sorted(l.vertex_index
+                                    for l in loops[lstart:lend]))
+            # As we have no poly.center yet...
+            pcents[i] = tuple(map(lambda x : x / p.loop_total,
+                                  map(sum, zip(*(verts[idx].co
+                                                 for idx in vidxs[i])))))
+            # Preparing next step finding matching polys.
+            mirror_pm[vidxs[i]] = i
+
+        for i in range(nbr_polys):
+            # Find matching mirror poly.
+            tvidxs = [vmap.get(j) for j in vidxs[i]]
+            if None not in tvidxs:
+                tvidxs.sort()
+                j = mirror_pm.get(tuple(tvidxs))
                 if j is not None:
-                    fmap[i] = j
+                    pmap[i] = j
 
-        for i, j in fmap.items():
-
-            if not fuvsel[i] or not fuvsel[j]:
+        for i, j in pmap.items():
+            if not puvsel[i] or not puvsel[j]:
                 continue
-            elif DIR == 0 and fcents[i][0] < 0.0:
+            elif DIR == 0 and pcents[i][0] < 0.0:
                 continue
-            elif DIR == 1 and fcents[i][0] > 0.0:
+            elif DIR == 1 and pcents[i][0] > 0.0:
                 continue
 
             # copy UVs
-            uv1 = fuvs[i]
-            uv2 = fuvs_cpy[j]
+            uv1 = puvs[i]
+            uv2 = puvs_cpy[j]
 
             # get the correct rotation
-            v1 = faces[j].vertices[:]
-            v2 = [vmap[k] for k in faces[i].vertices[:]]
+            v1 = vidxs[j]
+            v2 = tuple(vmap[k] for k in vidxs[i])
 
             if len(v1) == len(v2):
                 for k in range(len(v1)):
index c1b49d087caf70955ce1216b3533b4268a521a20..ce6c7ad4e928581e51a73f3b8c43aa238e72b813 100644 (file)
@@ -816,7 +816,7 @@ class ConstraintButtonsPanel():
         layout.operator("clip.constraint_to_fcurve")
 
     def SCRIPT(self, context, layout, con):
-        layout.label("Blender 2.5 has no py-constraints")
+        layout.label("Blender 2.6 doesn't support python constraints yet.")
 
 
 class OBJECT_PT_constraints(ConstraintButtonsPanel, Panel):
index d8433414db99b258f366d14e8f338d3a5bc5765f..baae996334c4b56158a38dd350683e4977dd2f3d 100644 (file)
@@ -1188,6 +1188,7 @@ class VIEW3D_MT_paint_weight(Menu):
         layout.operator("object.vertex_group_invert", text="Invert")
         layout.operator("object.vertex_group_clean", text="Clean")
         layout.operator("object.vertex_group_levels", text="Levels")
+        layout.operator("object.vertex_group_blend", text="Blend")
         layout.operator("object.vertex_group_fix", text="Fix Deforms")
 
         layout.separator()
index e6c89478287d9f946c3f42ff8f6589aee0f48cd6..55eb4f26c3f02fea61c32ba307b1c4aa9f7093e1 100644 (file)
@@ -977,6 +977,7 @@ class VIEW3D_PT_tools_weightpaint(View3DPanel, Panel):
         col.operator("object.vertex_group_invert", text="Invert")
         col.operator("object.vertex_group_clean", text="Clean")
         col.operator("object.vertex_group_levels", text="Levels")
+        col.operator("object.vertex_group_blend", text="Blend")
         col.operator("object.vertex_group_fix", text="Fix Deforms")
 
 
index 5966f8e0ff0c1a78d7a00adc11d01b4733f09dc4..944cce675ccf5e2469f3d99fc7485fd5e0e15e99 100644 (file)
@@ -117,6 +117,7 @@ bContext *CTX_copy(const bContext *C);
 /* Stored Context */
 
 bContextStore *CTX_store_add(ListBase *contexts, const char *name, PointerRNA *ptr);
+bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context);
 void CTX_store_set(bContext *C, bContextStore *store);
 bContextStore *CTX_store_copy(bContextStore *store);
 void CTX_store_free(bContextStore *store);
index 0041553ec44ece05cfba04e6d9f80ea8e3af56a5..65ef4e5b43154ea9b7d768109ef595ac6e8150e2 100644 (file)
@@ -382,6 +382,13 @@ void DM_ensure_tessface(DerivedMesh *dm)
                               __func__, numPolys, dm->type);
                }
        }
+
+       else if (dm->dirty && DM_DIRTY_TESS_CDLAYERS) {
+               BLI_assert(CustomData_has_layer(&dm->faceData, CD_POLYINDEX));
+               DM_update_tessface_data(dm);
+       }
+
+       dm->dirty &= ~DM_DIRTY_TESS_CDLAYERS;
 }
 
 /* Update tessface CD data from loop/poly ones. Needed when not retessellating after modstack evaluation. */
@@ -1629,7 +1636,7 @@ static void mesh_calc_modifiers(Scene *scene, Object *ob, float (*inputVertexCos
 
                                        deformedVerts = NULL;
                                }
-                       } 
+                       }
 
                        /* create an orco derivedmesh in parallel */
                        if (nextmask & CD_MASK_ORCO) {
@@ -3061,6 +3068,8 @@ void DM_init_origspace(DerivedMesh *dm)
                        }
                }
        }
+
+       dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
 }
 
 
index b457e71affd9f83b9f6b97b3a8f899bac06d3cab..03f2851531cea3c9e3887decd91bc65bbd9d2437 100644 (file)
@@ -583,10 +583,11 @@ static void cdDM_drawFacesSolid(DerivedMesh *dm,
                GPU_normal_setup( dm );
                if ( !GPU_buffer_legacy(dm) ) {
                        glShadeModel(GL_SMOOTH);
-                       for ( a = 0; a < dm->drawObject->totmaterial; a++ ) {
-                               if ( setMaterial(dm->drawObject->materials[a].mat_nr+1, NULL) )
+                       for (a = 0; a < dm->drawObject->totmaterial; a++) {
+                               if (setMaterial(dm->drawObject->materials[a].mat_nr + 1, NULL)) {
                                        glDrawArrays(GL_TRIANGLES, dm->drawObject->materials[a].start,
-                                                    dm->drawObject->materials[a].totpoint);
+                                                    dm->drawObject->materials[a].totpoint);
+                               }
                        }
                }
                GPU_buffer_unbind( );
@@ -1466,13 +1467,13 @@ static void cdDM_foreachMappedFaceCenter(
 {
        CDDerivedMesh *cddm = (CDDerivedMesh*)dm;
        MVert *mv = cddm->mvert;
-       MPoly *mf = cddm->mpoly;
+       MPoly *mp = cddm->mpoly;
        MLoop *ml = cddm->mloop;
        int i, j, orig, *index;
 
        index = CustomData_get_layer(&dm->polyData, CD_ORIGINDEX);
-       mf = cddm->mpoly;
-       for (i = 0; i < dm->numPolyData; i++, mf++) {
+       mp = cddm->mpoly;
+       for (i = 0; i < dm->numPolyData; i++, mp++) {
                float cent[3];
                float no[3];
 
@@ -1483,20 +1484,26 @@ static void cdDM_foreachMappedFaceCenter(
                else
                        orig = i;
                
-               ml = &cddm->mloop[mf->loopstart];
+               ml = &cddm->mloop[mp->loopstart];
                cent[0] = cent[1] = cent[2] = 0.0f;
-               for (j=0; j<mf->totloop; j++, ml++) {
+               for (j=0; j<mp->totloop; j++, ml++) {
                        add_v3_v3v3(cent, cent, mv[ml->v].co);
                }
                mul_v3_fl(cent, 1.0f / (float)j);
 
-               ml = &cddm->mloop[mf->loopstart];
+               ml = &cddm->mloop[mp->loopstart];
                if (j > 3) {
-                       normal_quad_v3(no, mv[ml->v].co, mv[(ml+1)->v].co,
-                                      mv[(ml+2)->v].co, mv[(ml+3)->v].co);
+                       normal_quad_v3(no,
+                                      mv[(ml + 0)->v].co,
+                                      mv[(ml + 1)->v].co,
+                                      mv[(ml + 2)->v].co,
+                                      mv[(ml + 3)->v].co);
                }
                else {
-                       normal_tri_v3(no, mv[ml->v].co, mv[(ml+1)->v].co, mv[(ml+2)->v].co);
+                       normal_tri_v3(no,
+                                     mv[(ml + 0)->v].co,
+                                     mv[(ml + 1)->v].co,
+                                     mv[(ml + 2)->v].co);
                }
 
                func(userData, orig, cent, no);
index a725b5f4c52afb51926a63dde96d4a6f62158276..e9dd4d01b0e89c03a34870a01ba2e01de3364ce4 100644 (file)
@@ -141,6 +141,35 @@ bContextStore *CTX_store_add(ListBase *contexts, const char *name, PointerRNA *p
        return ctx;
 }
 
+bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context)
+{
+       bContextStoreEntry *entry, *tentry;
+       bContextStore *ctx, *lastctx;
+
+       /* ensure we have a context to put the entries in, if it was already used
+        * we have to copy the context to ensure */
+       ctx= contexts->last;
+
+       if (!ctx || ctx->used) {
+               if (ctx) {
+                       lastctx= ctx;
+                       ctx= MEM_dupallocN(lastctx);
+                       BLI_duplicatelist(&ctx->entries, &lastctx->entries);
+               }
+               else
+                       ctx= MEM_callocN(sizeof(bContextStore), "bContextStore");
+
+               BLI_addtail(contexts, ctx);
+       }
+
+       for (tentry= context->entries.first; tentry; tentry= tentry->next) {
+               entry= MEM_dupallocN(tentry);
+               BLI_addtail(&ctx->entries, entry);
+       }
+
+       return ctx;
+}
+
 void CTX_store_set(bContext *C, bContextStore *store)
 {
        C->wm.store= store;
index 692eadd6bd35cc369dd492d19f5e2a4c9223bc63..c54461a5a130d7ec6c7c1b16679bbbc5769bebbf 100644 (file)
@@ -1401,7 +1401,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
                        curve_to_filledpoly(cu, nubase, dispbase);
                }
 
-               if (cu->flag & CU_PATH) calc_curvepath(ob);
+               if ((cu->flag & CU_PATH) && !forOrco) calc_curvepath(ob);
 
                /* make copy of 'undeformed" displist for texture space calculation
                 * actually, it's not totally undeformed -- pre-tessellation modifiers are
index 40d829808ca618d133224b3a418e72c86113fea9..872f678d456e8381b40decbab6c9457585a0f7ee 100644 (file)
@@ -1633,7 +1633,7 @@ static struct DerivedMesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData
                                                                #pragma omp parallel for schedule(static)
                                                                for (i=0; i<totpoly; i++) {
                                                                        int j=0;
-                                                                       Material *material = give_current_material(ob, mp[i].mat_nr+1);
+                                                                       Material *material = give_current_material(ob, mp[i].mat_nr + 1);
 
                                                                        for (; j<mp[i].totloop; j++) {
                                                                                int l_index = mp[i].loopstart + j;
index dd1546d694bd259683f662ee0b694f4a2d10b635..a851c44023009c41654a84e1cfd6106f89ba0767 100644 (file)
@@ -1616,13 +1616,13 @@ static void psys_origspace_to_w(OrigSpaceFace *osface, int quad, const float w[4
 int psys_particle_dm_face_lookup(Object *ob, DerivedMesh *dm, int index, const float fw[4], struct LinkNode *node)
 {
        Mesh *me= (Mesh*)ob->data;
-       MPoly *mface;
+       MPoly *mpoly;
        OrigSpaceFace *osface;
        int *origindex;
        int quad, findex, totface;
        float uv[2], (*faceuv)[2];
 
-       mface = dm->getPolyArray(dm);
+       mpoly = dm->getPolyArray(dm);
        origindex = dm->getTessFaceDataArray(dm, CD_ORIGINDEX);
        osface = dm->getTessFaceDataArray(dm, CD_ORIGSPACE);
 
@@ -1648,7 +1648,7 @@ int psys_particle_dm_face_lookup(Object *ob, DerivedMesh *dm, int index, const f
                for (;node; node=node->next) {
                        findex= GET_INT_FROM_POINTER(node->link);
                        faceuv= osface[findex].uv;
-                       quad = (mface[findex].totloop == 4);
+                       quad = (mpoly[findex].totloop == 4);
 
                        /* check that this intersects - Its possible this misses :/ -
                         * could also check its not between */
@@ -1664,7 +1664,7 @@ int psys_particle_dm_face_lookup(Object *ob, DerivedMesh *dm, int index, const f
                for (findex=0; findex<totface; findex++) {
                        if (origindex[findex] == index) {
                                faceuv= osface[findex].uv;
-                               quad = (mface[findex].totloop == 4);
+                               quad = (mpoly[findex].totloop == 4);
 
                                /* check that this intersects - Its possible this misses :/ -
                                 * could also check its not between */
index 269c603bd15a6faa0def6a8c49e7b5f8b700b36f..3686e867b48cc443360709fd6e20a4277e5bd129 100644 (file)
@@ -1270,7 +1270,7 @@ static void ccgDM_copyFinalLoopArray(DerivedMesh *dm, MLoop *mloop)
        }
 }
 
-static void ccgDM_copyFinalPolyArray(DerivedMesh *dm, MPoly *mface)
+static void ccgDM_copyFinalPolyArray(DerivedMesh *dm, MPoly *mpoly)
 {
        CCGDerivedMesh *ccgdm = (CCGDerivedMesh*) dm;
        CCGSubSurf *ss = ccgdm->ss;
@@ -1291,12 +1291,12 @@ static void ccgDM_copyFinalPolyArray(DerivedMesh *dm, MPoly *mface)
                for (S = 0; S < numVerts; S++) {
                        for (y = 0; y < gridSize - 1; y++) {
                                for (x = 0; x < gridSize - 1; x++) {
-                                       MPoly *mf = &mface[i];
+                                       MPoly *mp = &mpoly[i];
 
-                                       mf->mat_nr = mat_nr;
-                                       mf->flag = flag;
-                                       mf->loopstart = k;
-                                       mf->totloop = 4;
+                                       mp->mat_nr = mat_nr;
+                                       mp->flag = flag;
+                                       mp->loopstart = k;
+                                       mp->totloop = 4;
 
                                        k += 4;
                                        i++;
index de4bd203eb6c9b18b95431f8d13977bf7b0269a8..00a751f9da38c2637bf932979790211de3c584a4 100644 (file)
@@ -123,6 +123,8 @@ void orthogonalize_m4(float R[4][4], int axis);
 
 int is_orthogonal_m3(float mat[3][3]);
 int is_orthogonal_m4(float mat[4][4]);
+int is_orthonormal_m3(float mat[3][3]);
+int is_orthonormal_m4(float mat[4][4]);
 
 void adjoint_m3_m3(float R[3][3], float A[3][3]);
 void adjoint_m4_m4(float R[4][4], float A[4][4]);
index e61a8ef041abf6644a3f452d1f1e719e4d17cf1e..76b986d7346b8d2402ae1800bd2c9187e988bac7 100644 (file)
@@ -816,9 +816,6 @@ int is_orthogonal_m3(float m[][3])
                        if (fabsf(dot_v3v3(m[i], m[j])) > 1.5f * FLT_EPSILON)
                                return 0;
                }
-
-               if (fabsf(dot_v3v3(m[i], m[i]) - 1) > 1.5f * FLT_EPSILON)
-                       return 0;
        }
 
        return 1;
@@ -834,13 +831,41 @@ int is_orthogonal_m4(float m[][4])
                                return 0;
                }
 
-               if (fabsf(dot_vn_vn(m[i], m[i], 4) - 1) > 1.5f * FLT_EPSILON)
-                       return 0;
        }
 
        return 1;
 }
 
+int is_orthonormal_m3(float m[][3])
+{
+       if (is_orthogonal_m3(m)) {
+               int i;
+
+               for (i = 0; i < 3; i++)
+                       if (fabsf(dot_v3v3(m[i], m[i]) - 1) > 1.5f * FLT_EPSILON)
+                               return 0;
+
+               return 1;
+       }
+
+       return 0;
+}
+
+int is_orthonormal_m4(float m[][4])
+{
+       if (is_orthogonal_m4(m)) {
+               int i;
+
+               for (i = 0; i < 4; i++)
+                       if (fabsf(dot_vn_vn(m[i], m[i], 4) - 1) > 1.5f * FLT_EPSILON)
+                               return 0;
+
+               return 1;
+       }
+
+       return 0;
+}
+
 void normalize_m3(float mat[][3])
 {
        normalize_v3(mat[0]);
index dbba672100e7538bbc76e037ce2282bec7414d64..ec5fd39cd874fee9081988b70e681ff130b2af8e 100644 (file)
@@ -708,7 +708,10 @@ void eulO_to_axis_angle(float axis[3], float *angle, const float eul[3], const s
        quat_to_axis_angle(axis, angle, q);
 }
 
-/* axis angle to 3x3 matrix - safer version (normalization of axis performed) */
+/* axis angle to 3x3 matrix - safer version (normalization of axis performed)
+ *
+ * note: we may want a normalized and non normalized version of this function.
+ */
 void axis_angle_to_mat3(float mat[3][3], const float axis[3], const float angle)
 {
        float nor[3], nsi[3], co, si, ico;
@@ -818,7 +821,7 @@ void single_axis_angle_to_mat3(float mat[3][3], const char axis, const float ang
 /****************************** Vector/Rotation ******************************/
 /* TODO: the following calls should probably be depreceated sometime         */
 
-/* axis angle to 3x3 matrix */
+/* ODO, replace use of this function with axis_angle_to_mat3() */
 void vec_rot_to_mat3(float mat[][3], const float vec[3], const float phi)
 {
        /* rotation of phi radials around vec */
index 3150da247547e94bfcb5f984005c87a4840f414d..ccff9ce02ff4e2ddf8ff5846fd67c62e98f0647b 100644 (file)
@@ -14559,6 +14559,8 @@ static void expand_scene(FileData *fd, Main *mainvar, Scene *sce)
                }
        }
 #endif
+
+       expand_doit(fd, mainvar, sce->clip);
 }
 
 static void expand_camera(FileData *fd, Main *mainvar, Camera *ca)
index d539b6d8c5bec67a832000b19d22a95cfa550aa4..75d1eec4111f52bd5299af7cc9deaf865b3cabc5 100644 (file)
@@ -532,18 +532,19 @@ static void bmo_remove_tagged_context_verts(BMesh *bm, const short oflag)
        BMEdge *e;
        BMFace *f;
 
-       BMIter verts;
-       BMIter edges;
-       BMIter faces;
+       BMIter iter;
+       BMIter itersub;
 
-       for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) {
+       BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                if (BMO_elem_flag_test(bm, v, oflag)) {
                        /* Visit edge */
-                       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_VERT, v); e; e = BM_iter_step(&edges))
+                       BM_ITER(e, &itersub, bm, BM_EDGES_OF_VERT, v) {
                                BMO_elem_flag_enable(bm, e, oflag);
+                       }
                        /* Visit face */
-                       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_VERT, v); f; f = BM_iter_step(&faces))
+                       BM_ITER(f, &itersub, bm, BM_FACES_OF_VERT, v) {
                                BMO_elem_flag_enable(bm, f, oflag);
+                       }
                }
        }
 
@@ -557,12 +558,12 @@ static void bmo_remove_tagged_context_edges(BMesh *bm, const short oflag)
        BMEdge *e;
        BMFace *f;
 
-       BMIter edges;
-       BMIter faces;
+       BMIter iter;
+       BMIter itersub;
 
-       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+       BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
                if (BMO_elem_flag_test(bm, e, oflag)) {
-                       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_EDGE, e); f; f = BM_iter_step(&faces)) {
+                       BM_ITER(f, &itersub, bm, BM_FACES_OF_EDGE, e) {
                                BMO_elem_flag_enable(bm, f, oflag);
                        }
                }
@@ -585,9 +586,9 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
        BMEdge *e;
        BMFace *f;
 
-       BMIter verts;
-       BMIter edges;
-       BMIter faces;
+       BMIter viter;
+       BMIter eiter;
+       BMIter fiter;
 
        switch (type) {
                case DEL_VERTS:
@@ -599,7 +600,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
                case DEL_EDGES:
                {
                        /* flush down to vert */
-                       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+                       BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
                                if (BMO_elem_flag_test(bm, e, oflag)) {
                                        BMO_elem_flag_enable(bm, e->v1, oflag);
                                        BMO_elem_flag_enable(bm, e->v2, oflag);
@@ -607,7 +608,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
                        }
                        bmo_remove_tagged_context_edges(bm, oflag);
                        /* remove loose vertice */
-                       for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) {
+                       BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
                                if (BMO_elem_flag_test(bm, v, oflag) && (!(v->e)))
                                        BMO_elem_flag_enable(bm, v, DEL_WIREVERT);
                        }
@@ -638,27 +639,27 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
                case DEL_FACES:
                {
                        /* go through and mark all edges and all verts of all faces for delet */
-                       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+                       BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                                if (BMO_elem_flag_test(bm, f, oflag)) {
-                                       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&edges))
+                                       for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter))
                                                BMO_elem_flag_enable(bm, e, oflag);
-                                       for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&verts))
+                                       for (v = BM_iter_new(&viter, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&viter))
                                                BMO_elem_flag_enable(bm, v, oflag);
                                }
                        }
                        /* now go through and mark all remaining faces all edges for keeping */
-                       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+                       BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                                if (!BMO_elem_flag_test(bm, f, oflag)) {
-                                       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&edges)) {
+                                       for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter)) {
                                                BMO_elem_flag_disable(bm, e, oflag);
                                        }
-                                       for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&verts)) {
+                                       for (v = BM_iter_new(&viter, bm, BM_VERTS_OF_FACE, f); v; v = BM_iter_step(&viter)) {
                                                BMO_elem_flag_disable(bm, v, oflag);
                                        }
                                }
                        }
                        /* also mark all the vertices of remaining edges for keeping */
-                       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+                       BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
                                if (!BMO_elem_flag_test(bm, e, oflag)) {
                                        BMO_elem_flag_disable(bm, e->v1, oflag);
                                        BMO_elem_flag_disable(bm, e->v2, oflag);
@@ -676,12 +677,15 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
                case DEL_ALL:
                {
                        /* does this option even belong in here? */
-                       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces))
+                       BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                                BMO_elem_flag_enable(bm, f, oflag);
-                       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges))
+                       }
+                       BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
                                BMO_elem_flag_enable(bm, e, oflag);
-                       for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts))
+                       }
+                       BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
                                BMO_elem_flag_enable(bm, v, oflag);
+                       }
 
                        BMO_remove_tagged_faces(bm, oflag);
                        BMO_remove_tagged_edges(bm, oflag);
index 2cfaf49d51e1b1514587fc5a5474f26c204faf15..400f4a55b0e84c0ced47d7dcd2236d584dbaf21e 100644 (file)
 #define __BMESH_INLINE_H__
 
 /* stuff for dealing with header flags */
-#define BM_elem_flag_test(   ele, hflag)      _bm_elem_flag_test    (&(ele)->head, hflag)
-#define BM_elem_flag_enable( ele, hflag)      _bm_elem_flag_enable  (&(ele)->head, hflag)
-#define BM_elem_flag_disable(ele, hflag)      _bm_elem_flag_disable (&(ele)->head, hflag)
-#define BM_elem_flag_set(    ele, hflag, val) _bm_elem_flag_set     (&(ele)->head, hflag, val)
-#define BM_elem_flag_toggle( ele, hflag)      _bm_elem_flag_toggle  (&(ele)->head, hflag)
-#define BM_elem_flag_merge(  ele_a, ele_b)    _bm_elem_flag_merge   (&(ele_a)->head, &(ele_b)->head)
+#define BM_elem_flag_test(     ele, hflag)      _bm_elem_flag_test     (&(ele)->head, hflag)
+#define BM_elem_flag_test_bool(ele, hflag)      _bm_elem_flag_test_bool(&(ele)->head, hflag)
+#define BM_elem_flag_enable(   ele, hflag)      _bm_elem_flag_enable   (&(ele)->head, hflag)
+#define BM_elem_flag_disable(  ele, hflag)      _bm_elem_flag_disable  (&(ele)->head, hflag)
+#define BM_elem_flag_set(      ele, hflag, val) _bm_elem_flag_set      (&(ele)->head, hflag, val)
+#define BM_elem_flag_toggle(   ele, hflag)      _bm_elem_flag_toggle   (&(ele)->head, hflag)
+#define BM_elem_flag_merge(    ele_a, ele_b)    _bm_elem_flag_merge    (&(ele_a)->head, &(ele_b)->head)
 
 BLI_INLINE char _bm_elem_flag_test(const BMHeader *head, const char hflag)
 {
        return head->hflag & hflag;
 }
 
+BLI_INLINE short _bm_elem_flag_test_bool(const BMHeader *head, const char hflag)
+{
+       return (head->hflag & hflag) != 0;
+}
+
 BLI_INLINE void _bm_elem_flag_enable(BMHeader *head, const char hflag)
 {
        head->hflag |= hflag;
index 2116acc337eb56c62e3e243141b22f4b4254bb6b..03c4d3c9cbb5124c1c3d0198f99783f9a1311c87 100644 (file)
@@ -78,13 +78,13 @@ void BM_mesh_select_mode_flush(BMesh *bm)
        BMLoop *l_first;
        BMFace *f;
 
-       BMIter edges;
-       BMIter faces;
+       BMIter eiter;
+       BMIter fiter;
 
        int ok;
 
        if (bm->selectmode & SCE_SELECT_VERTEX) {
-               for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+               BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
                        if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
                            BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
                            !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
@@ -95,7 +95,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
                                BM_elem_flag_disable(e, BM_ELEM_SELECT);
                        }
                }
-               for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+               BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                        ok = TRUE;
                        if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
                                l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -114,7 +114,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
                }
        }
        else if (bm->selectmode & SCE_SELECT_EDGE) {
-               for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+               BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                        ok = TRUE;
                        if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
                                l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -149,12 +149,12 @@ void BM_mesh_deselect_flush(BMesh *bm)
        BMLoop *l_first;
        BMFace *f;
 
-       BMIter edges;
-       BMIter faces;
+       BMIter eiter;
+       BMIter fiter;
 
        int ok;
 
-       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+       BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
                if (!(BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
                      BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
                      !BM_elem_flag_test(e, BM_ELEM_HIDDEN)))
@@ -163,7 +163,7 @@ void BM_mesh_deselect_flush(BMesh *bm)
                }
        }
 
-       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+       BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                ok = TRUE;
                if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
                        l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -200,12 +200,12 @@ void BM_mesh_select_flush(BMesh *bm)
        BMLoop *l_first;
        BMFace *f;
 
-       BMIter edges;
-       BMIter faces;
+       BMIter eiter;
+       BMIter fiter;
 
        int ok;
 
-       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+       BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
                if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
                    BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
                    !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
@@ -214,7 +214,7 @@ void BM_mesh_select_flush(BMesh *bm)
                }
        }
 
-       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+       BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
                ok = TRUE;
                if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
                        l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -397,39 +397,48 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select)
  */
 void BM_select_mode_set(BMesh *bm, int selectmode)
 {
-       BMVert *v;
-       BMEdge *e;
-       BMFace *f;
-       
-       BMIter verts;
-       BMIter edges;
-       BMIter faces;
+       BMIter iter;
+       BMElem *ele;
        
        bm->selectmode = selectmode;
 
        if (bm->selectmode & SCE_SELECT_VERTEX) {
-               for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges))
-                       BM_elem_flag_disable(e, 0);
-               for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces))
-                       BM_elem_flag_disable(f, 0);
+               /* disabled because selection flushing handles these */
+#if 0
+               BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+                       BM_elem_flag_disable(ele, BM_ELEM_SELECT);
+               }
+               BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+                       BM_elem_flag_disable(ele, BM_ELEM_SELECT);
+               }
+#endif
                BM_mesh_select_mode_flush(bm);
        }
        else if (bm->selectmode & SCE_SELECT_EDGE) {
-               for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts))
-                       BM_elem_flag_disable(v, 0);
-               for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
-                       if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
-                               BM_edge_select_set(bm, e, TRUE);
+               /* disabled because selection flushing handles these */
+#if 0
+               BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+                       BM_elem_flag_disable(ele, BM_ELEM_SELECT);
+               }
+#endif
+
+               BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+                       if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
+                               BM_edge_select_set(bm, (BMEdge *)ele, TRUE);
                        }
                }
                BM_mesh_select_mode_flush(bm);
        }
        else if (bm->selectmode & SCE_SELECT_FACE) {
-               for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges))
-                       BM_elem_flag_disable(e, 0);
-               for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
-                       if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
-                               BM_face_select_set(bm, f, TRUE);
+               /* disabled because selection flushing handles these */
+#if 0
+               BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+                       BM_elem_flag_disable(ele, BM_ELEM_SELECT);
+               }
+#endif
+               BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+                       if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
+                               BM_face_select_set(bm, (BMFace *)ele, TRUE);
                        }
                }
                BM_mesh_select_mode_flush(bm);
@@ -440,29 +449,30 @@ void BM_select_mode_set(BMesh *bm, int selectmode)
  * counts number of elements with flag enabled/disabled
  */
 static int bm_mesh_flag_count(BMesh *bm, const char htype, const char hflag,
-                                                         int respecthide, int test_for_enabled)
+                              const short respecthide, const short test_for_enabled)
 {
        BMElem *ele;
        BMIter iter;
-       int test = (test_for_enabled ? hflag : 0);
        int tot = 0;
 
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
        if (htype & BM_VERT) {
                for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) {
                        if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue;
-                       if (BM_elem_flag_test(ele, hflag) == test) tot++;
+                       if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) tot++;
                }
        }
        if (htype & BM_EDGE) {
                for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) {
                        if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue;
-                       if (BM_elem_flag_test(ele, hflag) == test) tot++;
+                       if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) tot++;
                }
        }
        if (htype & BM_FACE) {
                for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) {
                        if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue;
-                       if (BM_elem_flag_test(ele, hflag) == test) tot++;
+                       if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) tot++;
                }
        }
 
@@ -762,7 +772,7 @@ void BM_select_history_validate(BMesh *bm)
        }
 }
 
-void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag)
+void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag, int respecthide)
 {
        const char iter_types[3] = {BM_VERTS_OF_MESH,
                                    BM_EDGES_OF_MESH,
@@ -778,7 +788,10 @@ void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag
                BM_select_history_clear(bm);
        }
 
-       if (htype == (BM_VERT | BM_EDGE | BM_FACE) && (hflag == BM_ELEM_SELECT)) {
+       if ((htype == (BM_VERT | BM_EDGE | BM_FACE)) &&
+           (hflag == BM_ELEM_SELECT) &&
+           (respecthide == FALSE))
+       {
                /* fast path for deselect all, avoid topology loops
                 * since we know all will be de-selected anyway. */
                for (i = 0; i < 3; i++) {
@@ -794,6 +807,11 @@ void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag
                        if (htype & flag_types[i]) {
                                ele = BM_iter_new(&iter, bm, iter_types[i], NULL);
                                for ( ; ele; ele = BM_iter_step(&iter)) {
+
+                                       if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
+                                               continue;
+                                       }
+
                                        if (hflag & BM_ELEM_SELECT) {
                                                BM_elem_select_set(bm, ele, FALSE);
                                        }
@@ -804,7 +822,7 @@ void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag
        }
 }
 
-void BM_mesh_elem_flag_enable_all(BMesh *bm, const char htype, const char hflag)
+void BM_mesh_elem_flag_enable_all(BMesh *bm, const char htype, const char hflag, int respecthide)
 {
        const char iter_types[3] = {BM_VERTS_OF_MESH,
                                    BM_EDGES_OF_MESH,
@@ -812,6 +830,11 @@ void BM_mesh_elem_flag_enable_all(BMesh *bm, const char htype, const char hflag)
 
        const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
 
+       /* use the nosel version when setting so under no
+        * condition may a hidden face become selected.
+        * Applying other flags to hidden faces is OK. */
+       const char hflag_nosel = hflag & ~BM_ELEM_SELECT;
+
        BMIter iter;
        BMElem *ele;
        int i;
@@ -828,10 +851,15 @@ void BM_mesh_elem_flag_enable_all(BMesh *bm, const char htype, const char hflag)
                if (htype & flag_types[i]) {
                        ele = BM_iter_new(&iter, bm, iter_types[i], NULL);
                        for ( ; ele; ele = BM_iter_step(&iter)) {
+
+                               if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
+                                       continue;
+                               }
+
                                if (hflag & BM_ELEM_SELECT) {
                                        BM_elem_select_set(bm, ele, TRUE);
                                }
-                               BM_elem_flag_enable(ele, hflag);
+                               BM_elem_flag_enable(ele, hflag_nosel);
                        }
                }
        }
index a02931b0e886d6caceac2ee36e11b11e69575c99..fa078c74b2ebf2cc7c6aac86dca879471f71c1d7 100644 (file)
@@ -45,8 +45,8 @@ void BM_face_hide_set(BMesh *bm, BMFace *f, int hide);
 #define BM_elem_select_set(bm, ele, hide) _bm_elem_select_set(bm, &(ele)->head, hide)
 void _bm_elem_select_set(BMesh *bm, BMHeader *ele, int select);
 
-void BM_mesh_elem_flag_enable_all(BMesh *bm, const char htype, const char hflag);
-void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag);
+void BM_mesh_elem_flag_enable_all(BMesh *bm, const char htype, const char hflag, int respecthide);
+void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag, int respecthide);
 
 /* individual element select functions, BM_elem_select_set is a shortcut for these
  * that automatically detects which one to use*/
index f69a46e7d8c71fbec173e87039b423bc6163acaa..c15937abf1deeaf7d85b9788b0c8b01453b7bdd7 100644 (file)
@@ -101,20 +101,18 @@ void BM_mesh_data_free(BMesh *bm)
        BMFace *f;
        
 
-       BMIter verts;
-       BMIter edges;
-       BMIter faces;
-       BMIter loops;
+       BMIter iter;
+       BMIter itersub;
        
-       for (v = BM_iter_new(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BM_iter_step(&verts)) {
+       BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data));
        }
-       for (e = BM_iter_new(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&edges)) {
+       BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
                CustomData_bmesh_free_block(&(bm->edata), &(e->head.data));
        }
-       for (f = BM_iter_new(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BM_iter_step(&faces)) {
+       BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
                CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data));
-               for (l = BM_iter_new(&loops, bm, BM_LOOPS_OF_FACE, f); l; l = BM_iter_step(&loops)) {
+               BM_ITER(l, &itersub, bm, BM_LOOPS_OF_FACE, f) {
                        CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data));
                }
        }
index 1db0280b4af65f947a7d61c6ea964ec47b3231da..69defb15112eda22786fbeee5d433357f3373cb2 100644 (file)
@@ -256,10 +256,10 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
                BM_elem_index_set(f, bm->totface - 1); /* set_ok */
 
                /* transfer flag */
-               f->head.hflag = BM_face_flag_from_mflag(mpoly->flag & ~SELECT);
+               f->head.hflag = BM_face_flag_from_mflag(mpoly->flag & ~ME_FACE_SEL);
 
                /* this is necessary for selection counts to work properly */
-               if (mpoly->flag & SELECT) {
+               if (mpoly->flag & ME_FACE_SEL) {
                        BM_elem_select_set(bm, f, TRUE);
                }
 
@@ -849,10 +849,8 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
                        mvert = me->mvert;
                        while (eve) {
                                keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
-                               if (!keyi) {
-                                       break;
-                               }
-                               if (*keyi >= 0 && *keyi < currkey->totelem) { // valid old vertex
+
+                               if (keyi && *keyi != ORIGINDEX_NONE && *keyi < currkey->totelem) { /* valid old vertex */
                                        if (currkey == actkey) {
                                                if (actkey == me->key->refkey) {
                                                        copy_v3_v3(fp, mvert->co);
index 0ec13f1df8ff53694b10104e83559d9b8364244c..f91e9d828799c8f36f5b281c404ae470e61a9649 100644 (file)
@@ -71,9 +71,13 @@ int BM_mesh_validate(BMesh *bm)
        BM_mesh_elem_index_ensure(bm, BM_ALL);
 
        BM_ITER_INDEX(v, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+               if (BM_elem_flag_test(v, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
+                       ERRMSG("vert %d: is hidden and selected", i);
+               }
+
                if (v->e) {
                        if (!BM_vert_in_edge(v->e, v)) {
-                               ERRMSG("vert: %d - is not in its referenced edge: %d", i, BM_elem_index_get(v->e));
+                               ERRMSG("vert %d: is not in its referenced edge: %d", i, BM_elem_index_get(v->e));
                        }
                }
        }
@@ -86,6 +90,10 @@ int BM_mesh_validate(BMesh *bm)
 
        /* edge radial structure */
        BM_ITER_INDEX(e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
+               if (BM_elem_flag_test(e, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
+                       ERRMSG("edge %d: is hidden and selected", i);
+               }
+
                if (e->l) {
                        BMLoop *l_iter;
                        BMLoop *l_first;
@@ -113,6 +121,10 @@ int BM_mesh_validate(BMesh *bm)
                BMLoop *l_iter;
                BMLoop *l_first;
 
+               if (BM_elem_flag_test(f, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
+                       ERRMSG("face %d: is hidden and selected", i);
+               }
+
                l_iter = l_first = BM_FACE_FIRST_LOOP(f);
 
                do {
index bb980a6386170f13a6caf121d608e964560e3c17..7cba66995c920bfd5f880886a41ddd481c4be356 100644 (file)
@@ -75,17 +75,19 @@ extern "C" {
 
 struct GHashIterator;
 
-#define BMO_elem_flag_test(   bm, ele, oflag)      _bmo_elem_flag_test    (bm, (ele)->oflags, oflag)
-#define BMO_elem_flag_enable( bm, ele, oflag)      _bmo_elem_flag_enable  (bm, (ele)->oflags, oflag)
-#define BMO_elem_flag_disable(bm, ele, oflag)      _bmo_elem_flag_disable (bm, (ele)->oflags, oflag)
-#define BMO_elem_flag_set(    bm, ele, oflag, val) _bmo_elem_flag_set     (bm, (ele)->oflags, oflag, val)
-#define BMO_elem_flag_toggle( bm, ele, oflag)      _bmo_elem_flag_toggle  (bm, (ele)->oflags, oflag)
-
-BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag);
-BLI_INLINE void  _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag);
-BLI_INLINE void  _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag);
-BLI_INLINE void  _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val);
-BLI_INLINE void  _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag);
+#define BMO_elem_flag_test(     bm, ele, oflag)      _bmo_elem_flag_test     (bm, (ele)->oflags, oflag)
+#define BMO_elem_flag_test_bool(bm, ele, oflag)      _bmo_elem_flag_test_bool(bm, (ele)->oflags, oflag)
+#define BMO_elem_flag_enable(   bm, ele, oflag)      _bmo_elem_flag_enable   (bm, (ele)->oflags, oflag)
+#define BMO_elem_flag_disable(  bm, ele, oflag)      _bmo_elem_flag_disable  (bm, (ele)->oflags, oflag)
+#define BMO_elem_flag_set(      bm, ele, oflag, val) _bmo_elem_flag_set      (bm, (ele)->oflags, oflag, val)
+#define BMO_elem_flag_toggle(   bm, ele, oflag)      _bmo_elem_flag_toggle   (bm, (ele)->oflags, oflag)
+
+BLI_INLINE short _bmo_elem_flag_test(     BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE short _bmo_elem_flag_test_bool(BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE void  _bmo_elem_flag_enable(   BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE void  _bmo_elem_flag_disable(  BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE void  _bmo_elem_flag_set(      BMesh *bm, BMFlagLayer *oflags, const short oflag, int val);
+BLI_INLINE void  _bmo_elem_flag_toggle(   BMesh *bm, BMFlagLayer *oflags, const short oflag);
 
 /* slot type arrays are terminated by the last member
  * having a slot type of 0.*/
@@ -297,17 +299,17 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *op, const char htype, cons
 
 /* copies the values from another slot to the end of the output slot */
 void BMO_slot_buffer_append(BMOperator *output_op, const char *output_op_slot,
-                                                       BMOperator *other_op, const char *other_op_slot);
+                            BMOperator *other_op, const char *other_op_slot);
 
 /* puts every element of type 'type' (which is a bitmask) with tool
  * flag 'flag', into a slot. */
 void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                          const char htype, const short oflag);
+                                       const char htype, const short oflag);
 
 /* puts every element of type 'type' (which is a bitmask) without tool
  * flag 'flag', into a slot. */
 void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                               const char htype, const short oflag);
+                                        const char htype, const short oflag);
 
 /* tool-flags all elements inside an element slot array with flag flag. */
 void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname,
@@ -327,15 +329,15 @@ void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotna
  * flag 'flag', into a slot.  note: ignores hidden elements
  * (e.g. elements with header flag BM_ELEM_HIDDEN set).*/
 void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op,
-                                                                               const char *slotname,
-                                                                               const char htype, const char hflag);
+                                        const char *slotname,
+                                        const char htype, const char hflag);
 
 /* puts every element of type 'type' (which is a bitmask) without
  * header flag 'flag', into a slot.  note: ignores hidden elements
  * (e.g. elements with header flag BM_ELEM_HIDDEN set).*/
 void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op,
-                                                                                const char *slotname,
-                                                                                const char htype, const char hflag);
+                                         const char *slotname,
+                                         const char htype, const char hflag);
 
 /* counts number of elements inside a slot array. */
 int BMO_slot_buffer_count(BMesh *bm, BMOperator *op, const char *slotname);
index 268736cfe0e0445b21be9a0b4a596d1719847904..e04079f42c97466abf67edb865a91970a08e5eec 100644 (file)
 /* flags 15 and 16 (1 << 14 and 1 << 15) are reserved for bmesh api use */
 BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
-    return oflags[bm->stackdepth - 1].f & oflag;
+       return oflags[bm->stackdepth - 1].f & oflag;
+}
+
+BLI_INLINE short _bmo_elem_flag_test_bool(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+{
+       return (oflags[bm->stackdepth - 1].f & oflag) != 0;
 }
 
 BLI_INLINE void _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
@@ -65,13 +70,13 @@ BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const shor
 }
 
 BLI_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slotname,
-                                       void *element, int val)
+                                        void *element, int val)
 {
        BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(int));
 }
 
 BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname,
-                                         void *element, float val)
+                                          void *element, float val)
 {
        BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(float));
 }
@@ -83,7 +88,7 @@ BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char
  * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
 
 BLI_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname,
-                                       void *element, void *val)
+                                        void *element, void *val)
 {
        BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(void *));
 }
@@ -100,7 +105,7 @@ BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const ch
 }
 
 BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
-                                      void *element)
+                                       void *element)
 {
        BMOElemMapping *mapping;
        BMOpSlot *slot = BMO_slot_get(op, slotname);
@@ -117,7 +122,7 @@ BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const
 }
 
 BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname,
-                                       void *element)
+                                        void *element)
 {
        float *val = (float *) BMO_slot_map_data_get(bm, op, slotname, element);
        if (val) return *val;
@@ -126,7 +131,7 @@ BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *s
 }
 
 BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotname,
-                                   void *element)
+                                    void *element)
 {
        int *val = (int *) BMO_slot_map_data_get(bm, op, slotname, element);
        if (val) return *val;
@@ -135,7 +140,7 @@ BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotn
 }
 
 BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname,
-                                     void *element)
+                                      void *element)
 {
        void **val = (void **) BMO_slot_map_data_get(bm, op, slotname, element);
        if (val) return *val;
index e09be79633e7fac98559e112d2d25b47cabb861c..00292e481b2314e76c273491af7d6737a6e539fb 100644 (file)
@@ -274,8 +274,7 @@ void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src,
                }
 
                if (!dest_slot->data.ghash) {
-                       dest_slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash,
-                                                                                                 BLI_ghashutil_ptrcmp, "bmesh operator 2");
+                       dest_slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh operator 2");
                }
 
                BLI_ghashIterator_init(&it, source_slot->data.ghash);
@@ -457,29 +456,27 @@ void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3])
  */
 
 static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag,
-                                                          int test_for_enabled)
+                               const short test_for_enabled)
 {
-       BMIter elements;
+       const char iter_types[3] = {BM_VERTS_OF_MESH,
+                                   BM_EDGES_OF_MESH,
+                                   BM_FACES_OF_MESH};
+
+       const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
+
+       BMIter iter;
        int count = 0;
        BMElemF *ele_f;
-       int test = (test_for_enabled ? oflag : 0);
+       int i;
 
-       if (htype & BM_VERT) {
-               for (ele_f = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); ele_f; ele_f = BM_iter_step(&elements)) {
-                       if (BMO_elem_flag_test(bm, ele_f, oflag) == test)
-                               count++;
-               }
-       }
-       if (htype & BM_EDGE) {
-               for (ele_f = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); ele_f; ele_f = BM_iter_step(&elements)) {
-                       if (BMO_elem_flag_test(bm, ele_f, oflag) == test)
-                               count++;
-               }
-       }
-       if (htype & BM_FACE) {
-               for (ele_f = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); ele_f; ele_f = BM_iter_step(&elements)) {
-                       if (BMO_elem_flag_test(bm, ele_f, oflag) == test)
-                               count++;
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
+       for (i = 0; i < 3; i++) {
+               if (htype & flag_types[i]) {
+                       BM_ITER(ele_f, &iter, bm, iter_types[i], NULL) {
+                               if (BMO_elem_flag_test_bool(bm, ele_f, oflag) == test_for_enabled)
+                                       count++;
+                       }
                }
        }
 
@@ -559,8 +556,7 @@ void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname
        memcpy(mapping + 1, data, len);
 
        if (!slot->data.ghash) {
-               slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash,
-                                                BLI_ghashutil_ptrcmp, "bmesh slot map hash");
+               slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh slot map hash");
        }
 
        BLI_ghash_insert(slot->data.ghash, element, mapping);
@@ -651,8 +647,6 @@ static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len
  */
 static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
 {
-       BMIter elements;
-       BMHeader *e;
        BMOpSlot *output = BMO_slot_get(op, slotname);
        int totelement = 0, i = 0;
        
@@ -661,25 +655,30 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
        if (htype & BM_FACE) totelement += bm->totface;
 
        if (totelement) {
+               BMIter iter;
+               BMHeader *ele;
+
                bmo_slot_buffer_alloc(op, slotname, totelement);
 
+               /* TODO - collapse these loops into one */
+
                if (htype & BM_VERT) {
-                       for (e = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BM_iter_step(&elements)) {
-                               ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+                               ((BMHeader **)output->data.p)[i] = ele;
                                i++;
                        }
                }
 
                if (htype & BM_EDGE) {
-                       for (e = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BM_iter_step(&elements)) {
-                               ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+                               ((BMHeader **)output->data.p)[i] = ele;
                                i++;
                        }
                }
 
                if (htype & BM_FACE) {
-                       for (e = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BM_iter_step(&elements)) {
-                               ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+                               ((BMHeader **)output->data.p)[i] = ele;
                                i++;
                        }
                }
@@ -693,28 +692,32 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
  * enabled/disabled into a slot for an operator.
  */
 static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                          const char htype, const char hflag,
-                                                                          int test_for_enabled)
+                                       const char htype, const char hflag,
+                                       const short test_for_enabled)
 {
-       BMIter elements;
-       BMElem *ele;
        BMOpSlot *output = BMO_slot_get(op, slotname);
        int totelement = 0, i = 0;
 
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
        if (test_for_enabled)
                totelement = BM_mesh_enabled_flag_count(bm, htype, hflag, TRUE);
        else
                totelement = BM_mesh_disabled_flag_count(bm, htype, hflag, TRUE);
 
        if (totelement) {
-               int test = (test_for_enabled ? hflag : 0);
+               BMIter iter;
+               BMElem *ele;
 
                bmo_slot_buffer_alloc(op, slotname, totelement);
 
+               /* TODO - collapse these loops into one */
+
                if (htype & BM_VERT) {
-                       for (ele = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
+                       BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                                if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
-                                       BM_elem_flag_test(ele, hflag) == test) {
+                                   BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
+                               {
                                        ((BMElem **)output->data.p)[i] = ele;
                                        i++;
                                }
@@ -722,9 +725,10 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
                }
 
                if (htype & BM_EDGE) {
-                       for (ele = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
+                       BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
                                if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
-                                       BM_elem_flag_test(ele, hflag) == test) {
+                                   BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
+                               {
                                        ((BMElem **)output->data.p)[i] = ele;
                                        i++;
                                }
@@ -732,9 +736,10 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
                }
 
                if (htype & BM_FACE) {
-                       for (ele = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
+                       BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
                                if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
-                                       BM_elem_flag_test(ele, hflag) == test) {
+                                   BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
+                               {
                                        ((BMElem **)output->data.p)[i] = ele;
                                        i++;
                                }
@@ -747,13 +752,13 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
 }
 
 void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                               const char htype, const char hflag)
+                                        const char htype, const char hflag)
 {
        bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, TRUE);
 }
 
 void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                               const char htype, const char hflag)
+                                         const char htype, const char hflag)
 {
        bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, FALSE);
 }
@@ -762,13 +767,13 @@ void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *
  * Copies the values from another slot to the end of the output slot.
  */
 void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
-                                                       BMOperator *other_op, const char *other_slot_name)
+                            BMOperator *other_op, const char *other_slot_name)
 {
        BMOpSlot *output_slot = BMO_slot_get(output_op, output_slot_name);
        BMOpSlot *other_slot = BMO_slot_get(other_op, other_slot_name);
 
        BLI_assert(output_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF &&
-                          other_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+                  other_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
 
        if (output_slot->len == 0) {
                /* output slot is empty, copy rather than append */
@@ -782,8 +787,7 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
 
                /* copy slot data */
                memcpy(buf, output_slot->data.buf, elem_size * output_slot->len);
-               memcpy(((char*)buf) + elem_size * output_slot->len,
-                          other_slot->data.buf, elem_size * other_slot->len);
+               memcpy(((char *)buf) + elem_size * output_slot->len, other_slot->data.buf, elem_size * other_slot->len);
 
                output_slot->data.buf = buf;
                output_slot->len += other_slot->len;
@@ -797,32 +801,35 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
  * into an output slot for an operator.
  */
 static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                         const char htype, const short oflag,
-                                                                         int test_for_enabled)
+                                      const char htype, const short oflag,
+                                      const short test_for_enabled)
 {
-       BMIter elements;
        BMOpSlot *slot = BMO_slot_get(op, slotname);
        int totelement, i = 0;
 
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
        if (test_for_enabled)
                totelement = BMO_mesh_enabled_flag_count(bm, htype, oflag);
        else
-               totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag);    
+               totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag);
 
        BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
 
        if (totelement) {
+               BMIter iter;
                BMHeader *ele;
                BMHeader **ele_array;
-               int test = (test_for_enabled ? oflag : 0);
 
                bmo_slot_buffer_alloc(op, slotname, totelement);
 
                ele_array = (BMHeader **)slot->data.p;
 
+               /* TODO - collapse these loops into one */
+
                if (htype & BM_VERT) {
-                       for (ele = BM_iter_new(&elements, bm, BM_VERTS_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
-                               if (BMO_elem_flag_test(bm, (BMElemF *)ele, oflag) == test) {
+                       BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+                               if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
                                        ele_array[i] = ele;
                                        i++;
                                }
@@ -830,8 +837,8 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
                }
 
                if (htype & BM_EDGE) {
-                       for (ele = BM_iter_new(&elements, bm, BM_EDGES_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
-                               if (BMO_elem_flag_test(bm, (BMElemF *)ele, oflag) == test) {
+                       BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+                               if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
                                        ele_array[i] = ele;
                                        i++;
                                }
@@ -839,8 +846,8 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
                }
 
                if (htype & BM_FACE) {
-                       for (ele = BM_iter_new(&elements, bm, BM_FACES_OF_MESH, bm); ele; ele = BM_iter_step(&elements)) {
-                               if (BMO_elem_flag_test(bm, (BMElemF *)ele, oflag) == test) {
+                       BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+                               if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
                                        ele_array[i] = ele;
                                        i++;
                                }
@@ -853,13 +860,13 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
 }
 
 void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                          const char htype, const short oflag)
+                                       const char htype, const short oflag)
 {
        bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, TRUE);
 }
 
 void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
-                                                                               const char htype, const short oflag)
+                                        const char htype, const short oflag)
 {
        bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, FALSE);
 }
@@ -1028,19 +1035,19 @@ static void bmo_flag_layer_alloc(BMesh *bm)
        bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, 512, 512, 0);
        
        /* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
-       for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
                oldflags = ele->oflags;
                ele->oflags = BLI_mempool_calloc(newpool);
                memcpy(ele->oflags, oldflags, old_totflags_size);
                BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
                oldflags = ele->oflags;
                ele->oflags = BLI_mempool_calloc(newpool);
                memcpy(ele->oflags, oldflags, old_totflags_size);
                BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
                oldflags = ele->oflags;
                ele->oflags = BLI_mempool_calloc(newpool);
                memcpy(ele->oflags, oldflags, old_totflags_size);
@@ -1073,19 +1080,19 @@ static void bmo_flag_layer_free(BMesh *bm)
        bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, BLI_MEMPOOL_SYSMALLOC);
        
        /* now go through and memcpy all the flag */
-       for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
                oldflags = ele->oflags;
                ele->oflags = BLI_mempool_calloc(newpool);
                memcpy(ele->oflags, oldflags, new_totflags_size);
                BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
                oldflags = ele->oflags;
                ele->oflags = BLI_mempool_calloc(newpool);
                memcpy(ele->oflags, oldflags, new_totflags_size);
                BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
                oldflags = ele->oflags;
                ele->oflags = BLI_mempool_calloc(newpool);
                memcpy(ele->oflags, oldflags, new_totflags_size);
@@ -1108,15 +1115,15 @@ static void bmo_flag_layer_clear(BMesh *bm)
        const int totflags_offset = bm->totflags - 1;
 
        /* now go through and memcpy all the flag */
-       for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
                memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
                BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BM_iter_new(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
                memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
                BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BM_iter_new(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BM_iter_step(&iter), i++) {
+       BM_ITER_INDEX(ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
                memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
                BM_elem_index_set(ele, i); /* set_inline */
        }
index 24c60e22a9028ef8608ae550c058911f2f00651c..435818a59214aaa4e426e89bbb689effbf070384 100644 (file)
@@ -537,21 +537,21 @@ int BM_vert_is_manifold(BMVert *v)
 
 /**
  * Tests whether or not this edge is manifold.
- * A manifold edge either has 1 or 2 faces attached to it.
+ * A manifold edge has exactly 2 faces attached to it.
  */
 
 #if 1 /* fast path for checking manifold */
 int BM_edge_is_manifold(BMEdge *e)
 {
        const BMLoop *l = e->l;
-       return (l && ((l->radial_next == l) ||              /* 1 face user  */
-                     (l->radial_next->radial_next == l))); /* 2 face users */
+       return (l && (l->radial_next != l) &&             /* not 0 or 1 face users */
+                    (l->radial_next->radial_next == l)); /* 2 face users */
 }
 #else
 int BM_edge_is_manifold(BMEdge *e)
 {
        int count = BM_edge_face_count(e);
-       if (count == 2 || count == 1) {
+       if (count == 2) {
                return TRUE;
        }
        else {
index 818a7fb3cfa6584db869d138fcaf08a0585e4eec..5391c7c56d2e4de12de42decf98540ce6d0e28e2 100644 (file)
@@ -667,7 +667,7 @@ static int bmw_FaceLoopWalker_edge_begins_loop(BMWalker *walker, BMEdge *e)
        
        /* Don't start a loop from a boundary edge if it cannot
         * be extended to cover any faces */
-       if (BM_edge_face_count(e) == 1) {
+       if (BM_edge_is_boundary(e)) {
                if (!bmw_FaceLoopWalker_include_face(walker, e->l)) {
                        return FALSE;
                }
@@ -843,7 +843,7 @@ static void *bmw_EdgeringWalker_step(BMWalker *walker)
        int i, len;
 #endif
 
-#define EDGE_CHECK(e) (bmw_mask_check_edge(walker, e) && BM_edge_is_manifold(e))
+#define EDGE_CHECK(e) (bmw_mask_check_edge(walker, e) && (BM_edge_is_boundary(e) || BM_edge_is_manifold(e)))
 
        BMW_state_remove(walker);
 
index 4b559400bb8b1187a61558d7887de727b1282662..18ad784dc94eddec2a18c830e2affd21defee163 100644 (file)
 #include "bmesh.h"
 
 /* local flag define */
-#define DUPE_INPUT             1 /* input from operator */
-#define DUPE_NEW               2
-#define DUPE_DONE              4
-#define DUPE_MAPPED            8
+#define DUPE_INPUT      1 /* input from operator */
+#define DUPE_NEW        2
+#define DUPE_DONE       4
+#define DUPE_MAPPED     8
 
-/*
- *  COPY VERTEX
- *
- *   Copy an existing vertex from one bmesh to another.
+/**
+ * COPY VERTEX
  *
+ * Copy an existing vertex from one bmesh to another.
  */
 static BMVert *copy_vertex(BMesh *source_mesh, BMVert *source_vertex, BMesh *target_mesh, GHash *vhash)
 {
        BMVert *target_vertex = NULL;
 
        /* Create a new vertex */
-       target_vertex = BM_vert_create(target_mesh, source_vertex->co,  NULL);
+       target_vertex = BM_vert_create(target_mesh, source_vertex->co, NULL);
        
        /* Insert new vertex into the vert hash */
        BLI_ghash_insert(vhash, source_vertex, target_vertex);
@@ -59,11 +58,10 @@ static BMVert *copy_vertex(BMesh *source_mesh, BMVert *source_vertex, BMesh *tar
        return target_vertex;
 }
 
-/*
+/**
  * COPY EDGE
  *
  * Copy an existing edge from one bmesh to another.
- *
  */
 static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
                          BMEdge *source_edge, BMesh *target_mesh,
@@ -115,10 +113,10 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
        return target_edge;
 }
 
-/*
+/**
  * COPY FACE
  *
- *  Copy an existing face from one bmesh to another.
+ * Copy an existing face from one bmesh to another.
  */
 
 static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
@@ -151,10 +149,8 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
        
        /* create new face */
        target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, FALSE);
-       BMO_slot_map_ptr_insert(source_mesh, op,
-                               "facemap", source_face, target_face);
-       BMO_slot_map_ptr_insert(source_mesh, op,
-                               "facemap", target_face, source_face);
+       BMO_slot_map_ptr_insert(source_mesh, op, "facemap", source_face, target_face);
+       BMO_slot_map_ptr_insert(source_mesh, op, "facemap", target_face, source_face);
 
        BM_elem_attrs_copy(source_mesh, target_mesh, source_face, target_face);
 
@@ -174,11 +170,12 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
        return target_face;
 }
 
-/*
+/**
  * COPY MESH
  *
  * Internal Copy function.
  */
+
 static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
 {
 
@@ -195,15 +192,14 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
        GHash *vhash, *ehash;
 
        /* initialize pointer hashes */
-       vhash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp,
-                                                 "bmesh dupeops v");
-       ehash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp,
-                                                 "bmesh dupeops e");
+       vhash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh dupeops v");
+       ehash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh dupeops e");
 
        /* duplicate flagged vertices */
        BM_ITER(v, &viter, source, BM_VERTS_OF_MESH, source) {
                if (BMO_elem_flag_test(source, v, DUPE_INPUT) &&
-                       !BMO_elem_flag_test(source, v, DUPE_DONE)) {
+                   !BMO_elem_flag_test(source, v, DUPE_DONE))
+               {
                        BMIter iter;
                        int isolated = 1;
 
@@ -236,7 +232,8 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
        /* now we dupe all the edges */
        BM_ITER(e, &eiter, source, BM_EDGES_OF_MESH, source) {
                if (BMO_elem_flag_test(source, e, DUPE_INPUT) &&
-                       !BMO_elem_flag_test(source, e, DUPE_DONE)) {
+                   !BMO_elem_flag_test(source, e, DUPE_DONE))
+               {
                        /* make sure that verts are copied */
                        if (!BMO_elem_flag_test(source, e->v1, DUPE_DONE)) {
                                copy_vertex(source, e->v1, target, vhash);
@@ -247,7 +244,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
                                BMO_elem_flag_enable(source, e->v2, DUPE_DONE);
                        }
                        /* now copy the actual edge */
-                       copy_edge(op, source, e, target,  vhash,  ehash);
+                       copy_edge(op, source, e, target, vhash, ehash);
                        BMO_elem_flag_enable(source, e, DUPE_DONE);
                }
        }
@@ -266,7 +263,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
                        /* edge pass */
                        BM_ITER(e, &eiter, source, BM_EDGES_OF_FACE, f) {
                                if (!BMO_elem_flag_test(source, e, DUPE_DONE)) {
-                                       copy_edge(op, source, e, target,  vhash,  ehash);
+                                       copy_edge(op, source, e, target, vhash, ehash);
                                        BMO_elem_flag_enable(source, e, DUPE_DONE);
                                }
                        }
@@ -291,7 +288,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
        BLI_array_free(edar); /* free edge pointer array */
 }
 
-/*
+/**
  * Duplicate Operator
  *
  * Duplicates verts, edges and faces of a mesh.
@@ -310,7 +307,6 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
  * BMOP_DUPE_VNEW: Buffer containing pointers to the new mesh vertices
  * BMOP_DUPE_ENEW: Buffer containing pointers to the new mesh edges
  * BMOP_DUPE_FNEW: Buffer containing pointers to the new mesh faces
- *
  */
 
 void bmo_dupe_exec(BMesh *bm, BMOperator *op)
@@ -352,7 +348,7 @@ void BMO_dupe_from_flag(BMesh *bm, int htype, const char hflag)
 }
 #endif
 
-/*
+/**
  * Split Operator
  *
  * Duplicates verts, edges and faces of a mesh but also deletes the originals.
@@ -370,7 +366,8 @@ void BMO_dupe_from_flag(BMesh *bm, int htype, const char hflag)
  * BMOP_DUPE_FOUTPUT: Buffer containing pointers to the split mesh faces
  */
 
-#define SPLIT_INPUT    1
+#define SPLIT_INPUT 1
+
 void bmo_split_exec(BMesh *bm, BMOperator *op)
 {
        BMOperator *splitop = op;
@@ -432,10 +429,8 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
 
        /* now we make our outputs by copying the dupe output */
        BMO_slot_copy(&dupeop, splitop, "newout", "geomout");
-       BMO_slot_copy(&dupeop, splitop, "boundarymap",
-                     "boundarymap");
-       BMO_slot_copy(&dupeop, splitop, "isovertmap",
-                     "isovertmap");
+       BMO_slot_copy(&dupeop, splitop, "boundarymap", "boundarymap");
+       BMO_slot_copy(&dupeop, splitop, "isovertmap", "isovertmap");
        
        /* cleanup */
        BMO_op_finish(bm, &delop);
@@ -457,7 +452,7 @@ void bmo_del_exec(BMesh *bm, BMOperator *op)
 #undef DEL_INPUT
 }
 
-/*
+/**
  * Spin Operator
  *
  * Extrude or duplicate geometry a number of times,
@@ -469,9 +464,8 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
        BMOperator dupop, extop;
        float cent[3], dvec[3];
        float axis[3] = {0.0f, 0.0f, 1.0f};
-       float q[4];
        float rmat[3][3];
-       float phi, si;
+       float phi;
        int steps, do_dupli, a, usedvec;
 
        BMO_slot_vec_get(op, "cent", cent);
@@ -480,16 +474,10 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
        BMO_slot_vec_get(op, "dvec", dvec);
        usedvec = !is_zero_v3(dvec);
        steps = BMO_slot_int_get(op, "steps");
-       phi = BMO_slot_float_get(op, "ang") * (float)M_PI / (360.0f * steps);
+       phi = BMO_slot_float_get(op, "ang") * DEG2RADF(1.0f) / steps;
        do_dupli = BMO_slot_bool_get(op, "do_dupli");
 
-       /* BMESH_TODO - can replace this with BLI_math? */
-       si = (float)sin(phi);
-       q[0] = (float)cos(phi);
-       q[1] = axis[0] * si;
-       q[2] = axis[1] * si;
-       q[3] = axis[2] * si;
-       quat_to_mat3(rmat, q);
+       axis_angle_to_mat3(rmat, axis, phi);
 
        BMO_slot_copy(op, op, "geom", "lastout");
        for (a = 0; a < steps; a++) {
index 77ba69b23728bae54f877599c8e135b7436ae575..981232b4d66d86a9c083b36c40ff67eafb87e49c 100644 (file)
@@ -116,46 +116,46 @@ void bmo_extrude_face_indiv_exec(BMesh *bm, BMOperator *op)
 static void bm_extrude_copy_face_loop_attributes(BMesh *bm, BMFace *f, BMEdge *e, BMEdge *newedge)
 {
        BMIter iter;
-       BMLoop *l, *l2;
-
-       /* copy attribute */
-       l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f);
-       for ( ; l; l = BM_iter_step(&iter)) {
+       BMLoop *l, *l_other;
 
+       /* copy attributes */
+       BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
                if (l->e != e && l->e != newedge) {
                        continue;
                }
 
-               l2 = l->radial_next;
+               l_other = l->radial_next;
                
-               if (l2 == l) {
-                       l2 = newedge->l;
+               if (l_other == l) {
+                       l_other = newedge->l;
 
-                       if (l2 != l) {
-                               BM_elem_attrs_copy(bm, bm, l2->f, l->f);
+                       if (l_other != l) {
+                               BM_elem_attrs_copy(bm, bm, l_other->f, f);
+                               BM_elem_flag_disable(f, BM_ELEM_HIDDEN); /* possibly we copy from a hidden face */
 
-                               BM_elem_attrs_copy(bm, bm, l2, l);
-                               l2 = l2->next;
+                               BM_elem_attrs_copy(bm, bm, l_other, l);
+                               l_other = l_other->next;
                                l = l->next;
-                               BM_elem_attrs_copy(bm, bm, l2, l);
+                               BM_elem_attrs_copy(bm, bm, l_other, l);
                        }
                }
                else {
-                       BM_elem_attrs_copy(bm, bm, l2->f, l->f);
+                       BM_elem_attrs_copy(bm, bm, l_other->f, f);
+                       BM_elem_flag_disable(f, BM_ELEM_HIDDEN); /* possibly we copy from a hidden face */
 
-                       /* copy dat */
-                       if (l2->v == l->v) {
-                               BM_elem_attrs_copy(bm, bm, l2, l);
-                               l2 = l2->next;
+                       /* copy data */
+                       if (l_other->v == l->v) {
+                               BM_elem_attrs_copy(bm, bm, l_other, l);
+                               l_other = l_other->next;
                                l = l->next;
-                               BM_elem_attrs_copy(bm, bm, l2, l);
+                               BM_elem_attrs_copy(bm, bm, l_other, l);
                        }
                        else {
-                               l2 = l2->next;
-                               BM_elem_attrs_copy(bm, bm, l2, l);
-                               l2 = l2->prev;
+                               l_other = l_other->next;
+                               BM_elem_attrs_copy(bm, bm, l_other, l);
+                               l_other = l_other->prev;
                                l = l->next;
-                               BM_elem_attrs_copy(bm, bm, l2, l);
+                               BM_elem_attrs_copy(bm, bm, l_other, l);
                        }
                }
        }
index 4a426b40995e93a22795aa4455bb55595f181dcb..7aeeca99d58c8ff56a525aefd59bdb5a9e8ebdce 100644 (file)
@@ -119,11 +119,11 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
        int i, j, k;
 
        if (use_outset == FALSE) {
-               BM_mesh_elem_flag_disable_all(bm, BM_FACE, BM_ELEM_TAG);
+               BM_mesh_elem_flag_disable_all(bm, BM_FACE, BM_ELEM_TAG, FALSE);
                BMO_slot_buffer_hflag_enable(bm, op, "faces", BM_FACE, BM_ELEM_TAG, FALSE);
        }
        else {
-               BM_mesh_elem_flag_enable_all(bm, BM_FACE, BM_ELEM_TAG);
+               BM_mesh_elem_flag_enable_all(bm, BM_FACE, BM_ELEM_TAG, FALSE);
                BMO_slot_buffer_hflag_disable(bm, op, "faces", BM_FACE, BM_ELEM_TAG, FALSE);
        }
 
@@ -187,6 +187,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
                edge_loop_tangent(es->e_new, es->l, es->no);
 
                if (es->e_new == es->e_old) { /* happens on boundary edges */
+                       /* take care here, we're creating this double edge which _must_ have its verts replaced later on */
                        es->e_old = BM_edge_create(bm, es->e_new->v1, es->e_new->v2, es->e_new, FALSE);
                }
 
@@ -254,7 +255,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
                                        /* find adjacent */
                                        BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v_split) {
                                                if (BM_elem_flag_test(e, BM_ELEM_TAG) &&
-                                                   BM_elem_flag_test(e->l->f, BM_ELEM_TAG))
+                                                   e->l && BM_elem_flag_test(e->l->f, BM_ELEM_TAG))
                                                {
                                                        if (vert_edge_tag_tot < 2) {
                                                                vecpair[vert_edge_tag_tot] = BM_elem_index_get(e);
index 03f9fe04394b4a49bfa74256c22f42d2372e2e19..f9758e3bf7f56d0952b30403ec6aa0e807d76e99 100644 (file)
@@ -1023,9 +1023,9 @@ void bmo_esubd_exec(BMesh *bmesh, BMOperator *op)
 
 /* editmesh-emulating function */
 void BM_mesh_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float smooth,
-                       float fractal, int beauty, int numcuts,
-                       int seltype, int cornertype, int singleedge,
-                       int gridfill, int seed)
+                            float fractal, int beauty, int numcuts,
+                            int seltype, int cornertype, int singleedge,
+                            int gridfill, int seed)
 {
        BMOperator op;
        
@@ -1053,7 +1053,7 @@ void BM_mesh_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float s
                // int i;
                
                /* deselect input */
-               BM_mesh_elem_flag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT);
+               BM_mesh_elem_flag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
 
                ele = BMO_iter_new(&iter, bm, &op, "outinner", BM_EDGE|BM_VERT);
                for ( ; ele; ele = BMO_iter_step(&iter)) {
@@ -1069,14 +1069,12 @@ void BM_mesh_esubdivideflag(Object *UNUSED(obedit), BMesh *bm, int flag, float s
                                             BM_elem_flag_test(e->v2, BM_ELEM_SELECT))
                                        {
                                                BM_elem_select_set(bm, e, TRUE);
-                                               bm->totedgesel += 1;
                                        }
                                        else if (BM_elem_flag_test(e, BM_ELEM_SELECT) &&
                                                 (!BM_elem_flag_test(e->v1, BM_ELEM_SELECT) ||
                                                  !BM_elem_flag_test(e->v2, BM_ELEM_SELECT)))
                                        {
                                                BM_elem_select_set(bm, e, FALSE);
-                                               bm->totedgesel -= 1;
                                        }
                                }
                        }
index 3b8337f46aeecb26356440172cf1cd490e200e92..9160848aa603b175719b83fb4e915e30cb4f684c 100644 (file)
@@ -905,7 +905,7 @@ static BMesh *BME_bevel_initialize(BMesh *bm, int options, int UNUSED(defgrp_ind
 
        BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
                BMO_elem_flag_enable(bm, e, BME_BEVEL_ORIG);
-               if (!BM_edge_is_manifold(e)) {
+               if (!(BM_edge_is_boundary(e) || BM_edge_is_manifold(e))) {
                        BMO_elem_flag_enable(bm, e->v1, BME_BEVEL_NONMAN);
                        BMO_elem_flag_enable(bm, e->v2, BME_BEVEL_NONMAN);
                        BMO_elem_flag_enable(bm, e, BME_BEVEL_NONMAN);
index 8bb476b1f17d4ba133a4f0b4102cb9a9466be296..adf59dfa4622b84d591faddacf3de949cc5ac691 100644 (file)
@@ -363,7 +363,10 @@ short ANIM_animdata_get_context (const bContext *C, bAnimContext *ac)
                else {\
                        filter_mode |= ANIMFILTER_TMP_PEEK; \
                } \
-               (void) _doSubChannels;
+                 \
+               { \
+                       (void) _doSubChannels; \
+               }
                /* ... standard sub-channel filtering can go on here now ... */
 #define END_ANIMFILTER_SUBCHANNELS \
                filter_mode = _filter; \
@@ -968,7 +971,7 @@ static FCurve *animfilter_fcurve_next (bDopeSheet *ads, FCurve *first, bActionGr
                        /* only work with this channel and its subchannels if it is editable */
                        if (!(filter_mode & ANIMFILTER_FOREDIT) || EDITABLE_FCU(fcu)) {
                                /* only include this curve if selected in a way consistent with the filtering requirements */
-                               if ( ANIMCHANNEL_SELOK(SEL_FCU(fcu)) && ANIMCHANNEL_SELEDITOK(SEL_FCU(fcu)) ) {
+                               if (ANIMCHANNEL_SELOK(SEL_FCU(fcu)) && ANIMCHANNEL_SELEDITOK(SEL_FCU(fcu))) {
                                        /* only include if this curve is active */
                                        if (!(filter_mode & ANIMFILTER_ACTIVE) || (fcu->flag & FCURVE_ACTIVE)) {
                                                /* name based filtering... */
@@ -1182,7 +1185,7 @@ static size_t animfilter_nla (bAnimContext *UNUSED(ac), ListBase *anim_data, bDo
                /* only work with this channel and its subchannels if it is editable */
                if (!(filter_mode & ANIMFILTER_FOREDIT) || EDITABLE_NLT(nlt)) {
                        /* only include this track if selected in a way consistent with the filtering requirements */
-                       if ( ANIMCHANNEL_SELOK(SEL_NLT(nlt)) ) {
+                       if (ANIMCHANNEL_SELOK(SEL_NLT(nlt))) {
                                /* only include if this track is active */
                                if (!(filter_mode & ANIMFILTER_ACTIVE) || (nlt->flag & NLATRACK_ACTIVE)) {
                                        ANIMCHANNEL_NEW_CHANNEL(nlt, ANIMTYPE_NLATRACK, owner_id);
@@ -1362,7 +1365,7 @@ static size_t animdata_filter_ds_nodetree (bAnimContext *ac, ListBase *anim_data
                /* include data-expand widget first */
                if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                        /* check if filtering by active status */
-                       if ANIMCHANNEL_ACTIVEOK(ntree) {
+                       if (ANIMCHANNEL_ACTIVEOK(ntree)) {
                                ANIMCHANNEL_NEW_CHANNEL(ntree, ANIMTYPE_DSNTREE, owner_id);
                        }
                }
@@ -1495,7 +1498,7 @@ static size_t animdata_filter_ds_textures (bAnimContext *ac, ListBase *anim_data
                        /* include texture-expand widget? */
                        if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                                /* check if filtering by active status */
-                               if ANIMCHANNEL_ACTIVEOK(tex) {
+                               if (ANIMCHANNEL_ACTIVEOK(tex)) {
                                        ANIMCHANNEL_NEW_CHANNEL(tex, ANIMTYPE_DSTEX, owner_id);
                                }
                        }
@@ -1547,7 +1550,7 @@ static size_t animdata_filter_ds_materials (bAnimContext *ac, ListBase *anim_dat
                        // hmm... do we need to store the index of this material in the array anywhere?
                        if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                                /* check if filtering by active status */
-                               if ANIMCHANNEL_ACTIVEOK(ma) {
+                               if (ANIMCHANNEL_ACTIVEOK(ma)) {
                                        ANIMCHANNEL_NEW_CHANNEL(ma, ANIMTYPE_DSMAT, ma);
                                }
                        }
@@ -1589,7 +1592,7 @@ static size_t animdata_filter_ds_particles (bAnimContext *ac, ListBase *anim_dat
                        /* include particle-expand widget first */
                        if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                                /* check if filtering by active status */
-                               if ANIMCHANNEL_ACTIVEOK(psys->part) {
+                               if (ANIMCHANNEL_ACTIVEOK(psys->part)) {
                                        ANIMCHANNEL_NEW_CHANNEL(psys->part, ANIMTYPE_DSPART, psys->part);
                                }
                        }
@@ -1729,7 +1732,7 @@ static size_t animdata_filter_ds_obdata (bAnimContext *ac, ListBase *anim_data,
                /* include data-expand widget first */
                if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                        /* check if filtering by active status */
-                       if ANIMCHANNEL_ACTIVEOK(iat) {
+                       if (ANIMCHANNEL_ACTIVEOK(iat)) {
                                ANIMCHANNEL_NEW_CHANNEL(iat, type, iat);
                        }
                }
@@ -1763,7 +1766,7 @@ static size_t animdata_filter_ds_keyanim (bAnimContext *ac, ListBase *anim_data,
        if (tmp_items) {
                /* include key-expand widget first */
                if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
-                       if ANIMCHANNEL_ACTIVEOK(key) {
+                       if (ANIMCHANNEL_ACTIVEOK(key)) {
                                ANIMCHANNEL_NEW_CHANNEL(key, ANIMTYPE_DSSKEY, ob);
                        }
                }
@@ -1880,7 +1883,7 @@ static size_t animdata_filter_dopesheet_ob (bAnimContext *ac, ListBase *anim_dat
                if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                        /* check if filtering by selection */
                        // XXX: double-check on this - most of the time, a lot of tools need to filter out these channels!
-                       if ANIMCHANNEL_SELOK((base->flag & SELECT)) {
+                       if (ANIMCHANNEL_SELOK((base->flag & SELECT))) {
                                /* check if filtering by active status */
                                if (ANIMCHANNEL_ACTIVEOK(ob)) {
                                        ANIMCHANNEL_NEW_CHANNEL(base, ANIMTYPE_OBJECT, ob);
@@ -1925,7 +1928,7 @@ static size_t animdata_filter_ds_world (bAnimContext *ac, ListBase *anim_data, b
                /* include data-expand widget first */
                if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                        /* check if filtering by active status */
-                       if ANIMCHANNEL_ACTIVEOK(wo) {
+                       if (ANIMCHANNEL_ACTIVEOK(wo)) {
                                ANIMCHANNEL_NEW_CHANNEL(wo, ANIMTYPE_DSWOR, sce);
                        }
                }
@@ -2035,7 +2038,7 @@ static size_t animdata_filter_dopesheet_scene (bAnimContext *ac, ListBase *anim_
                /* firstly add object expander if required */
                if (filter_mode & ANIMFILTER_LIST_CHANNELS) {
                        /* check if filtering by selection */
-                       if ANIMCHANNEL_SELOK((sce->flag & SCE_DS_SELECTED)) {
+                       if (ANIMCHANNEL_SELOK((sce->flag & SCE_DS_SELECTED))) {
                                /* NOTE: active-status doesn't matter for this! */
                                ANIMCHANNEL_NEW_CHANNEL(sce, ANIMTYPE_SCENE, sce);
                        }
index 6768c884868ed9571ca40383059a245af9d37e1c..9d84b236aad92dba2c6474c666a7d66fa840c847 100644 (file)
@@ -407,8 +407,30 @@ static int pose_select_hierarchy_exec(bContext *C, wmOperator *op)
                                        }
                                } 
                                else { /* direction == BONE_SELECT_CHILD */
+
+                                       /* the child member is only assigned to connected bones, see [#30340] */
+#if 0
                                        if (pchan->child == NULL) continue;
                                        else chbone = pchan->child->bone;
+#else
+                                       /* instead. find _any_ visible child bone, using the first one is a little arbitrary  - campbell */
+                                       chbone = pchan->child ? pchan->child->bone : NULL;
+                                       if (chbone == NULL) {
+                                               bPoseChannel *pchan_child;
+
+                                               for (pchan_child = ob->pose->chanbase.first; pchan_child; pchan_child = pchan_child->next) {
+                                                       /* possible we have multiple children, some invisible */
+                                                       if (PBONE_VISIBLE(arm, pchan_child->bone)) {
+                                                               if (pchan_child->parent == pchan) {
+                                                                       chbone = pchan_child->bone;
+                                                                       break;
+                                                               }
+                                                       }
+                                               }
+                                       }
+
+                                       if (chbone == NULL) continue;
+#endif
                                        
                                        if (PBONE_VISIBLE(arm, chbone)) {
                                                if (!add_to_sel) curbone->flag &= ~BONE_SELECTED;
index a5188ea769ecaa1bb2c463484a89552b0bd1cba0..9190cd940d690b8c054aa12a798939887aa02de0 100644 (file)
@@ -4378,6 +4378,7 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
        BPoint *bp, *newbp = NULL;
        float imat[4][4], temp[3];
        int ok= 0;
+       BezTriple *bezt_recalc[3] = {NULL};
 
        invert_m4_m4(imat, obedit->obmat);
 
@@ -4471,9 +4472,14 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                        newbezt+= nu->pntsu;
                        BEZ_SEL(newbezt);
                        cu->lastsel= newbezt;
-                       newbezt->h2= newbezt->h1;
+                       newbezt->h1 = newbezt->h2;
                        bezt= nu->bezt+nu->pntsu-1;
                        ok= 1;
+
+                       if (nu->pntsu > 1) {
+                               bezt_recalc[1] = newbezt;
+                               bezt_recalc[0] = newbezt - 1;
+                       }
                }
                else if (bezt== nu->bezt) {   /* first */
                        BEZ_DESEL(bezt);
@@ -4489,6 +4495,11 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                        nu->bezt= newbezt;
                        bezt= newbezt+1;
                        ok= 1;
+
+                       if (nu->pntsu > 1) {
+                               bezt_recalc[1] = newbezt;
+                               bezt_recalc[2] = newbezt + 1;
+                       }
                }
                else if (mode!='e') {
                        BEZ_DESEL(bezt);
@@ -4523,8 +4534,19 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                        else {
                                mul_v3_m4v3(newbezt->vec[1], imat, location);
                                sub_v3_v3v3(temp, newbezt->vec[1],temp);
-                               add_v3_v3v3(newbezt->vec[0], bezt->vec[0],temp);
-                               add_v3_v3v3(newbezt->vec[2], bezt->vec[2],temp);
+
+                               if (bezt_recalc[1]) {
+                                       const char h1 = bezt_recalc[1]->h1, h2 = bezt_recalc[1]->h2;
+                                       bezt_recalc[1]->h1 = bezt_recalc[1]->h2 = HD_AUTO;
+                                       calchandleNurb(bezt_recalc[1], bezt_recalc[0], bezt_recalc[2], 0);
+                                       bezt_recalc[1]->h1 = h1;
+                                       bezt_recalc[1]->h2 = h2;
+                               }
+                               else {
+                                       add_v3_v3v3(newbezt->vec[0], bezt->vec[0],temp);
+                                       add_v3_v3v3(newbezt->vec[2], bezt->vec[2],temp);
+                               }
+                               
 
                                if (newnu) calchandlesNurb(newnu);
                                else calchandlesNurb(nu);
index 18e2af939fddc8ff469b92c6572398b27a3aa406..cdb2472706c17e28579226814f36121966c8b26e 100644 (file)
@@ -48,6 +48,7 @@ struct wmWindowManager;
 struct wmOperator;
 struct AutoComplete;
 struct bContext;
+struct bContextStore;
 struct Panel;
 struct PanelType;
 struct PointerRNA;
@@ -692,6 +693,7 @@ uiBlock *uiLayoutGetBlock(uiLayout *layout);
 
 void uiLayoutSetFunc(uiLayout *layout, uiMenuHandleFunc handlefunc, void *argv);
 void uiLayoutSetContextPointer(uiLayout *layout, const char *name, struct PointerRNA *ptr);
+void uiLayoutContextCopy(uiLayout *layout, struct bContextStore *context);
 const char *uiLayoutIntrospect(uiLayout *layout); // XXX - testing
 void uiLayoutOperatorButs(const struct bContext *C, struct uiLayout *layout, struct wmOperator *op, int (*check_prop)(struct PointerRNA *, struct PropertyRNA *), const char label_align, const short flag);
 struct MenuType *uiButGetMenuType(uiBut *but);
index 91e38e7d914a100f7deaf151ba140d33a6f0deb2..58b54fef0dfd0e822ddb2fca812f3d6192d6a3f4 100644 (file)
@@ -2722,6 +2722,12 @@ void uiLayoutSetContextPointer(uiLayout *layout, const char *name, PointerRNA *p
        layout->context = CTX_store_add(&block->contexts, name, ptr);
 }
 
+void uiLayoutContextCopy(uiLayout *layout, bContextStore *context)
+{
+       uiBlock *block= layout->root->block;
+       layout->context= CTX_store_add_all(&block->contexts, context);
+}
+
 
 /* introspect funcs */
 #include "BLI_dynstr.h"
index 1c37fcdd4889b3f84d34dc28e671b17d6c399cc6..b5d56f278e583ffe539bcbdc2f83a9e4963e67f9 100644 (file)
@@ -2404,16 +2404,18 @@ uiPopupBlockHandle *ui_popup_menu_create(bContext *C, ARegion *butregion, uiBut
        /* some enums reversing is strange, currently we have no good way to
         * reverse some enum's but not others, so reverse all so the first menu
         * items are always close to the mouse cursor */
-#if 0
        else {
+#if 0
                /* if this is an rna button then we can assume its an enum
                 * flipping enums is generally not good since the order can be
                 * important [#28786] */
                if (but->rnaprop && RNA_property_type(but->rnaprop) == PROP_ENUM) {
                        pup->block->flag |= UI_BLOCK_NO_FLIP;
                }
-       }
 #endif
+               if (but->context)
+                       uiLayoutContextCopy(pup->layout, but->context);
+       }
 
        if (str) {
                /* menu is created from a string */
index d2446d1ad0ef9477d7cfe94990df74eb2bc44f32..d4a799764df197b664233b533376c4b8d9191eb4 100644 (file)
@@ -163,26 +163,26 @@ static int facesel_face_pick(struct bContext *C, Mesh *me, Object *ob, const int
 void paintface_hide(Object *ob, const int unselected)
 {
        Mesh *me;
-       MPoly *mface;
+       MPoly *mpoly;
        int a;
        
        me = get_mesh(ob);
        if (me == NULL || me->totpoly == 0) return;
 
-       mface = me->mpoly;
+       mpoly = me->mpoly;
        a = me->totpoly;
        while (a--) {
-               if ((mface->flag & ME_HIDE) == 0) {
+               if ((mpoly->flag & ME_HIDE) == 0) {
                        if (unselected) {
-                               if ( (mface->flag & ME_FACE_SEL) == 0) mface->flag |= ME_HIDE;
+                               if ( (mpoly->flag & ME_FACE_SEL) == 0) mpoly->flag |= ME_HIDE;
                        }
                        else {
-                               if ( (mface->flag & ME_FACE_SEL)) mface->flag |= ME_HIDE;
+                               if ( (mpoly->flag & ME_FACE_SEL)) mpoly->flag |= ME_HIDE;
                        }
                }
-               if (mface->flag & ME_HIDE) mface->flag &= ~ME_FACE_SEL;
+               if (mpoly->flag & ME_HIDE) mpoly->flag &= ~ME_FACE_SEL;
                
-               mface++;
+               mpoly++;
        }
        
        paintface_flush_flags(ob);
@@ -192,20 +192,20 @@ void paintface_hide(Object *ob, const int unselected)
 void paintface_reveal(Object *ob)
 {
        Mesh *me;
-       MPoly *mface;
+       MPoly *mpoly;
        int a;
 
        me = get_mesh(ob);
        if (me == NULL || me->totpoly == 0) return;
 
-       mface = me->mpoly;
+       mpoly = me->mpoly;
        a = me->totpoly;
        while (a--) {
-               if (mface->flag & ME_HIDE) {
-                       mface->flag |= ME_FACE_SEL;
-                       mface->flag -= ME_HIDE;
+               if (mpoly->flag & ME_HIDE) {
+                       mpoly->flag |= ME_FACE_SEL;
+                       mpoly->flag -= ME_HIDE;
                }
-               mface++;
+               mpoly++;
        }
 
        paintface_flush_flags(ob);
@@ -227,7 +227,7 @@ static void hash_add_face(EdgeHash *ehash, MPoly *mp, MLoop *mloop)
 static void select_linked_tfaces_with_seams(int mode, Mesh *me, unsigned int index)
 {
        EdgeHash *ehash, *seamhash;
-       MPoly *mf;
+       MPoly *mp;
        MLoop *ml;
        MEdge *med;
        char *linkflag;
@@ -243,17 +243,17 @@ static void select_linked_tfaces_with_seams(int mode, Mesh *me, unsigned int ind
 
        if (mode == 0 || mode == 1) {
                /* only put face under cursor in array */
-               mf = ((MPoly *)me->mpoly) + index;
-               hash_add_face(ehash, mf, me->mloop + mf->loopstart);
+               mp = ((MPoly *)me->mpoly) + index;
+               hash_add_face(ehash, mp, me->mloop + mp->loopstart);
                linkflag[index] = 1;
        }
        else {
                /* fill array by selection */
-               mf = me->mpoly;
-               for (a = 0; a < me->totpoly; a++, mf++) {
-                       if (mf->flag & ME_HIDE) ;
-                       else if (mf->flag & ME_FACE_SEL) {
-                               hash_add_face(ehash, mf, me->mloop + mf->loopstart);
+               mp = me->mpoly;
+               for (a = 0; a < me->totpoly; a++, mp++) {
+                       if (mp->flag & ME_HIDE) ;
+                       else if (mp->flag & ME_FACE_SEL) {
+                               hash_add_face(ehash, mp, me->mloop + mp->loopstart);
                                linkflag[a] = 1;
                        }
                }
@@ -263,18 +263,18 @@ static void select_linked_tfaces_with_seams(int mode, Mesh *me, unsigned int ind
                doit = 0;
 
                /* expand selection */
-               mf = me->mpoly;
-               for (a = 0; a < me->totpoly; a++, mf++) {
-                       if (mf->flag & ME_HIDE)
+               mp = me->mpoly;
+               for (a = 0; a < me->totpoly; a++, mp++) {
+                       if (mp->flag & ME_HIDE)
                                continue;
 
                        if (!linkflag[a]) {
                                MLoop *mnextl;
                                mark = 0;
 
-                               ml = me->mloop + mf->loopstart;
-                               for (b = 0; b < mf->totloop; b++, ml++) {
-                                       mnextl = b < mf->totloop - 1 ? ml - 1 : me->mloop + mf->loopstart;
+                               ml = me->mloop + mp->loopstart;
+                               for (b = 0; b < mp->totloop; b++, ml++) {
+                                       mnextl = b < mp->totloop - 1 ? ml - 1 : me->mloop + mp->loopstart;
                                        if (!BLI_edgehash_haskey(seamhash, ml->v, mnextl->v))
                                                if (!BLI_edgehash_haskey(ehash, ml->v, mnextl->v))
                                                        mark = 1;
@@ -282,7 +282,7 @@ static void select_linked_tfaces_with_seams(int mode, Mesh *me, unsigned int ind
 
                                if (mark) {
                                        linkflag[a] = 1;
-                                       hash_add_face(ehash, mf, me->mloop + mf->loopstart);
+                                       hash_add_face(ehash, mp, me->mloop + mp->loopstart);
                                        doit = 1;
                                }
                        }
@@ -294,26 +294,26 @@ static void select_linked_tfaces_with_seams(int mode, Mesh *me, unsigned int ind
        BLI_edgehash_free(seamhash, NULL);
 
        if (mode == 0 || mode == 2) {
-               for (a = 0, mf = me->mpoly; a < me->totpoly; a++, mf++)
+               for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++)
                        if (linkflag[a])
-                               mf->flag |= ME_FACE_SEL;
+                               mp->flag |= ME_FACE_SEL;
                        else
-                               mf->flag &= ~ME_FACE_SEL;
+                               mp->flag &= ~ME_FACE_SEL;
        }
        else if (mode == 1) {
-               for (a = 0, mf = me->mpoly; a < me->totpoly; a++, mf++)
-                       if (linkflag[a] && (mf->flag & ME_FACE_SEL))
+               for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++)
+                       if (linkflag[a] && (mp->flag & ME_FACE_SEL))
                                break;
 
                if (a < me->totpoly) {
-                       for (a = 0, mf = me->mpoly; a < me->totpoly; a++, mf++)
+                       for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++)
                                if (linkflag[a])
-                                       mf->flag &= ~ME_FACE_SEL;
+                                       mp->flag &= ~ME_FACE_SEL;
                }
                else {
-                       for (a = 0, mf = me->mpoly; a < me->totpoly; a++, mf++)
+                       for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++)
                                if (linkflag[a])
-                                       mf->flag |= ME_FACE_SEL;
+                                       mp->flag |= ME_FACE_SEL;
                }
        }
 
@@ -344,54 +344,54 @@ void paintface_select_linked(bContext *UNUSED(C), Object *ob, int UNUSED(mval[2]
 void paintface_deselect_all_visible(Object *ob, int action, short flush_flags)
 {
        Mesh *me;
-       MPoly *mface;
+       MPoly *mpoly;
        int a;
 
        me = get_mesh(ob);
        if (me == NULL) return;
        
        if (action == SEL_INVERT) {
-               mface = me->mpoly;
+               mpoly = me->mpoly;
                a = me->totpoly;
                while (a--) {
-                       if ((mface->flag & ME_HIDE) == 0) {
-                               mface->flag ^= ME_FACE_SEL;
+                       if ((mpoly->flag & ME_HIDE) == 0) {
+                               mpoly->flag ^= ME_FACE_SEL;
                        }
-                       mface++;
+                       mpoly++;
                }
        }
        else {
                if (action == SEL_TOGGLE) {
                        action = SEL_SELECT;
 
-                       mface = me->mpoly;
+                       mpoly = me->mpoly;
                        a = me->totpoly;
                        while (a--) {
-                               if ((mface->flag & ME_HIDE) == 0 && mface->flag & ME_FACE_SEL) {
+                               if ((mpoly->flag & ME_HIDE) == 0 && mpoly->flag & ME_FACE_SEL) {
                                        action = SEL_DESELECT;
                                        break;
                                }
-                               mface++;
+                               mpoly++;
                        }
                }
 
-               mface = me->mpoly;
+               mpoly = me->mpoly;
                a = me->totpoly;
                while (a--) {
-                       if ((mface->flag & ME_HIDE) == 0) {
+                       if ((mpoly->flag & ME_HIDE) == 0) {
                                switch (action) {
                                        case SEL_SELECT:
-                                               mface->flag |= ME_FACE_SEL;
+                                               mpoly->flag |= ME_FACE_SEL;
                                                break;
                                        case SEL_DESELECT:
-                                               mface->flag &= ~ME_FACE_SEL;
+                                               mpoly->flag &= ~ME_FACE_SEL;
                                                break;
                                        case SEL_INVERT:
-                                               mface->flag ^= ME_FACE_SEL;
+                                               mpoly->flag ^= ME_FACE_SEL;
                                                break;
                                }
                        }
-                       mface++;
+                       mpoly++;
                }
        }
 
@@ -403,7 +403,7 @@ void paintface_deselect_all_visible(Object *ob, int action, short flush_flags)
 int paintface_minmax(Object *ob, float *min, float *max)
 {
        Mesh *me;
-       MPoly *mf;
+       MPoly *mp;
        MTexPoly *tf;
        MLoop *ml;
        MVert *mvert;
@@ -416,14 +416,14 @@ int paintface_minmax(Object *ob, float *min, float *max)
        copy_m3_m4(bmat, ob->obmat);
 
        mvert = me->mvert;
-       mf = me->mpoly;
+       mp = me->mpoly;
        tf = me->mtpoly;
-       for (a = me->totpoly; a > 0; a--, mf++, tf++) {
-               if (mf->flag & ME_HIDE || !(mf->flag & ME_FACE_SEL))
+       for (a = me->totpoly; a > 0; a--, mp++, tf++) {
+               if (mp->flag & ME_HIDE || !(mp->flag & ME_FACE_SEL))
                        continue;
 
-               ml = me->mloop + mf->totloop;
-               for (b = 0; b < mf->totloop; b++, ml++) {
+               ml = me->mloop + mp->totloop;
+               for (b = 0; b < mp->totloop; b++, ml++) {
                        copy_v3_v3(vec, (mvert[ml->v].co));
                        mul_m3_v3(bmat, vec);
                        add_v3_v3v3(vec, vec, ob->obmat[3]);
@@ -438,14 +438,14 @@ int paintface_minmax(Object *ob, float *min, float *max)
 
 /* *************************************** */
 #if 0
-static void seam_edgehash_insert_face(EdgeHash *ehash, MPoly *mf, MLoop *loopstart)
+static void seam_edgehash_insert_face(EdgeHash *ehash, MPoly *mp, MLoop *loopstart)
 {
        MLoop *ml1, *ml2;
        int a;
 
-       for (a = 0; a < mf->totloop; a++) {
+       for (a = 0; a < mp->totloop; a++) {
                ml1 = loopstart + a;
-               ml2 = loopstart + (a + 1) % mf->totloop;
+               ml2 = loopstart + (a + 1) % mp->totloop;
 
                BLI_edgehash_insert(ehash, ml1->v, ml2->v, NULL);
        }
@@ -454,7 +454,7 @@ static void seam_edgehash_insert_face(EdgeHash *ehash, MPoly *mf, MLoop *loopsta
 void seam_mark_clear_tface(Scene *scene, short mode)
 {
        Mesh *me;
-       MPoly *mf;
+       MPoly *mp;
        MLoop *ml1, *ml2;
        MEdge *med;
        int a, b;
@@ -471,9 +471,9 @@ void seam_mark_clear_tface(Scene *scene, short mode)
        if (mode == 2) {
                EdgeHash *ehash = BLI_edgehash_new();
 
-               for (a = 0, mf = me->mpoly; a < me->totpoly; a++, mf++)
-                       if (!(mf->flag & ME_HIDE) && (mf->flag & ME_FACE_SEL))
-                               seam_edgehash_insert_face(ehash, mf, me->mloop + mf->loopstart);
+               for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++)
+                       if (!(mp->flag & ME_HIDE) && (mp->flag & ME_FACE_SEL))
+                               seam_edgehash_insert_face(ehash, mp, me->mloop + mp->loopstart);
 
                for (a = 0, med = me->medge; a < me->totedge; a++, med++)
                        if (BLI_edgehash_haskey(ehash, med->v1, med->v2))
@@ -486,11 +486,11 @@ void seam_mark_clear_tface(Scene *scene, short mode)
                EdgeHash *ehash1 = BLI_edgehash_new();
                EdgeHash *ehash2 = BLI_edgehash_new();
 
-               for (a = 0, mf = me->mpoly; a < me->totpoly; a++, mf++) {
-                       if ((mf->flag & ME_HIDE) || !(mf->flag & ME_FACE_SEL))
-                               seam_edgehash_insert_face(ehash1, mf, me->mloop + mf->loopstart);
+               for (a = 0, mp = me->mpoly; a < me->totpoly; a++, mp++) {
+                       if ((mp->flag & ME_HIDE) || !(mp->flag & ME_FACE_SEL))
+                               seam_edgehash_insert_face(ehash1, mp, me->mloop + mp->loopstart);
                        else
-                               seam_edgehash_insert_face(ehash2, mf, me->mloop + mf->loopstart);
+                               seam_edgehash_insert_face(ehash2, mp, me->mloop + mp->loopstart);
                }
 
                for (a = 0, med = me->medge; a < me->totedge; a++, med++)
@@ -512,7 +512,7 @@ void seam_mark_clear_tface(Scene *scene, short mode)
 int paintface_mouse_select(struct bContext *C, Object *ob, const int mval[2], int extend)
 {
        Mesh *me;
-       MPoly *mface, *msel;
+       MPoly *mpoly, *mpoly_sel;
        unsigned int a, index;
        
        /* Get the face under the cursor */
@@ -524,28 +524,28 @@ int paintface_mouse_select(struct bContext *C, Object *ob, const int mval[2], in
        if (index >= me->totpoly || index < 0)
                return 0;
 
-       msel = me->mpoly + index;
-       if (msel->flag & ME_HIDE) return 0;
+       mpoly_sel = me->mpoly + index;
+       if (mpoly_sel->flag & ME_HIDE) return 0;
        
        /* clear flags */
-       mface = me->mpoly;
+       mpoly = me->mpoly;
        a = me->totpoly;
        if (!extend) {
                while (a--) {
-                       mface->flag &= ~ME_FACE_SEL;
-                       mface++;
+                       mpoly->flag &= ~ME_FACE_SEL;
+                       mpoly++;
                }
        }
        
        me->act_face = (int)index;
 
        if (extend) {
-               if (msel->flag & ME_FACE_SEL)
-                       msel->flag &= ~ME_FACE_SEL;
+               if (mpoly_sel->flag & ME_FACE_SEL)
+                       mpoly_sel->flag &= ~ME_FACE_SEL;
                else
-                       msel->flag |= ME_FACE_SEL;
+                       mpoly_sel->flag |= ME_FACE_SEL;
        }
-       else msel->flag |= ME_FACE_SEL;
+       else mpoly_sel->flag |= ME_FACE_SEL;
        
        /* image window redraw */
        
@@ -559,7 +559,7 @@ int do_paintface_box_select(ViewContext *vc, rcti *rect, int select, int extend)
 {
        Object *ob = vc->obact;
        Mesh *me;
-       MPoly *mface;
+       MPoly *mpoly;
        struct ImBuf *ibuf;
        unsigned int *rt;
        char *selar;
@@ -577,10 +577,10 @@ int do_paintface_box_select(ViewContext *vc, rcti *rect, int select, int extend)
        if (extend == 0 && select) {
                paintface_deselect_all_visible(vc->obact, SEL_DESELECT, FALSE);
 
-               mface = me->mpoly;
-               for (a = 1; a <= me->totpoly; a++, mface++) {
-                       if ((mface->flag & ME_HIDE) == 0)
-                               mface->flag &= ~ME_FACE_SEL;
+               mpoly = me->mpoly;
+               for (a = 1; a <= me->totpoly; a++, mpoly++) {
+                       if ((mpoly->flag & ME_HIDE) == 0)
+                               mpoly->flag &= ~ME_FACE_SEL;
                }
        }
 
@@ -600,13 +600,13 @@ int do_paintface_box_select(ViewContext *vc, rcti *rect, int select, int extend)
                rt++;
        }
 
-       mface = me->mpoly;
-       for (a = 1; a <= me->totpoly; a++, mface++) {
+       mpoly = me->mpoly;
+       for (a = 1; a <= me->totpoly; a++, mpoly++) {
                if (selar[a]) {
-                       if (mface->flag & ME_HIDE) ;
+                       if (mpoly->flag & ME_HIDE) ;
                        else {
-                               if (select) mface->flag |= ME_FACE_SEL;
-                               else mface->flag &= ~ME_FACE_SEL;
+                               if (select) mpoly->flag |= ME_FACE_SEL;
+                               else mpoly->flag &= ~ME_FACE_SEL;
                        }
                }
        }
index 638eaabbfd350a3285f36bd466662aab3f52f569..90698a79c251d90c7a7c1dadac81d294b6d97024 100644 (file)
@@ -206,7 +206,7 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select)
        if (select) {
                BMW_init(&walker, em->bm, BMW_EDGERING,
                         BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP,
-                        BMW_FLAG_NOP, /* BMESH_TODO - should be BMW_FLAG_TEST_HIDDEN ? */
+                        BMW_FLAG_TEST_HIDDEN,
                         BMW_NIL_LAY);
 
                eed = BMW_begin(&walker, startedge);
@@ -220,7 +220,7 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select)
 
        BMW_init(&walker, em->bm, BMW_EDGERING,
                 BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP,
-                BMW_FLAG_NOP, /* BMESH_TODO - should be BMW_FLAG_TEST_HIDDEN ? */
+                BMW_FLAG_TEST_HIDDEN,
                 BMW_NIL_LAY);
 
        eed = startedge = BMW_begin(&walker, startedge);
@@ -240,6 +240,8 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select)
                        edgering_find_order(em, lasteed, eed, lastv1, v);
                        lastv1 = v[0][0];
 
+                       BLI_array_growitems(edges, previewlines);
+
                        for (i = 1; i <= previewlines; i++) {
                                co[0][0] = (v[0][1]->co[0] - v[0][0]->co[0]) * (i / ((float)previewlines + 1)) + v[0][0]->co[0];
                                co[0][1] = (v[0][1]->co[1] - v[0][0]->co[1]) * (i / ((float)previewlines + 1)) + v[0][0]->co[1];
@@ -249,7 +251,6 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select)
                                co[1][1] = (v[1][1]->co[1] - v[1][0]->co[1]) * (i / ((float)previewlines + 1)) + v[1][0]->co[1];
                                co[1][2] = (v[1][1]->co[2] - v[1][0]->co[2]) * (i / ((float)previewlines + 1)) + v[1][0]->co[2];
 
-                               BLI_array_growone(edges);
                                copy_v3_v3(edges[tot][0], co[0]);
                                copy_v3_v3(edges[tot][1], co[1]);
                                tot++;
@@ -264,6 +265,8 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select)
 
                edgering_find_order(em, lasteed, startedge, lastv1, v);
                
+               BLI_array_growitems(edges, previewlines);
+
                for (i = 1; i <= previewlines; i++) {
                        if (!v[0][0] || !v[0][1] || !v[1][0] || !v[1][1])
                                continue;
@@ -276,7 +279,6 @@ static void edgering_sel(tringselOpData *lcd, int previewlines, int select)
                        co[1][1] = (v[1][1]->co[1] - v[1][0]->co[1]) * (i / ((float)previewlines + 1)) + v[1][0]->co[1];
                        co[1][2] = (v[1][1]->co[2] - v[1][0]->co[2]) * (i / ((float)previewlines + 1)) + v[1][0]->co[2];
                        
-                       BLI_array_growone(edges);
                        copy_v3_v3(edges[tot][0], co[0]);
                        copy_v3_v3(edges[tot][1], co[1]);
                        tot++;
index 737506bc73cb7dc18a48f35298e3ffdf47a76051..0cf27c613812971c9917bc85ae62c70db9b0002e 100644 (file)
@@ -1509,12 +1509,13 @@ int mouse_mesh(bContext *C, const int mval[2], short extend)
                
                EDBM_selectmode_flush(vc.em);
                  
-//             if (EM_texFaceCheck()) {
-
+               /* change active material on object */
                if (efa && efa->mat_nr != vc.obedit->actcol - 1) {
                        vc.obedit->actcol = efa->mat_nr + 1;
                        vc.em->mat_nr = efa->mat_nr;
-//                     BIF_preview_changed(ID_MA);
+
+                       WM_event_add_notifier(C, NC_MATERIAL|ND_SHADING, NULL);
+
                }
 
                WM_event_add_notifier(C, NC_GEOM | ND_SELECT, vc.obedit);
@@ -1928,7 +1929,7 @@ static int edbm_select_linked_exec(bContext *C, wmOperator *op)
 
                BMW_init(&walker, em->bm, BMW_SHELL,
                         BMW_MASK_NOP, BMW_MASK_NOP, BMW_MASK_NOP,
-                        BMW_FLAG_NOP, /* BMESH_TODO - should be BMW_FLAG_TEST_HIDDEN ? */
+                        BMW_FLAG_TEST_HIDDEN,
                         BMW_NIL_LAY);
 
                BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
index a0cffd4266872389dfdbbb9d7355b733c4af0023..d9f76552093090bb943933734a0ba29e759a9a27 100644 (file)
@@ -658,9 +658,10 @@ static int edbm_select_all_exec(bContext *C, wmOperator *op)
                        break;
                case SEL_INVERT:
                        EDBM_select_swap(em);
+                       EDBM_selectmode_flush(em);
                        break;
        }
-       
+
        WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
 
        return OPERATOR_FINISHED;
@@ -2132,6 +2133,8 @@ static float mesh_rip_edgedist(ARegion *ar, float mat[][4], float *co1, float *c
        return dist_to_line_segment_v2(mvalf, vec1, vec2);
 }
 
+
+
 /* based on mouse cursor position, it defines how is being ripped */
 static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
@@ -2174,6 +2177,7 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
         * then rip two adjacent edges in the vert fan. */
        if (bm->totvertsel == 1 && bm->totedgesel == 0 && bm->totfacesel == 0) {
                BMEditSelection ese;
+               int totboundary_edge = 0;
                singlesel = TRUE;
 
                /* find selected vert - same some time and check history first */
@@ -2196,17 +2200,93 @@ static int edbm_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
                if (v->e) {
                        /* find closest edge to mouse cursor */
                        BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
-                               if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN) && BM_edge_face_count(e) == 2) {
-                                       d = mesh_rip_edgedist(ar, projectMat, e->v1->co, e->v2->co, fmval);
-                                       if (d < dist) {
-                                               dist = d;
-                                               e2 = e;
+                               int is_boundary = BM_edge_is_boundary(e);
+                               /* consider wire as boundary for this purpose,
+                                * otherwise we can't a face away from a wire edge */
+                               totboundary_edge += (is_boundary != 0 || BM_edge_is_wire(e));
+                               if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN)) {
+                                       if (is_boundary == FALSE && BM_edge_face_count(e) == 2) {
+                                               d = mesh_rip_edgedist(ar, projectMat, e->v1->co, e->v2->co, fmval);
+                                               if (d < dist) {
+                                                       dist = d;
+                                                       e2 = e;
+                                               }
                                        }
                                }
                        }
 
                }
 
+               /* should we go ahead with edge rip or do we need to do special case, split off vertex?:
+                * split off vertex if...
+                * - we cant find an edge - this means we are ripping a faces vert that is connected to other
+                *   geometry only at the vertex.
+                * - the boundary edge total is greater then 2,
+                *   in this case edge split _can_ work but we get far nicer results if we use this special case. */
+               if (totboundary_edge > 2) {
+                       BMVert **vout;
+                       int vout_len;
+
+                       BM_elem_select_set(bm, v, FALSE);
+                       bmesh_vert_separate(bm, v, &vout, &vout_len);
+
+                       if (vout_len < 2) {
+                               /* should never happen */
+                               BKE_report(op->reports, RPT_ERROR, "Error ripping vertex from faces");
+                               return OPERATOR_CANCELLED;
+                       }
+                       else {
+                               int vi_best = 0;
+
+                               dist = FLT_MAX;
+
+                               for (i = 0; i < vout_len; i++) {
+                                       BM_ITER(l, &iter, bm, BM_LOOPS_OF_VERT, vout[i]) {
+                                               if (!BM_elem_flag_test(l->f, BM_ELEM_HIDDEN)) {
+                                                       float l_mid_co[3];
+                                                       BM_loop_face_tangent(l, l_mid_co);
+
+                                                       /* scale to average of surrounding edge size, only needs to be approx */
+                                                       mul_v3_fl(l_mid_co, (BM_edge_length_calc(l->e) + BM_edge_length_calc(l->prev->e)) / 2.0f);
+                                                       add_v3_v3(l_mid_co, v->co);
+
+                                                       d = mesh_rip_edgedist(ar, projectMat, v->co, l_mid_co, fmval);
+
+                                                       if (d < dist) {
+                                                               dist = d;
+                                                               vi_best = i;
+                                                       }
+                                               }
+                                       }
+                               }
+
+                               /* select the vert from the best region */
+                               v = vout[vi_best];
+                               BM_elem_select_set(bm, v, TRUE);
+
+                               /* splice all others back together */
+                               if (vout_len > 2) {
+
+                                       /* vout[0]  == best
+                                        * vout[1]  == glue
+                                        * vout[2+] == splice with glue
+                                        */
+                                       if (vi_best != 0) {
+                                               SWAP(BMVert *, vout[0], vout[vi_best]);
+                                               vi_best = 0;
+                                       }
+
+                                       for (i = 2; i < vout_len; i++) {
+                                               BM_vert_splice(bm, vout[i], vout[1]);
+                                       }
+                               }
+
+                               MEM_freeN(vout);
+
+                               return OPERATOR_FINISHED;
+                       }
+               }
+
                if (!e2) {
                        BKE_report(op->reports, RPT_ERROR, "Selected vertex has no edge/face pairs attached");
                        return OPERATOR_CANCELLED;
@@ -3463,7 +3543,7 @@ static int edbm_split_exec(bContext *C, wmOperator *op)
 
        EDBM_op_init(em, &bmop, op, "split geom=%hvef use_only_faces=%b", BM_ELEM_SELECT, FALSE);
        BMO_op_exec(em->bm, &bmop);
-       BM_mesh_elem_flag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT);
+       BM_mesh_elem_flag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
        BMO_slot_buffer_hflag_enable(em->bm, &bmop, "geomout", BM_ALL, BM_ELEM_SELECT, TRUE);
        if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
                return OPERATOR_CANCELLED;
@@ -4426,7 +4506,7 @@ static int edbm_inset_exec(bContext *C, wmOperator *op)
        Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = BMEdit_FromObject(obedit);
        BMOperator bmop;
-       const int use_boundary        = FALSE; //RNA_boolean_get(op->ptr, "use_boundary");
+       const int use_boundary        = RNA_boolean_get(op->ptr, "use_boundary");
        const int use_even_offset     = RNA_boolean_get(op->ptr, "use_even_offset");
        const int use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset");
        const float thickness         = RNA_float_get(op->ptr, "thickness");
@@ -4469,7 +4549,7 @@ void MESH_OT_inset(wmOperatorType *ot)
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
        /* properties */
-       // RNA_def_boolean(ot->srna, "use_boundary",        TRUE, "Boundary",  "Inset face boundries");
+       RNA_def_boolean(ot->srna, "use_boundary",        TRUE, "Boundary",  "Inset face boundries");
        RNA_def_boolean(ot->srna, "use_even_offset",     TRUE, "Offset Even",      "Scale the offset to give more even thickness");
        RNA_def_boolean(ot->srna, "use_relative_offset", FALSE, "Offset Relative", "Scale the offset by surrounding geometry");
 
index f824a9062c9492b198ba7c7e13f3b7e104659889..11f58303215b621cf91397677e697ffab73d0a39 100644 (file)
@@ -225,7 +225,7 @@ int EDBM_op_call_and_selectf(BMEditMesh *em, wmOperator *op, const char *selects
 
        BMO_op_exec(bm, &bmop);
 
-       BM_mesh_elem_flag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT);
+       BM_mesh_elem_flag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
 
        BMO_slot_buffer_hflag_enable(em->bm, &bmop, selectslot, BM_ALL, BM_ELEM_SELECT, TRUE);
 
@@ -426,7 +426,7 @@ void EDBM_select_flush(BMEditMesh *em)
 void EDBM_select_more(BMEditMesh *em)
 {
        BMOperator bmop;
-       int use_faces = em->selectmode > SCE_SELECT_EDGE;
+       int use_faces = em->selectmode == SCE_SELECT_FACE;
 
        BMO_op_initf(em->bm, &bmop,
                     "regionextend geom=%hvef constrict=%b use_faces=%b",
@@ -442,7 +442,7 @@ void EDBM_select_more(BMEditMesh *em)
 void EDBM_select_less(BMEditMesh *em)
 {
        BMOperator bmop;
-       int use_faces = em->selectmode > SCE_SELECT_EDGE;
+       int use_faces = em->selectmode == SCE_SELECT_FACE;
 
        BMO_op_initf(em->bm, &bmop,
                     "regionextend geom=%hvef constrict=%b use_faces=%b",
@@ -490,12 +490,12 @@ int EDBM_editselection_active_get(BMEditMesh *em, BMEditSelection *ese)
 
 void EDBM_flag_disable_all(BMEditMesh *em, const char hflag)
 {
-       BM_mesh_elem_flag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag);
+       BM_mesh_elem_flag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag, FALSE);
 }
 
 void EDBM_flag_enable_all(BMEditMesh *em, const char hflag)
 {
-       BM_mesh_elem_flag_enable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag);
+       BM_mesh_elem_flag_enable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, hflag, TRUE);
 }
 
 /**************-------------- Undo ------------*****************/
index e0f808aa1a17a2ecf839bb932488a5215f19afd0..a87268a24024a4fc08ba88ffeac6d40aa1765c1d 100644 (file)
@@ -1249,91 +1249,132 @@ static void vgroup_invert(Object *ob, const short auto_assign, const short auto_
        }
 }
 
-static void vgroup_blend(Object *ob)
+static void vgroup_blend(Object *ob, const float fac)
 {
+       MDeformVert *dv;
        MDeformWeight *dw;
-       MDeformVert *dvert_array=NULL, *dvert;
        int i, dvert_tot=0;
-       const int def_nr= ob->actdef-1;
+       const int def_nr= ob->actdef - 1;
 
-       BMEditMesh *em;
+       BLI_assert(fac >= 0.0 && fac <= 1.0f);
 
-       if (ob->type != OB_MESH || ((em = BMEdit_FromObject(ob)) == NULL)) {
+       if (ob->type != OB_MESH) {
                return;
        }
 
        if (BLI_findlink(&ob->defbase, def_nr)) {
+               const float ifac = 1.0f - fac;
+               int i1, i2;
+
+               BMEditMesh *em = BMEdit_FromObject(ob);
+               BMesh *bm = em ? em->bm : NULL;
+               Mesh  *me = em ? NULL   : ob->data;
+
+               /* bmesh only*/
                BMEdge *eed;
                BMVert *eve;
                BMIter iter;
 
-               int i1, i2;
+               /* mesh only */
+               MDeformVert *dvert_array = NULL;
+
 
                float *vg_weights;
                float *vg_users;
                int sel1, sel2;
 
-               BM_mesh_elem_index_ensure(em->bm, BM_VERT);
+               if (bm) {
+                       BM_mesh_elem_index_ensure(bm, BM_VERT);
+                       dvert_tot = bm->totvert;
+               }
+               else {
+                       dvert_tot = me->totvert;
+                       dvert_array = me->dvert;
+               }
 
-               dvert_tot= em->bm->totvert;
+               vg_weights = MEM_callocN(sizeof(float) * dvert_tot, "vgroup_blend_f");
+               vg_users = MEM_callocN(sizeof(int) * dvert_tot, "vgroup_blend_i");
 
-               vg_weights= MEM_callocN(sizeof(float)*dvert_tot, "vgroup_blend_f");
-               vg_users= MEM_callocN(sizeof(int)*dvert_tot, "vgroup_blend_i");
+               if (bm) {
+                       BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+                               sel1 = BM_elem_flag_test(eed->v1, BM_ELEM_SELECT);
+                               sel2 = BM_elem_flag_test(eed->v2, BM_ELEM_SELECT);
 
-               BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
-                       sel1= BM_elem_flag_test(eed->v1, BM_ELEM_SELECT);
-                       sel2= BM_elem_flag_test(eed->v2, BM_ELEM_SELECT);
+                               if (sel1 != sel2) {
+                                       /* i1 is always the selected one */
+                                       if (sel1) {
+                                               i1= BM_elem_index_get(eed->v1);
+                                               i2= BM_elem_index_get(eed->v2);
+                                               eve= eed->v2;
+                                       }
+                                       else {
+                                               i2= BM_elem_index_get(eed->v1);
+                                               i1= BM_elem_index_get(eed->v2);
+                                               eve= eed->v1;
+                                       }
 
-                       if (sel1 != sel2) {
-                               /* i1 is always the selected one */
-                               if (sel1==TRUE && sel2==FALSE) {
-                                       i1= BM_elem_index_get(eed->v1);
-                                       i2= BM_elem_index_get(eed->v2);
-                                       eve= eed->v2;
-                               }
-                               else {
-                                       i2= BM_elem_index_get(eed->v1);
-                                       i1= BM_elem_index_get(eed->v2);
-                                       eve= eed->v1;
+                                       dv = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_MDEFORMVERT);
+                                       dw = defvert_find_index(dv, def_nr);
+                                       if (dw) {
+                                               vg_weights[i1] += dw->weight;
+                                       }
+                                       vg_users[i1]++;
                                }
+                       }
 
-                               vg_users[i1]++;
+                       BM_ITER_INDEX(eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+                               if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && vg_users[i] > 0) {
+                                       dv = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_MDEFORMVERT);
 
-                               /* TODO, we may want object mode blending */
-#if 0
-                               if (em) {
-                                       dvert = CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
-                               }
-                               else
-#endif
-                               {
-                                       dvert= dvert_array+i2;
+                                       dw = defvert_verify_index(dv, def_nr);
+                                       dw->weight = (fac * (vg_weights[i] / (float)vg_users[i])) + (ifac * dw->weight);
+                                       /* in case of division errors */
+                                       CLAMP(dw->weight, 0.0f, 1.0f);
                                }
+                       }
+               }
+               else {
+                       MEdge *ed = me->medge;
+                       MVert *mv;
 
-                               dw = defvert_find_index(dvert, def_nr);
+                       for (i = 0; i < me->totedge; i++, ed++) {
+                               sel1 = me->mvert[ed->v1].flag & SELECT;
+                               sel2 = me->mvert[ed->v2].flag & SELECT;
 
-                               if (dw) {
-                                       vg_weights[i1] += dw->weight;
+                               if (sel1 != sel2) {
+                                       /* i1 is always the selected one */
+                                       if (sel1) {
+                                               i1 = ed->v1;
+                                               i2 = ed->v2;
+                                       }
+                                       else {
+                                               i2 = ed->v1;
+                                               i1 = ed->v2;
+                                       }
+
+                                       dv = &dvert_array[i2];
+                                       dw = defvert_find_index(dv, def_nr);
+                                       if (dw) {
+                                               vg_weights[i1] += dw->weight;
+                                       }
+                                       vg_users[i1]++;
                                }
                        }
-               }
 
-               i= 0;
-               BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-                       if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && vg_users[i] > 0) {
-                               /* TODO, we may want object mode blending */
-                               if (em)  dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
-                               else    dvert= dvert_array+i;
+                       mv = me->mvert;
+                       dv = dvert_array;
 
-                               dw= defvert_verify_index(dvert, def_nr);
-                               dw->weight= vg_weights[i] / (float)vg_users[i];
+                       for (i = 0; i < dvert_tot; i++, mv++, dv++) {
+                               if ((mv->flag & SELECT) && (vg_users[i] > 0)) {
+                                       dw = defvert_verify_index(dv, def_nr);
+                                       dw->weight = (fac * (vg_weights[i] / (float)vg_users[i])) + (ifac * dw->weight);
 
-                               /* in case of division errors */
-                               CLAMP(dw->weight, 0.0f, 1.0f);
+                                       /* in case of division errors */
+                                       CLAMP(dw->weight, 0.0f, 1.0f);
+                               }
                        }
-
-                       i++;
                }
+
                MEM_freeN(vg_weights);
                MEM_freeN(vg_users);
        }
@@ -2482,11 +2523,12 @@ void OBJECT_OT_vertex_group_invert(wmOperatorType *ot)
 }
 
 
-static int vertex_group_blend_exec(bContext *C, wmOperator *UNUSED(op))
+static int vertex_group_blend_exec(bContext *C, wmOperator *op)
 {
-       Object *ob= ED_object_context(C);
+       Object *ob = ED_object_context(C);
+       float fac = RNA_float_get(op->ptr, "factor");
 
-       vgroup_blend(ob);
+       vgroup_blend(ob, fac);
 
        DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
@@ -2495,19 +2537,53 @@ static int vertex_group_blend_exec(bContext *C, wmOperator *UNUSED(op))
        return OPERATOR_FINISHED;
 }
 
+/* check we have a vertex selection, either in weight paint or editmode */
+static int vertex_group_blend_poll(bContext *C)
+{
+       Object *ob = ED_object_context(C);
+       ID *data = (ob) ? ob->data: NULL;
+
+       if (!(ob && !ob->id.lib && data && !data->lib))
+               return FALSE;
+
+       if (vgroup_object_in_edit_mode(ob)) {
+               return TRUE;
+       }
+       else if ((ob->type == OB_MESH) && (ob->mode & OB_MODE_WEIGHT_PAINT)) {
+               if (ME_EDIT_PAINT_SEL_MODE(((Mesh *)data)) == SCE_SELECT_VERTEX) {
+                       return TRUE;
+               }
+               else {
+                       CTX_wm_operator_poll_msg_set(C, "Vertex select needs to be enabled in weight paint mode");
+                       return FALSE;
+               }
+
+       }
+       else {
+               return FALSE;
+       }
+}
+
 void OBJECT_OT_vertex_group_blend(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
+
        /* identifiers */
        ot->name = "Blend Vertex Group";
        ot->idname = "OBJECT_OT_vertex_group_blend";
-       ot->description = "";
+       ot->description = "Blend selected vertex weights with unselected for the active group";
 
        /* api callbacks */
-       ot->poll = vertex_group_poll_edit; /* TODO - add object mode support */
+       ot->poll = vertex_group_blend_poll;
        ot->exec = vertex_group_blend_exec;
 
        /* flags */
        ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
+
+       prop = RNA_def_property(ot->srna, "factor", PROP_FLOAT, PROP_FACTOR);
+       RNA_def_property_ui_text(prop, "Factor", "");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_float_default(prop, 1.0f);
 }
 
 
index 180e72c8cd7ac998af8e0b6140cf3e736d10b00f..397f2cc697812c133a0fa4b192fde4fcd7a64986 100644 (file)
@@ -687,7 +687,7 @@ void RENDER_OT_opengl(wmOperatorType *ot)
 
        prop = RNA_def_boolean(ot->srna, "animation", 0, "Animation", "Render files from the animation range of this scene");
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
-       prop = RNA_def_boolean(ot->srna, "sequencer", 0, "Sequencer", "Render using the sequencers OpenGL display");
+       prop = RNA_def_boolean(ot->srna, "sequencer", 0, "Sequencer", "Render using the sequencer's OpenGL display");
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
        prop = RNA_def_boolean(ot->srna, "write_still", 0, "Write Image", "Save rendered the image to the output path (used only when animation is disabled)");
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
index 9cf8cc2199665c9977f2efd7b68191a70dd1b34f..18f3094fa318afb684292a0900279ea89be8816b 100644 (file)
@@ -531,7 +531,7 @@ static Image *imapaint_face_image(const ImagePaintState *s, int face_index)
 
        if (scene_use_new_shading_nodes(s->scene)) {
                MFace *mf = &s->dm_mface[face_index];
-               ED_object_get_active_image(s->ob, mf->mat_nr, &ima, NULL, NULL);
+               ED_object_get_active_image(s->ob, mf->mat_nr + 1, &ima, NULL, NULL);
        }
        else {
                MTFace *tf = &s->dm_mtface[face_index];
@@ -547,7 +547,7 @@ static Image *project_paint_face_image(const ProjPaintState *ps, MTFace *dm_mtfa
 
        if (ps->do_new_shading_nodes) { /* cached scene_use_new_shading_nodes result */
                MFace *mf = ps->dm_mface + face_index;
-               ED_object_get_active_image(ps->ob, mf->mat_nr, &ima, NULL, NULL);
+               ED_object_get_active_image(ps->ob, mf->mat_nr + 1, &ima, NULL, NULL);
        }
        else {
                ima = dm_mtface[face_index].tpage;
index ae0c19d7245c482fcebbacce148a7fe5c67409a3..1aeaad1bfabe4aa9964ca62e080880ca376541b6 100644 (file)
@@ -473,7 +473,7 @@ void vpaint_fill(Object *ob, unsigned int paintcol)
 void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
 {
        Mesh *me = ob->data;
-       MPoly *mf;
+       MPoly *mp;
        MDeformWeight *dw, *dw_prev;
        int vgroup_active, vgroup_mirror = -1;
        unsigned int index;
@@ -492,15 +492,15 @@ void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
        
        copy_wpaint_prev(wp, me->dvert, me->totvert);
        
-       for (index = 0, mf = me->mpoly; index < me->totpoly; index++, mf++) {
-               unsigned int fidx = mf->totloop - 1;
+       for (index = 0, mp = me->mpoly; index < me->totpoly; index++, mp++) {
+               unsigned int fidx = mp->totloop - 1;
 
-               if ((paint_selmode == SCE_SELECT_FACE) && !(mf->flag & ME_FACE_SEL)) {
+               if ((paint_selmode == SCE_SELECT_FACE) && !(mp->flag & ME_FACE_SEL)) {
                        continue;
                }
 
                do {
-                       unsigned int vidx = me->mloop[mf->loopstart + fidx].v;
+                       unsigned int vidx = me->mloop[mp->loopstart + fidx].v;
 
                        if (!me->dvert[vidx].flag) {
                                if ((paint_selmode == SCE_SELECT_VERTEX) && !(me->mvert[vidx].flag & SELECT)) {
@@ -1032,7 +1032,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
                                BKE_report(op->reports, RPT_WARNING, "The modifier used does not support deformed locations");
                        }
                        else {
-                               MPoly *mf = ((MPoly *)me->mpoly) + index - 1;
+                               MPoly *mp = ((MPoly *)me->mpoly) + (index - 1);
                                const int vgroup_active = vc.obact->actdef - 1;
                                ToolSettings *ts = vc.scene->toolsettings;
                                float mval_f[2];
@@ -1043,10 +1043,10 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
                                mval_f[0] = (float)event->mval[0];
                                mval_f[1] = (float)event->mval[1];
 
-                               fidx = mf->totloop - 1;
+                               fidx = mp->totloop - 1;
                                do {
                                        float co[3], sco[3], len;
-                                       const int v_idx = me->mloop[mf->loopstart + fidx].v;
+                                       const int v_idx = me->mloop[mp->loopstart + fidx].v;
                                        dm->getVertCo(dm, v_idx, co);
                                        project_float_noclip(vc.ar, co, sco);
                                        len = len_squared_v2v2(mval_f, sco);
@@ -1112,13 +1112,13 @@ static EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C, PointerRNA
                                if (index && index <= me->totpoly) {
                                        const int defbase_tot = BLI_countlist(&vc.obact->defbase);
                                        if (defbase_tot) {
-                                               MPoly *mf = ((MPoly *)me->mpoly) + index - 1;
-                                               unsigned int fidx = mf->totloop - 1;
+                                               MPoly *mp = ((MPoly *)me->mpoly) + (index - 1);
+                                               unsigned int fidx = mp->totloop - 1;
                                                int *groups = MEM_callocN(defbase_tot * sizeof(int), "groups");
                                                int found = FALSE;
 
                                                do {
-                                                       MDeformVert *dvert = me->dvert + me->mloop[mf->loopstart + fidx].v;
+                                                       MDeformVert *dvert = me->dvert + me->mloop[mp->loopstart + fidx].v;
                                                        int i = dvert->totweight;
                                                        MDeformWeight *dw;
                                                        for (dw = dvert->dw; i > 0; dw++, i--) {
index 5378ce7872a6d38310dcc9f1777259147fe4f3ac..89a786d02a9b38bfbb1e8bd1de724f1e52759758 100644 (file)
@@ -274,7 +274,8 @@ static void sculpt_undo_restore(bContext *C, ListBase *lb)
 
                if (ss->modifiers_active) {
                        Mesh *mesh = ob->data;
-                       mesh_calc_normals_mapping(mesh->mvert, mesh->totvert, mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly, NULL, NULL, 0, NULL, NULL);
+                       mesh_calc_normals_tessface(mesh->mvert, mesh->totvert,
+                                                                          mesh->mface, mesh->totface, NULL);
 
                        free_sculptsession_deformMats(ss);
                        tag_update |= 1;
@@ -471,14 +472,6 @@ SculptUndoNode *sculpt_undo_push_node(Object *ob, PBVHNode *node,
        BLI_unlock_thread(LOCK_CUSTOM1);
 
        /* copy threaded, hopefully this is the performance critical part */
-       switch (type) {
-               case SCULPT_UNDO_COORDS:
-                       sculpt_undo_store_coords(ob, unode);
-                       break;
-               case SCULPT_UNDO_HIDDEN:
-                       sculpt_undo_store_hidden(ob, unode);
-                       break;
-       }
 
        if (unode->grids) {
                int totgrid, *grids;
@@ -493,6 +486,15 @@ SculptUndoNode *sculpt_undo_push_node(Object *ob, PBVHNode *node,
                memcpy(unode->index, vert_indices, sizeof(int) * unode->totvert);
        }
 
+       switch (type) {
+               case SCULPT_UNDO_COORDS:
+                       sculpt_undo_store_coords(ob, unode);
+                       break;
+               case SCULPT_UNDO_HIDDEN:
+                       sculpt_undo_store_hidden(ob, unode);
+                       break;
+       }
+
        /* store active shape key */
        if (ss->kb) BLI_strncpy(unode->shapeName, ss->kb->name, sizeof(ss->kb->name));
        else unode->shapeName[0] = '\0';
index ca0e999d7ea980f0bcf1eff5f34e85aa6833e3a6..33588cc0923521c44c7480c3ff7ecddc4283dff4 100644 (file)
@@ -64,6 +64,6 @@ void CONSOLE_OT_paste(struct wmOperatorType *ot);
 void CONSOLE_OT_select_set(struct wmOperatorType *ot);
 
 enum { LINE_BEGIN, LINE_END, PREV_CHAR, NEXT_CHAR, PREV_WORD, NEXT_WORD };
-enum { DEL_ALL, DEL_NEXT_CHAR, DEL_PREV_CHAR, DEL_SELECTION, DEL_NEXT_SEL, DEL_PREV_SEL };
+enum { DEL_ALL, DEL_NEXT_CHAR, DEL_PREV_CHAR, DEL_NEXT_WORD, DEL_PREV_WORD, DEL_SELECTION, DEL_NEXT_SEL, DEL_PREV_SEL };
 
 #endif /* __CONSOLE_INTERN_H__ */
index d80b9e2ffb9f6c7e6913bf2175e61e6e7bbf8da0..ef036b071be975d1519f69d7a45c4d22dcae4f8c 100644 (file)
@@ -434,8 +434,8 @@ void CONSOLE_OT_insert(wmOperatorType *ot)
 static EnumPropertyItem console_delete_type_items[] = {
        {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
        {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
-//     {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
-//     {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
+       {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
+       {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
        {0, NULL, 0, NULL, NULL}
 };
 
@@ -444,6 +444,8 @@ static int console_delete_exec(bContext *C, wmOperator *op)
        SpaceConsole *sc = CTX_wm_space_console(C);
        ARegion *ar = CTX_wm_region(C);
        ConsoleLine *ci = console_history_verify(C);
+       int pos;
+       int stride;
 
        const short type = RNA_enum_get(op->ptr, "type");
        int done = 0;
@@ -454,22 +456,38 @@ static int console_delete_exec(bContext *C, wmOperator *op)
        
        switch (type) {
                case DEL_NEXT_CHAR:
+               case DEL_NEXT_WORD:
                        if (ci->cursor < ci->len) {
-                               memmove(ci->line + ci->cursor, ci->line + ci->cursor + 1, (ci->len - ci->cursor) + 1);
-                               ci->len--;
-                               done = 1;
+                               pos = ci->cursor;
+                               BLI_str_cursor_step_utf8(ci->line, ci->len,
+                                                        &pos, STRCUR_DIR_NEXT,
+                                                        (type == DEL_NEXT_CHAR) ? STRCUR_JUMP_NONE : STRCUR_JUMP_DELIM);
+                               stride = pos - ci->cursor;
+                               if (stride) {
+                                       memmove(ci->line + ci->cursor, ci->line + ci->cursor + stride, (ci->len - ci->cursor) + 1);
+                                       ci->len -= stride;
+                                       done = 1;
+                               }
                        }
                        break;
                case DEL_PREV_CHAR:
+               case DEL_PREV_WORD:
                        if (ci->cursor > 0) {
-                               ci->cursor--; /* same as above */
-                               memmove(ci->line + ci->cursor, ci->line + ci->cursor + 1, (ci->len - ci->cursor) + 1);
-                               ci->len--;
-                               done = 1;
+                               pos = ci->cursor;
+                               BLI_str_cursor_step_utf8(ci->line, ci->len,
+                                                        &pos, STRCUR_DIR_PREV,
+                                                        (type == DEL_PREV_CHAR) ? STRCUR_JUMP_NONE : STRCUR_JUMP_DELIM);
+                               stride = ci->cursor - pos;
+                               if (stride) {
+                                       ci->cursor -= stride; /* same as above */
+                                       memmove(ci->line + ci->cursor, ci->line + ci->cursor + stride, (ci->len - ci->cursor) + 1);
+                                       ci->len -= stride;
+                                       done = 1;
+                               }
                        }
                        break;
        }
-       
+
        if (!done) {
                return OPERATOR_CANCELLED;
        }
index 0dbd4876a656d64f6b46da9c64869f504f43f0eb..b71ca6c36c4f8fcb0a1d8a524f17c10e0e499a6a 100644 (file)
@@ -303,19 +303,15 @@ static void console_keymap(struct wmKeyConfig *keyconf)
        RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_move", DOWNARROWKEY, KM_PRESS, 0, 0)->ptr, "type", NEXT_LINE);
        RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_move", PAGEUPKEY, KM_PRESS, 0, 0)->ptr, "type", PREV_PAGE);
        RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_move", PAGEDOWNKEY, KM_PRESS, 0, 0)->ptr, "type", NEXT_PAGE);
-
-
-       //RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DELKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_NEXT_CHAR);
-       RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_NEXT_CHAR);
-       //RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_PREV_CHAR);
-       RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DELKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_NEXT_WORD);
-       RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_PREV_WORD);
 #endif
        
        RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DELKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_NEXT_CHAR);
        RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_PREV_CHAR);
        RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, KM_SHIFT, 0)->ptr, "type", DEL_PREV_CHAR);  /* same as above [#26623] */
 
+       RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DELKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_NEXT_WORD);
+       RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_PREV_WORD);
+
 #ifdef WITH_PYTHON
        WM_keymap_add_item(keymap, "CONSOLE_OT_execute", RETKEY, KM_PRESS, 0, 0); /* python operator - space_text.py */
        WM_keymap_add_item(keymap, "CONSOLE_OT_execute", PADENTER, KM_PRESS, 0, 0);
index 25998e7bce21a0189871d8142e523c55e3c73b18..fc84cfc46a2b87f06f0be0fba5384cc79f988339 100644 (file)
@@ -118,7 +118,7 @@ static void draw_fcurve_modifier_controls_envelope (FModifier *fcm, View2D *v2d)
                /* only draw if visible
                 *      - min/max here are fixed, not relative
                 */
-               if IN_RANGE(fed->time, (v2d->cur.xmin - fac), (v2d->cur.xmax + fac)) {
+               if (IN_RANGE(fed->time, (v2d->cur.xmin - fac), (v2d->cur.xmax + fac))) {
                        glVertex2f(fed->time, fed->min);
                        glVertex2f(fed->time, fed->max);
                }
@@ -149,7 +149,7 @@ static void draw_fcurve_vertices_keyframes (FCurve *fcu, SpaceIpo *UNUSED(sipo),
                /* as an optimization step, only draw those in view 
                 *      - we apply a correction factor to ensure that points don't pop in/out due to slight twitches of view size
                 */
-               if IN_RANGE(bezt->vec[1][0], (v2d->cur.xmin - fac), (v2d->cur.xmax + fac)) {
+               if (IN_RANGE(bezt->vec[1][0], (v2d->cur.xmin - fac), (v2d->cur.xmax + fac))) {
                        if (edit) {
                                /* 'Keyframe' vertex only, as handle lines and handles have already been drawn
                                 *      - only draw those with correct selection state for the current drawing color
index ad4921d225c6aa00156a05affd74b8df100a369c..1602fe48a1728bebedd9d5dd6d89681535fc2fec 100644 (file)
@@ -342,7 +342,7 @@ void IMAGE_OT_view_pan(wmOperatorType *ot)
        ot->poll = space_image_main_area_poll;
 
        /* flags */
-       ot->flag = OPTYPE_BLOCKING;
+       ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_POINTER;
        
        /* properties */
        RNA_def_float_vector(ot->srna, "offset", 2, NULL, -FLT_MAX, FLT_MAX,
index c6d36842207984dcfdcff4a213fe5ca37c74f04b..3c1c8ac9941a45f54253ee553a3da24a90f5a33f 100644 (file)
@@ -603,7 +603,7 @@ static void image_refresh(const bContext *C, ScrArea *UNUSED(sa))
 
                        if (efa) {
                                Image *node_ima;
-                               ED_object_get_active_image(obedit, efa->mat_nr, &node_ima, NULL, NULL);
+                               ED_object_get_active_image(obedit, efa->mat_nr + 1, &node_ima, NULL, NULL);
 
                                if (node_ima)
                                        sima->image = node_ima;
index 39f1552c8a6618fcaa20c9e5f2bb376c5b5769e1..e808a66bc24afcb58c878840ed1ced3e8e7633e4 100644 (file)
@@ -172,8 +172,8 @@ static DMDrawOption draw_mesh_face_select__drawFaceOptsInv(void *userData, int i
 {
        Mesh *me = (Mesh *)userData;
 
-       MPoly *mface = &me->mpoly[index];
-       if (!(mface->flag & ME_HIDE) && !(mface->flag & ME_FACE_SEL))
+       MPoly *mpoly = &me->mpoly[index];
+       if (!(mpoly->flag & ME_HIDE) && !(mpoly->flag & ME_FACE_SEL))
                return DM_DRAW_OPTION_NO_MCOL;  /* Don't set color */
        else
                return DM_DRAW_OPTION_SKIP;
index 36a3ca4d6f9602050b4c9bcf56db38312d8d2358..80666b17eaa16ceeb59c467f89b68ad94af15d11 100644 (file)
 
 #include "view3d_intern.h"  // own include
 
-
-/* this condition has been made more complex since editmode can draw textures */
-#define CHECK_OB_DRAWTEXTURE(vd, dt)                                          \
-    ((ELEM(vd->drawtype, OB_TEXTURE, OB_MATERIAL) && dt > OB_SOLID) ||          \
-     (vd->drawtype == OB_SOLID && vd->flag2 & V3D_SOLID_TEX))
-
 typedef enum eWireDrawMode {
        OBDRAW_WIRE_OFF = 0,
        OBDRAW_WIRE_ON = 1,
@@ -183,6 +177,20 @@ static void drawcircle_size(float size);
 static void draw_empty_sphere(float size);
 static void draw_empty_cone(float size);
 
+/* this condition has been made more complex since editmode can draw textures */
+static int check_object_draw_texture(Scene *scene, View3D *v3d, int drawtype)
+{
+       /* texture and material draw modes */
+    if(ELEM(v3d->drawtype, OB_TEXTURE, OB_MATERIAL) && drawtype > OB_SOLID)
+               return TRUE;
+
+       /* textured solid */
+       if(v3d->drawtype == OB_SOLID && (v3d->flag2 & V3D_SOLID_TEX) && !scene_use_new_shading_nodes(scene))
+               return TRUE;
+       
+       return FALSE;
+}
+
 static int check_ob_drawface_dot(Scene *sce, View3D *vd, char dt)
 {
        if ((sce->toolsettings->selectmode & SCE_SELECT_FACE) == 0)
@@ -315,7 +323,7 @@ int draw_glsl_material(Scene *scene, Object *ob, View3D *v3d, int dt)
                return 0;
        if (G.f & G_PICKSEL)
                return 0;
-       if (!CHECK_OB_DRAWTEXTURE(v3d, dt))
+       if (!check_object_draw_texture(scene, v3d, dt))
                return 0;
        if (ob == OBACT && (ob && ob->mode & OB_MODE_WEIGHT_PAINT))
                return 0;
@@ -3048,7 +3056,7 @@ static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d,
        EDBM_index_arrays_init(em, 1, 1, 1);
 
        if (dt > OB_WIRE) {
-               if (CHECK_OB_DRAWTEXTURE(v3d, dt)) {
+               if (check_object_draw_texture(scene, v3d, dt)) {
                        if (draw_glsl_material(scene, ob, v3d, dt)) {
                                glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
 
@@ -3102,7 +3110,7 @@ static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d,
                glDepthMask(0);     // disable write in zbuffer, needed for nice transp
                
                /* don't draw unselected faces, only selected, this is MUCH nicer when texturing */
-               if (CHECK_OB_DRAWTEXTURE(v3d, dt))
+               if (check_object_draw_texture(scene, v3d, dt))
                        col1[3] = 0;
                
                if (!(me->drawflag & ME_DRAW_FREESTYLE_FACE))
@@ -3132,7 +3140,7 @@ static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d,
        }
 
        /* here starts all fancy draw-extra over */
-       if ((me->drawflag & ME_DRAWEDGES) == 0 && CHECK_OB_DRAWTEXTURE(v3d, dt)) {
+       if ((me->drawflag & ME_DRAWEDGES) == 0 && check_object_draw_texture(scene, v3d, dt)) {
                /* we are drawing textures and 'ME_DRAWEDGES' is disabled, don't draw any edges */
                
                /* only draw selected edges otherwise there is no way of telling if a face is selected */
@@ -3288,7 +3296,7 @@ static void draw_mesh_fancy(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D
                draw_wire = OBDRAW_WIRE_ON; /* draw wire only, no depth buffer stuff  */
        }
        else if ( (draw_flags & DRAW_FACE_SELECT || (is_obact && ob->mode & OB_MODE_TEXTURE_PAINT)) ||
-                 CHECK_OB_DRAWTEXTURE(v3d, dt))
+                 check_object_draw_texture(scene, v3d, dt))
        {
                if ( (v3d->flag & V3D_SELECT_OUTLINE) &&
                     ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) &&
index 0e7c71f0c0a6b7ce7eadc70aac76673b45bfb376..31beda3b3f97ee00739275f68f363e564fbc949e 100644 (file)
@@ -56,7 +56,7 @@
 
 #include "PIL_time.h" /* smoothview */
 
-#include "view3d_intern.h"  // own include
+#include "view3d_intern.h"  /* own include */
 /* NOTE: these defines are saved in keymap files, do not change values but just add new ones */
 enum {
        FLY_MODAL_CANCEL = 1,
@@ -272,7 +272,7 @@ static void drawFlyPixel(const struct bContext *UNUSED(C), struct ARegion *UNUSE
 static int initFlyInfo(bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event)
 {
        wmWindow *win = CTX_wm_window(C);
-       float upvec[3]; // tmp
+       float upvec[3]; /* tmp */
        float mat[3][3];
 
        fly->rv3d = CTX_wm_region_view3d(C);
@@ -376,7 +376,7 @@ static int initFlyInfo(bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event
        else {
                /* perspective or ortho */
                if (fly->rv3d->persp == RV3D_ORTHO)
-                       fly->rv3d->persp = RV3D_PERSP;  /*if ortho projection, make perspective */
+                       fly->rv3d->persp = RV3D_PERSP;  /* if ortho projection, make perspective */
 
                copy_qt_qt(fly->rot_backup, fly->rv3d->viewquat);
                copy_v3_v3(fly->ofs_backup, fly->rv3d->ofs);
@@ -390,10 +390,10 @@ static int initFlyInfo(bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event
 
                fly->rv3d->dist = 0.0f;
 
-               upvec[2] = fly->dist_backup; /*x and y are 0*/
+               upvec[2] = fly->dist_backup; /* x and y are 0 */
                mul_m3_v3(mat, upvec);
                sub_v3_v3(fly->rv3d->ofs, upvec);
-               /*Done with correcting for the dist*/
+               /* Done with correcting for the dist */
        }
 
        /* center the mouse, probably the UI mafia are against this but without its quite annoying */
@@ -449,11 +449,11 @@ static int flyEnd(bContext *C, FlyInfo *fly)
                /* restore the dist */
                float mat[3][3];
                upvec[0] = upvec[1] = 0;
-               upvec[2] = fly->dist_backup; /*x and y are 0*/
+               upvec[2] = fly->dist_backup; /* x and y are 0 */
                copy_m3_m4(mat, rv3d->viewinv);
                mul_m3_v3(mat, upvec);
                add_v3_v3(rv3d->ofs, upvec);
-               /*Done with correcting for the dist */
+               /* Done with correcting for the dist */
        }
 
        if (fly->is_ortho_cam) {
@@ -486,20 +486,20 @@ static void flyEvent(FlyInfo *fly, wmEvent *event)
                copy_v2_v2_int(fly->mval, event->mval);
        }
        else if (event->type == NDOF_MOTION) {
-               // do these automagically get delivered? yes.
+               /* do these automagically get delivered? yes. */
                // puts("ndof motion detected in fly mode!");
                // static const char* tag_name = "3D mouse position";
 
                wmNDOFMotionData *incoming_ndof = (wmNDOFMotionData *)event->customdata;
                switch (incoming_ndof->progress) {
                        case P_STARTING:
-                               // start keeping track of 3D mouse position
+                               /* start keeping track of 3D mouse position */
 #ifdef NDOF_FLY_DEBUG
                                puts("start keeping track of 3D mouse position");
 #endif
-                       // fall through...
+                       /* fall through... */
                        case P_IN_PROGRESS:
-                               // update 3D mouse position
+                               /* update 3D mouse position */
 #ifdef NDOF_FLY_DEBUG
                                putchar('.'); fflush(stdout);
 #endif
@@ -547,8 +547,7 @@ static void flyEvent(FlyInfo *fly, wmEvent *event)
                                time_currwheel = PIL_check_seconds_timer();
                                time_wheel = (float)(time_currwheel - fly->time_lastwheel);
                                fly->time_lastwheel = time_currwheel;
-                               /*printf("Wheel %f\n", time_wheel);*/
-                               /*Mouse wheel delays range from 0.5==slow to 0.01==fast*/
+                               /* Mouse wheel delays range from 0.5==slow to 0.01==fast */
                                time_wheel = 1.0f + (10.0f - (20.0f * MIN2(time_wheel, 0.5f))); /* 0-0.5 -> 0-5.0 */
 
                                if (fly->speed < 0.0f) {
@@ -845,7 +844,6 @@ static int flyApply(bContext *C, FlyInfo *fly)
                        time_redraw = (float)(time_current - fly->time_lastdraw);
                        time_redraw_clamped = MIN2(0.05f, time_redraw); /* clamp redraw time to avoid jitter in roll correction */
                        fly->time_lastdraw = time_current;
-                       /*fprintf(stderr, "%f\n", time_redraw);*//* 0.002 is a small redraw 0.02 is larger */
 
                        /* Scale the time to use shift to scale the speed down- just like
                         * shift slows many other areas of blender down */
@@ -883,7 +881,7 @@ static int flyApply(bContext *C, FlyInfo *fly)
                                        mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
 
                                        if (fly->xlock)
-                                               fly->xlock = 2;  /*check for rotation*/
+                                               fly->xlock = 2;  /* check for rotation */
                                        if (fly->zlock)
                                                fly->zlock = 2;
                                        fly->xlock_momentum = 0.0f;
@@ -919,7 +917,7 @@ static int flyApply(bContext *C, FlyInfo *fly)
                                        mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
 
                                        if (fly->xlock)
-                                               fly->xlock = 2;  /*check for rotation*/
+                                               fly->xlock = 2;  /* check for rotation */
                                        if (fly->zlock)
                                                fly->zlock = 2;
                                }
@@ -930,10 +928,10 @@ static int flyApply(bContext *C, FlyInfo *fly)
                                        upvec[2] = 0.0f;
                                        mul_m3_v3(mat, upvec);
 
-                                       /*make sure we have some z rolling*/
+                                       /* make sure we have some z rolling */
                                        if (fabsf(upvec[2]) > 0.00001f) {
                                                roll = upvec[2] * 5.0f;
-                                               upvec[0] = 0.0f; /*rotate the view about this axis*/
+                                               upvec[0] = 0.0f; /* rotate the view about this axis */
                                                upvec[1] = 0.0f;
                                                upvec[2] = 1.0f;
 
@@ -951,16 +949,16 @@ static int flyApply(bContext *C, FlyInfo *fly)
                                        }
                                }
 
-                               if (fly->xlock == 2 && moffset[1] == 0) { /*only apply xcorrect when mouse isn't applying x rot*/
+                               if (fly->xlock == 2 && moffset[1] == 0) { /* only apply xcorrect when mouse isn't applying x rot */
                                        upvec[0] = 0;
                                        upvec[1] = 0;
                                        upvec[2] = 1;
                                        mul_m3_v3(mat, upvec);
-                                       /*make sure we have some z rolling*/
+                                       /* make sure we have some z rolling */
                                        if (fabsf(upvec[2]) > 0.00001f) {
                                                roll = upvec[2] * -5.0f;
 
-                                               upvec[0] = 1.0f; /*rotate the view about this axis*/
+                                               upvec[0] = 1.0f; /* rotate the view about this axis */
                                                upvec[1] = 0.0f;
                                                upvec[2] = 0.0f;
 
@@ -982,10 +980,10 @@ static int flyApply(bContext *C, FlyInfo *fly)
                                        /* pause */
                                        zero_v3(dvec_tmp);
                                }
-                               if (!fly->use_freelook) {
+                               else if (!fly->use_freelook) {
                                        /* Normal operation */
                                        /* define dvec, view direction vector */
-                                       dvec_tmp[0] = dvec_tmp[1] = dvec_tmp[2] = 0.0f;
+                                       zero_v3(dvec_tmp);
                                        /* move along the current axis */
                                        dvec_tmp[fly->axis] = 1.0f;
 
@@ -1041,22 +1039,23 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
            shouldTranslate = (flag & (NDOF_SHOULD_PAN | NDOF_SHOULD_ZOOM));
 #endif
 
-       int shouldRotate = (fly->pan_view == FALSE), shouldTranslate = TRUE;
+       int shouldRotate = (fly->pan_view == FALSE);
+       int shouldTranslate = TRUE;
 
        float view_inv[4];
        invert_qt_qt(view_inv, rv3d->viewquat);
 
-       rv3d->rot_angle = 0.f; // disable onscreen rotation doo-dad
+       rv3d->rot_angle = 0.0f; /* disable onscreen rotation doo-dad */
 
        if (shouldTranslate) {
-               const float forward_sensitivity = 1.f;
+               const float forward_sensitivity  = 1.0f;
                const float vertical_sensitivity = 0.4f;
-               const float lateral_sensitivity = 0.6f;
+               const float lateral_sensitivity  = 0.6f;
 
-               float speed = 10.f; /* blender units per second */
+               float speed = 10.0f; /* blender units per second */
                /* ^^ this is ok for default cube scene, but should scale with.. something */
 
-               float trans[3] = {lateral_sensitivity  *ndof->tvec[0],
+               float trans[3] = {lateral_sensitivity  * ndof->tvec[0],
                                  vertical_sensitivity * ndof->tvec[1],
                                  forward_sensitivity  * ndof->tvec[2]};
 
@@ -1065,7 +1064,7 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
 
                mul_v3_fl(trans, speed * dt);
 
-               // transform motion from view to world coordinates
+               /* transform motion from view to world coordinates */
                mul_qt_v3(view_inv, trans);
 
                if (flag & NDOF_FLY_HELICOPTER) {
@@ -1074,7 +1073,7 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
                }
 
                if (rv3d->persp == RV3D_CAMOB) {
-                       // respect camera position locks
+                       /* respect camera position locks */
                        Object *lock_ob = fly->root_parent ? fly->root_parent : fly->v3d->camera;
                        if (lock_ob->protectflag & OB_LOCK_LOCX) trans[0] = 0.0f;
                        if (lock_ob->protectflag & OB_LOCK_LOCY) trans[1] = 0.0f;
@@ -1082,7 +1081,7 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
                }
 
                if (!is_zero_v3(trans)) {
-                       // move center of view opposite of hand motion (this is camera mode, not object mode)
+                       /* move center of view opposite of hand motion (this is camera mode, not object mode) */
                        sub_v3_v3(rv3d->ofs, trans);
                        shouldTranslate = TRUE;
                }
@@ -1092,7 +1091,7 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
        }
 
        if (shouldRotate) {
-               const float turn_sensitivity = 1.f;
+               const float turn_sensitivity = 1.0f;
 
                float rotation[4];
                float axis[3];
@@ -1107,15 +1106,15 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
                        /* transform rotation axis from view to world coordinates */
                        mul_qt_v3(view_inv, axis);
 
-                       // apply rotation to view
+                       /* apply rotation to view */
                        axis_angle_to_quat(rotation, axis, angle);
                        mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, rotation);
 
                        if (flag & NDOF_LOCK_HORIZON) {
                                /* force an upright viewpoint
                                 * TODO: make this less... sudden */
-                               float view_horizon[3] = {1.f, 0.f, 0.f}; /* view +x */
-                               float view_direction[3] = {0.f, 0.f, -1.f}; /* view -z (into screen) */
+                               float view_horizon[3] = {1.0f, 0.0f, 0.0f}; /* view +x */
+                               float view_direction[3] = {0.0f, 0.0f, -1.0f}; /* view -z (into screen) */
 
                                /* find new inverse since viewquat has changed */
                                invert_qt_qt(view_inv, rv3d->viewquat);
index c773b91a2bb93cbb1536f987063e13e2e0c61da7..739ccc48f14436759902bb7f98b2db4b42939cc1 100644 (file)
@@ -4402,7 +4402,7 @@ static int createSlideVerts(TransInfo *t)
        int numsel, i, j;
 
        if (!v3d) {
-               /*ok, let's try to survive this*/
+               /* ok, let's try to survive this */
                unit_m4(projectMat);
        }
        else {
@@ -4428,15 +4428,20 @@ static int createSlideVerts(TransInfo *t)
                        }
 
                        if (numsel == 0 || numsel > 2) {
-                               return 0; //invalid edge selection
+                               MEM_freeN(sld);
+                               BMBVH_FreeBVH(btree);
+                               return 0; /* invalid edge selection */
                        }
                }
        }
 
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
-                       if (BM_edge_face_count(e) != 2)
-                               return 0; //can only handle exactly 2 faces around each edge
+                       if (BM_edge_face_count(e) != 2) {
+                               MEM_freeN(sld);
+                               BMBVH_FreeBVH(btree);
+                               return 0; /* can only handle exactly 2 faces around each edge */
+                       }
                }
        }
 
@@ -4452,8 +4457,11 @@ static int createSlideVerts(TransInfo *t)
                }
        }
 
-       if (!j)
+       if (!j) {
+               MEM_freeN(sld);
+               BMBVH_FreeBVH(btree);
                return 0;
+       }
 
        tempsv = MEM_callocN(sizeof(TransDataSlideVert)*j, "tempsv");
 
@@ -4760,12 +4768,14 @@ void projectSVData(TransInfo *t, int final)
                                }
                        }
                        
-                       /*make sure face-attributes are correct (e.g. MTexPoly)*/
+                       /* make sure face-attributes are correct (e.g. MTexPoly) */
                        BM_elem_attrs_copy(em->bm, em->bm, copyf2, f);
                        
-                       /*restore selection and hidden flags*/
+                       /* restore selection and hidden flags */
                        BM_elem_select_set(em->bm, f, sel);
-                       BM_elem_hide_set(em->bm, f, hide);
+                       if (!hide) { /* this check is a workaround for bug, see note - [#30735], without this edge can be hidden and selected */
+                               BM_elem_hide_set(em->bm, f, hide);
+                       }
                }
        }
        
index 4754e1731c8783fb88625aef53040164d9dbdf6f..c273d6a5b4cb7a01576877d8914456dfa814089d 100644 (file)
@@ -4491,7 +4491,7 @@ static void set_trans_object_base_flags(TransInfo *t)
                                if (parsel->flag & SELECT) {
                                        Base *parbase = object_in_scene(parsel, scene);
                                        if (parbase) { /* in rare cases this can fail */
-                                               if TESTBASELIB_BGMODE(v3d, scene, parbase) {
+                                               if (TESTBASELIB_BGMODE(v3d, scene, parbase)) {
                                                        break;
                                                }
                                        }
index 513f7df19577e9529cf3a31891584f15a937d97f..c6b8403d54f1e70575001c75c0eefb99bcfc7c1a 100644 (file)
@@ -531,7 +531,7 @@ int calc_manipulator_stats(const bContext *C)
                if (ob && !(ob->flag & SELECT)) ob= NULL;
 
                for (base= scene->base.first; base; base= base->next) {
-                       if TESTBASELIB(v3d, base) {
+                       if (TESTBASELIB(v3d, base)) {
                                if (ob==NULL)
                                        ob= base->object;
                                calc_tw_center(scene, base->object->obmat[3]);
index 025de8a47293b4112fa9110f7173189ee482eb37..af9c03af1b6c059dad9b7425ffd71f3fa24c9f19 100644 (file)
@@ -858,7 +858,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
                if (ob && !(ob->flag & SELECT)) ob = NULL;
                
                for (base= scene->base.first; base; base= base->next) {
-                       if TESTBASELIB(v3d, base) {
+                       if (TESTBASELIB(v3d, base)) {
                                if (ob == NULL) {
                                        ob= base->object;
                                        break;
index ff673fa0eab7027d395a9678acfb8e750b3923c5..1b5cef6f07d80cab04d7a62358359d09f9fbb265 100644 (file)
 
 /* UV Utilities */
 
-static int uvedit_center(Scene *scene, BMEditMesh *em, Image *UNUSED(ima), float center[2])
+static int uvedit_center(Scene *scene, BMEditMesh *em, Image *ima, float center[2])
 {
        BMFace *f;
        BMLoop *l;
        BMIter iter, liter;
+       MTexPoly *tf;
        MLoopUV *luv;
        int tot = 0.0;
        
        zero_v2(center);
        BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
+               tf = CustomData_bmesh_get(&em->bm->pdata, f->head.data, CD_MTEXPOLY);
+               if (!uvedit_face_visible(scene, ima, f, tf))
+                       continue;
+
                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
                        luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
                        if (uvedit_uv_selected(em, scene, l)) {
index 4690f11d9afd87a68a8c4a2e4fe5f37b9f7ad667..2fe007a42e8e03ad8db0e926df2b454616fe8d95 100644 (file)
@@ -383,18 +383,18 @@ static void draw_uvs_other(Scene *scene, Object *obedit, Image *curimage)
                if ((ob->type==OB_MESH) && (ob!=obedit)) {
                        Mesh *me= ob->data;
 
-                       if (me->mtface) {
-                               MPoly *mface= me->mpoly;
-                               MTexPoly *tface= me->mtpoly;
+                       if (me->mtpoly) {
+                               MPoly *mpoly = me->mpoly;
+                               MTexPoly *mtpoly = me->mtpoly;
                                MLoopUV *mloopuv;
                                int a, b;
 
-                               for (a=me->totpoly; a>0; a--, tface++, mface++) {
-                                       if (tface->tpage == curimage) {
+                               for (a = me->totpoly; a > 0; a--, mtpoly++, mpoly++) {
+                                       if (mtpoly->tpage == curimage) {
                                                glBegin(GL_LINE_LOOP);
 
-                                               mloopuv = me->mloopuv + mface->loopstart;
-                                               for (b=0; b<mface->totloop; b++, mloopuv++) {
+                                               mloopuv = me->mloopuv + mpoly->loopstart;
+                                               for (b = 0; b < mpoly->totloop; b++, mloopuv++) {
                                                        glVertex2fv(mloopuv->uv);
                                                }
                                                glEnd();
@@ -416,17 +416,17 @@ static void draw_uvs_texpaint(SpaceImage *sima, Scene *scene, Object *ob)
        glColor3ub(112, 112, 112);
 
        if (me->mtface) {
-               MPoly *mface= me->mpoly;
+               MPoly *mpoly= me->mpoly;
                MTexPoly *tface= me->mtpoly;
                MLoopUV *mloopuv;
                int a, b;
 
-               for (a=me->totpoly; a>0; a--, tface++, mface++) {
+               for (a=me->totpoly; a>0; a--, tface++, mpoly++) {
                        if (tface->tpage == curimage) {
                                glBegin(GL_LINE_LOOP);
 
-                               mloopuv = me->mloopuv + mface->loopstart;
-                               for (b=0; b<mface->totloop; b++, mloopuv++) {
+                               mloopuv = me->mloopuv + mpoly->loopstart;
+                               for (b=0; b<mpoly->totloop; b++, mloopuv++) {
                                        glVertex2fv(mloopuv->uv);
                                }
                                glEnd();
index 3f4352d8ab31cedaf45c7dbe72f1642f41b2ee4b..4bffc7098b3ca51a249dbf1d28ed4d93ea5cd577 100644 (file)
@@ -191,7 +191,7 @@ void ED_uvedit_assign_image(Main *bmain, Scene *scene, Object *obedit, Image *im
                BMFace *efa= BM_active_face_get(em->bm, sloppy);
 
                if (efa)
-                       ED_object_assign_active_image(bmain, obedit, efa->mat_nr, ima);
+                       ED_object_assign_active_image(bmain, obedit, efa->mat_nr + 1, ima);
        }
        else {
                /* old shading system, assign image to selected faces */
@@ -1620,6 +1620,7 @@ static void select_all_perform(bContext *C, int action)
                        break;
                case SEL_INVERT:
                        EDBM_select_swap(em);
+                       EDBM_selectmode_flush(em);
                        break;
                }
        }
index 53555346caf9beb591977952c9978ab713c3ed00..869cc0444aabcd6638121fcf790a034ed26a5f15 100644 (file)
@@ -1774,7 +1774,7 @@ void GPU_draw_buffers(GPU_Buffers *buffers, DMSetMaterial setMaterial)
 
        if (buffers->totface) {
                const MFace *f = &buffers->mface[buffers->face_indices[0]];
-               if (!setMaterial(f->mat_nr+1, NULL))
+               if (!setMaterial(f->mat_nr + 1, NULL))
                        return;
 
                smooth = f->flag & ME_SMOOTH;
@@ -1782,7 +1782,7 @@ void GPU_draw_buffers(GPU_Buffers *buffers, DMSetMaterial setMaterial)
        }
        else if (buffers->totgrid) {
                const DMFlagMat *f = &buffers->grid_flag_mats[buffers->grid_indices[0]];
-               if (!setMaterial(f->mat_nr+1, NULL))
+               if (!setMaterial(f->mat_nr + 1, NULL))
                        return;
 
                smooth = f->flag & ME_SMOOTH;
index 8a700053d30190d1bceff07242e9ff71228a8276..01a9a0a730368b9cbf8ea9d3ba08dc1c38073a3f 100644 (file)
 #undef AVIIF_KEYFRAME // redefined in AVI_avi.h
 #undef AVIIF_LIST // redefined in AVI_avi.h
 
-#define FIXCC(fcc)  if (fcc == 0)      fcc = mmioFOURCC('N', 'o', 'n', 'e'); \
-               if (fcc == BI_RLE8) fcc = mmioFOURCC('R', 'l', 'e', '8');
+#define FIXCC(fcc) \
+       { \
+               if (fcc == 0)       { fcc = mmioFOURCC('N', 'o', 'n', 'e'); } \
+               if (fcc == BI_RLE8) { fcc = mmioFOURCC('R', 'l', 'e', '8'); } \
+       }
+
 #endif
 
 #include <sys/types.h>
index 9ece4bd9f6dff351780ad4a4b0f70bf5a933e321..59c10165974a7bcade0a25242c333a1972febfb3 100644 (file)
@@ -77,7 +77,7 @@ ImFileType IMB_FILE_TYPES[]= {
        {NULL, NULL, imb_is_a_hdr, imb_ftype_default, imb_loadhdr, imb_savehdr, NULL, IM_FTYPE_FLOAT, RADHDR},
 #endif
 #ifdef WITH_OPENEXR
-       {NULL, NULL, imb_is_a_openexr, imb_ftype_default, imb_load_openexr, imb_save_openexr, NULL, IM_FTYPE_FLOAT, OPENEXR},
+       {imb_initopenexr, NULL, imb_is_a_openexr, imb_ftype_default, imb_load_openexr, imb_save_openexr, NULL, IM_FTYPE_FLOAT, OPENEXR},
 #endif
 #ifdef WITH_OPENJPEG
        {NULL, NULL, imb_is_a_jp2, imb_ftype_default, imb_jp2_decode, imb_savejp2, NULL, IM_FTYPE_FLOAT, JP2},
index 082bb82c3220271470e18a6f3f4351eddba378c0..e590077db2bf400ddd2f04ef67ff711ff7365117 100644 (file)
@@ -15,4 +15,7 @@ incs += Split(env['BF_OPENEXR_INC'])
 
 defs = ['WITH_OPENEXR']
 
+if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'):
+    incs.append(env['BF_PTHREADS_INC'])
+
 env.BlenderLib ('bf_imbuf_openexr', source_files, incs, defs, libtype=['core','player'], priority = [225,180])
index 3d90267b030f9e81b70af28c8b37c61ad24910c2..caca00cbe200da1e9c381821777f769260ed8ba3 100644 (file)
@@ -33,6 +33,7 @@
 #include <stdio.h>
 #include <stddef.h>
 #include <string>
+#include <set>
 
 
 #include <openexr_api.h>
@@ -51,6 +52,7 @@ _CRTIMP void __cdecl _invalid_parameter_noinfo(void)
 
 #include "BLI_blenlib.h"
 #include "BLI_math_color.h"
+#include "BLI_threads.h"
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
@@ -93,7 +95,7 @@ _CRTIMP void __cdecl _invalid_parameter_noinfo(void)
 using namespace Imf;
 using namespace Imath;
 
-class Mem_IStream: public IStream
+class Mem_IStream: public Imf::IStream
 {
 public:
        
@@ -211,7 +213,7 @@ static int imb_save_openexr_half(struct ImBuf *ibuf, const char *name, int flags
                if (ibuf->planes==32 && channels >= 4)
                        header.channels().insert ("A", Channel (HALF));
                if (write_zbuf)         // z we do as float always
-                       header.channels().insert ("Z", Channel (FLOAT));
+                       header.channels().insert ("Z", Channel (Imf::FLOAT));
                
                FrameBuffer frameBuffer;                        
                OutputFile *file = new OutputFile(name, header);                        
@@ -229,7 +231,7 @@ static int imb_save_openexr_half(struct ImBuf *ibuf, const char *name, int flags
                if (ibuf->planes==32 && channels >= 4)
                        frameBuffer.insert ("A", Slice (HALF, (char *) &pixels[0].a, xstride, ystride));
                if (write_zbuf)
-                       frameBuffer.insert ("Z", Slice (FLOAT, (char *)(ibuf->zbuf_float + (height-1)*width),
+                       frameBuffer.insert ("Z", Slice (Imf::FLOAT, (char *)(ibuf->zbuf_float + (height-1)*width),
                                                                                        sizeof(float), sizeof(float) * -width));
                if (ibuf->rect_float) {
                        float *from;
@@ -315,13 +317,13 @@ static int imb_save_openexr_float(struct ImBuf *ibuf, const char *name, int flag
                openexr_header_compression(&header, ibuf->ftype & OPENEXR_COMPRESS);
                openexr_header_metadata(&header, ibuf);
                
-               header.channels().insert ("R", Channel (FLOAT));
-               header.channels().insert ("G", Channel (FLOAT));
-               header.channels().insert ("B", Channel (FLOAT));
+               header.channels().insert ("R", Channel (Imf::FLOAT));
+               header.channels().insert ("G", Channel (Imf::FLOAT));
+               header.channels().insert ("B", Channel (Imf::FLOAT));
                if (ibuf->planes==32 && channels >= 4)
-                       header.channels().insert ("A", Channel (FLOAT));
+                       header.channels().insert ("A", Channel (Imf::FLOAT));
                if (write_zbuf)
-                       header.channels().insert ("Z", Channel (FLOAT));
+                       header.channels().insert ("Z", Channel (Imf::FLOAT));
                
                FrameBuffer frameBuffer;                        
                OutputFile *file = new OutputFile(name, header);                        
@@ -335,13 +337,13 @@ static int imb_save_openexr_float(struct ImBuf *ibuf, const char *name, int flag
                rect[2]= rect[0]+2;
                rect[3]= (channels >= 4)? rect[0]+3:rect[0]; /* red as alpha, is this needed since alpha isn't written? */
 
-               frameBuffer.insert ("R", Slice (FLOAT,  (char *)rect[0], xstride, ystride));
-               frameBuffer.insert ("G", Slice (FLOAT,  (char *)rect[1], xstride, ystride));
-               frameBuffer.insert ("B", Slice (FLOAT,  (char *)rect[2], xstride, ystride));
+               frameBuffer.insert ("R", Slice (Imf::FLOAT,  (char *)rect[0], xstride, ystride));
+               frameBuffer.insert ("G", Slice (Imf::FLOAT,  (char *)rect[1], xstride, ystride));
+               frameBuffer.insert ("B", Slice (Imf::FLOAT,  (char *)rect[2], xstride, ystride));
                if (ibuf->planes==32 && channels >= 4)
-                       frameBuffer.insert ("A", Slice (FLOAT,  (char *)rect[3], xstride, ystride));
+                       frameBuffer.insert ("A", Slice (Imf::FLOAT,  (char *)rect[3], xstride, ystride));
                if (write_zbuf)
-                       frameBuffer.insert ("Z", Slice (FLOAT, (char *) (ibuf->zbuf_float + (height-1)*width),
+                       frameBuffer.insert ("Z", Slice (Imf::FLOAT, (char *) (ibuf->zbuf_float + (height-1)*width),
                                                                                        sizeof(float), sizeof(float) * -width));
                file->setFrameBuffer (frameBuffer);                               
                file->writePixels (height);                                       
@@ -480,7 +482,7 @@ int IMB_exr_begin_write(void *handle, const char *filename, int width, int heigh
        data->height= height;
        
        for (echan= (ExrChannel *)data->channels.first; echan; echan= echan->next)
-               header.channels().insert (echan->name, Channel (FLOAT));
+               header.channels().insert (echan->name, Channel (Imf::FLOAT));
        
        openexr_header_compression(&header, compress);
        // openexr_header_metadata(&header, ibuf); // no imbuf. cant write
@@ -513,7 +515,7 @@ void IMB_exrtile_begin_write(void *handle, const char *filename, int mipmap, int
        data->mipmap= mipmap;
        
        for (echan= (ExrChannel *)data->channels.first; echan; echan= echan->next)
-               header.channels().insert (echan->name, Channel (FLOAT));
+               header.channels().insert (echan->name, Channel (Imf::FLOAT));
        
        header.setTileDescription (TileDescription (tilex, tiley, (mipmap)? MIPMAP_LEVELS: ONE_LEVEL));
        header.lineOrder() = RANDOM_Y;
@@ -590,7 +592,7 @@ void IMB_exrtile_write_channels(void *handle, int partx, int party, int level)
        for (echan= (ExrChannel *)data->channels.first; echan; echan= echan->next) {
                float *rect= echan->rect - echan->xstride*partx - echan->ystride*party;
 
-               frameBuffer.insert (echan->name, Slice (FLOAT,  (char *)rect, 
+               frameBuffer.insert (echan->name, Slice (Imf::FLOAT,  (char *)rect,
                                                        echan->xstride*sizeof(float), echan->ystride*sizeof(float)));
        }
        
@@ -616,7 +618,7 @@ void IMB_exr_write_channels(void *handle)
                        /* last scanline, stride negative */
                        float *rect = echan->rect + echan->xstride*(data->height-1)*data->width;
                        
-                       frameBuffer.insert (echan->name, Slice (FLOAT,  (char *)rect, 
+                       frameBuffer.insert (echan->name, Slice (Imf::FLOAT,  (char *)rect,
                                                                                                        echan->xstride*sizeof(float), -echan->ystride*sizeof(float)));
                }
                
@@ -647,10 +649,10 @@ void IMB_exr_read_channels(void *handle)
                
                if (echan->rect) {
                        if (flip)
-                               frameBuffer.insert (echan->name, Slice (FLOAT,  (char *)echan->rect, 
+                               frameBuffer.insert (echan->name, Slice (Imf::FLOAT,  (char *)echan->rect,
                                                                                        echan->xstride*sizeof(float), echan->ystride*sizeof(float)));
                        else
-                               frameBuffer.insert (echan->name, Slice (FLOAT,  (char *)(echan->rect + echan->xstride*(data->height-1)*data->width), 
+                               frameBuffer.insert (echan->name, Slice (Imf::FLOAT,  (char *)(echan->rect + echan->xstride*(data->height-1)*data->width),
                                                                                        echan->xstride*sizeof(float), -echan->ystride*sizeof(float)));
                }
                else 
@@ -944,12 +946,17 @@ static int exr_has_zbuffer(InputFile *file)
        return !(file->header().channels().findChannel("Z") == NULL);
 }
 
-static int exr_is_renderresult(InputFile *file)
+static int exr_is_multilayer(InputFile *file)
 {
        const StringAttribute *comments= file->header().findTypedAttribute<StringAttribute>("BlenderMultiChannel");
-       if (comments)
-//             if (comments->value() == "Blender MultiChannel")
+       const ChannelList &channels = file->header().channels();
+       std::set <std::string> layerNames;
+
+       channels.layers(layerNames);
+
+       if (comments || layerNames.size()>1)
                        return 1;
+
        return 0;
 }
 
@@ -976,7 +983,7 @@ struct ImBuf *imb_load_openexr(unsigned char *mem, size_t size, int flags)
                if (0) // debug
                        exr_print_filecontents(file);
                
-               is_multi= exr_is_renderresult(file);
+               is_multi= exr_is_multilayer(file);
                
                /* do not make an ibuf when */
                if (is_multi && !(flags & IB_test) && !(flags & IB_multilayer)) 
@@ -1017,14 +1024,14 @@ struct ImBuf *imb_load_openexr(unsigned char *mem, size_t size, int flags)
                                        first+= 4*(height-1)*width;
                                        
                                        frameBuffer.insert ( exr_rgba_channelname(file, "R"), 
-                                                                               Slice (FLOAT,  (char *) first, xstride, ystride));
+                                                                               Slice (Imf::FLOAT,  (char *) first, xstride, ystride));
                                        frameBuffer.insert ( exr_rgba_channelname(file, "G"), 
-                                                                               Slice (FLOAT,  (char *) (first+1), xstride, ystride));
+                                                                               Slice (Imf::FLOAT,  (char *) (first+1), xstride, ystride));
                                        frameBuffer.insert ( exr_rgba_channelname(file, "B"), 
-                                                                               Slice (FLOAT,  (char *) (first+2), xstride, ystride));
+                                                                               Slice (Imf::FLOAT,  (char *) (first+2), xstride, ystride));
                                                                                                                                                        
                                        frameBuffer.insert ( exr_rgba_channelname(file, "A"), 
-                                                                               Slice (FLOAT,  (char *) (first+3), xstride, ystride, 1, 1, 1.0f)); /* 1.0 is fill value */
+                                                                               Slice (Imf::FLOAT,  (char *) (first+3), xstride, ystride, 1, 1, 1.0f)); /* 1.0 is fill value */
 
                                        if (exr_has_zbuffer(file)) 
                                        {
@@ -1033,7 +1040,7 @@ struct ImBuf *imb_load_openexr(unsigned char *mem, size_t size, int flags)
                                                addzbuffloatImBuf(ibuf);
                                                firstz= ibuf->zbuf_float - (dw.min.x - dw.min.y*width);
                                                firstz+= (height-1)*width;
-                                               frameBuffer.insert ("Z", Slice (FLOAT,  (char *)firstz , sizeof(float), -width*sizeof(float)));
+                                               frameBuffer.insert ("Z", Slice (Imf::FLOAT,  (char *)firstz , sizeof(float), -width*sizeof(float)));
                                        }
                                        
                                        file->setFrameBuffer (frameBuffer);
@@ -1066,5 +1073,11 @@ struct ImBuf *imb_load_openexr(unsigned char *mem, size_t size, int flags)
        
 }
 
+void imb_initopenexr(void)
+{
+       int num_threads = BLI_system_thread_count();
+
+       setGlobalThreadCount(num_threads);
+}
 
 } // export "C"
index e03583617134b0f4dbe8610783362b187c020253..d12fe2fc49f99c1e723975c7575958833d9e5d1b 100644 (file)
@@ -43,7 +43,9 @@ extern "C" {
  * Test presence of OpenEXR file.
  * \param mem pointer to loaded OpenEXR bitstream
  */
-  
+
+void           imb_initopenexr                                 (void);
+
 int            imb_is_a_openexr                        (unsigned char *mem);
        
 int            imb_save_openexr                        (struct ImBuf *ibuf, const char *name, int flags);
index 57bfe3d93d295ef01467cad9cfc277bf5b1e0643..d2109955805798c9b13ff0bd7aca258b9b751255 100644 (file)
@@ -93,7 +93,7 @@ static int replace_if_different(char *tmpfile, const char *dep_files[])
                return -1;                                                            \
        }                                                                         \
        remove(tmpfile);                                                          \
-       return 1;                                                                 \
+       return 1                                                                  \
 
 /* end REN_IF_DIFF */
 
index 33acc924af1791c5ab867f8ed038f7d518cddbae..e0b8feb2e79bbe1b9520f2ee22ea950579aedaaa 100644 (file)
@@ -744,13 +744,13 @@ static void rna_MeshFloatPropertyLayer_data_begin(CollectionPropertyIterator *it
 {
        Mesh *me = rna_mesh(ptr);
        CustomDataLayer *layer = (CustomDataLayer*)ptr->data;
-       rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totface, 0, NULL);
+       rna_iterator_array_begin(iter, layer->data, sizeof(MFloatProperty), me->totpoly, 0, NULL);
 }
 
 static int rna_MeshFloatPropertyLayer_data_length(PointerRNA *ptr)
 {
        Mesh *me = rna_mesh(ptr);
-       return me->totface;
+       return me->totpoly;
 }
 
 static int rna_float_layer_check(CollectionPropertyIterator *iter, void *data)
@@ -759,14 +759,14 @@ static int rna_float_layer_check(CollectionPropertyIterator *iter, void *data)
        return (layer->type != CD_PROP_FLT);
 }
 
-static void rna_Mesh_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+static void rna_Mesh_polygon_float_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
        CustomData *pdata = rna_mesh_pdata(ptr);
        rna_iterator_array_begin(iter, (void*)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
                                 rna_float_layer_check);
 }
 
-static int rna_Mesh_float_layers_length(PointerRNA *ptr)
+static int rna_Mesh_polygon_float_layers_length(PointerRNA *ptr)
 {
        return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_FLT);
 }
@@ -781,23 +781,23 @@ static void rna_MeshIntPropertyLayer_data_begin(CollectionPropertyIterator *iter
 {
        Mesh *me = rna_mesh(ptr);
        CustomDataLayer *layer = (CustomDataLayer*)ptr->data;
-       rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totface, 0, NULL);
+       rna_iterator_array_begin(iter, layer->data, sizeof(MIntProperty), me->totpoly, 0, NULL);
 }
 
 static int rna_MeshIntPropertyLayer_data_length(PointerRNA *ptr)
 {
        Mesh *me = rna_mesh(ptr);
-       return me->totface;
+       return me->totpoly;
 }
 
-static void rna_Mesh_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+static void rna_Mesh_polygon_int_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
        CustomData *pdata = rna_mesh_pdata(ptr);
        rna_iterator_array_begin(iter, (void*)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
                                 rna_int_layer_check);
 }
 
-static int rna_Mesh_int_layers_length(PointerRNA *ptr)
+static int rna_Mesh_polygon_int_layers_length(PointerRNA *ptr)
 {
        return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_INT);
 }
@@ -812,23 +812,23 @@ static void rna_MeshStringPropertyLayer_data_begin(CollectionPropertyIterator *i
 {
        Mesh *me = rna_mesh(ptr);
        CustomDataLayer *layer = (CustomDataLayer*)ptr->data;
-       rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totface, 0, NULL);
+       rna_iterator_array_begin(iter, layer->data, sizeof(MStringProperty), me->totpoly, 0, NULL);
 }
 
 static int rna_MeshStringPropertyLayer_data_length(PointerRNA *ptr)
 {
        Mesh *me = rna_mesh(ptr);
-       return me->totface;
+       return me->totpoly;
 }
 
-static void rna_Mesh_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+static void rna_Mesh_polygon_string_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
        CustomData *pdata = rna_mesh_pdata(ptr);
        rna_iterator_array_begin(iter, (void*)pdata->layers, sizeof(CustomDataLayer), pdata->totlayer, 0,
                                 rna_string_layer_check);
 }
 
-static int rna_Mesh_string_layers_length(PointerRNA *ptr)
+static int rna_Mesh_polygon_string_layers_length(PointerRNA *ptr)
 {
        return CustomData_number_of_layers(rna_mesh_pdata(ptr), CD_PROP_STR);
 }
@@ -1213,46 +1213,46 @@ static PointerRNA rna_Mesh_tessface_vertex_color_new(struct Mesh *me, struct bCo
        return ptr;
 }
 
-static PointerRNA rna_Mesh_int_property_new(struct Mesh *me, struct bContext *C, const char *name)
+static PointerRNA rna_Mesh_polygon_int_property_new(struct Mesh *me, struct bContext *C, const char *name)
 {
        PointerRNA ptr;
        CustomDataLayer *cdl = NULL;
        int index;
 
-       CustomData_add_layer_named(&me->fdata, CD_PROP_INT, CD_DEFAULT, NULL, me->totface, name);
-       index = CustomData_get_named_layer_index(&me->fdata, CD_PROP_INT, name);
+       CustomData_add_layer_named(&me->pdata, CD_PROP_INT, CD_DEFAULT, NULL, me->totpoly, name);
+       index = CustomData_get_named_layer_index(&me->pdata, CD_PROP_INT, name);
 
-       cdl = (index == -1) ? NULL : &(me->fdata.layers[index]);
+       cdl = (index == -1) ? NULL : &(me->pdata.layers[index]);
 
        RNA_pointer_create(&me->id, &RNA_MeshIntPropertyLayer, cdl, &ptr);
        return ptr;
 }
 
-static PointerRNA rna_Mesh_float_property_new(struct Mesh *me, struct bContext *C, const char *name)
+static PointerRNA rna_Mesh_polygon_float_property_new(struct Mesh *me, struct bContext *C, const char *name)
 {
        PointerRNA ptr;
        CustomDataLayer *cdl = NULL;
        int index;
 
-       CustomData_add_layer_named(&me->fdata, CD_PROP_FLT, CD_DEFAULT, NULL, me->totface, name);
-       index = CustomData_get_named_layer_index(&me->fdata, CD_PROP_FLT, name);
+       CustomData_add_layer_named(&me->pdata, CD_PROP_FLT, CD_DEFAULT, NULL, me->totpoly, name);
+       index = CustomData_get_named_layer_index(&me->pdata, CD_PROP_FLT, name);
 
-       cdl = (index == -1) ? NULL : &(me->fdata.layers[index]);
+       cdl = (index == -1) ? NULL : &(me->pdata.layers[index]);
 
        RNA_pointer_create(&me->id, &RNA_MeshFloatPropertyLayer, cdl, &ptr);
        return ptr;
 }
 
-static PointerRNA rna_Mesh_string_property_new(struct Mesh *me, struct bContext *C, const char *name)
+static PointerRNA rna_Mesh_polygon_string_property_new(struct Mesh *me, struct bContext *C, const char *name)
 {
        PointerRNA ptr;
        CustomDataLayer *cdl = NULL;
        int index;
 
-       CustomData_add_layer_named(&me->fdata, CD_PROP_STR, CD_DEFAULT, NULL, me->totface, name);
-       index = CustomData_get_named_layer_index(&me->fdata, CD_PROP_STR, name);
+       CustomData_add_layer_named(&me->pdata, CD_PROP_STR, CD_DEFAULT, NULL, me->totpoly, name);
+       index = CustomData_get_named_layer_index(&me->pdata, CD_PROP_STR, name);
 
-       cdl = (index == -1) ? NULL : &(me->fdata.layers[index]);
+       cdl = (index == -1) ? NULL : &(me->pdata.layers[index]);
 
        RNA_pointer_create(&me->id, &RNA_MeshStringPropertyLayer, cdl, &ptr);
        return ptr;
@@ -2334,7 +2334,7 @@ static void rna_def_uv_loop_layers(BlenderRNA *brna, PropertyRNA *cprop)
 }
 
 /* mesh int layers */
-static void rna_def_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
+static void rna_def_polygon_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
 
@@ -2346,7 +2346,7 @@ static void rna_def_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_struct_sdna(srna, "Mesh");
        RNA_def_struct_ui_text(srna, "Int Properties", "Collection of int properties");
 
-       func = RNA_def_function(srna, "new", "rna_Mesh_int_property_new");
+       func = RNA_def_function(srna, "new", "rna_Mesh_polygon_int_property_new");
        RNA_def_function_flag(func, FUNC_USE_CONTEXT);
        RNA_def_function_ui_description(func, "Add a integer property layer to Mesh");
        RNA_def_string(func, "name", "Int Prop", 0, "",  "Int property name");
@@ -2356,7 +2356,7 @@ static void rna_def_int_layers(BlenderRNA *brna, PropertyRNA *cprop)
 }
 
 /* mesh float layers */
-static void rna_def_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
+static void rna_def_polygon_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
 
@@ -2368,7 +2368,7 @@ static void rna_def_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_struct_sdna(srna, "Mesh");
        RNA_def_struct_ui_text(srna, "Float Properties", "Collection of float properties");
 
-       func = RNA_def_function(srna, "new", "rna_Mesh_float_property_new");
+       func = RNA_def_function(srna, "new", "rna_Mesh_polygon_float_property_new");
        RNA_def_function_flag(func, FUNC_USE_CONTEXT);
        RNA_def_function_ui_description(func, "Add a float property layer to Mesh");
        RNA_def_string(func, "name", "Float Prop", 0, "", "Float property name");
@@ -2378,7 +2378,7 @@ static void rna_def_float_layers(BlenderRNA *brna, PropertyRNA *cprop)
 }
 
 /* mesh string layers */
-static void rna_def_string_layers(BlenderRNA *brna, PropertyRNA *cprop)
+static void rna_def_polygon_string_layers(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
 
@@ -2390,7 +2390,7 @@ static void rna_def_string_layers(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_struct_sdna(srna, "Mesh");
        RNA_def_struct_ui_text(srna, "String Properties", "Collection of string properties");
 
-       func = RNA_def_function(srna, "new", "rna_Mesh_string_property_new");
+       func = RNA_def_function(srna, "new", "rna_Mesh_polygon_string_property_new");
        RNA_def_function_flag(func, FUNC_USE_CONTEXT);
        RNA_def_function_ui_description(func, "Add a string property layer to Mesh");
        RNA_def_string(func, "name", "String Prop", 0, "", "String property name");
@@ -2629,29 +2629,29 @@ static void rna_def_mesh(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Vertex Colors", "All vertex colors");
        rna_def_loop_colors(brna, prop);
 
-       prop = RNA_def_property(srna, "layers_float", PROP_COLLECTION, PROP_NONE);
+       prop = RNA_def_property(srna, "polygon_layers_float", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
-       RNA_def_property_collection_funcs(prop, "rna_Mesh_float_layers_begin", NULL, NULL, NULL,
-                                         "rna_Mesh_float_layers_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_float_layers_begin", NULL, NULL, NULL,
+                                         "rna_Mesh_polygon_float_layers_length", NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "MeshFloatPropertyLayer");
        RNA_def_property_ui_text(prop, "Float Property Layers", "");
-       rna_def_float_layers(brna, prop);
+       rna_def_polygon_float_layers(brna, prop);
 
-       prop = RNA_def_property(srna, "layers_int", PROP_COLLECTION, PROP_NONE);
+       prop = RNA_def_property(srna, "polygon_layers_int", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
-       RNA_def_property_collection_funcs(prop, "rna_Mesh_int_layers_begin", NULL, NULL, NULL,
-                                         "rna_Mesh_int_layers_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_int_layers_begin", NULL, NULL, NULL,
+                                         "rna_Mesh_polygon_int_layers_length", NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "MeshIntPropertyLayer");
        RNA_def_property_ui_text(prop, "Int Property Layers", "");
-       rna_def_int_layers(brna, prop);
+       rna_def_polygon_int_layers(brna, prop);
 
-       prop = RNA_def_property(srna, "layers_string", PROP_COLLECTION, PROP_NONE);
+       prop = RNA_def_property(srna, "polygon_layers_string", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "pdata.layers", "pdata.totlayer");
-       RNA_def_property_collection_funcs(prop, "rna_Mesh_string_layers_begin", NULL, NULL, NULL,
-                                         "rna_Mesh_string_layers_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_Mesh_polygon_string_layers_begin", NULL, NULL, NULL,
+                                         "rna_Mesh_polygon_string_layers_length", NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "MeshStringPropertyLayer");
        RNA_def_property_ui_text(prop, "String Property Layers", "");
-       rna_def_string_layers(brna, prop);
+       rna_def_polygon_string_layers(brna, prop);
 
        prop = RNA_def_property(srna, "use_auto_smooth", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL,