Improve texture unit handling

diff --git a/blender/io_mesh_mspgl/export_mspgl.py b/blender/io_mesh_mspgl/export_mspgl.py
index 1046630ba088d1bc8ec191448249c6e7881e9fd6..f888dc4528d9981250e9b6ea950d35244ac7b4ee 100644 (file)
--- a/blender/io_mesh_mspgl/export_mspgl.py
+++ b/blender/io_mesh_mspgl/export_mspgl.py
@@ -249,23 +249,28 @@ class Exporter:
 
                texunits = []
                if mesh.uv_layers and self.export_uv!="NONE":
+                       # Figure out which UV layers to export
                        if self.export_uv=="UNIT0":
-                               texunits = [0]
+                               if mesh.uv_layers[0].unit==0:
+                                       texunits = [0]
                        else:
-                               texunits = list(range(len(mesh.uv_layers)))
+                               texunits = range(len(mesh.uv_layers))
+                       texunits = [(i, mesh.uv_layers[i]) for i in texunits]
+                       texunits = [u for u in texunits if not u[1].hidden]
 
-                       tbn_unit = 0
                        if self.tbn_vecs:
-                               uvtex_names = [u.name for u in mesh.uv_layers]
-                               if self.tbn_uvtex in uvtex_names:
-                                       tbn_unit = uvtex_names.index(uvtex)
-                                       del texunits[tbn_unit]
-                                       texunits.insert(0, tbn_unit)
-
-                       for i in texunits:
+                               # TBN coordinates must be generated before vertices are split by any other layer
+                               uv_names = [u.name for i, u in texunits]
+                               if self.tbn_uvtex in uv_names:
+                                       tbn_index = uv_names.index(self.tbn_uvtex)
+                                       unit = texunits[tbn_index]
+                                       del texunits[tbn_index]
+                                       texunits.insert(0, unit)
+
+                       for i, u in texunits:
                                progress.set_task("Splitting UVs", 0.35+0.3*i/len(texunits), 0.35+0.3*(i+1)/len(texunits))
                                mesh.split_uv(i, progress)
-                               if self.tbn_vecs and i==tbn_unit:
+                               if self.tbn_vecs and u.name==self.tbn_uvtex:
                                        mesh.compute_uv()
                                        mesh.compute_tbn(i)
 
@@ -285,27 +290,29 @@ class Exporter:
 
                fmt = "NORMAL3"
                if texunits:
-                       fmt += "_TEXCOORD2"
-                       for i in texunits[1:]:
-                               fmt += "_TEXCOORD2%d"%i
+                       for i, u in texunits:
+                               if u.unit==0:
+                                       fmt += "_TEXCOORD2"
+                               else:
+                                       fmt += "_TEXCOORD2%d"%u.unit
                        if self.tbn_vecs:
                                fmt += "_ATTRIB33_ATTRIB34"
                fmt += "_VERTEX3"
                out_file.begin("vertices", fmt)
                normal = None
-               uvs = [None]*len(mesh.uv_layers)
+               uvs = [None]*len(texunits)
                tan = None
                bino = None
                for v in mesh.vertices:
                        if v.normal!=normal:
                                out_file.write("normal3", *v.normal)
                                normal = v.normal
-                       for i in texunits:
+                       for i, u in texunits:
                                if v.uvs[i]!=uvs[i]:
-                                       if i==0:
+                                       if u.unit==0:
                                                out_file.write("texcoord2", *v.uvs[i])
                                        else:
-                                               out_file.write("multitexcoord2", i, *v.uvs[i])
+                                               out_file.write("multitexcoord2", u.unit, *v.uvs[i])
                                        uvs[i] = v.uvs[i]
                        if v.tan!=tan:
                                out_file.write("attrib3", 3, *v.tan)
@@ -350,7 +357,11 @@ class Exporter:
                                        out_file.begin("material")
                                        out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
                                        out_file.end()
-                                       out_file.begin("texunit", 0)
+                                       index = 0
+                                       for u in mesh.uv_layers:
+                                               if u.name=="material_tex":
+                                                       index = u.unit
+                                       out_file.begin("texunit", index)
                                        out_file.begin("texture2d")
                                        out_file.write("min_filter", "NEAREST")
                                        out_file.write("mag_filter", "NEAREST")

diff --git a/blender/io_mesh_mspgl/mesh.py b/blender/io_mesh_mspgl/mesh.py
index 99fb2ee4dafe4f63fbf476440b229654db137de3..8b3ad37052a62eba8d03237a5386a43cf8775e22 100644 (file)
--- a/blender/io_mesh_mspgl/mesh.py
+++ b/blender/io_mesh_mspgl/mesh.py
@@ -99,23 +99,29 @@ class Line:
 
 
 class UvLayer:
-       def __init__(self, l):
+       def __init__(self, l, t):
                self._layer = l
-               self.name = None
+               self.uvtex = t
+               self.name = self.uvtex.name
+               self.unit = None
+               self.hidden = False
+               dot = self.name.find('.')
+               if dot>=0:
+                       ext = self.name[dot:]
+                       if ext.startswith(".unit") and ext[5:].isdigit():
+                               self.unit = int(ext[5:])
+                       elif ext==".hidden":
+                               self.hidden = True
 
        def __getattr__(self, attr):
                return getattr(self._layer, attr)
 
 class FakeUvLayer:
        def __init__(self, n):
+               self.uvtex = None
                self.name = n
-
-def uvtex_unit_number(uvtex):
-       dot = uvtex.name.find('.')
-       if dot!=-1 and uvtex.name[dot+1:dot+5]=="unit" and uvtex.name[dot+5:].isdigit():
-               return int(uvtex.name[dot+5])
-       else:
-               return 1000
+               self.unit = None
+               self.hidden = False
 
 class Mesh:
        def __init__(self, m):
@@ -126,11 +132,8 @@ class Mesh:
 
                self.materials = self.materials[:]
 
-               self.uv_layers = [UvLayer(u) for u in self.uv_layers]
-               for i in range(len(self.uv_layers)):
-                       self.uv_layers[i].name = self.uv_textures[i].name
-               self.uv_layers = [u for u in self.uv_layers if not u.name.endswith(".hidden")]
-               self.uv_layers.sort(key=uvtex_unit_number)
+               self.uv_layers = [UvLayer(self.uv_layers[i], self.uv_textures[i]) for i in range(len(self.uv_layers))]
+               self.assign_texture_units()
 
                for f in self.faces:
                        f.vertices = [self.vertices[i] for i in f.vertices]
@@ -194,8 +197,22 @@ class Mesh:
                for e in self.edges.values():
                        e.check_smooth(1)
 
+       def assign_texture_units(self):
+               # Assign texture units for any non-hidden UV layers that lack one
+               units = [u.unit for u in self.uv_layers if u.unit is not None]
+               if units:
+                       free_unit = max(units)+1
+               else:
+                       free_unit = 0
+               for u in self.uv_layers:
+                       if u.unit is None:
+                               if not u.hidden:
+                                       u.unit = free_unit
+                                       free_unit += 1
+
        def generate_material_uv(self):
                self.uv_layers.append(FakeUvLayer("material_tex"))
+               self.assign_texture_units()
                for f in self.faces:
                        f.uvs.append([((f.material_index+0.5)/len(self.materials), 0.5)]*len(f.vertices))