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[:]
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
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
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
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
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
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
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]
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 = []
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
+ v.co = matrix@v.co
def splice(self, other):
if len(self.uv_layers)!=len(other.uv_layers):
self.faces += other.faces
for f in self.faces[offset:]:
f.index += offset
- f.loop_start += loop_offset
- f.loop_indices = range(f.loop_start, f.loop_start+f.loop_total)
+ f.loop_indices = range(f.loop_indices.start+offset, f.loop_indices.stop+offset)
if other.materials:
f.material_index = material_map[f.material_index]
def apply_material_map(self, material_map):
for m in self.materials:
- if m not in material_map.materials:
+ if m.name not in material_map.material_names:
raise Exception("Material map is not compatible with Mesh")
if self.use_uv=='NONE':
def prepare_uv(self, progress):
# Form a list of UV layers referenced by materials with the array atlas
# property set
- array_uv_layers = [t.uv_layer for m in self.materials if m.array_atlas for t in m.texture_slots if t and t.texture_coords=='UV']
+ array_uv_layers = [] #[t.uv_layer for m in self.materials if m.array_atlas for t in m.texture_slots if t and t.texture_coords=='UV']
array_uv_layers = [u for u in self.uv_layers if u.name in array_uv_layers]
if array_uv_layers:
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":
if c.type=="MESH" and c.compound:
objs.append((c, m*c.matrix_local))
+ dg = context.evaluated_depsgraph_get()
+
mesh = None
- bmeshes = []
for o, m in objs:
- bmesh = o.to_mesh(context.scene, True, "PREVIEW")
- bmeshes.append(bmesh)
+ eval_obj = o.evaluated_get(dg)
+ bmesh = eval_obj.to_mesh()
# Object.to_mesh does not copy custom properties
bmesh.winding_test = o.data.winding_test
me = Mesh(bmesh)
me.transform(m)
+ for i, s in enumerate(eval_obj.material_slots):
+ if s.link=='OBJECT':
+ me.materials[i] = s.material
+
if mesh:
mesh.splice(me)
else:
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()
- for m in bmeshes:
- bpy.data.meshes.remove(m)
-
progress.pop_task()
return mesh