Improve progress reporting in the Blender exporter

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

diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py
index a303db9983811b398bf21e2c6255bd2d9487d283..565fdc4929e3a9db1deaecb0ecf8efd3695e378a 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.compute_tbn(tbn_layer_index, progress)
+                               progress.set_task_slice(self.tbn_uvtex, 1, prog_count)
                                self.split_vertices(self.find_uv_group, progress, tbn_layer_index)
+                               progress.pop_task()
+                               prog_step = 2
 
-               for i in range(len(self.uv_layers)):
+               for i, u in enumerate(self.uv_layers):
+                       if i==tbn_layer_index:
+                               continue
+
+                       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:]:
@@ -416,8 +433,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 +466,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 +481,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 +511,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 +571,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 +610,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