]> git.tdb.fi Git - libs/gl.git/blobdiff - blender/io_mspgl/mesh.py
Include only tangent in mesh data and calculate binormal on the fly
[libs/gl.git] / blender / io_mspgl / mesh.py
index 42adabe66f79c8716266e6319371d376b858d133..9741b8dd916f28495d3e25cde8fd64e767a7d118 100644 (file)
@@ -48,14 +48,13 @@ class Vertex:
                if vertex.__class__==Vertex:
                        self.uvs = vertex.uvs[:]
                        self.tan = vertex.tan
-                       self.bino = vertex.bino
                else:
                        self.uvs = []
                        self.tan = None
-                       self.bino = None
                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 +68,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:
@@ -83,7 +86,6 @@ class Face:
                self.normal = face.normal
                self.use_smooth = face.use_smooth
                self.material_index = face.material_index
-               self.uvs = []
                self.flag = False
 
        def __cmp__(self, other):
@@ -95,12 +97,8 @@ class Face:
                n = self.vertices.index(v)
                return [(n+i)%len(self.vertices) for i in range(len(self.vertices))]
 
-       def pivot_vertices(self, *vt):
-               flags = [(v in vt) for v in self.vertices]
-               l = len(self.vertices)
-               for i in range(l):
-                       if flags[i] and not flags[(i+l-1)%l]:
-                               return self.vertices[i:]+self.vertices[:i]
+       def get_loop_index(self, v):
+               return self.loop_indices[self.vertices.index(v)]
 
        def get_edge(self, v1, v2):
                key = make_edge_key(v1.index, v2.index)
@@ -147,6 +145,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
@@ -154,14 +158,15 @@ class Mesh:
                self.winding_test = mesh.winding_test
                self.smoothing = mesh.smoothing
                self.use_uv = mesh.use_uv
-               self.tbn_vecs = mesh.tbn_vecs
-               self.tbn_uvtex = mesh.tbn_uvtex
+               self.tangent_vecs = mesh.tangent_vecs
+               self.tangent_uvtex = mesh.tangent_uvtex
                self.vertex_groups = mesh.vertex_groups
 
                # 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]
@@ -170,6 +175,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:
@@ -192,6 +198,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}
@@ -234,12 +244,12 @@ class Mesh:
 
                # Merge materials and form a lookup from source material indices to the
                # merged material list
-               material_map = []
+               material_atlas = []
                for m in other.materials:
                        if m in self.materials:
-                               material_map.append(self.materials.index(m))
+                               material_atlas.append(self.materials.index(m))
                        else:
-                               material_map.append(len(self.materials))
+                               material_atlas.append(len(self.materials))
                                self.materials.append(m)
 
                # Append data and adjust indices where necessary.  Since the data is
@@ -247,6 +257,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:]:
@@ -261,7 +280,7 @@ class Mesh:
                        f.index += offset
                        f.loop_indices = range(f.loop_indices.start+offset, f.loop_indices.stop+offset)
                        if other.materials:
-                               f.material_index = material_map[f.material_index]
+                               f.material_index = material_atlas[f.material_index]
 
                offset = len(self.edges)
                self.edges += other.edges
@@ -356,6 +375,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)
@@ -363,6 +385,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
@@ -376,15 +400,15 @@ class Mesh:
                                for g in v.groups:
                                        g.group = group_index_map[g.group]
 
-       def apply_material_map(self, material_map):
+       def apply_material_atlas(self, material_atlas):
                for m in self.materials:
-                       if m.name not in material_map.material_names:
-                               raise Exception("Material map is not compatible with Mesh")
+                       if m.name not in material_atlas.material_names:
+                               raise Exception("Material atlas is not compatible with Mesh")
 
                if self.use_uv=='NONE':
                        return
 
-               layer = UvLayer("material_map")
+               layer = UvLayer("material_atlas")
                if self.use_uv=='UNIT0':
                        self.uv_layers = [layer]
                        layer.unit = 0
@@ -396,7 +420,7 @@ class Mesh:
 
                layer.uvs = [(0.0, 0.0)]*len(self.loops)
                for f in self.faces:
-                       uv = material_map.get_material_uv(self.materials[f.material_index])
+                       uv = material_atlas.get_material_uv(self.materials[f.material_index])
                        for i in f.loop_indices:
                                layer.uvs[i] = uv
 
@@ -418,32 +442,34 @@ class Mesh:
                                        for i in f.loop_indices:
                                                l.uvs[i] = mathutils.Vector((*l.uvs[i], layer))
 
-               # Copy UVs from layers to faces
-               for f in self.faces:
-                       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
 
-               # Split by the UV layer used for TBN vectors first so connectivity
-               # remains intact for TBN vector computation
-               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:
+               # Split by the UV layer used for tangent vectors first so connectivity
+               # remains intact for tangent vector computation
+               tangent_layer_index = -1
+               if self.tangent_vecs:
+                       if self.tangent_uvtex:
+                               uv_names = [u.name for u in self.uv_layers]
+                               if self.tangent_uvtex in uv_names:
+                                       tangent_layer_index = uv_names.index(self.tangent_uvtex)
+                       elif self.uv_layers[0].unit==0:
+                               tangent_layer_index = 0
+
+                       if tangent_layer_index>=0:
                                prog_count += 1
-                               tbn_layer_index = uv_names.index(self.tbn_uvtex)
-                               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.push_task_slice("Computing tangents", 0, prog_count)
+                               self.split_vertices(self.find_uv_group, progress, tangent_layer_index)
+                               progress.set_task_slice(self.tangent_uvtex, 1, prog_count)
+                               self.compute_tangents(tangent_layer_index, progress)
                                progress.pop_task()
                                prog_step = 2
+                       else:
+                               raise Exception("Tangent UV layer not found")
 
                # Split by the remaining UV layers
                for i, u in enumerate(self.uv_layers):
-                       if i==tbn_layer_index:
+                       if i==tangent_layer_index:
                                continue
 
                        progress.push_task_slice(u.name, prog_step, prog_count)
@@ -451,16 +477,29 @@ class Mesh:
                        progress.pop_task()
                        prog_step += 1
 
-               # Copy UVs from faces to vertices
+               # Copy UVs from layers to vertices
                for v in self.vertices:
                        if v.faces:
                                # All faces still connected to the vertex have the same UV value
                                f = v.faces[0]
-                               i = f.vertices.index(v)
-                               v.uvs = [u[i] for u in f.uvs]
+                               i = f.get_loop_index(v)
+                               v.uvs = [u.uvs[i] for u in self.uv_layers]
                        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):
@@ -535,12 +574,25 @@ class Mesh:
                return group
 
        def find_uv_group(self, vertex, face, index):
-               uv = face.uvs[index][face.vertices.index(vertex)]
+               layer = self.uv_layers[index]
+               uv = layer.uvs[face.get_loop_index(vertex)]
                face.flag = True
 
                group = [face]
                for f in vertex.faces:
-                       if not f.flag and f.uvs[index][f.vertices.index(vertex)]==uv:
+                       if not f.flag and layer.uvs[f.get_loop_index(vertex)]==uv:
+                               f.flag = True
+                               group.append(f)
+
+               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)
 
@@ -550,9 +602,9 @@ class Mesh:
                for i, v in enumerate(self.vertices):
                        v.normal = mathutils.Vector()
                        for f in v.faces:
-                               fv = f.pivot_vertices(v)
-                               edge1 = fv[1].co-fv[0].co
-                               edge2 = fv[-1].co-fv[0].co
+                               vi = f.pivot_vertex(v)
+                               edge1 = f.vertices[vi[1]].co-v.co
+                               edge2 = f.vertices[vi[-1]].co-v.co
                                if edge1.length and edge2.length:
                                        # Use the angle between edges as a weighting factor.  This gives
                                        # more consistent normals on bends with an inequal number of
@@ -566,14 +618,11 @@ class Mesh:
 
                        progress.set_progress(i/len(self.vertices))
 
-       def compute_tbn(self, index, progress):
-               # This function is called at an early stage during UV preparation when
-               # face UVs are not available yet
+       def compute_tangents(self, index, progress):
                layer_uvs = self.uv_layers[index].uvs
 
                for i, v in enumerate(self.vertices):
                        v.tan = mathutils.Vector()
-                       v.bino = mathutils.Vector()
                        for f in v.faces:
                                vi = f.pivot_vertex(v)
                                uv0 = layer_uvs[f.loop_indices[vi[0]]]
@@ -589,12 +638,9 @@ class Mesh:
                                if div:
                                        mul = edge1.angle(edge2)/div
                                        v.tan += (edge1*dv2-edge2*dv1)*mul
-                                       v.bino += (edge2*du1-edge1*du2)*mul
 
                        if v.tan.length:
                                v.tan.normalize()
-                       if v.bino.length:
-                               v.bino.normalize()
 
                        progress.set_progress(i/len(self.vertices))
 
@@ -734,7 +780,7 @@ class Mesh:
                        e.key = make_edge_key(e.vertices[0].index, e.vertices[1].index)
 
 
-def create_mesh_from_object(context, obj, progress, *, material_map=None):
+def create_mesh_from_object(context, obj, progress, *, material_atlas=None):
        if obj.type!="MESH":
                raise Exception("Object is not a mesh")
 
@@ -763,8 +809,8 @@ def create_mesh_from_object(context, obj, progress, *, material_map=None):
                bmesh.vertex_groups = o.data.vertex_groups
                bmesh.max_groups_per_vertex = o.data.max_groups_per_vertex
                bmesh.use_uv = o.data.use_uv
-               bmesh.tbn_vecs = o.data.tbn_vecs
-               bmesh.tbn_uvtex = o.data.tbn_uvtex
+               bmesh.tangent_vecs = o.data.tangent_vecs
+               bmesh.tangent_uvtex = o.data.tangent_uvtex
 
                me = Mesh(bmesh)
                me.transform(m)
@@ -780,8 +826,8 @@ def create_mesh_from_object(context, obj, progress, *, material_map=None):
 
        mesh.name = obj.data.name
 
-       if material_map:
-               mesh.apply_material_map(material_map)
+       if material_atlas:
+               mesh.apply_material_atlas(material_atlas)
 
        progress.set_task("Triangulating", 0.2, 0.3)
        mesh.prepare_triangles(progress)
@@ -789,9 +835,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()