Fix and improve vertex group support

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

diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py
index f5665256b2eeced61c654abc329d4849e45d82cf..d9ae6b760ff545c8043269bb9e120b597f8b05f7 100644 (file)
--- a/blender/io_mspgl/mesh.py
+++ b/blender/io_mspgl/mesh.py
@@ -56,6 +56,7 @@ class Vertex:
                self.index = vertex.index
                self.co = mathutils.Vector(vertex.co)
                self.normal = mathutils.Vector(vertex.normal)
+               self.color = None
                self.flag = False
                self.edges = []
                self.faces = []
@@ -69,8 +70,12 @@ class Vertex:
 
 class VertexGroup:
        def __init__(self, group):
-               self.group = group.group
-               self.weight = group.weight
+               if group:
+                       self.group = group.group
+                       self.weight = group.weight
+               else:
+                       self.group = 0
+                       self.weight = 0.0
 
 
 class Face:
@@ -142,6 +147,12 @@ class UvLayer:
                                self.hidden = True
 
 
+class ColorLayer:
+       def __init__(self, l):
+               self.name = l.name
+               self.colors = [c.color[:] for c in l.data]
+
+
 class Mesh:
        def __init__(self, mesh):
                self.name = mesh.name
@@ -155,8 +166,9 @@ class Mesh:
 
                # Clone basic data
                self.vertices = [Vertex(v) for v in mesh.vertices]
-               for v in self.vertices:
-                       v.groups = [VertexGroup(g) for g in v.groups]
+               if self.vertex_groups:
+                       for v in self.vertices:
+                               v.groups = [VertexGroup(g) for g in v.groups]
 
                self.faces = [Face(f) for f in mesh.polygons]
                self.edges = [Edge(e) for e in mesh.edges]
@@ -165,6 +177,7 @@ class Mesh:
 
                self.use_auto_smooth = mesh.use_auto_smooth
                self.auto_smooth_angle = mesh.auto_smooth_angle
+               self.max_groups_per_vertex = mesh.max_groups_per_vertex
 
                # Clone only the desired UV layers
                if mesh.use_uv=='NONE' or not mesh.uv_layers:
@@ -187,6 +200,10 @@ class Mesh:
                                if self.uv_layers[0].unit!=0:
                                        self.uv_layers = []
 
+               self.colors = None
+               if mesh.vertex_colors:
+                       self.colors = ColorLayer(mesh.vertex_colors[0])
+
                # Rewrite links between elements to point to cloned data, or create links
                # where they don't exist
                edge_map = {e.key: e for e in self.edges}
@@ -242,6 +259,15 @@ class Mesh:
                for i, u in enumerate(self.uv_layers):
                        u.uvs += other.uv_layers[i].uvs
 
+               if self.colors:
+                       if other.colors:
+                               self.colors.colors += other.colors.colors
+                       else:
+                               self.colors.colors += [(1.0, 1.0, 1.0, 1.0)]*len(other.loops)
+               elif other.colors:
+                       self.colors = ColorLayer(other.colors.name)
+                       self.colors.colors = [(1.0, 1.0, 1.0, 1.0)]*len(self.loops)+other.colors.colors
+
                offset = len(self.vertices)
                self.vertices += other.vertices
                for v in self.vertices[offset:]:
@@ -351,6 +377,9 @@ class Mesh:
                progress.pop_task()
 
        def prepare_vertex_groups(self, obj):
+               if not self.vertex_groups:
+                       return
+
                for v in self.vertices:
                        if v.groups:
                                weight_sum = sum(g.weight for g in v.groups)
@@ -358,6 +387,8 @@ class Mesh:
                                weight_scale = weight_sum/sum(g.weight for g in v.groups)
                                for g in v.groups:
                                        g.weight *= weight_scale
+                       while len(v.groups)<self.max_groups_per_vertex:
+                               v.groups.append(VertexGroup(None))
 
                if obj.parent and obj.parent.type=="ARMATURE":
                        armature = obj.parent.data
@@ -453,6 +484,19 @@ class Mesh:
                        else:
                                v.uvs = [(0.0, 0.0)]*len(self.uv_layers)
 
+       def prepare_colors(self, progress):
+               if not self.colors:
+                       return
+
+               self.split_vertices(self.find_color_group, progress)
+
+               for v in self.vertices:
+                       if v.faces:
+                               f = v.faces[0]
+                               v.color = self.colors.colors[f.get_loop_index(v)]
+                       else:
+                               v.color = (1.0, 1.0, 1.0, 1.0)
+
        def split_vertices(self, find_group_func, progress, *args):
                vertex_count = len(self.vertices)
                for i in range(vertex_count):
@@ -539,6 +583,18 @@ class Mesh:
 
                return group
 
+       def find_color_group(self, vertex, face):
+               color = self.colors.colors[face.get_loop_index(vertex)]
+               face.flag = True
+
+               group = [face]
+               for f in vertex.faces:
+                       if not f.flag and self.colors.colors[f.get_loop_index(vertex)]==color:
+                               f.flag = True
+                               group.append(f)
+
+               return group
+
        def compute_normals(self, progress):
                for i, v in enumerate(self.vertices):
                        v.normal = mathutils.Vector()
@@ -782,9 +838,11 @@ def create_mesh_from_object(context, obj, progress, *, material_map=None):
        mesh.prepare_smoothing(progress)
        progress.set_task("Vertex groups", 0.5, 0.6)
        mesh.prepare_vertex_groups(obj)
-       progress.set_task("Preparing UVs", 0.6, 0.8)
+       progress.set_task("Preparing UVs", 0.6, 0.75)
        mesh.prepare_uv(progress)
-       progress.set_task("Render sequence", 0.8, 1.0)
+       progress.set_task("Preparing vertex colors", 0.75, 0.85)
+       mesh.prepare_colors(progress)
+       progress.set_task("Render sequence", 0.85, 1.0)
        mesh.prepare_sequence(progress)
 
        progress.pop_task()