Refactor scene data preparation to its own class

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

diff --git a/blender/io_mspgl/export_scene.py b/blender/io_mspgl/export_scene.py
index 02566ef6a3dc68b7691741d5cb47ab9bf101f693..e272823ee164d257b1464a6f840ddb8a51e2e7cb 100644 (file)
--- a/blender/io_mspgl/export_scene.py
+++ b/blender/io_mspgl/export_scene.py
@@ -10,40 +10,18 @@ class SceneExporter:
                self.show_progress = True
 
        def export_to_file(self, context, out_fn):
-               if self.selected_only:
-                       objs = context.selected_objects
-               else:
-                       objs = context.scene.objects
-               if self.visible_only:
-                       collections = [c.collection for c in context.view_layer.layer_collection.children if not (c.hide_viewport or c.collection.hide_viewport)]
-                       objs = [o for o in objs if any((o.name in c.all_objects) for c in collections)]
-               objs = [o for o in objs if o.type=="MESH" and not o.lod_for_parent and o.data.vertices]
-               objs = [o for o in objs if (not o.compound or o.parent not in objs)]
-               objs.sort(key=lambda x:x.name)
+               from .scene import create_scene_from_current
+               scene = create_scene_from_current(context, selected_only=self.selected_only, visible_only=self.visible_only)
 
                path, base = os.path.split(out_fn)
                base, ext = os.path.splitext(base)
 
-               object_prototypes = {}
-               unique_objects = []
                export_names = {}
                used_names = set()
-               for o in objs:
-                       if o.name in object_prototypes:
-                               continue
-
-                       clones = [o]
-                       for u in objs:
-                               if u is o:
-                                       continue
-                               if u.data.name!=o.data.name:
-                                       continue
-                               if any(m1.name!=m2.name for m1, m2 in zip(o.material_slots, u.material_slots)):
-                                       continue
-
-                               clones.append(u)
-
-                       prefix = o.name
+               for p in scene.prototypes:
+                       clones = [i for i in scene.instances if i.prototype==p.name]
+
+                       prefix = p.name
                        for c in clones:
                                while not c.name.startswith(prefix):
                                        pos = max(prefix.rfind(' '), prefix.rfind('.'))
@@ -52,13 +30,9 @@ class SceneExporter:
                                        prefix = prefix[:pos]
 
                        if prefix:
-                               export_names[o.name+".object"] = prefix.strip(" .")
+                               export_names[p.name+".object"] = prefix.strip(" .")
                        else:
-                               used_names.add(o.name)
-
-                       unique_objects.append(o)
-                       for c in clones:
-                               object_prototypes[c.name] = o
+                               used_names.add(p.name)
 
                for n, e in export_names.items():
                        if e in used_names:
@@ -76,12 +50,12 @@ class SceneExporter:
                data_exporter = DataExporter()
 
                resources = {}
-               data_exporter.export_resources(context, unique_objects, resources, None, progress)
+               data_exporter.export_resources(context, scene.prototypes, resources, None, progress)
                for n, r in resources.items():
                        if r.name in export_names:
                                r.name = export_names[r.name]
 
-               scene_res = self.export_scene(context, objs, resources, object_prototypes, progress)
+               scene_res = self.export_scene(scene, resources, progress)
                refs = scene_res.collect_references()
 
                if self.collection:
@@ -94,29 +68,29 @@ class SceneExporter:
                        for r in refs:
                                r.write_to_file(os.path.join(path, r.name))
 
-       def export_scene(self, context, objs, resources, prototypes, progress):
+       def export_scene(self, scene, resources, progress):
                from .datafile import Resource, Statement, Token
-               scene_res = Resource(context.scene.name+".scene", "scene")
+               scene_res = Resource(scene.name+".scene", "scene")
 
-               scene_res.statements.append(Statement("type", Token(context.scene.scene_type.lower())))
+               scene_res.statements.append(Statement("type", Token(scene.scene_type.lower())))
 
-               for o in objs:
-                       obj_res = resources[prototypes[o.name].name+".object"]
-                       st = scene_res.create_reference_statement("object", obj_res, o.name)
+               for i in scene.instances:
+                       obj_res = resources[i.prototype+".object"]
+                       st = scene_res.create_reference_statement("object", obj_res, i.name)
 
                        ss = Statement("transform")
 
-                       loc = o.matrix_world.to_translation()
+                       loc = i.matrix_world.to_translation()
                        ss.sub.append(Statement("position", *tuple(loc)))
 
-                       quat = o.matrix_world.to_quaternion()
-                       if o.rotation_mode in ('XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'):
+                       quat = i.matrix_world.to_quaternion()
+                       if i.rotation_mode in ('XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'):
                                angles = [a*180/math.pi for a in quat.to_euler()]
                                ss.sub.append(Statement("euler", *angles));
                        else:
                                ss.sub.append(Statement("rotation", quat.angle*180/math.pi, *tuple(quat.axis)))
 
-                       scale = o.matrix_world.to_scale()
+                       scale = i.matrix_world.to_scale()
                        ss.sub.append(Statement("scale", *tuple(scale)))
 
                        st.sub.append(ss)