Support exporting splat materials from Blender

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

diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py
index 3a24db96a07f29a8cd9aacff8e6ede446f7cc81a..e4db4afb2a2abae7262564828aa9cc821422961d 100644 (file)
--- a/blender/io_mspgl/mesh.py
+++ b/blender/io_mspgl/mesh.py
@@ -66,8 +66,11 @@ class Vertex:
 
 
 class VertexGroup:
-       def __init__(self, group):
-               if group:
+       def __init__(self, *args):
+               if len(args)==2:
+                       self.group = args[0]
+                       self.weight = args[1]
+               elif len(args)==1 and args[0]:
                        self.group = group.group
                        self.weight = group.weight
                else:
@@ -92,6 +95,7 @@ class Face:
                self.normal = face.normal
                self.use_smooth = face.use_smooth
                self.material_index = face.material_index
+               self.splat_mask = 0
                self.flag = False
 
        def __cmp__(self, other):
@@ -184,6 +188,19 @@ class Mesh:
                self.auto_smooth_angle = mesh.auto_smooth_angle
                self.max_groups_per_vertex = mesh.max_groups_per_vertex
 
+               # Check some material properties
+               from .material import Material
+               has_normal_maps = False
+               splat_material = None
+               for m in self.materials:
+                       mat = Material(m)
+                       for p in itertools.chain(mat.properties, *(s.properties for s in mat.sub_materials)):
+                               if p.tex_keyword=="normal_map" and p.texture:
+                                       has_normal_maps = True
+                                       break
+                       if mat.type=="splat":
+                               splat_material = mat
+
                # Clone only the desired UV layers
                if mesh.use_uv=='NONE' or not mesh.uv_layers:
                        self.uv_layers = []
@@ -206,7 +223,7 @@ class Mesh:
                                        self.uv_layers = []
 
                self.colors = None
-               if mesh.vertex_colors:
+               if mesh.vertex_colors and not splat_material:
                        self.colors = ColorLayer(mesh.vertex_colors[0])
 
                # Rewrite links between elements to point to cloned data, or create links
@@ -242,14 +259,24 @@ class Mesh:
                elif mesh.tangent_vecs=='YES':
                        self.tangent_vecs = True
                elif mesh.tangent_vecs=='AUTO':
-                       from .material import Material
-                       self.tangent_vecs = False
-                       for m in self.materials:
-                               mat = Material(m)
-                               if mat.type=="pbr":
-                                       normal_prop = next((p for p in mat.properties if p.tex_keyword=="normal_map"), None)
-                                       if normal_prop and normal_prop.texture:
-                                               self.tangent_vecs = True
+                       self.tangent_vecs = has_normal_maps
+
+               # Collect splat weight sources if needed
+               self.splat_layers = []
+               self.splat_sources = []
+               if splat_material:
+                       names = {s.weight_source[0] for s in splat_material.sub_materials}
+                       self.splat_layers = [ColorLayer(l) for l in mesh.vertex_colors if l.name in names]
+
+                       layers_by_name = {l.name:l for l in self.splat_layers}
+                       for s in splat_material.sub_materials:
+                               if s.weight_source[0] is None:
+                                       self.splat_sources.append((None, None))
+                               else:
+                                       self.splat_sources.append((layers_by_name[s.weight_source[0]], "RGBA".index(s.weight_source[1])))
+
+                       self.vertex_groups = True
+                       self.max_groups_per_vertex = 3
 
                self.batches = []
 
@@ -497,6 +524,43 @@ class Mesh:
                        else:
                                v.color = (1.0, 1.0, 1.0, 1.0)
 
+       def prepare_splat_weights(self, task):
+               if not self.splat_layers:
+                       return
+
+               splat_weights = []
+               remainder = None
+               for s in self.splat_sources:
+                       if s[0] is None:
+                               splat_weights.append(remainder)
+                       else:
+                               index = s[1]
+                               layer_values = [c[index] for c in s[0].colors]
+                               if remainder:
+                                       splat_weights.append([v*r for v, r in zip(layer_values, remainder)])
+                                       remainder = [(1-v)*r for v, r in zip(layer_values, remainder)]
+                               else:
+                                       splat_weights.append(layer_values)
+                                       remainder = [1-v for v in layer_values]
+
+               splat_weights = list(zip(*splat_weights))
+
+               for f in self.faces:
+                       for i in f.loop_indices:
+                               f.splat_mask |= sum(1<<j for j, w in enumerate(splat_weights[i]) if w>0)
+
+               self.split_vertices(self.find_splat_group, task)
+
+               for v in self.vertices:
+                       if v.faces:
+                               f = v.faces[0]
+                               weights = splat_weights[f.get_loop_index(v)]
+                               v.groups = [VertexGroup(i, w) for i, w in enumerate(weights) if (f.splat_mask>>i)&1]
+                       else:
+                               v.groups = []
+                       while len(v.groups)<self.max_groups_per_vertex:
+                               v.groups.append(VertexGroup(None))
+
        def split_vertices(self, find_group_func, task, *args):
                vertex_count = len(self.vertices)
                for i in range(vertex_count):
@@ -595,6 +659,17 @@ class Mesh:
 
                return group
 
+       def find_splat_group(self, vertex, face):
+               face.flag = True
+
+               group = [face]
+               for f in vertex.faces:
+                       if not f.flag and f.splat_mask==face.splat_mask:
+                               f.flag = True
+                               group.append(f)
+
+               return group
+
        def compute_normals(self, task):
                for i, v in enumerate(self.vertices):
                        v.normal = mathutils.Vector()
@@ -899,8 +974,12 @@ def create_mesh_from_object(ctx, obj):
        mesh.prepare_triangles(task)
        task = ctx.task("Smoothing", 0.5)
        mesh.prepare_smoothing(task)
-       task = ctx.task("Vertex groups", 0.6)
-       mesh.prepare_vertex_groups(obj)
+       if mesh.splat_sources:
+               task = ctx.task("Splat weights", 0.6)
+               mesh.prepare_splat_weights(task)
+       else:
+               task = ctx.task("Vertex groups", 0.6)
+               mesh.prepare_vertex_groups(obj)
        task = ctx.task("Preparing UVs", 0.75)
        mesh.prepare_uv(task)
        task = ctx.task("Preparing vertex colors", 0.85)