Data field 0 overrunning bounds of UI_MATERIAL_ANIMATION_LENGTHS bugfix

addons/io_scene_swbf_msh/__init__.py

@@ -64,6 +64,7 @@ from .msh_skeleton_properties import *
 from .msh_collision_prim_properties import *
 from .msh_material_operators import *
 from .msh_scene_to_blend import *
+from .msh_anim_to_blend import *
 from .zaa_to_blend import *
 
 

addons/io_scene_swbf_msh/msh_anim_to_blend.py

@@ -0,0 +1,106 @@
+""" Gathers the Blender objects from the current scene and returns them as a list of
+    Model objects. """
+
+import bpy
+import bmesh
+import math
+
+from enum import Enum
+from typing import List, Set, Dict, Tuple
+
+from .msh_scene import Scene
+from .msh_material_to_blend import *
+from .msh_model import *
+from .msh_skeleton_utilities import *
+from .msh_skeleton_to_blend import *
+from .msh_model_gather import get_is_model_hidden
+from .msh_mesh_to_blend import model_to_mesh_object
+
+
+from .crc import *
+
+import os
+
+
+# Extracts and applies anims in the scene to the currently selected armature
+def extract_and_apply_anim(filename : str, scene : Scene):
+
+    arma = bpy.context.view_layer.objects.active
+
+    if not arma or arma.type != 'ARMATURE':
+        raise Exception("Select an armature to attach the imported animation to!")
+
+    if scene.animation is None:
+        raise Exception("No animation found in msh file!")
+    
+    else:
+        head, tail = os.path.split(filename)
+        anim_name = tail.split(".")[0]
+
+        if anim_name in bpy.data.actions:
+            bpy.data.actions.remove(bpy.data.actions[anim_name], do_unlink=True)
+
+        action = bpy.data.actions.new(anim_name)
+        action.use_fake_user = True
+
+        if not arma.animation_data:
+            arma.animation_data_create()
+
+
+        # Record the starting transforms of each bone.  Pose space is relative 
+        # to bones starting transforms.  Starting = in edit mode
+        bone_bind_poses = {}
+
+        bpy.context.view_layer.objects.active = arma
+        bpy.ops.object.mode_set(mode='EDIT')
+
+        for edit_bone in arma.data.edit_bones:
+            if edit_bone.parent:
+                bone_local = edit_bone.parent.matrix.inverted() @ edit_bone.matrix 
+            else:
+                bone_local = arma.matrix_local @ edit_bone.matrix
+
+            bone_bind_poses[edit_bone.name] = bone_local.inverted()
+
+        bpy.ops.object.mode_set(mode='OBJECT')
+
+
+        for bone in arma.pose.bones:
+            if to_crc(bone.name) in scene.animation.bone_frames:
+
+                bind_mat = bone_bind_poses[bone.name]
+
+                translation_frames, rotation_frames = scene.animation.bone_frames[to_crc(bone.name)]
+
+                loc_data_path = "pose.bones[\"{}\"].location".format(bone.name) 
+                rot_data_path = "pose.bones[\"{}\"].rotation_quaternion".format(bone.name) 
+
+
+                fcurve_rot_w = action.fcurves.new(rot_data_path, index=0, action_group=bone.name)
+                fcurve_rot_x = action.fcurves.new(rot_data_path, index=1, action_group=bone.name)
+                fcurve_rot_y = action.fcurves.new(rot_data_path, index=2, action_group=bone.name)
+                fcurve_rot_z = action.fcurves.new(rot_data_path, index=3, action_group=bone.name)
+
+                for frame in rotation_frames:
+                    i = frame.index
+                    q = (bind_mat @ convert_rotation_space(frame.rotation).to_matrix().to_4x4()).to_quaternion()
+
+                    fcurve_rot_w.keyframe_points.insert(i,q.w)
+                    fcurve_rot_x.keyframe_points.insert(i,q.x)
+                    fcurve_rot_y.keyframe_points.insert(i,q.y)
+                    fcurve_rot_z.keyframe_points.insert(i,q.z)
+
+                fcurve_loc_x = action.fcurves.new(loc_data_path, index=0, action_group=bone.name)
+                fcurve_loc_y = action.fcurves.new(loc_data_path, index=1, action_group=bone.name)
+                fcurve_loc_z = action.fcurves.new(loc_data_path, index=2, action_group=bone.name)
+
+                for frame in translation_frames:
+                    i = frame.index
+                    t = (bind_mat @ Matrix.Translation(convert_vector_space(frame.translation))).translation
+
+                    fcurve_loc_x.keyframe_points.insert(i,t.x)
+                    fcurve_loc_y.keyframe_points.insert(i,t.y)
+                    fcurve_loc_z.keyframe_points.insert(i,t.z)
+
+        arma.animation_data.action = action
+

addons/io_scene_swbf_msh/msh_material_operators.py

@@ -107,45 +107,119 @@ to provide an exact emulation"""
 
     def execute(self, context):
 
-        material = bpy.data.materials[self.material_name]
+        material = bpy.data.materials.get(self.material_name, None)
 
-        if material and material.swbf_msh_mat:
+        if not material or not material.swbf_msh_mat:
+            return {'CANCELLED'}
 
-            mat_props = material.swbf_msh_mat
+        mat_props = material.swbf_msh_mat
 
-            diffuse_texture_path = mat_props.diffuse_map
-            if diffuse_texture_path and os.path.exists(diffuse_texture_path):
-               
-                material.use_nodes = True
-                material.node_tree.nodes.clear()
 
-                bsdf = material.node_tree.nodes.new("ShaderNodeBsdfPrincipled")
-                
-                texImage = material.node_tree.nodes.new('ShaderNodeTexImage')
-                texImage.image = bpy.data.images.load(diffuse_texture_path)
-                texImage.image.alpha_mode = 'CHANNEL_PACKED'
-                material.node_tree.links.new(bsdf.inputs['Base Color'], texImage.outputs['Color']) 
+        texture_input_nodes = []
+        surface_output_nodes = []
 
-                bsdf.inputs["Roughness"].default_value = 1.0
-                bsdf.inputs["Specular"].default_value = 0.0
 
-                if mat_props.hardedged_transparency:
-                    material.blend_method = "CLIP"
-                    material.node_tree.links.new(bsdf.inputs['Alpha'], texImage.outputs['Alpha']) 
+        diffuse_texture_path = mat_props.diffuse_map
+        if diffuse_texture_path and os.path.exists(diffuse_texture_path):
 
-                material.use_backface_culling = not bool(mat_props.doublesided)
+            material.use_nodes = True
+            material.node_tree.nodes.clear()
 
-                output = material.node_tree.nodes.new("ShaderNodeOutputMaterial")
-                material.node_tree.links.new(output.inputs['Surface'], bsdf.outputs['BSDF']) 
+            bsdf = material.node_tree.nodes.new("ShaderNodeBsdfPrincipled")
 
+
+            texImage = material.node_tree.nodes.new('ShaderNodeTexImage')
+            texImage.image = bpy.data.images.load(diffuse_texture_path)
+            texImage.image.alpha_mode = 'CHANNEL_PACKED'
+            material.node_tree.links.new(bsdf.inputs['Base Color'], texImage.outputs['Color']) 
+
+            texture_input_nodes.append(texImage)
+
+            bsdf.inputs["Roughness"].default_value = 1.0
+            bsdf.inputs["Specular"].default_value = 0.0
+
+            if mat_props.hardedged_transparency and not mat_props.glow:
+                material.blend_method = "CLIP"
+                material.node_tree.links.new(bsdf.inputs['Alpha'], texImage.outputs['Alpha']) 
+
+            material.use_backface_culling = not bool(mat_props.doublesided)
+
+            surface_output_nodes.append(tuple(('BSDF', bsdf)))
+
+
+            if mat_props.glow:
+
+                emission = material.node_tree.nodes.new("ShaderNodeEmission")
+                material.node_tree.links.new(emission.inputs['Color'], texImage.outputs['Color']) 
+
+                emission_strength_multiplier = material.node_tree.nodes.new("ShaderNodeMath")
+                emission_strength_multiplier.operation = 'MULTIPLY'
+                emission_strength_multiplier.inputs[1].default_value = 32.0
+
+                material.node_tree.links.new(emission_strength_multiplier.inputs[0], texImage.outputs['Alpha']) 
+
+                material.node_tree.links.new(emission.inputs['Strength'], emission_strength_multiplier.outputs[0])
+
+                surface_output_nodes.append(tuple(("Emission", emission)))
+
+            surfaces_output = None
+            if (len(surface_output_nodes) == 1):
+                surfaces_output = surface_output_nodes[0][1]
             else:
+                mix = material.node_tree.nodes.new("ShaderNodeMixShader")
+                material.node_tree.links.new(mix.inputs[1], surface_output_nodes[0][1].outputs[0])
+                material.node_tree.links.new(mix.inputs[2], surface_output_nodes[1][1].outputs[0])
 
-                # Todo: figure out some way to raise an error but continue operator execution...
-                if self.fail_silently:
-                    return {'CANCELLED'}
-                else:
-                    raise RuntimeError(f"Diffuse texture at path: '{diffuse_texture_path}' was not found.")
+                surfaces_output = mix
 
 
+            output = material.node_tree.nodes.new("ShaderNodeOutputMaterial")
+            material.node_tree.links.new(output.inputs['Surface'], surfaces_output.outputs[0]) 
+
+
+            # Clear all anims in all cases
+            if material.node_tree.animation_data:
+                material.node_tree.animation_data.action.fcurves.clear()
+
+
+            if "SCROLL" in mat_props.rendertype:
+                uv_input = material.node_tree.nodes.new("ShaderNodeUVMap")
+
+                vector_add = material.node_tree.nodes.new("ShaderNodeVectorMath")
+
+                # Add keyframes
+                scroll_per_sec_divisor = 255.0 
+                frame_step = 60.0
+                fps = bpy.context.scene.render.fps
+                for i in range(2):
+                    vector_add.inputs[1].default_value[0] = i * mat_props.scroll_speed_u * frame_step / scroll_per_sec_divisor              
+                    vector_add.inputs[1].keyframe_insert("default_value", index=0, frame=i * frame_step * fps)
+
+                    vector_add.inputs[1].default_value[1] = i * mat_props.scroll_speed_v * frame_step / scroll_per_sec_divisor               
+                    vector_add.inputs[1].keyframe_insert("default_value", index=1, frame=i * frame_step * fps)
+
+
+                material.node_tree.links.new(vector_add.inputs[0], uv_input.outputs[0])
+
+                for texture_node in texture_input_nodes:
+                    material.node_tree.links.new(texture_node.inputs["Vector"], vector_add.outputs[0])
+
+            # Don't know how to set interpolation when adding keyframes
+            # so we must do it after the fact
+            if material.node_tree.animation_data:
+                for fcurve in material.node_tree.animation_data.action.fcurves:
+                    for kf in fcurve.keyframe_points.values():
+                        kf.interpolation = 'LINEAR'
+
+        '''
+        else:
+
+            # Todo: figure out some way to raise an error but continue operator execution...
+            if self.fail_silently:
+                return {'CANCELLED'}
+            else:
+                raise RuntimeError(f"Diffuse texture at path: '{diffuse_texture_path}' was not found.")
+        '''
+
         return {'FINISHED'}
 

addons/io_scene_swbf_msh/msh_material_to_blend.py

@@ -2,10 +2,9 @@
 
 import bpy
 from typing import Dict
-from .msh_material import *
-from .msh_material_gather import *
+
 from .msh_material_properties import *
-from .msh_material_operators import *
+from .msh_material import *
 
 from .msh_material_utilities import _REVERSE_RENDERTYPES_MAPPING
 
@@ -15,6 +14,8 @@ import os
 
 
 
+
+
 def find_texture_path(folder_path : str, name : str) -> str:
 
     if not folder_path or not name:
@@ -105,7 +106,7 @@ def _fill_material_props_data(material, material_properties):
     anim_length_index = int(sqrt(material.data[0]))
     if anim_length_index < 0:
         anim_length_index = 0
-    elif anim_length_index > len(UI_MATERIAL_ANIMATION_LENGTHS):
+    elif anim_length_index >= len(UI_MATERIAL_ANIMATION_LENGTHS):
         anim_length_index = len(UI_MATERIAL_ANIMATION_LENGTHS) - 1
 
     material_properties.animation_length = UI_MATERIAL_ANIMATION_LENGTHS[anim_length_index][0]

addons/io_scene_swbf_msh/msh_material_utilities.py

@@ -18,19 +18,7 @@ _RENDERTYPES_MAPPING = {
     "NORMALMAPPED_TILED_ENVMAPPED_BF2": Rendertype.NORMALMAPPED_TILED_ENVMAP}
 
 
-_REVERSE_RENDERTYPES_MAPPING = {
-    Rendertype.NORMAL : "NORMAL_BF2",
-    Rendertype.SCROLLING : "SCROLLING_BF2",
-    Rendertype.ENVMAPPED : "ENVMAPPED_BF2",
-    Rendertype.ANIMATED : "ANIMATED_BF2",
-    Rendertype.REFRACTION : "REFRACTION_BF2",
-    Rendertype.BLINK : "BLINK_BF2",
-    Rendertype.NORMALMAPPED_TILED : "NORMALMAPPED_TILED_BF2",
-    Rendertype.NORMALMAPPED_ENVMAPPED : "NORMALMAPPED_ENVMAPPED_BF2",
-    Rendertype.NORMALMAPPED : "NORMALMAPPED_BF2",
-    Rendertype.NORMALMAPPED_TILED_ENVMAP : "NORMALMAPPED_TILED_ENVMAPPED_BF2"}
-
-
+_REVERSE_RENDERTYPES_MAPPING = {val: key for (key, val) in _RENDERTYPES_MAPPING.items()}
 
 
 def remove_unused_materials(materials: Dict[str, Material], 

addons/io_scene_swbf_msh/msh_model_gather.py

@@ -30,6 +30,7 @@ def gather_models(apply_modifiers: bool, export_target: str, skeleton_only: bool
     # Pure bones are just bones and after all objects are explored the only
     # entries remaining in this dict will be bones without geometry.  
     pure_bones_from_armature = {}
+    armature_found = None
 
     objects_to_export = select_objects(export_target)
 

addons/io_scene_swbf_msh/msh_scene_to_blend.py

@@ -23,92 +23,6 @@ import os
 
 
 
-# Extracts and applies anims in the scene to the currently selected armature
-def extract_and_apply_anim(filename : str, scene : Scene):
-
-    arma = bpy.context.view_layer.objects.active
-
-    if not arma or arma.type != 'ARMATURE':
-        raise Exception("Select an armature to attach the imported animation to!")
-
-    if scene.animation is None:
-        raise Exception("No animation found in msh file!")
-    
-    else:
-        head, tail = os.path.split(filename)
-        anim_name = tail.split(".")[0]
-
-        if anim_name in bpy.data.actions:
-            bpy.data.actions.remove(bpy.data.actions[anim_name], do_unlink=True)
-
-        action = bpy.data.actions.new(anim_name)
-        action.use_fake_user = True
-
-        if not arma.animation_data:
-            arma.animation_data_create()
-
-
-        # Record the starting transforms of each bone.  Pose space is relative 
-        # to bones starting transforms.  Starting = in edit mode
-        bone_bind_poses = {}
-
-        bpy.context.view_layer.objects.active = arma
-        bpy.ops.object.mode_set(mode='EDIT')
-
-        for edit_bone in arma.data.edit_bones:
-            if edit_bone.parent:
-                bone_local = edit_bone.parent.matrix.inverted() @ edit_bone.matrix 
-            else:
-                bone_local = arma.matrix_local @ edit_bone.matrix
-
-            bone_bind_poses[edit_bone.name] = bone_local.inverted()
-
-        bpy.ops.object.mode_set(mode='OBJECT')
-
-
-        for bone in arma.pose.bones:
-            if to_crc(bone.name) in scene.animation.bone_frames:
-
-                bind_mat = bone_bind_poses[bone.name]
-
-                translation_frames, rotation_frames = scene.animation.bone_frames[to_crc(bone.name)]
-
-                loc_data_path = "pose.bones[\"{}\"].location".format(bone.name) 
-                rot_data_path = "pose.bones[\"{}\"].rotation_quaternion".format(bone.name) 
-
-
-                fcurve_rot_w = action.fcurves.new(rot_data_path, index=0, action_group=bone.name)
-                fcurve_rot_x = action.fcurves.new(rot_data_path, index=1, action_group=bone.name)
-                fcurve_rot_y = action.fcurves.new(rot_data_path, index=2, action_group=bone.name)
-                fcurve_rot_z = action.fcurves.new(rot_data_path, index=3, action_group=bone.name)
-
-                for frame in rotation_frames:
-                    i = frame.index
-                    q = (bind_mat @ convert_rotation_space(frame.rotation).to_matrix().to_4x4()).to_quaternion()
-
-                    fcurve_rot_w.keyframe_points.insert(i,q.w)
-                    fcurve_rot_x.keyframe_points.insert(i,q.x)
-                    fcurve_rot_y.keyframe_points.insert(i,q.y)
-                    fcurve_rot_z.keyframe_points.insert(i,q.z)
-
-                fcurve_loc_x = action.fcurves.new(loc_data_path, index=0, action_group=bone.name)
-                fcurve_loc_y = action.fcurves.new(loc_data_path, index=1, action_group=bone.name)
-                fcurve_loc_z = action.fcurves.new(loc_data_path, index=2, action_group=bone.name)
-
-                for frame in translation_frames:
-                    i = frame.index
-                    t = (bind_mat @ Matrix.Translation(convert_vector_space(frame.translation))).translation
-
-                    fcurve_loc_x.keyframe_points.insert(i,t.x)
-                    fcurve_loc_y.keyframe_points.insert(i,t.y)
-                    fcurve_loc_z.keyframe_points.insert(i,t.z)
-
-        arma.animation_data.action = action
-
-
-
-
-
 # Create the msh hierachy.  Armatures are not created here.
 def extract_models(scene: Scene, materials_map : Dict[str, bpy.types.Material]) -> Dict[str, bpy.types.Object]: