X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=blender%2Fio_mspgl%2Fmesh.py;h=e4db4afb2a2abae7262564828aa9cc821422961d;hb=HEAD;hp=fadbcee9a18e7ac1e397559c63eddb68504a2218;hpb=d9fbb830ddf5c9b69a046a641b16d6ae25d216b1;p=libs%2Fgl.git diff --git a/blender/io_mspgl/mesh.py b/blender/io_mspgl/mesh.py index fadbcee9..e4db4afb 100644 --- a/blender/io_mspgl/mesh.py +++ b/blender/io_mspgl/mesh.py @@ -66,8 +66,11 @@ class Vertex: class VertexGroup: - def __init__(self, group): - if group: + 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: @@ -75,6 +78,13 @@ class VertexGroup: self.weight = 0.0 +class Batch: + def __init__(self, pt): + self.primitive_type = pt + self.patch_size = 0 + self.vertices = [] + + class Face: def __init__(self, face): self.index = face.index @@ -85,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): @@ -154,11 +165,12 @@ 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.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 @@ -176,6 +188,19 @@ class Mesh: 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 = [] @@ -198,14 +223,14 @@ class Mesh: self.uv_layers = [] self.colors = None - if mesh.vertex_colors: + 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: + 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] @@ -223,7 +248,7 @@ 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 = [] @@ -234,16 +259,26 @@ class Mesh: 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 + 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.vertex_sequence = [] + self.batches = [] def transform(self, matrix): for v in self.vertices: @@ -258,12 +293,12 @@ class Mesh: # Merge materials and form a lookup from source material indices to the # merged material list - material_atlas = [] + material_lookup = [] for m in other.materials: if m in self.materials: - material_atlas.append(self.materials.index(m)) + material_lookup.append(self.materials.index(m)) else: - material_atlas.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 @@ -294,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_atlas[f.material_index] + f.material_index = material_lookup[f.material_index] offset = len(self.edges) self.edges += other.edges @@ -305,6 +340,9 @@ class Mesh: self.lines += other.lines 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] @@ -412,30 +450,6 @@ class Mesh: for g in v.groups: g.group = group_index_map[g.group] - def apply_material_atlas(self, material_atlas): - for m in self.materials: - if m.name not in material_atlas.material_names: - raise Exception("Material atlas {} is not compatible with Mesh {}".format(material_atlas.name, self.name)) - - if self.use_uv=='NONE': - return - - layer = UvLayer("material_atlas") - 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_atlas.get_material_uv(self.materials[f.material_index]) - for i in f.loop_indices: - layer.uvs[i] = uv - def prepare_uv(self, task): # Form a list of UV layers referenced by materials with the array atlas # property set @@ -510,6 +524,43 @@ class Mesh: 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)