Move most properties from exporters to the relevant types

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

diff --git a/blender/io_mspgl/export_mesh.py b/blender/io_mspgl/export_mesh.py
index 541874b2bd2018c052d286962956a0a0a45f77b6..3873bf329e627f2d108085b73cc0ca76b1c2b8af 100644 (file)
--- a/blender/io_mspgl/export_mesh.py
+++ b/blender/io_mspgl/export_mesh.py
@@ -41,15 +41,8 @@ class MeshExporter:
                self.max_strip_len = 1024
                self.optimize_cache = True
                self.cache_size = 64
-               self.export_lines = False
-               self.export_uv = "UNIT0"
-               self.tbn_vecs = False
-               self.tbn_uvtex = ""
                self.compound = False
                self.material_tex = False
-               self.smoothing = "MSPGL"
-               self.export_groups = False
-               self.max_groups = 2
 
        def stripify(self, mesh, progress=None):
                for f in mesh.faces:
@@ -237,6 +230,8 @@ class MeshExporter:
                for o, m in objs:
                        if o.data.winding_test:
                                winding_test = True
+                       if o.material_tex:
+                               self.material_tex = True
                        bmesh = o.to_mesh(context.scene, True, "PREVIEW")
                        bmeshes.append(bmesh)
                        me = Mesh(bmesh)
@@ -248,15 +243,15 @@ class MeshExporter:
 
                if progress:
                        progress.set_task("Smoothing", 0.05, 0.35)
-               if self.smoothing=="NONE":
+               if mesh.smoothing=="NONE":
                        mesh.flatten_faces()
                mesh.split_smooth(progress)
 
-               if self.smoothing!="BLENDER":
+               if mesh.smoothing!="BLENDER":
                        mesh.compute_normals()
 
-               if self.export_groups:
-                       mesh.sort_vertex_groups(self.max_groups)
+               if mesh.vertex_groups:
+                       mesh.sort_vertex_groups(mesh.max_groups_per_vertex)
 
                        # Create a mapping from vertex group indices to bone indices
                        first_obj = objs[0][0]
@@ -273,9 +268,9 @@ class MeshExporter:
 
                texunits = []
                force_unit0 = False
-               if mesh.uv_layers and (self.export_uv!="NONE" or self.material_tex):
+               if mesh.uv_layers and (mesh.use_uv!="NONE" or self.material_tex):
                        # Figure out which UV layers to export
-                       if self.export_uv=="ALL":
+                       if mesh.use_uv=="ALL":
                                texunits = range(len(mesh.uv_layers))
                        elif self.material_tex:
                                # The material UV layer is always the last one
@@ -289,11 +284,11 @@ class MeshExporter:
                        texunits = [(i, mesh.uv_layers[i]) for i in texunits]
                        texunits = [u for u in texunits if not u[1].hidden]
 
-                       if self.tbn_vecs:
+                       if mesh.tbn_vecs:
                                # 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)
+                               if mesh.tbn_uvtex in uv_names:
+                                       tbn_index = uv_names.index(mesh.tbn_uvtex)
                                        unit = texunits[tbn_index]
                                        del texunits[tbn_index]
                                        texunits.insert(0, unit)
@@ -302,7 +297,7 @@ class MeshExporter:
                                if progress:
                                        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 u.name==self.tbn_uvtex:
+                               if mesh.tbn_vecs and u.name==mesh.tbn_uvtex:
                                        mesh.compute_uv()
                                        mesh.compute_tbn(i)
 
@@ -329,10 +324,10 @@ class MeshExporter:
                                        fmt.append("TEXCOORD"+size)
                                else:
                                        fmt.append("TEXCOORD%s_%d"%(size, u.unit))
-                       if self.tbn_vecs:
+                       if mesh.tbn_vecs:
                                fmt += ["TANGENT3", "BINORMAL3"]
-               if self.export_groups:
-                       fmt.append("ATTRIB%d_5"%(self.max_groups*2))
+               if mesh.vertex_groups:
+                       fmt.append("ATTRIB%d_5"%(mesh.max_groups_per_vertex*2))
                fmt.append("VERTEX3")
                out_file.begin("vertices", *fmt)
                normal = None
@@ -352,16 +347,16 @@ class MeshExporter:
                                        else:
                                                out_file.write("multitexcoord"+size, u.unit, *v.uvs[i])
                                        uvs[i] = v.uvs[i]
-                       if self.tbn_vecs:
+                       if mesh.tbn_vecs:
                                if v.tan!=tan:
                                        out_file.write("tangent3", *v.tan)
                                        tan = v.tan
                                if v.bino!=bino:
                                        out_file.write("binormal3", *v.bino)
                                        bino = v.bino
-                       if self.export_groups:
-                               group_attr = [(group_index_map[g.group], g.weight*v.group_weight_scale) for g in v.groups[:self.max_groups]]
-                               while len(group_attr)<self.max_groups:
+                       if mesh.vertex_groups:
+                               group_attr = [(group_index_map[g.group], g.weight*v.group_weight_scale) for g in v.groups[:mesh.max_groups_per_vertex]]
+                               while len(group_attr)<mesh.max_groups_per_vertex:
                                        group_attr.append((0, 0.0))
                                group_attr = list(itertools.chain(*group_attr))
                                if group_attr!=group:
@@ -389,7 +384,7 @@ class MeshExporter:
                                        out_file.write("indices", f.vertices[0].index, f.vertices[i-1].index, f.vertices[i].index)
                        out_file.end()
 
-               if self.export_lines and mesh.lines:
+               if mesh.use_lines and mesh.lines:
                        out_file.begin("batch", "LINES")
                        for l in mesh.lines:
                                out_file.write("indices", l.vertices[0].index, l.vertices[1].index)