More post-refactoring bugfixes

[libs/gl.git] / blender / io_mspgl / mesh.py

diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py
index a303db9983811b398bf21e2c6255bd2d9487d283..42b1b1bd054417a4156fbd247cfad37592f23785 100644 (file)
--- a/blender/io_mspgl/mesh.py
+++ b/blender/io_mspgl/mesh.py
@@ -266,7 +266,7 @@ class Mesh:
 
                self.lines += other.lines
 
-       def prepare_smoothing(self, progress=None):
+       def prepare_smoothing(self, progress):
                smooth_limit = -1
                if self.smoothing=='NONE':
                        for f in self.faces:
@@ -279,10 +279,14 @@ class Mesh:
                for e in self.edges:
                        e.check_smooth(smooth_limit)
 
+               progress.push_task("Sharp edges", 0.0, 0.7)
                self.split_vertices(self.find_smooth_group, progress)
 
                if self.smoothing!='BLENDER':
-                       self.compute_normals()
+                       progress.set_task("Updating normals", 0.7, 1.0)
+                       self.compute_normals(progress)
+
+               progress.pop_task()
 
        def prepare_vertex_groups(self, obj):
                for v in self.vertices:
@@ -305,7 +309,7 @@ class Mesh:
                                for g in v.groups:
                                        g.group = group_index_map[g.group]
 
-       def prepare_uv(self, obj, progress=None):
+       def prepare_uv(self, obj, progress):
                if obj.material_tex and self.use_uv!='NONE':
                        layer = UvLayer("material_tex")
 
@@ -341,16 +345,30 @@ class Mesh:
                        for u in self.uv_layers:
                                f.uvs.append([u.uvs[i] for i in f.loop_indices])
 
+               prog_count = len(self.uv_layers)
+               prog_step = 0
+
                tbn_layer_index = -1
                if self.tbn_vecs:
                        uv_names = [u.name for u in self.uv_layers]
                        if self.tbn_uvtex in uv_names:
+                               prog_count += 1
                                tbn_layer_index = uv_names.index(self.tbn_uvtex)
-                               self.compute_tbn(tbn_layer_index)
+                               progress.push_task_slice("Computing TBN", 0, prog_count)
                                self.split_vertices(self.find_uv_group, progress, tbn_layer_index)
+                               progress.set_task_slice(self.tbn_uvtex, 1, prog_count)
+                               self.compute_tbn(tbn_layer_index, progress)
+                               progress.pop_task()
+                               prog_step = 2
+
+               for i, u in enumerate(self.uv_layers):
+                       if i==tbn_layer_index:
+                               continue
 
-               for i in range(len(self.uv_layers)):
+                       progress.push_task_slice(u.name, prog_step, prog_count)
                        self.split_vertices(self.find_uv_group, progress, i)
+                       progress.pop_task()
+                       prog_step += 1
 
                for v in self.vertices:
                        if v.faces:
@@ -374,8 +392,7 @@ class Mesh:
 
                        groups.append(vg)
 
-                       if progress:
-                               progress.set_progress(i*0.5/len(self.vertices))
+                       progress.set_progress(i*0.5/len(self.vertices))
 
                for i in range(len(self.vertices)):
                        for g in groups[i][1:]:
@@ -396,6 +413,8 @@ class Mesh:
                                                ne.index = len(self.edges)
                                                self.edges.append(ne)
 
+                                               ne.other_vertex(self.vertices[i]).edges.append(ne)
+
                                                for f in e_faces_in_g:
                                                        e.faces.remove(f)
                                                        f.edges[f.edges.index(e)] = ne
@@ -404,9 +423,9 @@ class Mesh:
                                        else:
                                                del self.edge_map[e.key]
                                                self.vertices[i].edges.remove(e)
-                                               v.edges.append(e)
 
                                        e.vertices[e.vertices.index(self.vertices[i])] = v
+                                       v.edges.append(e)
 
                                        e.key = make_edge_key(e.vertices[0].index, e.vertices[1].index)
                                        self.edge_map[e.key] = e
@@ -416,8 +435,7 @@ class Mesh:
                                        f.vertices[f.vertices.index(self.vertices[i])] = v
                                        v.faces.append(f)
 
-                       if progress:
-                               progress.set_progress(0.5+i*0.5/len(self.vertices))
+                       progress.set_progress(0.5+i*0.5/len(self.vertices))
 
        def find_smooth_group(self, vertex, face):
                face.flag = True
@@ -450,8 +468,8 @@ class Mesh:
 
                return group
 
-       def compute_normals(self):
-               for v in self.vertices:
+       def compute_normals(self, progress):
+               for i, v in enumerate(self.vertices):
                        v.normal = mathutils.Vector()
                        for f in v.faces:
                                fv = f.pivot_vertices(v)
@@ -465,10 +483,12 @@ class Mesh:
                        else:
                                v.normal = mathutils.Vector((0, 0, 1))
 
-       def compute_tbn(self, index):
+                       progress.set_progress(i/len(self.vertices))
+
+       def compute_tbn(self, index, progress):
                layer_uvs = self.uv_layers[index].uvs
 
-               for v in self.vertices:
+               for i, v in enumerate(self.vertices):
                        v.tan = mathutils.Vector()
                        v.bino = mathutils.Vector()
                        for f in v.faces:
@@ -493,6 +513,8 @@ class Mesh:
                        if v.bino.length:
                                v.bino.normalize()
 
+                       progress.set_progress(i/len(self.vertices))
+
        def drop_references(self):
                for v in self.vertices:
                        v._mvert = None
@@ -551,10 +573,12 @@ class Mesh:
 
                return result
 
-def create_mesh_from_object(context, obj, progress=None):
+def create_mesh_from_object(context, obj, progress):
        if obj.type!="MESH":
                raise Exception("Object is not a mesh")
 
+       progress.push_task("Preparing mesh", 0.0, 0.3)
+
        objs = [(obj, mathutils.Matrix())]
        i = 0
        while i<len(objs):
@@ -588,12 +612,17 @@ def create_mesh_from_object(context, obj, progress=None):
                else:
                        mesh = me
 
+       progress.set_task("Smoothing", 0.3, 0.6)
        mesh.prepare_smoothing(progress)
+       progress.set_task("Vertex groups", 0.6, 0.7)
        mesh.prepare_vertex_groups(obj)
+       progress.set_task("Preparing UVs", 0.7, 1.0)
        mesh.prepare_uv(obj, progress)
 
        mesh.drop_references()
        for m in bmeshes:
                bpy.data.meshes.remove(m)
 
+       progress.pop_task()
+
        return mesh