Remove attribute proxying from Mesh in the Blender exporter

Instead just copy all the data.  This makes the script easier to read and
avoids holding references to stale data.

diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py
index 4403c6a01dd92a2d1b2eff36cf95cd4e9853a120..42adabe66f79c8716266e6319371d376b858d133 100644 (file)
--- a/blender/io_mspgl/mesh.py
+++ b/blender/io_mspgl/mesh.py
@@ -9,10 +9,8 @@ def make_edge_key(i1, i2):
 class Edge:
        def __init__(self, edge):
                if edge.__class__==Edge:
-                       self._edge = edge._edge
                        self.smooth = edge.smooth
                else:
-                       self._edge = edge
                        self.smooth = False
                if edge:
                        self.vertices = edge.vertices[:]
@@ -22,9 +20,6 @@ class Edge:
                        self.key = None
                self.faces = []
 
-       def __getattr__(self, attr):
-               return getattr(self._edge, attr)
-
        def check_smooth(self, limit):
                if len(self.faces)!=2:
                        return
@@ -51,12 +46,10 @@ class Edge:
 class Vertex:
        def __init__(self, vertex):
                if vertex.__class__==Vertex:
-                       self._vertex = vertex._vertex
                        self.uvs = vertex.uvs[:]
                        self.tan = vertex.tan
                        self.bino = vertex.bino
                else:
-                       self._vertex = vertex
                        self.uvs = []
                        self.tan = None
                        self.bino = None
@@ -68,9 +61,6 @@ class Vertex:
                self.faces = []
                self.groups = vertex.groups[:]
 
-       def __getattr__(self, attr):
-               return getattr(self._vertex, attr)
-
        def __cmp__(self, other):
                if other is None:
                        return 1
@@ -79,26 +69,23 @@ class Vertex:
 
 class VertexGroup:
        def __init__(self, group):
-               self._group = group
                self.group = group.group
                self.weight = group.weight
 
-       def __getattr__(self, attr):
-               return getattr(self._group, attr)
-
 
 class Face:
        def __init__(self, face):
-               self._face = face
                self.index = face.index
                self.edges = []
+               self.edge_keys = face.edge_keys
                self.vertices = face.vertices[:]
+               self.loop_indices = face.loop_indices
+               self.normal = face.normal
+               self.use_smooth = face.use_smooth
+               self.material_index = face.material_index
                self.uvs = []
                self.flag = False
 
-       def __getattr__(self, attr):
-               return getattr(self._face, attr)
-
        def __cmp__(self, other):
                if other is None:
                        return 1
@@ -142,13 +129,11 @@ class Line:
 class UvLayer:
        def __init__(self, arg):
                if type(arg)==str:
-                       self._layer = None
                        self.name = arg
                        self.uvs = []
                else:
-                       self._layer = arg
                        self.name = arg.name
-                       self.uvs = [mathutils.Vector(d.uv) for d in self.data]
+                       self.uvs = [mathutils.Vector(d.uv) for d in arg.data]
 
                self.unit = None
                self.hidden = False
@@ -161,17 +146,16 @@ class UvLayer:
                        elif ext==".hidden":
                                self.hidden = True
 
-       def __getattr__(self, attr):
-               return getattr(self._layer, attr)
-
 
 class Mesh:
        def __init__(self, mesh):
-               self._mesh = mesh
                self.name = mesh.name
 
                self.winding_test = mesh.winding_test
+               self.smoothing = mesh.smoothing
+               self.use_uv = mesh.use_uv
                self.tbn_vecs = mesh.tbn_vecs
+               self.tbn_uvtex = mesh.tbn_uvtex
                self.vertex_groups = mesh.vertex_groups
 
                # Clone basic data
@@ -184,8 +168,11 @@ class Mesh:
                self.loops = mesh.loops[:]
                self.materials = mesh.materials[:]
 
+               self.use_auto_smooth = mesh.use_auto_smooth
+               self.auto_smooth_angle = mesh.auto_smooth_angle
+
                # Clone only the desired UV layers
-               if self.use_uv=='NONE' or not mesh.uv_layers:
+               if mesh.use_uv=='NONE' or not mesh.uv_layers:
                        self.uv_layers = []
                else:
                        self.uv_layers = [UvLayer(u) for u in mesh.uv_layers]
@@ -200,7 +187,7 @@ class Mesh:
 
                        self.uv_layers = sorted(self.uv_layers, key=(lambda u: u.unit))
 
-                       if self.use_uv=='UNIT0':
+                       if mesh.use_uv=='UNIT0':
                                self.uv_layers = [self.uv_layers[0]]
                                if self.uv_layers[0].unit!=0:
                                        self.uv_layers = []
@@ -227,16 +214,13 @@ class Mesh:
                                v.edges.append(e)
 
                # Store loose edges as lines
-               if self.use_lines:
+               if mesh.use_lines:
                        self.lines = [Line(e) for e in self.edges if not e.faces]
                else:
                        self.lines = []
 
                self.vertex_sequence = []
 
-       def __getattr__(self, attr):
-               return getattr(self._mesh, attr)
-
        def transform(self, matrix):
                for v in self.vertices:
                        v.co = matrix@v.co
@@ -749,19 +733,6 @@ class Mesh:
                for e in self.edges:
                        e.key = make_edge_key(e.vertices[0].index, e.vertices[1].index)
 
-       def drop_references(self):
-               for v in self.vertices:
-                       v._vertex = None
-                       for g in v.groups:
-                               g._group = None
-               for e in self.edges:
-                       e._edge = None
-               for f in self.faces:
-                       f._face = None
-               for u in self.uv_layers:
-                       u._layer = None
-               self._mesh = None
-
 
 def create_mesh_from_object(context, obj, progress, *, material_map=None):
        if obj.type!="MESH":
@@ -823,10 +794,6 @@ def create_mesh_from_object(context, obj, progress, *, material_map=None):
        progress.set_task("Render sequence", 0.8, 1.0)
        mesh.prepare_sequence(progress)
 
-       # Discard the temporary Blender meshes after making sure there's no
-       # references to the data
-       mesh.drop_references()
-
        progress.pop_task()
 
        return mesh