X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=blender%2Fio_mspgl%2Fmesh.py;h=bf5d108ba5e27caa68c9767638702aca3b9ea7d6;hb=f2d504006ec97c7d84e8059c48f5a37e005ece5f;hp=78cae28b22f662d3e0eb2ca9fdbb8073536f7893;hpb=171f8e9be4fd17ebc7a467d9a8f959a1bba6b3e6;p=libs%2Fgl.git diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py index 78cae28b..bf5d108b 100644 --- a/blender/io_mspgl/mesh.py +++ b/blender/io_mspgl/mesh.py @@ -1,6 +1,6 @@ -import bpy import math import mathutils +import itertools def make_edge_key(i1, i2): return (min(i1, i2), max(i1, i2)) @@ -8,10 +8,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[:] @@ -21,9 +19,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 @@ -50,26 +45,20 @@ 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.color = None 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 @@ -78,26 +67,26 @@ 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) + if group: + self.group = group.group + self.weight = group.weight + else: + self.group = 0 + self.weight = 0.0 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 @@ -107,12 +96,8 @@ 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): key = make_edge_key(v1.index, v2.index) @@ -141,13 +126,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 @@ -160,51 +143,69 @@ class UvLayer: elif ext==".hidden": self.hidden = True - def __getattr__(self, attr): - return getattr(self._layer, attr) + +class ColorLayer: + def __init__(self, l): + self.name = l.name + self.colors = [c.color[:] for c in l.data] class Mesh: def __init__(self, mesh): - self._mesh = mesh + self.name = mesh.name - self.winding_test = mesh.winding_test - self.tbn_vecs = mesh.tbn_vecs + self.smoothing = mesh.smoothing + self.use_uv = mesh.use_uv + self.tangent_uvtex = mesh.tangent_uvtex + self.use_strips = mesh.use_strips self.vertex_groups = mesh.vertex_groups # Clone basic data self.vertices = [Vertex(v) for v in mesh.vertices] - for v in self.vertices: - v.groups = [VertexGroup(g) for g in v.groups] + if self.vertex_groups: + for v in self.vertices: + v.groups = [VertexGroup(g) for g in v.groups] 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 + self.max_groups_per_vertex = mesh.max_groups_per_vertex + # 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([u for u in self.uv_layers if not u.hidden], key=(lambda u: (u.unit or 1000, u.name))) + self.uv_layers = [UvLayer(u) for u in mesh.uv_layers if u.data] + + # Assign texture unit numbers to UV layers that lack one + 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 self.use_uv=='UNIT0': + if mesh.use_uv=='UNIT0' and self.uv_layers: self.uv_layers = [self.uv_layers[0]] + if self.uv_layers[0].unit!=0: + self.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 + self.colors = None + if mesh.vertex_colors: + self.colors = ColorLayer(mesh.vertex_colors[0]) # Rewrite links between elements to point to cloned data, or create links # where they don't exist edge_map = {e.key: e for e in self.edges} for f in self.faces: if len(f.vertices)>4: - raise ValueError("Ngons are not supported") + raise ValueError("Unsupported face on mesh {}: N-gon".format(self.name)) f.vertices = [self.vertices[i] for i in f.vertices] for v in f.vertices: @@ -221,35 +222,47 @@ 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 = [] + # Check if tangent vectors are needed + if mesh.tangent_vecs=='NO': + self.tangent_vecs = False + elif mesh.tangent_vecs=='YES': + self.tangent_vecs = True + elif mesh.tangent_vecs=='AUTO': + from .material import Material + self.tangent_vecs = False + for m in self.materials: + mat = Material(m) + if mat.type=="pbr": + normal_prop = next((p for p in mat.properties if p.tex_keyword=="normal_map"), None) + if normal_prop and normal_prop.texture: + self.tangent_vecs = True - 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): - raise ValueError("Meshes have incompatible UV layers") + raise ValueError("Meshes {} and {} have incompatible UV layers".format(self.name, other.name)) for i, u in enumerate(self.uv_layers): if u.name!=other.uv_layers[i].name: - raise ValueError("Meshes have incompatible UV layers") + raise ValueError("Meshes {} and {} have incompatible UV layers".format(self.name, other.name)) # Merge materials and form a lookup from source material indices to the # merged material list - material_map = [] + material_lookup = [] for m in other.materials: if m in self.materials: - material_map.append(self.materials.index(m)) + material_lookup.append(self.materials.index(m)) else: - material_map.append(len(self.materials)) + material_lookup.append(len(self.materials)) self.materials.append(m) # Append data and adjust indices where necessary. Since the data is @@ -257,6 +270,15 @@ class Mesh: for i, u in enumerate(self.uv_layers): u.uvs += other.uv_layers[i].uvs + if self.colors: + if other.colors: + self.colors.colors += other.colors.colors + else: + self.colors.colors += [(1.0, 1.0, 1.0, 1.0)]*len(other.loops) + elif other.colors: + self.colors = ColorLayer(other.colors.name) + self.colors.colors = [(1.0, 1.0, 1.0, 1.0)]*len(self.loops)+other.colors.colors + offset = len(self.vertices) self.vertices += other.vertices for v in self.vertices[offset:]: @@ -269,10 +291,9 @@ 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] + f.material_index = material_lookup[f.material_index] offset = len(self.edges) self.edges += other.edges @@ -282,7 +303,7 @@ class Mesh: self.lines += other.lines - def prepare_triangles(self, progress): + def prepare_triangles(self, task): face_count = len(self.faces) for i in range(face_count): f = self.faces[i] @@ -342,9 +363,9 @@ class Mesh: f.normal = normals[1-cut_index] nf.normal = normals[3-cut_index] - progress.set_progress(i/face_count) + task.set_progress(i/face_count) - def prepare_smoothing(self, progress): + def prepare_smoothing(self, task): smooth_limit = -1 if self.smoothing=='NONE': for f in self.faces: @@ -357,16 +378,17 @@ class Mesh: for e in self.edges: e.check_smooth(smooth_limit) - progress.push_task("Sharp edges", 0.0, 0.7) - self.split_vertices(self.find_smooth_group, progress) + subtask = task.task("Sharp edges", 0.7) + self.split_vertices(self.find_smooth_group, subtask) if self.smoothing!='BLENDER': - progress.set_task("Updating normals", 0.7, 1.0) - self.compute_normals(progress) - - progress.pop_task() + subtask = task.task("Updating normals", 1.0) + self.compute_normals(subtask) def prepare_vertex_groups(self, obj): + if not self.vertex_groups: + return + for v in self.vertices: if v.groups: weight_sum = sum(g.weight for g in v.groups) @@ -374,6 +396,8 @@ class Mesh: weight_scale = weight_sum/sum(g.weight for g in v.groups) for g in v.groups: g.weight *= weight_scale + while len(v.groups)=0: + prog_count += 1 + task.set_slices(prog_count) + + if tangent_layer_index>=0: + subtask = task.next_slice("Computing tangents") + self.split_vertices(self.find_uv_group, subtask, tangent_layer_index) + subtask = task.next_slice(self.tangent_uvtex) + self.compute_tangents(tangent_layer_index, subtask) # Split by the remaining UV layers for i, u in enumerate(self.uv_layers): - if i==tbn_layer_index: + if i==tangent_layer_index: continue - progress.push_task_slice(u.name, prog_step, prog_count) - self.split_vertices(self.find_uv_group, progress, i) - progress.pop_task() - prog_step += 1 + subtask = task.next_slice(u.name) + self.split_vertices(self.find_uv_group, subtask, i) - # 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) - def split_vertices(self, find_group_func, progress, *args): + def prepare_colors(self, task): + if not self.colors: + return + + self.split_vertices(self.find_color_group, task) + + for v in self.vertices: + if v.faces: + f = v.faces[0] + v.color = self.colors.colors[f.get_loop_index(v)] + else: + v.color = (1.0, 1.0, 1.0, 1.0) + + def split_vertices(self, find_group_func, task, *args): vertex_count = len(self.vertices) for i in range(vertex_count): v = self.vertices[i] @@ -500,7 +537,7 @@ class Mesh: f.vertices[f.vertices.index(v)] = nv nv.faces.append(f) - progress.set_progress(i/vertex_count) + task.set_progress(i/vertex_count) def find_smooth_group(self, vertex, face): face.flag = True @@ -522,24 +559,37 @@ 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) return group - def compute_normals(self, progress): + def find_color_group(self, vertex, face): + color = self.colors.colors[face.get_loop_index(vertex)] + face.flag = True + + group = [face] + for f in vertex.faces: + if not f.flag and self.colors.colors[f.get_loop_index(vertex)]==color: + f.flag = True + group.append(f) + + return group + + def compute_normals(self, task): 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 @@ -551,16 +601,13 @@ class Mesh: else: v.normal = mathutils.Vector((0, 0, 1)) - progress.set_progress(i/len(self.vertices)) + task.set_progress(i/len(self.vertices)) - def compute_tbn(self, index, progress): - # This function is called at an early stage during UV preparation when - # face UVs are not available yet + def compute_tangents(self, index, task): layer_uvs = self.uv_layers[index].uvs for i, v in enumerate(self.vertices): v.tan = mathutils.Vector() - v.bino = mathutils.Vector() for f in v.faces: vi = f.pivot_vertex(v) uv0 = layer_uvs[f.loop_indices[vi[0]]] @@ -576,20 +623,17 @@ class Mesh: if div: mul = edge1.angle(edge2)/div v.tan += (edge1*dv2-edge2*dv1)*mul - v.bino += (edge2*du1-edge1*du2)*mul if v.tan.length: v.tan.normalize() - if v.bino.length: - v.bino.normalize() - progress.set_progress(i/len(self.vertices)) + task.set_progress(i/len(self.vertices)) - def prepare_sequence(self, progress): - progress.push_task("Reordering faces", 0.0, 0.5) - self.reorder_faces(progress) + def prepare_sequence(self, task): + subtask = task.task("Reordering faces", 0.5) + self.reorder_faces(subtask) - progress.set_task("Building sequence", 0.5, 1.0) + subtask = task.task("Building sequence", 1.0) sequence = None for i, f in enumerate(self.faces): if sequence: @@ -616,13 +660,11 @@ class Mesh: sequence = f.vertices[:] self.vertex_sequence.append(sequence) - progress.set_progress(i/len(self.faces)) - - progress.pop_task() + subtask.set_progress(i/len(self.faces)) self.reorder_vertices() - def reorder_faces(self, progress): + def reorder_faces(self, task): # Tom Forsyth's vertex cache optimization algorithm # http://eelpi.gotdns.org/papers/fast_vert_cache_opt.html @@ -640,7 +682,8 @@ class Mesh: # 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) + if vi[1]: + vi[0] = valence_boost_scale*(vi[1]**valence_boost_power) face = None reordered_faces = [] @@ -698,7 +741,7 @@ class Mesh: del cached_vertices[max_cache_size:] n_processed += 1 - progress.set_progress(n_processed/len(self.faces)) + task.set_progress(n_processed/len(self.faces)) self.faces = reordered_faces for i, f in enumerate(self.faces): @@ -715,30 +758,22 @@ class Mesh: v.index = len(reordered_vertices) reordered_vertices.append(v) + for v in self.vertices: + if v.index<0: + v.index = len(reordered_vertices) + reordered_vertices.append(v) + self.vertices = reordered_vertices 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): +def create_mesh_from_object(ctx, obj): if obj.type!="MESH": - raise Exception("Object is not a mesh") + raise Exception("Object {} is not a mesh".format(obj.name)) - progress.push_task("Preparing mesh", 0.0, 0.2) + task = ctx.task("Collecting mesh data", 0.2) objs = [(obj, mathutils.Matrix())] i = 0 @@ -749,47 +784,47 @@ def create_mesh_from_object(context, obj, progress): if c.type=="MESH" and c.compound: objs.append((c, m*c.matrix_local)) + dg = ctx.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 bmesh.smoothing = o.data.smoothing bmesh.use_lines = o.data.use_lines bmesh.vertex_groups = o.data.vertex_groups bmesh.max_groups_per_vertex = o.data.max_groups_per_vertex bmesh.use_uv = o.data.use_uv - bmesh.tbn_vecs = o.data.tbn_vecs - bmesh.tbn_uvtex = o.data.tbn_uvtex + bmesh.tangent_vecs = o.data.tangent_vecs + bmesh.tangent_uvtex = o.data.tangent_uvtex 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("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.5, 0.6) + mesh.name = obj.data.name + + task = ctx.task("Triangulating", 0.3) + mesh.prepare_triangles(task) + task = ctx.task("Smoothing", 0.5) + mesh.prepare_smoothing(task) + task = ctx.task("Vertex groups", 0.6) mesh.prepare_vertex_groups(obj) - 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) - - # 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() + task = ctx.task("Preparing UVs", 0.75) + mesh.prepare_uv(task) + task = ctx.task("Preparing vertex colors", 0.85) + mesh.prepare_colors(task) + task = ctx.task("Render sequence", 1.0) + mesh.prepare_sequence(task) return mesh