fix vertex colors export

This is a very small change to skip adding the vertex colours to the Blender mesh if no segment of the geometry being loaded has vertex colours.

.gitignore

@@ -1,6 +1,8 @@
 .DS_Store
 *.msh
 
+*.swp
+
 # Created by https://www.gitignore.io/api/python,visualstudiocode
 # Edit at https://www.gitignore.io/?templates=python,visualstudiocode
 

addons/io_scene_swbf_msh/__init__.py

@@ -1,8 +1,8 @@
 bl_info = {
     'name': 'SWBF .msh Import-Export',
     'author': 'Will Snyder, PrismaticFlower',
-    "version": (1, 3, 3),
+    "version": (1, 3, 0),
-    'blender': (4, 3, 2),
+    'blender': (2, 80, 0),
     'location': 'File > Import-Export',
     'description': 'Export as SWBF .msh file',
     'warning': '',

addons/io_scene_swbf_msh/msh_anim_gather.py

@@ -67,7 +67,7 @@ def extract_anim(armature: bpy.types.Armature, root_name: str) -> Animation:
 
     for frame in range(num_frames):
         
-        frame_time = int(framerange.x + frame * increment)
+        frame_time = framerange.x + frame * increment
         bpy.context.scene.frame_set(frame_time)
 
         for keyable_bone in keyable_bones:

addons/io_scene_swbf_msh/msh_anim_to_blend.py

@@ -107,4 +107,4 @@ def extract_and_apply_anim(filename : str, scene : Scene):
 
         arma.animation_data.action = action
         track = arma.animation_data.nla_tracks.new()
-        track.strips.new(action.name, int(action.frame_range[0]), action)
+        track.strips.new(action.name, action.frame_range[0], action)

addons/io_scene_swbf_msh/msh_material_operators.py

@@ -180,10 +180,8 @@ to provide an exact emulation"""
 
             texture_input_nodes.append(texImage)
 
-            specular_key = "Specular" if bpy.app.version < (4, 0, 0) else "Specular IOR Level"
-
             bsdf.inputs["Roughness"].default_value = 1.0
-            bsdf.inputs[specular_key].default_value = 0.0
+            bsdf.inputs["Specular"].default_value = 0.0
 
             material.use_backface_culling = not bool(mat_props.doublesided)
 

addons/io_scene_swbf_msh/msh_mesh_to_blend.py

@@ -32,7 +32,111 @@ def validate_segment_geometry(segment : GeometrySegment):
     return True
 
 
-def model_to_mesh_object(model: Model, scene : Scene, materials_map : Dict[str, bpy.types.Material]) -> bpy.types.Object:
+def get_shadow_geometry(model: Model):
+    for segment in model.geometry:
+        if segment.shadow_geometry is not None:
+            return segment.shadow_geometry
+    return None
+
+
+
+# SHDW mesh info is of a different form from
+# normal segment geometry
+def model_to_shadow_mesh(model: Model, shadow_geometry : ShadowGeometry):
+
+    blender_mesh = bpy.data.meshes.new(model.name)
+
+    # As is the case with normal geometry processing,
+    # these will contain flattened lists
+    vertex_positions = [convert_vector_space(position) for position in shadow_geometry.positions]
+    
+    # Vertices
+    blender_mesh.vertices.add(len(vertex_positions))
+    blender_mesh.vertices.foreach_set("co", [component for vertex_position in vertex_positions for component in vertex_position])
+
+
+    def faces_from_half_edges(half_edges : List[Tuple[int,int,int,int]]) -> List[List[int]]:
+        faces = []
+        visited_edges = [False] * len(half_edges)
+        
+        for i in range(len(half_edges)):
+
+            if visited_edges[i]:
+                continue
+
+            curr_edge = half_edges[i]
+
+            curr_index = curr_edge[0]
+            starting_index = curr_index
+
+            face_length = 0
+            face_temp = [0] * 5
+
+            while True:
+                
+                if face_length + 1> len(face_temp):
+                    face_temp.append(curr_index)
+                else:    
+                    face_temp[face_length] = curr_index
+
+                face_length += 1
+
+                curr_edge = half_edges[curr_edge[1]]
+                curr_index = curr_edge[0]
+                
+                if (curr_index == starting_index):
+                    break
+
+            #print(f"Added a face of length: {face_length}")
+            faces.append(face_temp[0:face_length])
+
+        return faces
+
+    polygons = faces_from_half_edges(shadow_geometry.edges)
+
+    # LOOPS 
+    flat_indices = [index for polygon in polygons for index in polygon]
+    blender_mesh.loops.add(len(flat_indices))
+
+    # Position indices
+    blender_mesh.loops.foreach_set("vertex_index", flat_indices)
+
+
+
+    # POLYGONS/FACES
+    blender_mesh.polygons.add(len(polygons))
+
+    # Indices of starting loop for each polygon
+    polygon_loop_start_indices = [0] * len(polygons)
+    current_polygon_start_index = 0
+
+    # Number of loops in this polygon.  Polygon i will use
+    # loops from polygon_loop_start_indices[i] to 
+    # polygon_loop_start_indices[i] + polygon_loop_totals[i]
+    polygon_loop_totals = [0] * len(polygons)
+
+    for i,polygon in enumerate(polygons):
+        polygon_loop_start_indices[i] = current_polygon_start_index
+
+        current_polygon_length = len(polygon)
+        current_polygon_start_index += current_polygon_length
+
+        polygon_loop_totals[i] = current_polygon_length
+
+    blender_mesh.polygons.foreach_set("loop_start", polygon_loop_start_indices)
+    blender_mesh.polygons.foreach_set("loop_total", polygon_loop_totals)
+
+    blender_mesh.validate(clean_customdata=False) 
+    blender_mesh.update()
+
+    #sv_name = model.name if model.name.startswith("sv_") else "sv_" + model.name
+
+    blender_mesh_object = bpy.data.objects.new(model.name, blender_mesh)
+
+    return blender_mesh_object
+
+
+def model_to_mesh(model: Model, scene: Scene, materials_map : Dict[str, bpy.types.Material]) -> bpy.types.Object:
 
     blender_mesh = bpy.data.meshes.new(model.name)
 
@@ -128,6 +232,7 @@ def model_to_mesh_object(model: Model, scene : Scene, materials_map : Dict[str,
         blender_mesh.loops.foreach_set("vertex_index", flat_indices)
 
         # Normals
+        blender_mesh.create_normals_split()
         blender_mesh.loops.foreach_set("normal", [component for i in flat_indices for component in vertex_normals[i]])
 
         # UVs
@@ -141,25 +246,24 @@ def model_to_mesh_object(model: Model, scene : Scene, materials_map : Dict[str,
 
 
         # POLYGONS/FACES
-
         blender_mesh.polygons.add(len(polygons))
 
         # Indices of starting loop for each polygon
-        polygon_loop_start_indices = []
+        polygon_loop_start_indices = [0] * len(polygons)
         current_polygon_start_index = 0
 
         # Number of loops in this polygon.  Polygon i will use
         # loops from polygon_loop_start_indices[i] to 
         # polygon_loop_start_indices[i] + polygon_loop_totals[i]
-        polygon_loop_totals = []
+        polygon_loop_totals = [0] * len(polygons)
 
-        for polygon in polygons:
+        for i,polygon in enumerate(polygons):
-            polygon_loop_start_indices.append(current_polygon_start_index)
+            polygon_loop_start_indices[i] = current_polygon_start_index
 
             current_polygon_length = len(polygon)
             current_polygon_start_index += current_polygon_length
 
-            polygon_loop_totals.append(current_polygon_length)
+            polygon_loop_totals[i] = current_polygon_length
 
         blender_mesh.polygons.foreach_set("loop_start", polygon_loop_start_indices)
         blender_mesh.polygons.foreach_set("loop_total", polygon_loop_totals)
@@ -174,6 +278,7 @@ def model_to_mesh_object(model: Model, scene : Scene, materials_map : Dict[str,
         reset_normals = [0.0] * (len(blender_mesh.loops) * 3)
         blender_mesh.loops.foreach_get("normal", reset_normals)
         blender_mesh.normals_split_custom_set(tuple(zip(*(iter(reset_normals),) * 3)))
+        blender_mesh.use_auto_smooth = True
 
 
     blender_mesh_object = bpy.data.objects.new(model.name, blender_mesh)
@@ -196,3 +301,17 @@ def model_to_mesh_object(model: Model, scene : Scene, materials_map : Dict[str,
 
 
     return blender_mesh_object
+
+
+
+
+
+def model_to_mesh_object(model: Model, scene : Scene, materials_map : Dict[str, bpy.types.Material]) -> bpy.types.Object:
+    
+    shadow_geometry = get_shadow_geometry(model)
+    if shadow_geometry is not None:
+        return model_to_shadow_mesh(model, shadow_geometry)
+    else:
+        return model_to_mesh(model, scene, materials_map)
+
+

addons/io_scene_swbf_msh/msh_model.py

@@ -39,6 +39,20 @@ class VertexWeight:
     weight: float = 1.0
     bone: int = 0
 
+
+@dataclass 
+class ShadowGeometry:
+    """ Class representing 'SHDW' chunks. """
+
+    # Perhaps I could just use the positions list in the segment
+    # class, but I don't know if SHDW info can coexist with 
+    # a normal geometry segment...
+    positions: List[Vector] = field(default_factory=list)
+   
+    # The second two entries may not be necessary...
+    edges: List[Tuple[int,int,int,int]] = field(default_factory=list)
+
+
 @dataclass
 class GeometrySegment:
     """ Class representing a 'SEGM' section in a .msh file. """
@@ -56,6 +70,7 @@ class GeometrySegment:
     triangles: List[List[int]] = field(default_factory=list)
     triangle_strips: List[List[int]] = None
 
+    shadow_geometry: ShadowGeometry = None
 
 @dataclass
 class CollisionPrimitive:

addons/io_scene_swbf_msh/msh_model_gather.py

@@ -215,10 +215,9 @@ def create_mesh_geometry(mesh: bpy.types.Mesh, valid_vgroup_indices: Set[int]) -
                 yield mesh.uv_layers.active.data[loop_index].uv.y
 
             if segment.colors is not None:
-                active_color = mesh.color_attributes.active_color
+                data_type = mesh.color_attributes.active_color.data_type
-                data_index = loop_index if active_color.domain == "CORNER" else vertex_index
+                if data_type == "FLOAT_COLOR" or data_type == "BYTE_COLOR":
-
+                    for v in mesh.color_attributes.active_color.data[vertex_index].color:
-                for v in mesh.color_attributes.active_color.data[data_index].color:
                         yield v
 
             if segment.weights is not None:
@@ -248,10 +247,9 @@ def create_mesh_geometry(mesh: bpy.types.Mesh, valid_vgroup_indices: Set[int]) -
             segment.texcoords.append(mesh.uv_layers.active.data[loop_index].uv.copy())
 
         if segment.colors is not None:
-            active_color = mesh.color_attributes.active_color
+            data_type = mesh.color_attributes.active_color.data_type
-            data_index = loop_index if active_color.domain == "CORNER" else vertex_index
+            if data_type == "FLOAT_COLOR" or data_type == "BYTE_COLOR":
-
+                segment.colors.append(list(mesh.color_attributes.active_color.data[vertex_index].color))
-            segment.colors.append(list(active_color.data[data_index].color))
 
         if segment.weights is not None:
             groups = mesh.vertices[vertex_index].groups

addons/io_scene_swbf_msh/msh_scene_read.py

@@ -388,6 +388,28 @@ def _read_segm(segm: Reader, materials_list: List[Material]) -> GeometrySegment:
             #if segm.read_u16 != 0: 
             #    segm.skip_bytes(-2)
        
+        elif next_header == "SHDW":
+            
+            shadow_geometry = ShadowGeometry()
+
+            with segm.read_child() as shdw:
+                #print("Found shadow chunk")
+
+                num_positions = shdw.read_u32()
+                #print(f"  Num verts in shadow mesh: {num_positions}")
+                shadow_geometry.positions = [shdw.read_vec() for _ in range(num_positions)]
+
+                num_edges = shdw.read_u32()
+                #print(f" Num edges in shadow mesh: {num_edges}")
+                edges = []
+                for i in range(num_edges):
+                    edges.append(tuple(shdw.read_u16(4)))
+                    #print("    " + str(edges[-1]))
+                shadow_geometry.edges = edges
+
+            geometry_seg.shadow_geometry = shadow_geometry    
+
+                
         elif next_header == "WGHT":
             with segm.read_child() as wght:
                 

addons/io_scene_swbf_msh/msh_scene_to_blend.py

@@ -44,10 +44,9 @@ def extract_models(scene: Scene, materials_map : Dict[str, bpy.types.Material])
             new_obj = bpy.data.objects.new(model.name, None)
             new_obj.empty_display_size = 1
             new_obj.empty_display_type = 'PLAIN_AXES' 
-
+            new_obj.name = model.name
 
         model_map[model.name] = new_obj
-        new_obj.name = model.name
 
         if model.parent:
             new_obj.parent = model_map[model.parent]