X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=blender%2Fio_mspgl%2Fmesh.py;h=f5665256b2eeced61c654abc329d4849e45d82cf;hb=9ab994ab4fedf938cbbdfe1ec1415e6c91844d21;hp=b58637b7f76bb00515c82f29d211c7a380d51395;hpb=7370746bcad955eb813418d0e1d5686f22c99369;p=libs%2Fgl.git diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py index b58637b7..f5665256 100644 --- a/blender/io_mspgl/mesh.py +++ b/blender/io_mspgl/mesh.py @@ -1,6 +1,7 @@ import bpy import math import mathutils +import itertools def make_edge_key(i1, i2): return (min(i1, i2), max(i1, i2)) @@ -8,18 +9,17 @@ def make_edge_key(i1, i2): class Edge: def __init__(self, edge): if edge.__class__==Edge: - self._edge = edge._edge - self.vertices = edge.vertices[:] self.smooth = edge.smooth else: - self._edge = edge self.smooth = False - self.key = edge.key + if edge: + self.vertices = edge.vertices[:] + self.key = edge.key + else: + self.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 @@ -46,26 +46,21 @@ 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 self.index = vertex.index - self.co = vertex.co - self.normal = vertex.normal + self.co = mathutils.Vector(vertex.co) + self.normal = mathutils.Vector(vertex.normal) self.flag = False self.edges = [] 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 @@ -74,26 +69,22 @@ 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.uvs = [] + self.loop_indices = face.loop_indices + self.normal = face.normal + self.use_smooth = face.use_smooth + self.material_index = face.material_index self.flag = False - def __getattr__(self, attr): - return getattr(self._face, attr) - def __cmp__(self, other): if other is None: return 1 @@ -103,14 +94,10 @@ class Face: n = self.vertices.index(v) return [(n+i)%len(self.vertices) for i in range(len(self.vertices))] - def pivot_vertices(self, *vt): - flags = [(v in vt) for v in self.vertices] - l = len(self.vertices) - for i in range(l): - if flags[i] and not flags[(i+l-1)%l]: - return self.vertices[i:]+self.vertices[:i] + def get_loop_index(self, v): + return self.loop_indices[self.vertices.index(v)] - def get_edge(self, v1, v2): + def get_edge(self, v1, v2): key = make_edge_key(v1.index, v2.index) for e in self.edges: if e.key==key: @@ -137,12 +124,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 = [d.uv for d in self.data] + self.uvs = [mathutils.Vector(d.uv) for d in arg.data] self.unit = None self.hidden = False @@ -155,44 +141,51 @@ 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 - self.vertices = [Vertex(v) for v in self.vertices] + self.vertices = [Vertex(v) for v in mesh.vertices] for v in self.vertices: v.groups = [VertexGroup(g) for g in v.groups] - self.faces = [Face(f) for f in self.polygons] - self.edges = [Edge(e) for e in self.edges] - self.loops = self.loops[:] - self.materials = self.materials[:] + self.faces = [Face(f) for f in mesh.polygons] + self.edges = [Edge(e) for e in mesh.edges] + 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 self.uv_layers: + if mesh.use_uv=='NONE' or not mesh.uv_layers: self.uv_layers = [] else: - self.uv_layers = [UvLayer(u) for u in self.uv_layers] - self.uv_layers = sorted([u for u in self.uv_layers if not u.hidden], key=(lambda u: (u.unit or 1000, u.name))) - - if self.use_uv=='UNIT0': - self.uv_layers = [self.uv_layers[0]] + self.uv_layers = [UvLayer(u) for u in mesh.uv_layers] # Assign texture unit numbers to UV layers that lack one - next_unit = max((u.unit+1 for u in self.uv_layers if u.unit is not None), default=0) - for u in self.uv_layers: - if not u.unit: - u.unit = next_unit - next_unit += 1 + missing_unit = [u for u in self.uv_layers if u.unit is None] + if missing_unit: + missing_unit = sorted(missing_unit, key=(lambda u: u.name)) + used_units = [u.unit for u in self.uv_layers if u.unit is not None] + for u, n in zip(missing_unit, (i for i in itertools.count() if i not in used_units)): + u.unit = n + + self.uv_layers = sorted(self.uv_layers, key=(lambda u: u.unit)) + + if mesh.use_uv=='UNIT0': + self.uv_layers = [self.uv_layers[0]] + if self.uv_layers[0].unit!=0: + self.uv_layers = [] # Rewrite links between elements to point to cloned data, or create links # where they don't exist @@ -216,17 +209,16 @@ 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 = [] - def __getattr__(self, attr): - return getattr(self._mesh, attr) + self.vertex_sequence = [] 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): @@ -262,8 +254,7 @@ class Mesh: 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] @@ -275,6 +266,68 @@ class Mesh: self.lines += other.lines + def prepare_triangles(self, progress): + face_count = len(self.faces) + for i in range(face_count): + f = self.faces[i] + nverts = len(f.vertices) + if nverts==3: + continue + + # Calculate normals at each vertex of the face + edge_vecs = [] + for j in range(nverts): + edge_vecs.append(f.vertices[(j+1)%nverts].co-f.vertices[j].co) + + normals = [] + for j in range(nverts): + normals.append(edge_vecs[j-1].cross(edge_vecs[j]).normalized()) + + # Check which diagonal results in a flatter triangulation + flatness1 = normals[0].dot(normals[2]) + flatness2 = normals[1].dot(normals[3]) + cut_index = 1 if flatness1>flatness2 else 0 + + nf = Face(f) + nf.index = len(self.faces) + self.faces.append(nf) + + ne = Edge(None) + ne.index = len(self.edges) + self.edges.append(ne) + + nf.vertices = [f.vertices[cut_index], f.vertices[2], f.vertices[3]] + nf.loop_indices = [f.loop_indices[cut_index], f.loop_indices[2], f.loop_indices[3]] + for v in nf.vertices: + v.faces.append(nf) + + ne.vertices = [f.vertices[cut_index], f.vertices[2+cut_index]] + for v in ne.vertices: + v.edges.append(ne) + ne.key = make_edge_key(ne.vertices[0].index, ne.vertices[1].index) + ne.smooth = True + + f.vertices[3-cut_index].faces.remove(f) + del f.vertices[3-cut_index] + f.loop_indices = [f.loop_indices[0], f.loop_indices[1], f.loop_indices[2+cut_index]] + + ne.faces = [f, nf] + if cut_index==0: + nf.edges = [ne, f.edges[2], f.edges[3]] + f.edges = [f.edges[0], f.edges[1], ne] + else: + nf.edges = [f.edges[1], f.edges[2], ne] + f.edges = [f.edges[0], ne, f.edges[3]] + for e in nf.edges: + if e!=ne: + e.faces.remove(f) + e.faces.append(nf) + + f.normal = normals[1-cut_index] + nf.normal = normals[3-cut_index] + + progress.set_progress(i/face_count) + def prepare_smoothing(self, progress): smooth_limit = -1 if self.smoothing=='NONE': @@ -318,26 +371,34 @@ class Mesh: for g in v.groups: g.group = group_index_map[g.group] - def prepare_uv(self, obj, progress): - if obj.material_tex and self.use_uv!='NONE': - layer = UvLayer("material_tex") + def apply_material_map(self, material_map): + for m in self.materials: + if m.name not in material_map.material_names: + raise Exception("Material map is not compatible with Mesh") - if self.use_uv=='UNIT0': - self.uv_layers = [layer] - layer.unit = 0 - else: - self.uv_layers.append(layer) - layer.unit = max((u.unit+1 for u in self.uv_layers if u.unit is not None), default=0) + if self.use_uv=='NONE': + return - layer.uvs = [None]*len(self.loops) - for f in self.faces: - uv = mathutils.Vector(((f.material_index+0.5)/len(self.materials), 0.5)) - for i in f.loop_indices: - layer.uvs[i] = uv + layer = UvLayer("material_map") + if self.use_uv=='UNIT0': + self.uv_layers = [layer] + layer.unit = 0 + else: + self.uv_layers.append(layer) + used_units = [u.unit for u in self.uv_layers] + layer.unit = next(i for i in itertools.count() if i not in used_units) + self.uv_layers.sort(key=lambda u: u.unit) + layer.uvs = [(0.0, 0.0)]*len(self.loops) + for f in self.faces: + uv = material_map.get_material_uv(self.materials[f.material_index]) + for i in f.loop_indices: + layer.uvs[i] = uv + + 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: @@ -352,11 +413,6 @@ class Mesh: for i in f.loop_indices: l.uvs[i] = mathutils.Vector((*l.uvs[i], layer)) - # Copy UVs from layers to faces - for f in self.faces: - for u in self.uv_layers: - f.uvs.append([u.uvs[i] for i in f.loop_indices]) - prog_count = len(self.uv_layers) prog_step = 0 @@ -374,6 +430,8 @@ class Mesh: self.compute_tbn(tbn_layer_index, progress) progress.pop_task() prog_step = 2 + else: + raise Exception("TBN UV layer not found") # Split by the remaining UV layers for i, u in enumerate(self.uv_layers): @@ -385,13 +443,13 @@ class Mesh: progress.pop_task() prog_step += 1 - # Copy UVs from faces to vertices + # Copy UVs from layers to vertices for v in self.vertices: if v.faces: # All faces still connected to the vertex have the same UV value f = v.faces[0] - i = f.vertices.index(v) - v.uvs = [u[i] for u in f.uvs] + i = f.get_loop_index(v) + v.uvs = [u.uvs[i] for u in self.uv_layers] else: v.uvs = [(0.0, 0.0)]*len(self.uv_layers) @@ -469,12 +527,13 @@ class Mesh: return group def find_uv_group(self, vertex, face, index): - uv = face.uvs[index][face.vertices.index(vertex)] + layer = self.uv_layers[index] + uv = layer.uvs[face.get_loop_index(vertex)] face.flag = True group = [face] for f in vertex.faces: - if not f.flag and f.uvs[index][f.vertices.index(vertex)]==uv: + if not f.flag and layer.uvs[f.get_loop_index(vertex)]==uv: f.flag = True group.append(f) @@ -484,9 +543,9 @@ class Mesh: for i, v in enumerate(self.vertices): v.normal = mathutils.Vector() for f in v.faces: - fv = f.pivot_vertices(v) - edge1 = fv[1].co-fv[0].co - edge2 = fv[-1].co-fv[0].co + vi = f.pivot_vertex(v) + edge1 = f.vertices[vi[1]].co-v.co + edge2 = f.vertices[vi[-1]].co-v.co if edge1.length and edge2.length: # Use the angle between edges as a weighting factor. This gives # more consistent normals on bends with an inequal number of @@ -532,69 +591,147 @@ class Mesh: progress.set_progress(i/len(self.vertices)) - 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 + def prepare_sequence(self, progress): + progress.push_task("Reordering faces", 0.0, 0.5) + self.reorder_faces(progress) + + progress.set_task("Building sequence", 0.5, 1.0) + sequence = None + for i, f in enumerate(self.faces): + if sequence: + if len(sequence)==3: + # Rotate the first three vertices so that the new face can be added + if sequence[0] in f.vertices and sequence[1] not in f.vertices: + sequence.append(sequence[0]) + del sequence[0] + elif sequence[2] not in f.vertices and sequence[1] in f.vertices: + sequence.insert(0, sequence[-1]) + del sequence[-1] + + if sequence[-1] not in f.vertices: + sequence = None + else: + to_add = [v for v in f.vertices if v!=sequence[-1] and v!=sequence[-2]] + if len(to_add)==2: + if (f.vertices[1]==sequence[-1]) != (len(sequence)%2==1): + to_add.reverse() + sequence.append(sequence[-1]) + sequence += to_add + + if not sequence: + sequence = f.vertices[:] + self.vertex_sequence.append(sequence) + + progress.set_progress(i/len(self.faces)) + + progress.pop_task() + + self.reorder_vertices() + + def reorder_faces(self, progress): + # Tom Forsyth's vertex cache optimization algorithm + # http://eelpi.gotdns.org/papers/fast_vert_cache_opt.html + for f in self.faces: - f._face = None - for u in self.uv_layers: - u._layer = None - self._mesh = None - - def create_strip(self, face, max_len): - # Find an edge with another unused face next to it - edge = None - for e in face.edges: - other = e.other_face(face) - if other and not other.flag: - edge = e - break + f.flag = False - if not edge: - return None + last_triangle_score = 0.75 + cache_decay_power = 1.5 + valence_boost_scale = 2.0 + valence_boost_power = -0.5 - # Add initial vertices so that we'll complete the edge on the first - # iteration - vertices = face.pivot_vertices(*edge.vertices) - if len(vertices)==3: - result = [vertices[-1], vertices[0]] - else: - result = [vertices[-2], vertices[-1]] + max_cache_size = 32 + cached_vertices = [] + + # Keep track of the score and number of unused faces for each vertex + vertex_info = [[0, len(v.faces)] for v in self.vertices] + for vi in vertex_info: + vi[0] = valence_boost_scale*(vi[1]**valence_boost_power) + + face = None + reordered_faces = [] + n_processed = 0 while 1: + if not face: + # Previous iteration gave no candidate for best face (or this is + # the first iteration). Scan all faces for the highest score. + best_score = 0 + for f in self.faces: + if f.flag: + continue + + score = sum(vertex_info[v.index][0] for v in f.vertices) + if score>best_score: + best_score = score + face = f + + if not face: + break + + reordered_faces.append(face) face.flag = True - vertices = face.pivot_vertices(*result[-2:]) - k = len(result)%2 + for v in face.vertices: + vertex_info[v.index][1] -= 1 + + # Shuffle the vertex into the front of the cache + if v in cached_vertices: + cached_vertices.remove(v) + cached_vertices.insert(0, v) + + # Update scores for all vertices in the cache + for i, v in enumerate(cached_vertices): + score = 0 + if i<3: + score += last_triangle_score + elif ibest_score: + best_score = score + face = f + + del cached_vertices[max_cache_size:] + + n_processed += 1 + progress.set_progress(n_processed/len(self.faces)) + + self.faces = reordered_faces + for i, f in enumerate(self.faces): + f.index = i + + def reorder_vertices(self): + for v in self.vertices: + v.index = -1 - # Quads need special handling because the winding of every other - # triangle in the strip is reversed - if len(vertices)==4 and not k: - result.append(vertices[3]) - result.append(vertices[2]) - if len(vertices)==4 and k: - result.append(vertices[3]) + reordered_vertices = [] + for s in self.vertex_sequence: + for v in s: + if v.index<0: + v.index = len(reordered_vertices) + reordered_vertices.append(v) - if len(result)>=max_len: - break + self.vertices = reordered_vertices - # Hop over the last edge - edge = face.get_edge(*result[-2:]) - face = edge.other_face(face) - if not face or face.flag: - break + for e in self.edges: + e.key = make_edge_key(e.vertices[0].index, e.vertices[1].index) - return result -def create_mesh_from_object(context, obj, progress): +def create_mesh_from_object(context, obj, progress, *, material_map=None): if obj.type!="MESH": raise Exception("Object is not a mesh") - progress.push_task("Preparing mesh", 0.0, 0.3) + progress.push_task("Preparing mesh", 0.0, 0.2) objs = [(obj, mathutils.Matrix())] i = 0 @@ -605,11 +742,12 @@ def create_mesh_from_object(context, obj, progress): 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 @@ -624,23 +762,30 @@ def create_mesh_from_object(context, obj, progress): 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: mesh = me - progress.set_task("Smoothing", 0.3, 0.6) + mesh.name = obj.data.name + + if material_map: + mesh.apply_material_map(material_map) + + progress.set_task("Triangulating", 0.2, 0.3) + mesh.prepare_triangles(progress) + progress.set_task("Smoothing", 0.3, 0.5) mesh.prepare_smoothing(progress) - progress.set_task("Vertex groups", 0.6, 0.7) + progress.set_task("Vertex groups", 0.5, 0.6) mesh.prepare_vertex_groups(obj) - progress.set_task("Preparing UVs", 0.7, 1.0) - mesh.prepare_uv(obj, 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.set_task("Preparing UVs", 0.6, 0.8) + mesh.prepare_uv(progress) + progress.set_task("Render sequence", 0.8, 1.0) + mesh.prepare_sequence(progress) progress.pop_task()