X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=blender%2Fio_mspgl%2Fmesh.py;h=91648d28e5b28b1ab6db369586b46d974b0c332e;hb=HEAD;hp=f5665256b2eeced61c654abc329d4849e45d82cf;hpb=9ab994ab4fedf938cbbdfe1ec1415e6c91844d21;p=libs%2Fgl.git diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py index f5665256..e4db4afb 100644 --- a/blender/io_mspgl/mesh.py +++ b/blender/io_mspgl/mesh.py @@ -1,4 +1,3 @@ -import bpy import math import mathutils import itertools @@ -48,14 +47,13 @@ class Vertex: if vertex.__class__==Vertex: self.uvs = vertex.uvs[:] self.tan = vertex.tan - self.bino = vertex.bino else: self.uvs = [] self.tan = None - self.bino = None self.index = vertex.index self.co = mathutils.Vector(vertex.co) self.normal = mathutils.Vector(vertex.normal) + self.color = None self.flag = False self.edges = [] self.faces = [] @@ -68,9 +66,23 @@ class Vertex: class VertexGroup: - def __init__(self, group): - self.group = group.group - self.weight = group.weight + def __init__(self, *args): + if len(args)==2: + self.group = args[0] + self.weight = args[1] + elif len(args)==1 and args[0]: + self.group = group.group + self.weight = group.weight + else: + self.group = 0 + self.weight = 0.0 + + +class Batch: + def __init__(self, pt): + self.primitive_type = pt + self.patch_size = 0 + self.vertices = [] class Face: @@ -83,6 +95,7 @@ class Face: self.normal = face.normal self.use_smooth = face.use_smooth self.material_index = face.material_index + self.splat_mask = 0 self.flag = False def __cmp__(self, other): @@ -142,21 +155,29 @@ class UvLayer: self.hidden = True +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.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.tangent_uvtex = mesh.tangent_uvtex + self.use_strips = mesh.use_strips + self.use_patches = mesh.use_patches + self.use_lines = mesh.use_lines 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] @@ -165,12 +186,26 @@ class Mesh: 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 + + # Check some material properties + from .material import Material + has_normal_maps = False + splat_material = None + for m in self.materials: + mat = Material(m) + for p in itertools.chain(mat.properties, *(s.properties for s in mat.sub_materials)): + if p.tex_keyword=="normal_map" and p.texture: + has_normal_maps = True + break + if mat.type=="splat": + splat_material = mat # Clone only the desired 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 = [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] @@ -182,17 +217,21 @@ class Mesh: self.uv_layers = sorted(self.uv_layers, key=(lambda u: u.unit)) - if mesh.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 = [] + self.colors = None + if mesh.vertex_colors and not splat_material: + 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") + if len(f.vertices)>4 and not mesh.use.patches: + 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: @@ -209,12 +248,37 @@ class Mesh: v.edges.append(e) # Store loose edges as lines - if mesh.use_lines: + if mesh.use_lines and not mesh.use_patches: 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': + self.tangent_vecs = has_normal_maps + + # Collect splat weight sources if needed + self.splat_layers = [] + self.splat_sources = [] + if splat_material: + names = {s.weight_source[0] for s in splat_material.sub_materials} + self.splat_layers = [ColorLayer(l) for l in mesh.vertex_colors if l.name in names] + + layers_by_name = {l.name:l for l in self.splat_layers} + for s in splat_material.sub_materials: + if s.weight_source[0] is None: + self.splat_sources.append((None, None)) + else: + self.splat_sources.append((layers_by_name[s.weight_source[0]], "RGBA".index(s.weight_source[1]))) + + self.vertex_groups = True + self.max_groups_per_vertex = 3 + + self.batches = [] def transform(self, matrix): for v in self.vertices: @@ -222,19 +286,19 @@ class Mesh: 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 @@ -242,6 +306,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:]: @@ -256,7 +329,7 @@ class Mesh: f.index += offset 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 @@ -266,7 +339,10 @@ class Mesh: self.lines += other.lines - def prepare_triangles(self, progress): + def prepare_triangles(self, task): + if self.use_patches: + return + face_count = len(self.faces) for i in range(face_count): f = self.faces[i] @@ -326,9 +402,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: @@ -341,16 +417,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) @@ -358,6 +435,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 layers to vertices for v in self.vertices: @@ -453,7 +511,57 @@ class Mesh: 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 prepare_splat_weights(self, task): + if not self.splat_layers: + return + + splat_weights = [] + remainder = None + for s in self.splat_sources: + if s[0] is None: + splat_weights.append(remainder) + else: + index = s[1] + layer_values = [c[index] for c in s[0].colors] + if remainder: + splat_weights.append([v*r for v, r in zip(layer_values, remainder)]) + remainder = [(1-v)*r for v, r in zip(layer_values, remainder)] + else: + splat_weights.append(layer_values) + remainder = [1-v for v in layer_values] + + splat_weights = list(zip(*splat_weights)) + + for f in self.faces: + for i in f.loop_indices: + f.splat_mask |= sum(1<0) + + self.split_vertices(self.find_splat_group, task) + + for v in self.vertices: + if v.faces: + f = v.faces[0] + weights = splat_weights[f.get_loop_index(v)] + v.groups = [VertexGroup(i, w) for i, w in enumerate(weights) if (f.splat_mask>>i)&1] + else: + v.groups = [] + while len(v.groups)