Refactor object exporter to a separate class

diff --git a/blender/io_mspgl/__init__.py b/blender/io_mspgl/__init__.py
index e854134185f8cb938bff6406f0c60cbfc3e4f9ea..9b49da8ffa370f42f0ed129a2f5cd8d6dc20b313 100644 (file)
--- a/blender/io_mspgl/__init__.py
+++ b/blender/io_mspgl/__init__.py
@@ -7,7 +7,7 @@ bl_info = {
 
 if "bpy" in locals():
        import imp
-       for sub in "armature", "export_armature", "export_mesh", "mesh", "outfile", "util":
+       for sub in "armature", "export_armature", "export_mesh", "export_object", "mesh", "outfile", "util":
                if sub in locals():
                        imp.reload(locals()[sub])
 
@@ -48,10 +48,6 @@ class ExportMspGLMeshBase(ExportMspGLBase):
                        ("MSPGL", "MspGL", "Compute vertex normals internally")))
        export_groups = bpy.props.BoolProperty(name="Vertex groups", description="Export vertex groups and weights", default=False)
 
-       def create_exporter(self):
-               from .export_mesh import MeshExporter
-               return MeshExporter()
-
        def draw(self, context):
                col = self.layout.column()
                col.prop(self, "export_lines")
@@ -89,6 +85,10 @@ class ExportMspGLMesh(bpy.types.Operator, ExportMspGLMeshBase):
 
        filename_ext = ".mesh"
 
+       def create_exporter(self):
+               from .export_mesh import MeshExporter
+               return MeshExporter()
+
 class ExportMspGLObject(bpy.types.Operator, ExportMspGLMeshBase):
        bl_idname = "export_mesh.mspgl_object"
        bl_label = "Export Msp GL object"
@@ -102,9 +102,9 @@ class ExportMspGLObject(bpy.types.Operator, ExportMspGLMeshBase):
        material_tex = bpy.props.BoolProperty(name="Material texture", description="Generate a texture based on material colors", default=False)
        srgb_colors = bpy.props.BoolProperty(name="sRGB colors", description="Export material colors as sRGB instead of linear", default=True)
 
-       def prepare_exporter(self, exporter):
-               super().prepare_exporter(exporter)
-               exporter.object = True
+       def create_exporter(self):
+               from .export_object import ObjectExporter
+               return ObjectExporter()
 
        def draw(self, context):
                super().draw(context)

diff --git a/blender/io_mspgl/export_armature.py b/blender/io_mspgl/export_armature.py
index 1d70b591c3554cd86fd1d11b85bd5988324917fe..f3f18c8adcb1c8f2cf1c2e20bfb93535012c1cd2 100644 (file)
--- a/blender/io_mspgl/export_armature.py
+++ b/blender/io_mspgl/export_armature.py
@@ -1,7 +1,5 @@
-from .outfile import OutFile
-
 class ArmatureExporter:
-       def export(self, context, fn):
+       def export(self, context, out_file):
                obj = context.active_object
                if obj.type!="ARMATURE":
                        raise Exception("Can only export Armature data")
@@ -11,7 +9,9 @@ class ArmatureExporter:
                armature = Armature(obj.data)
                armature.sort_links()
 
-               out_file = OutFile(fn)
+               from .outfile import open_outfile
+               out_file = open_outfile(out_file)
+
                for l in armature.links:
                        out_file.begin("link", '"{}"'.format(l.name))
                        out_file.write("index", l.index)

diff --git a/blender/io_mspgl/export_mesh.py b/blender/io_mspgl/export_mesh.py
index 30a5b4630a145efaaa0829f1b118b176a5b4ff66..c1dd2ac09b488cd87e5e856b7a46ebdedf10b42d 100644 (file)
--- a/blender/io_mspgl/export_mesh.py
+++ b/blender/io_mspgl/export_mesh.py
@@ -1,12 +1,5 @@
 import itertools
 import bpy
-from .outfile import OutFile
-
-def linear_to_srgb(l):
-       if l<0.0031308:
-               return 12.92*l
-       else:
-               return 1.055*(l**(1/2.4))-0.055
 
 class VertexCache:
        def __init__(self, size):
@@ -51,10 +44,7 @@ class MeshExporter:
                self.tbn_vecs = False
                self.tbn_uvtex = ""
                self.compound = False
-               self.object = False
                self.material_tex = False
-               self.srgb_colors = True
-               self.textures = "REF"
                self.smoothing = "MSPGL"
                self.export_groups = False
                self.max_groups = 2
@@ -201,7 +191,7 @@ class MeshExporter:
 
                return strips, loose
 
-       def export(self, context, fn):
+       def export(self, context, out_file):
                if self.compound:
                        objs = context.selected_objects
                else:
@@ -289,9 +279,8 @@ class MeshExporter:
 
                progress.set_task("Writing file", 0.95, 1.0)
 
-               out_file = OutFile(fn)
-               if self.object:
-                       out_file.begin("mesh")
+               from .outfile import open_output
+               out_file = open_output(out_file)
 
                fmt = ["NORMAL3"]
                if texunits:
@@ -365,89 +354,9 @@ class MeshExporter:
                                out_file.write("indices", l.vertices[0].index, l.vertices[1].index)
                        out_file.end()
 
-               if self.object:
-                       out_file.end()
-                       out_file.begin("technique")
-                       out_file.begin("pass", '""')
-                       if mesh.materials:
-                               if self.srgb_colors:
-                                       cm = linear_to_srgb
-                               else:
-                                       cm = lambda x: x
-
-                               if self.material_tex:
-                                       out_file.begin("material")
-                                       out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
-                                       out_file.end()
-                                       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")
-                                       out_file.write("storage", "RGB", len(mesh.materials), 1)
-                                       texdata = '"'
-                                       for m in mesh.materials:
-                                               color = [int(cm(c)*255) for c in m.diffuse_color]
-                                               texdata += "\\x%02X\\x%02X\\x%02X"%tuple(color)
-                                       texdata += '"'
-                                       out_file.write("raw_data", texdata)
-                                       out_file.end()
-                                       out_file.end()
-                               else:
-                                       mat = mesh.materials[0]
-                                       out_file.begin("material")
-                                       if any((s and s.use_map_color_diffuse) for s in mat.texture_slots):
-                                               out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
-                                               amb = cm(mat.ambient)
-                                               out_file.write("ambient", amb, amb, amb, 1.0)
-                                       else:
-                                               diff = mat.diffuse_color
-                                               out_file.write("diffuse", cm(diff.r), cm(diff.g), cm(diff.b), 1.0)
-                                               amb = diff*mat.ambient
-                                               out_file.write("ambient", cm(amb.r), cm(amb.g), cm(amb.b), 1.0)
-                                       spec = mat.specular_color*mat.specular_intensity
-                                       out_file.write("specular", spec.r, spec.g, spec.b, 1.0)
-                                       out_file.write("shininess", mat.specular_hardness);
-                                       out_file.end()
-
-                               if self.textures!="NONE":
-                                       for slot in mesh.materials[0].texture_slots:
-                                               if not slot:
-                                                       continue
-
-                                               tex = slot.texture
-                                               if tex.type!="IMAGE":
-                                                       continue
-
-                                               if slot.uv_layer:
-                                                       for u in mesh.uv_layers:
-                                                               if u.name==slot.uv_layer:
-                                                                       index = u.unit
-                                               else:
-                                                       index = mesh.uv_layers[0].unit
-
-                                               out_file.begin("texunit", index)
-                                               if self.textures=="INLINE":
-                                                       out_file.begin("texture2d")
-                                                       out_file.write("min_filter", "LINEAR")
-                                                       out_file.write("storage", "RGBA", tex.image.size[0], tex.image.size[1])
-                                                       texdata = '"'
-                                                       for p in tex.image.pixels:
-                                                               texdata += "\\x%02X"%int(p*255)
-                                                       texdata += '"'
-                                                       out_file.write("raw_data", texdata)
-                                                       out_file.end()
-                                               else:
-                                                       out_file.write("texture", '"%s"'%tex.image.name)
-                                               out_file.end()
-
-                       out_file.end()
-                       out_file.end()
-
                progress.set_task("Done", 1.0, 1.0)
 
                for m in bmeshes:
                        bpy.data.meshes.remove(m)
+
+               return mesh

diff --git a/blender/io_mspgl/export_object.py b/blender/io_mspgl/export_object.py
new file mode 100644 (file)
index 0000000..12b15b6
--- /dev/null
+++ b/blender/io_mspgl/export_object.py
@@ -0,0 +1,105 @@
+def linear_to_srgb(l):
+       if l<0.0031308:
+               return 12.92*l
+       else:
+               return 1.055*(l**(1/2.4))-0.055
+
+
+class ObjectExporter:
+       def __init__(self):
+               self.material_tex = False
+               self.srgb_colors = True
+               self.textures = "REF"
+
+       def export(self, context, out_file):
+               from .outfile import open_output
+               out_file = open_output(out_file)
+
+               from .export_mesh import MeshExporter
+               mesh_export = MeshExporter()
+               for k, v in self.__dict__.items():
+                       setattr(mesh_export, k, v)
+
+               out_file.begin("mesh")
+               mesh = mesh_export.export(context, out_file)
+               out_file.end()
+
+               out_file.begin("technique")
+               out_file.begin("pass", '""')
+               if mesh.materials:
+                       if self.srgb_colors:
+                               cm = linear_to_srgb
+                       else:
+                               cm = lambda x: x
+
+                       if self.material_tex:
+                               out_file.begin("material")
+                               out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
+                               out_file.end()
+                               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")
+                               out_file.write("storage", "RGB", len(mesh.materials), 1)
+                               texdata = '"'
+                               for m in mesh.materials:
+                                       color = [int(cm(c)*255) for c in m.diffuse_color]
+                                       texdata += "\\x%02X\\x%02X\\x%02X"%tuple(color)
+                               texdata += '"'
+                               out_file.write("raw_data", texdata)
+                               out_file.end()
+                               out_file.end()
+                       else:
+                               mat = mesh.materials[0]
+                               out_file.begin("material")
+                               if any((s and s.use_map_color_diffuse) for s in mat.texture_slots):
+                                       out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
+                                       amb = cm(mat.ambient)
+                                       out_file.write("ambient", amb, amb, amb, 1.0)
+                               else:
+                                       diff = mat.diffuse_color
+                                       out_file.write("diffuse", cm(diff.r), cm(diff.g), cm(diff.b), 1.0)
+                                       amb = diff*mat.ambient
+                                       out_file.write("ambient", cm(amb.r), cm(amb.g), cm(amb.b), 1.0)
+                               spec = mat.specular_color*mat.specular_intensity
+                               out_file.write("specular", spec.r, spec.g, spec.b, 1.0)
+                               out_file.write("shininess", mat.specular_hardness);
+                               out_file.end()
+
+                       if self.textures!="NONE":
+                               for slot in mesh.materials[0].texture_slots:
+                                       if not slot:
+                                               continue
+
+                                       tex = slot.texture
+                                       if tex.type!="IMAGE":
+                                               continue
+
+                                       if slot.uv_layer:
+                                               for u in mesh.uv_layers:
+                                                       if u.name==slot.uv_layer:
+                                                               index = u.unit
+                                       else:
+                                               index = mesh.uv_layers[0].unit
+
+                                       out_file.begin("texunit", index)
+                                       if self.textures=="INLINE":
+                                               out_file.begin("texture2d")
+                                               out_file.write("min_filter", "LINEAR")
+                                               out_file.write("storage", "RGBA", tex.image.size[0], tex.image.size[1])
+                                               texdata = '"'
+                                               for p in tex.image.pixels:
+                                                       texdata += "\\x%02X"%int(p*255)
+                                               texdata += '"'
+                                               out_file.write("raw_data", texdata)
+                                               out_file.end()
+                                       else:
+                                               out_file.write("texture", '"%s"'%tex.image.name)
+                                       out_file.end()
+
+               out_file.end()
+               out_file.end()

diff --git a/blender/io_mspgl/outfile.py b/blender/io_mspgl/outfile.py
index ca7abcf9de4855dcd3ac3fa8029b7d7c48a809aa..5d5cb8ea798c80b5b352d82883fd39a4e3131d01 100644 (file)
--- a/blender/io_mspgl/outfile.py
+++ b/blender/io_mspgl/outfile.py
@@ -28,3 +28,9 @@ class OutFile:
        def end(self):
                self.indent -= 1
                self.file.write("%s};\n"%('\t'*self.indent))
+
+
+def open_output(f):
+       if isinstance(f, OutFile):
+               return f
+       return OutFile(f)