Blender Script FBX Export

2024-09-18 11:14 UTC o1-preview Open in ChatGPT ↗

You

modify this Blender script so that it uses an entire folder of .pkl files and generates an .fbx for each.

import os import bpy import joblib import numpy as np from mathutils import Vector, Matrix from bpy_extras.io_utils import ExportHelper

Set paths

path_code = os.path.dirname(os.path.dirname(os.path.abspath(file))) smpl_model = ‘C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx’ output_folder = ‘C:/Users/Uncharted Limbo/Downloads/‘

SMPL model bone name mapping

part_match_custom_less2 = { ‘root’: ‘root’, ‘bone_00’: ‘Pelvis’, ‘bone_01’: ‘L_Hip’, ‘bone_02’: ‘R_Hip’, ‘bone_03’: ‘Spine1’, ‘bone_04’: ‘L_Knee’, ‘bone_05’: ‘R_Knee’, ‘bone_06’: ‘Spine2’, ‘bone_07’: ‘L_Ankle’, ‘bone_08’: ‘R_Ankle’, ‘bone_09’: ‘Spine3’, ‘bone_10’: ‘L_Foot’, ‘bone_11’: ‘R_Foot’, ‘bone_12’: ‘Neck’, ‘bone_13’: ‘L_Collar’, ‘bone_14’: ‘R_Collar’, ‘bone_15’: ‘Head’, ‘bone_16’: ‘L_Shoulder’, ‘bone_17’: ‘R_Shoulder’, ‘bone_18’: ‘L_Elbow’, ‘bone_19’: ‘R_Elbow’, ‘bone_20’: ‘L_Wrist’, ‘bone_21’: ‘R_Wrist’, ‘bone_22’: ‘L_Hand’, ‘bone_23’: ‘R_Hand’, }

def Rodrigues(rotvec): """Converts a rotation vector to a rotation matrix using Rodrigues’ rotation formula.""" theta = np.linalg.norm(rotvec) r = (rotvec/theta).reshape(3, 1) if theta > 0. else rotvec cost = np.cos(theta) mat = np.asarray([[0, -r[2], r[1]], [r[2], 0, -r[0]], [-r[1], r[0], 0]]) return cost * np.eye(3) + (1 - cost) * r.dot(r.T) + np.sin(theta) * mat

def rodrigues2bshapes(pose): """Converts pose data from rotation vectors to blendshapes.""" rod_rots = pose.reshape(int(pose.shape[0]/3), 3) mat_rots = [Rodrigues(rod_rot) for rod_rot in rod_rots] bshapes = np.concatenate([(mat_rot - np.eye(3)).ravel() for mat_rot in mat_rots[1:]]) return mat_rots, bshapes

def apply_trans_pose_shape(trans, pose, shape, ob, arm_ob, obname, scene, frame=None): """Applies translation, pose, and shape data to the SMPL model in Blender.""" mrots, bsh = rodrigues2bshapes(pose)

arm_ob.pose.bones['m_avg_Pelvis'].location = trans
if frame is not None:
    arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)

for ibone, mrot in enumerate(mrots):
    bone = arm_ob.pose.bones[obname + '_' + part_match_custom_less2['bone_%02d' % ibone]]
    bone.rotation_quaternion = Matrix(mrot).to_quaternion()
    if frame is not None:
        bone.keyframe_insert('rotation_quaternion', frame=frame)

def init_scene(scene): """Initializes the Blender scene by clearing it and importing the SMPL model.""" bpy.ops.object.select_all(action=‘SELECT’) bpy.ops.object.delete()

# Ensure the FBX file exists
if not os.path.exists(smpl_model):
    raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='Z', global_scale=100)

obname = 'm_avg'
ob = bpy.data.objects[obname]
arm_obj = 'Armature'

ob.data.use_auto_smooth = False
ob.data.shape_keys.animation_data_clear()
arm_ob = bpy.data.objects[arm_obj]
arm_ob.animation_data_clear()

return ob, obname, arm_ob

def process_pkl_to_fbx(pkl_file, output_file): """Processes a single PKL file and converts it to an FBX animation.""" # Load PKL data data = joblib.load(pkl_file)

# Initialize Blender scene
scene = bpy.context.scene
ob, obname, arm_ob = init_scene(scene)

# Apply animation data
for character in range(len(data)):
    qtd_frames = len(data[character]['pose'])
    shape = data[character]['betas'].tolist()

    for frame in range(qtd_frames):
        scene.frame_set(frame)
        trans = data[character]['trans_world'][frame]
        pose = data[character]['pose_world'][frame]
        apply_trans_pose_shape(Vector(trans), pose, shape, ob, arm_ob, obname, scene, frame)

# Set the animation end frame
scene.frame_end = qtd_frames - 1

# Export to FBX
bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)

def main(): """Main function to process the PKL file and export to FBX.""" # Example PKL file path pkl_file = ‘C:/Users/Uncharted Limbo/Downloads/wham_output_02.pkl’

# Output FBX file path
output_file = os.path.join(output_folder, 'output_animation_02.fbx')

# Convert PKL to FBX
process_pkl_to_fbx(pkl_file, output_file)

print(f"FBX file saved to: {output_file}")

if name == “main”: main()

ChatGPT

Sure! Here’s the modified script that processes all .pkl files in a specified folder and generates an .fbx file for each one. I’ve updated the main() function to loop through all .pkl files in the input folder and adjusted the code accordingly.

import os
import bpy
import joblib
import numpy as np
from mathutils import Vector, Matrix
from bpy_extras.io_utils import ExportHelper

# Set paths
smpl_model = 'C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx'
output_folder = 'C:/Users/Uncharted Limbo/Downloads/fbx_output'  # Output folder for FBX files
os.makedirs(output_folder, exist_ok=True)

# SMPL model bone name mapping
part_match_custom_less2 = {
    'root': 'root', 'bone_00': 'Pelvis', 'bone_01': 'L_Hip', 'bone_02': 'R_Hip',
    'bone_03': 'Spine1', 'bone_04': 'L_Knee', 'bone_05': 'R_Knee', 'bone_06': 'Spine2',
    'bone_07': 'L_Ankle', 'bone_08': 'R_Ankle', 'bone_09': 'Spine3', 'bone_10': 'L_Foot',
    'bone_11': 'R_Foot', 'bone_12': 'Neck', 'bone_13': 'L_Collar', 'bone_14': 'R_Collar',
    'bone_15': 'Head', 'bone_16': 'L_Shoulder', 'bone_17': 'R_Shoulder', 'bone_18': 'L_Elbow',
    'bone_19': 'R_Elbow', 'bone_20': 'L_Wrist', 'bone_21': 'R_Wrist',
    'bone_22': 'L_Hand', 'bone_23': 'R_Hand',
}

def Rodrigues(rotvec):
    """Converts a rotation vector to a rotation matrix using Rodrigues' rotation formula."""
    theta = np.linalg.norm(rotvec)
    r = (rotvec / theta).reshape(3, 1) if theta > 0. else rotvec
    cost = np.cos(theta)
    mat = np.array([[0, -r[2][0], r[1][0]],
                    [r[2][0], 0, -r[0][0]],
                    [-r[1][0], r[0][0], 0]])
    return cost * np.eye(3) + (1 - cost) * r.dot(r.T) + np.sin(theta) * mat

def rodrigues2bshapes(pose):
    """Converts pose data from rotation vectors to blendshapes."""
    rod_rots = pose.reshape(int(pose.shape[0] / 3), 3)
    mat_rots = [Rodrigues(rod_rot) for rod_rot in rod_rots]
    bshapes = np.concatenate([(mat_rot - np.eye(3)).ravel()
                              for mat_rot in mat_rots[1:]])
    return mat_rots, bshapes

def apply_trans_pose_shape(trans, pose, shape, ob, arm_ob, obname, scene, frame=None):
    """Applies translation, pose, and shape data to the SMPL model in Blender."""
    mrots, bsh = rodrigues2bshapes(pose)

    arm_ob.pose.bones['m_avg_Pelvis'].location = trans
    if frame is not None:
        arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)

    for ibone, mrot in enumerate(mrots):
        bone_name = 'bone_%02d' % ibone
        if bone_name in part_match_custom_less2:
            bone = arm_ob.pose.bones[obname + '_' + part_match_custom_less2[bone_name]]
            bone.rotation_quaternion = Matrix(mrot).to_quaternion()
            if frame is not None:
                bone.keyframe_insert('rotation_quaternion', frame=frame)

def init_scene(scene):
    """Initializes the Blender scene by clearing it and importing the SMPL model."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()

    # Ensure the FBX file exists
    if not os.path.exists(smpl_model):
        raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

    bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='Z', global_scale=100)

    obname = 'm_avg'
    ob = bpy.data.objects[obname]
    arm_obj = 'Armature'

    ob.data.use_auto_smooth = False
    ob.data.shape_keys.animation_data_clear()
    arm_ob = bpy.data.objects[arm_obj]
    arm_ob.animation_data_clear()

    return ob, obname, arm_ob

def process_pkl_to_fbx(pkl_file, output_file):
    """Processes a single PKL file and converts it to an FBX animation."""
    # Load PKL data
    data = joblib.load(pkl_file)

    # Initialize Blender scene
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Apply animation data
    for character in range(len(data)):
        qtd_frames = len(data[character]['pose'])
        shape = data[character]['betas'].tolist()

        for frame in range(qtd_frames):
            scene.frame_set(frame)
            trans = data[character]['trans_world'][frame]
            pose = data[character]['pose_world'][frame]
            apply_trans_pose_shape(Vector(trans), pose, shape, ob, arm_ob, obname, scene, frame)

    # Set the animation end frame
    scene.frame_end = qtd_frames - 1

    # Export to FBX
    bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)

def main():
    """Main function to process all PKL files in a folder and export to FBX."""
    # Input folder containing .pkl files
    input_folder = 'C:/Users/Uncharted Limbo/Downloads/'  # Modify as needed

    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Get list of all .pkl files in the input folder
    pkl_files = [os.path.join(input_folder, f) for f in os.listdir(input_folder) if f.endswith('.pkl')]

    # Process each .pkl file
    for pkl_file in pkl_files:
        # Generate output .fbx file name
        base_name = os.path.basename(pkl_file)
        output_file_name = os.path.splitext(base_name)[0] + '.fbx'
        output_file = os.path.join(output_folder, output_file_name)

        # Convert PKL to FBX
        process_pkl_to_fbx(pkl_file, output_file)

        print(f"FBX file saved to: {output_file}")

if __name__ == "__main__":
    main()

Explanation of Changes:

1. Loop Through .pkl Files:

   • In the main() function, I’ve added code to list all .pkl files in the specified input_folder and loop through them.

2. Generate Output File Names:

   • For each .pkl file, the script generates an output .fbx file name by replacing the .pkl extension with .fbx.

3. Process Each File Individually:

   • The script calls process_pkl_to_fbx() for each .pkl file, which handles the conversion and exports the .fbx file.

4. Ensure Output Folder Exists:

   • The script creates the output_folder if it doesn’t already exist using os.makedirs(output_folder, exist_ok=True).

5. Updated Paths:

   • Adjusted the input_folder and output_folder variables to point to the directories you want to use.

Notes:

• Blender’s Python Environment:

  • This script is intended to be run within Blender’s Python environment, as it uses the bpy module.
  • To execute the script, you can run it from Blender’s scripting panel or use Blender’s command-line interface.

• SMPL Model Path:

  • Ensure that the smpl_model path is correct and points to the SMPL model .fbx file.

• Data Structure Assumptions:

  • The script assumes that each .pkl file contains a list of characters, and each character has pose, betas, trans_world, and pose_world data.

• Error Handling:

  • Basic error handling is included for missing files. You may want to add additional error checking based on your data.

• Performance Considerations:

  • Processing multiple files might take some time depending on the size of the .pkl files and the complexity of the animations.

How to Use the Modified Script:

1. Set the Paths:

   • Modify the input_folder variable to point to the directory containing your .pkl files.
   • Ensure the smpl_model path points to your SMPL model .fbx file.
   • Optionally, change the output_folder if you want the .fbx files saved elsewhere.

2. Run the Script in Blender:

   • Open Blender.
   • Switch to the “Scripting” workspace.
   • Copy and paste the modified script into a new text block.
   • Run the script by clicking the “Run Script” button.

3. Verify the Output:

   • After the script finishes, check the output_folder to find the generated .fbx files.

Example Output:

FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/wham_output_01.fbx
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/wham_output_02.fbx
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/wham_output_03.fbx
...

This modification allows you to efficiently process an entire folder of .pkl files and convert them into .fbx animations using Blender and the SMPL model.

You

each .pkl file is in each own folder.

we need to go through all the folders, find the .pkl inside each and name the fbx with the name of the folder

ChatGPT

Certainly! Based on your requirements, I’ve updated the script to process all subfolders within a specified input directory. The script will:

• Traverse each subfolder in the input directory.
• Find the .pkl file inside each subfolder (assuming there is only one per folder).
• Process the .pkl file and generate an .fbx file.
• Name the output .fbx file after the subfolder name.

Here’s the modified script:

import os
import bpy
import joblib
import numpy as np
from mathutils import Vector, Matrix

# Set paths
smpl_model = 'C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx'
input_folder = 'C:/Users/Uncharted Limbo/Downloads/'  # Input folder containing subfolders with .pkl files
output_folder = 'C:/Users/Uncharted Limbo/Downloads/fbx_output'  # Output folder for FBX files
os.makedirs(output_folder, exist_ok=True)

# SMPL model bone name mapping
part_match_custom_less2 = {
    'root': 'root', 'bone_00': 'Pelvis', 'bone_01': 'L_Hip', 'bone_02': 'R_Hip',
    'bone_03': 'Spine1', 'bone_04': 'L_Knee', 'bone_05': 'R_Knee', 'bone_06': 'Spine2',
    'bone_07': 'L_Ankle', 'bone_08': 'R_Ankle', 'bone_09': 'Spine3', 'bone_10': 'L_Foot',
    'bone_11': 'R_Foot', 'bone_12': 'Neck', 'bone_13': 'L_Collar', 'bone_14': 'R_Collar',
    'bone_15': 'Head', 'bone_16': 'L_Shoulder', 'bone_17': 'R_Shoulder', 'bone_18': 'L_Elbow',
    'bone_19': 'R_Elbow', 'bone_20': 'L_Wrist', 'bone_21': 'R_Wrist',
    'bone_22': 'L_Hand', 'bone_23': 'R_Hand',
}

def Rodrigues(rotvec):
    """Converts a rotation vector to a rotation matrix using Rodrigues' rotation formula."""
    theta = np.linalg.norm(rotvec)
    if theta < 1e-8:
        return np.eye(3)
    r = (rotvec / theta).reshape(3, 1)
    cost = np.cos(theta)
    mat = np.array([[0, -r[2][0], r[1][0]],
                    [r[2][0], 0, -r[0][0]],
                    [-r[1][0], r[0][0], 0]])
    return cost * np.eye(3) + (1 - cost) * r.dot(r.T) + np.sin(theta) * mat

def rodrigues2bshapes(pose):
    """Converts pose data from rotation vectors to blendshapes."""
    rod_rots = pose.reshape(int(pose.shape[0] / 3), 3)
    mat_rots = [Rodrigues(rod_rot) for rod_rot in rod_rots]
    bshapes = np.concatenate([(mat_rot - np.eye(3)).ravel()
                              for mat_rot in mat_rots[1:]])
    return mat_rots, bshapes

def apply_trans_pose_shape(trans, pose, shape, ob, arm_ob, obname, scene, frame=None):
    """Applies translation, pose, and shape data to the SMPL model in Blender."""
    mrots, bsh = rodrigues2bshapes(pose)

    arm_ob.pose.bones['m_avg_Pelvis'].location = trans
    if frame is not None:
        arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)

    for ibone, mrot in enumerate(mrots):
        bone_name = 'bone_%02d' % ibone
        if bone_name in part_match_custom_less2:
            bone = arm_ob.pose.bones[obname + '_' + part_match_custom_less2[bone_name]]
            bone.rotation_quaternion = Matrix(mrot).to_quaternion()
            if frame is not None:
                bone.keyframe_insert('rotation_quaternion', frame=frame)

def init_scene(scene):
    """Initializes the Blender scene by clearing it and importing the SMPL model."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()

    # Ensure the FBX file exists
    if not os.path.exists(smpl_model):
        raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

    bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='Z', global_scale=100)

    obname = 'm_avg'
    ob = bpy.data.objects[obname]
    arm_obj = 'Armature'

    ob.data.use_auto_smooth = False
    ob.data.shape_keys.animation_data_clear()
    arm_ob = bpy.data.objects[arm_obj]
    arm_ob.animation_data_clear()

    return ob, obname, arm_ob

def process_pkl_to_fbx(pkl_file, output_file):
    """Processes a single PKL file and converts it to an FBX animation."""
    # Load PKL data
    data = joblib.load(pkl_file)

    # Initialize Blender scene
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Apply animation data
    for character in range(len(data)):
        qtd_frames = len(data[character]['pose'])
        shape = data[character]['betas'].tolist()

        for frame in range(qtd_frames):
            scene.frame_set(frame)
            trans = data[character]['trans_world'][frame]
            pose = data[character]['pose_world'][frame]
            apply_trans_pose_shape(Vector(trans), pose, shape, ob, arm_ob, obname, scene, frame)

    # Set the animation end frame
    scene.frame_end = qtd_frames - 1

    # Export to FBX
    bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)

def main():
    """Main function to process PKL files in subfolders and export to FBX."""
    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Get list of all subdirectories in the input folder
    subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
               if os.path.isdir(os.path.join(input_folder, d))]

    # Process each subdirectory
    for subdir in subdirs:
        # Find the .pkl file in the subdirectory
        pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]
        if not pkl_files:
            print(f"No .pkl file found in {subdir}, skipping.")
            continue  # No .pkl file in this subdirectory, skip

        # Assume only one .pkl file per subdirectory
        pkl_file = os.path.join(subdir, pkl_files[0])

        # Generate output .fbx file name based on subdirectory name
        folder_name = os.path.basename(subdir)
        output_file_name = folder_name + '.fbx'
        output_file = os.path.join(output_folder, output_file_name)

        # Convert PKL to FBX
        print(f"Processing {pkl_file}...")
        process_pkl_to_fbx(pkl_file, output_file)

        print(f"FBX file saved to: {output_file}")

if __name__ == "__main__":
    main()

---

Explanation of Changes:

1. Traverse Subdirectories:

   • In the main() function, I’ve modified the script to list all subdirectories within the input_folder using os.listdir() and os.path.isdir().
   • It creates a list subdirs containing the paths to all subdirectories.

2. Find .pkl Files in Each Subdirectory:

   • For each subdirectory, the script searches for .pkl files.
   • It assumes there is only one .pkl file per subdirectory. If there are multiple, it picks the first one.
   • If no .pkl file is found in a subdirectory, the script prints a message and skips to the next subdirectory.

3. Name the Output .fbx File After the Folder:

   • The output .fbx file is named after the subdirectory (folder) name.
   • This is done by extracting the base name of the subdirectory using os.path.basename(subdir).

4. Process Each .pkl File Individually:

   • The script calls process_pkl_to_fbx() for each .pkl file found, passing the input and output file paths.

5. Additional Adjustments:

   • Added print statements to inform about the processing status, which is helpful for debugging and tracking progress.
   • Ensured that the output folder is created using os.makedirs(output_folder, exist_ok=True).

---

Notes and Considerations:

• Assumption of One .pkl File per Subdirectory:

  • The script assumes that each subfolder contains exactly one .pkl file.
  • If there are multiple .pkl files in a subdirectory, only the first one (based on the list order) will be processed.

• Data Structure Expectations:

  • The script expects the data structure within the .pkl files to be consistent, containing pose, betas, trans_world, and pose_world for each character.
  • Ensure that your .pkl files match this structure.

• Error Handling:

  • Basic error handling is included for missing .pkl files.
  • If you expect potential data inconsistencies or other issues, consider adding more robust error checking.

• Blender Execution:

  • This script is designed to run within Blender’s Python environment because it uses the bpy module.
  • To run the script, open Blender, go to the Scripting workspace, paste the script into a new text block, and click “Run Script”.
  • Alternatively, you can run the script from the command line using Blender’s --background mode.

• Performance:

  • Processing multiple files and animations can be time-consuming.
  • The processing time will depend on the size and complexity of your animations.

• Adjusting Paths:

  • Make sure to update the smpl_model, input_folder, and output_folder variables to match your directory structure.

---

How to Use the Modified Script:

1. Set the Paths:

   • Modify the smpl_model variable to point to the location of your SMPL model .fbx file.
   • Update input_folder to the directory that contains all the subfolders with the .pkl files.
   • Set output_folder to where you want the generated .fbx files to be saved.

2. Prepare Your Data:

   • Ensure that each .pkl file is placed inside its own subfolder within the input_folder.
   • Confirm that each subfolder contains only one .pkl file.

3. Run the Script in Blender:

   • Open Blender and navigate to the Scripting workspace.
   • Create a new text block and paste the modified script into it.
   • Run the script by clicking the “Run Script” button.

4. Check the Output:

   • After the script completes, check the output_folder for the generated .fbx files.
   • Each .fbx file will be named after the corresponding subfolder.

---

Example Output Messages:

Processing C:/Users/Uncharted Limbo/Downloads/subfolder1/data.pkl...
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/subfolder1.fbx
Processing C:/Users/Uncharted Limbo/Downloads/subfolder2/data.pkl...
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/subfolder2.fbx
No .pkl file found in C:/Users/Uncharted Limbo/Downloads/subfolder3, skipping.
...

This output informs you about the progress of the script, including any subfolders that did not contain a .pkl file.

---

Additional Tips:

• Logging:

  • For large batches, consider adding logging to a file to keep track of the processing status and any errors that may occur.

• Testing:

  • Before running the script on all your data, test it with a few subfolders to ensure it works as expected.

• Error Handling Enhancements:

  • You can enhance the script by adding try-except blocks around critical sections to handle exceptions gracefully.

• Adjusting Animation Parameters:

  • If you need to adjust any animation parameters or Blender settings (like frame rates or export options), you can modify the script accordingly.

---

I hope this updated script meets your requirements! Let me know if you need further assistance or additional modifications.

You

make sure the scene is cleaned after each export

ChatGPT

Certainly! To ensure that the Blender scene is cleaned after each export, I’ll modify the script by adding a function that clears the scene after exporting each .fbx file. This function will be called at the end of process_pkl_to_fbx().

Here’s the updated script with the necessary changes:

import os
import bpy
import joblib
import numpy as np
from mathutils import Vector, Matrix

# Set paths
smpl_model = 'C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx'
input_folder = 'C:/Users/Uncharted Limbo/Downloads/'  # Input folder containing subfolders with .pkl files
output_folder = 'C:/Users/Uncharted Limbo/Downloads/fbx_output'  # Output folder for FBX files
os.makedirs(output_folder, exist_ok=True)

# SMPL model bone name mapping
part_match_custom_less2 = {
    'root': 'root', 'bone_00': 'Pelvis', 'bone_01': 'L_Hip', 'bone_02': 'R_Hip',
    'bone_03': 'Spine1', 'bone_04': 'L_Knee', 'bone_05': 'R_Knee', 'bone_06': 'Spine2',
    'bone_07': 'L_Ankle', 'bone_08': 'R_Ankle', 'bone_09': 'Spine3', 'bone_10': 'L_Foot',
    'bone_11': 'R_Foot', 'bone_12': 'Neck', 'bone_13': 'L_Collar', 'bone_14': 'R_Collar',
    'bone_15': 'Head', 'bone_16': 'L_Shoulder', 'bone_17': 'R_Shoulder', 'bone_18': 'L_Elbow',
    'bone_19': 'R_Elbow', 'bone_20': 'L_Wrist', 'bone_21': 'R_Wrist',
    'bone_22': 'L_Hand', 'bone_23': 'R_Hand',
}

def Rodrigues(rotvec):
    """Converts a rotation vector to a rotation matrix using Rodrigues' rotation formula."""
    theta = np.linalg.norm(rotvec)
    if theta < 1e-8:
        return np.eye(3)
    r = (rotvec / theta).reshape(3, 1)
    cost = np.cos(theta)
    mat = np.array([[0, -r[2][0], r[1][0]],
                    [r[2][0], 0, -r[0][0]],
                    [-r[1][0], r[0][0], 0]])
    return cost * np.eye(3) + (1 - cost) * r.dot(r.T) + np.sin(theta) * mat

def rodrigues2bshapes(pose):
    """Converts pose data from rotation vectors to blendshapes."""
    rod_rots = pose.reshape(int(pose.shape[0] / 3), 3)
    mat_rots = [Rodrigues(rod_rot) for rod_rot in rod_rots]
    bshapes = np.concatenate([(mat_rot - np.eye(3)).ravel()
                              for mat_rot in mat_rots[1:]])
    return mat_rots, bshapes

def apply_trans_pose_shape(trans, pose, shape, ob, arm_ob, obname, scene, frame=None):
    """Applies translation, pose, and shape data to the SMPL model in Blender."""
    mrots, bsh = rodrigues2bshapes(pose)

    arm_ob.pose.bones['m_avg_Pelvis'].location = trans
    if frame is not None:
        arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)

    for ibone, mrot in enumerate(mrots):
        bone_name = 'bone_%02d' % ibone
        if bone_name in part_match_custom_less2:
            bone = arm_ob.pose.bones[obname + '_' + part_match_custom_less2[bone_name]]
            bone.rotation_quaternion = Matrix(mrot).to_quaternion()
            if frame is not None:
                bone.keyframe_insert('rotation_quaternion', frame=frame)

def init_scene(scene):
    """Initializes the Blender scene by clearing it and importing the SMPL model."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()

    # Ensure the FBX file exists
    if not os.path.exists(smpl_model):
        raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

    bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='Z', global_scale=100)

    obname = 'm_avg'
    ob = bpy.data.objects[obname]
    arm_obj = 'Armature'

    ob.data.use_auto_smooth = False
    ob.data.shape_keys.animation_data_clear()
    arm_ob = bpy.data.objects[arm_obj]
    arm_ob.animation_data_clear()

    return ob, obname, arm_ob

def clean_scene():
    """Cleans the Blender scene by deleting all objects."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()
    # Optionally, remove unused data blocks
    bpy.ops.outliner.orphans_purge(do_recursive=True)

def process_pkl_to_fbx(pkl_file, output_file):
    """Processes a single PKL file and converts it to an FBX animation."""
    # Load PKL data
    data = joblib.load(pkl_file)

    # Initialize Blender scene
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Apply animation data
    for character in range(len(data)):
        qtd_frames = len(data[character]['pose'])
        shape = data[character]['betas'].tolist()

        for frame in range(qtd_frames):
            scene.frame_set(frame)
            trans = data[character]['trans_world'][frame]
            pose = data[character]['pose_world'][frame]
            apply_trans_pose_shape(Vector(trans), pose, shape, ob, arm_ob, obname, scene, frame)

    # Set the animation end frame
    scene.frame_end = qtd_frames - 1

    # Export to FBX
    bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)

    # Clean the scene after export
    clean_scene()

def main():
    """Main function to process PKL files in subfolders and export to FBX."""
    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Get list of all subdirectories in the input folder
    subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
               if os.path.isdir(os.path.join(input_folder, d))]

    # Process each subdirectory
    for subdir in subdirs:
        # Find the .pkl file in the subdirectory
        pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]
        if not pkl_files:
            print(f"No .pkl file found in {subdir}, skipping.")
            continue  # No .pkl file in this subdirectory, skip

        # Assume only one .pkl file per subdirectory
        pkl_file = os.path.join(subdir, pkl_files[0])

        # Generate output .fbx file name based on subdirectory name
        folder_name = os.path.basename(subdir)
        output_file_name = folder_name + '.fbx'
        output_file = os.path.join(output_folder, output_file_name)

        # Convert PKL to FBX
        print(f"Processing {pkl_file}...")
        process_pkl_to_fbx(pkl_file, output_file)

        print(f"FBX file saved to: {output_file}")

if __name__ == "__main__":
    main()

---

Explanation of Changes:

1. Added clean_scene() Function:

   • I introduced a new function clean_scene() that clears the Blender scene after each export.
   • This function selects all objects in the scene and deletes them.
   • Optionally, it purges orphaned data blocks (materials, meshes, etc.) using bpy.ops.outliner.orphans_purge(do_recursive=True). This helps to free up memory and ensure the scene is entirely clean.

   def clean_scene():
       """Cleans the Blender scene by deleting all objects."""
       bpy.ops.object.select_all(action='SELECT')
       bpy.ops.object.delete()
       # Optionally, remove unused data blocks
       bpy.ops.outliner.orphans_purge(do_recursive=True)

2. Called clean_scene() After Export:

   • At the end of the process_pkl_to_fbx() function, I added a call to clean_scene() to reset the scene after exporting each .fbx file.
   • This ensures that any data from the previous processing does not affect the next one.

   # Export to FBX
   bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)
   
   # Clean the scene after export
   clean_scene()

3. Ensured Scene Initialization Before Processing Each File:

   • The init_scene(scene) function is called at the beginning of process_pkl_to_fbx() to set up the scene for each new .pkl file.
   • This function imports the SMPL model and prepares the scene for animation.

4. Removed Unnecessary Imports and Comments:

   • Cleaned up the imports by removing from bpy_extras.io_utils import ExportHelper since it’s not used.
   • Updated comments for clarity.

---

Why Cleaning the Scene After Each Export is Important:

• Memory Management:

  • Blender can consume a lot of memory when dealing with complex scenes and animations.
  • Cleaning the scene after each export frees up memory, which is especially important when processing many files in a loop.

• Data Integrity:

  • Residual data from previous operations can interfere with subsequent processing.
  • Cleaning the scene ensures that each .pkl file is processed in a fresh environment, preventing unexpected behaviors or errors.

• Performance:

  • A clean scene reduces the computational overhead, potentially improving the performance of the script.

---

How to Use the Updated Script:

1. Set the Paths:

   • Update the smpl_model variable with the correct path to your SMPL model .fbx file.
   • Set input_folder to the directory containing your subfolders with .pkl files.
   • Set output_folder to the directory where you want the exported .fbx files to be saved.

2. Prepare Your Data:

   • Ensure each .pkl file is placed inside its own subfolder within the input_folder.
   • Each subfolder should contain only one .pkl file.

3. Run the Script in Blender:

   • Open Blender and navigate to the Scripting workspace.
   • Create a new text block and paste the updated script into it.
   • Run the script by clicking the “Run Script” button or pressing Alt+P.

4. Monitor the Output:

   • The script will print messages indicating the progress of processing each .pkl file.
   • After completion, check the output_folder for the generated .fbx files.

---

Example Output Messages:

Processing C:/Users/Uncharted Limbo/Downloads/subfolder1/data.pkl...
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/subfolder1.fbx
Processing C:/Users/Uncharted Limbo/Downloads/subfolder2/data.pkl...
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/subfolder2.fbx
No .pkl file found in C:/Users/Uncharted Limbo/Downloads/subfolder3, skipping.
...

---

Additional Notes:

• Error Handling:

  • The script includes basic error handling for missing .pkl files and SMPL model files.
  • If you encounter any errors related to data formats or missing data, you may need to add more specific error handling based on your data structure.

• Blender’s Orphan Data Purge:

  • The bpy.ops.outliner.orphans_purge(do_recursive=True) command removes unused data blocks from Blender’s memory.
  • This can be helpful to prevent memory leaks, but use it cautiously if your script or scene relies on data blocks that are not linked to any objects.

• Performance Considerations:

  • Processing multiple animations can be time-consuming.
  • Consider running the script during off-hours or on a machine dedicated to processing if dealing with a large number of files.

• Testing:

  • Before running the script on all your data, test it with a few subfolders to ensure it works as expected.
  • Check the generated .fbx files to verify that the animations are correctly exported.

• Logging:

  • For extensive processing, you might want to implement a logging mechanism to record the processing status and any errors encountered.

---

I hope this updated script meets your requirements by ensuring the scene is cleaned after each export. If you have any further questions or need additional assistance, feel free to ask!

You

sometimes it fails. use a try…catch block and also check for already existing fbx, skip the calculation if it already exists. only give me the relevant code, not the whole script

ChatGPT

To address your requirements, we’ll make the following changes to your script:

1. Add a try-except block around the processing of each .pkl file to handle any exceptions and prevent the script from stopping if an error occurs.

2. Check if the output .fbx file already exists before processing a .pkl file. If it exists, skip processing that file.

Here are the relevant code modifications:

def main():
    """Main function to process PKL files in subfolders and export to FBX."""
    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Get list of all subdirectories in the input folder
    subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
               if os.path.isdir(os.path.join(input_folder, d))]

    # Process each subdirectory
    for subdir in subdirs:
        # Find the .pkl file in the subdirectory
        pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]
        if not pkl_files:
            print(f"No .pkl file found in {subdir}, skipping.")
            continue  # No .pkl file in this subdirectory, skip

        # Assume only one .pkl file per subdirectory
        pkl_file = os.path.join(subdir, pkl_files[0])

        # Generate output .fbx file name based on subdirectory name
        folder_name = os.path.basename(subdir)
        output_file_name = folder_name + '.fbx'
        output_file = os.path.join(output_folder, output_file_name)

        # Check if the .fbx file already exists
        if os.path.exists(output_file):
            print(f"FBX file {output_file} already exists, skipping.")
            continue  # Skip processing if the output file already exists

        try:
            # Convert PKL to FBX
            print(f"Processing {pkl_file}...")
            process_pkl_to_fbx(pkl_file, output_file)
            print(f"FBX file saved to: {output_file}")
        except Exception as e:
            print(f"Error processing {pkl_file}: {e}")
            # Optionally, you can log the error or handle it as needed

Explanation of Changes:

1. Check for Existing FBX File:

   Before processing each .pkl file, the script checks if the corresponding .fbx file already exists in the output directory. If it does, the script skips processing that file.

   if os.path.exists(output_file):
       print(f"FBX file {output_file} already exists, skipping.")
       continue  # Skip processing if the output file already exists

2. Add Try-Except Block:

   The processing code is wrapped in a try block to catch any exceptions that may occur during the processing of a .pkl file. If an error occurs, it is caught by the except block, and an error message is printed. This allows the script to continue processing the remaining files.

   try:
       # Convert PKL to FBX
       print(f"Processing {pkl_file}...")
       process_pkl_to_fbx(pkl_file, output_file)
       print(f"FBX file saved to: {output_file}")
   except Exception as e:
       print(f"Error processing {pkl_file}: {e}")
       # Optionally, you can log the error or handle it as needed

Additional Notes:

• Error Handling:

  • The try-except block ensures that any exceptions raised during the processing of a .pkl file do not stop the entire script.
  • The exception is caught, and an error message is printed with details of the error.
  • You can enhance the error handling by logging the errors to a file or taking additional recovery steps if needed.

• Skipping Existing Files:

  • By checking if the .fbx file already exists, the script avoids redundant processing, saving time and computational resources.
  • This is particularly useful if you need to rerun the script and only process new or failed files.

Incorporate Changes into Your Script:

• Place the modified main() function into your existing script, replacing the previous version.
• Ensure that any necessary imports or variables (e.g., os, input_folder, output_folder, process_pkl_to_fbx) are correctly defined in your script.

Example Usage:

After incorporating these changes, when you run your script, it will:

• Skip any .pkl files whose corresponding .fbx files already exist.
• Continue processing the remaining files even if an error occurs with a particular file.
• Print messages indicating the progress and any errors encountered.

Sample Output Messages:

Processing C:/path/to/subfolder1/data.pkl...
FBX file saved to: C:/output/path/subfolder1.fbx
FBX file C:/output/path/subfolder2.fbx already exists, skipping.
Processing C:/path/to/subfolder3/data.pkl...
Error processing C:/path/to/subfolder3/data.pkl: [Error details]
Processing C:/path/to/subfolder4/data.pkl...
FBX file saved to: C:/output/path/subfolder4.fbx

---

By implementing these modifications, your script will be more robust and efficient, handling errors gracefully and avoiding unnecessary computations.

Let me know if you need any further assistance or additional changes!

You

Use the above code as an example, and modify this code (Which converts different results to Blender animation).

import bpy import os

import sys

from os.path import join

import math import numpy as np from mathutils import Matrix, Vector, Quaternion, Euler import json import pickle

Change the variables here

############################### smpl_model = r”C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx” file = r’//wsl.localhost/Ubuntu/home/ulc/GVHMR/outputs/demo/ACT_03-WIL_02_CENTER_Part11_Balancing_Act/hmr4d_results.pt.pkl’ high_from_floor = 1.5 ##############################

with open(file, ‘rb’) as handle: results = pickle.load(handle)

part_match_custom_less2 = {‘root’: ‘root’, ‘bone_00’: ‘Pelvis’, ‘bone_01’: ‘L_Hip’, ‘bone_02’: ‘R_Hip’, ‘bone_03’: ‘Spine1’, ‘bone_04’: ‘L_Knee’, ‘bone_05’: ‘R_Knee’, ‘bone_06’: ‘Spine2’, ‘bone_07’: ‘L_Ankle’, ‘bone_08’: ‘R_Ankle’, ‘bone_09’: ‘Spine3’, ‘bone_10’: ‘L_Foot’, ‘bone_11’: ‘R_Foot’, ‘bone_12’: ‘Neck’, ‘bone_13’: ‘L_Collar’, ‘bone_14’: ‘R_Collar’, ‘bone_15’: ‘Head’, ‘bone_16’: ‘L_Shoulder’, ‘bone_17’: ‘R_Shoulder’, ‘bone_18’: ‘L_Elbow’, ‘bone_19’: ‘R_Elbow’, ‘bone_20’: ‘L_Wrist’, ‘bone_21’: ‘R_Wrist’, ‘bone_22’: ‘L_Hand’, ‘bone_23’: ‘R_Hand’, }

INICIO --- Inseri para utilizar no WHAM

def Rodrigues(rotvec): theta = np.linalg.norm(rotvec) r = (rotvec/theta).reshape(3, 1) if theta > 0. else rotvec cost = np.cos(theta) mat = np.asarray([[0, -r[2], r[1]], [r[2], 0, -r[0]], [-r[1], r[0], 0]],dtype=object) #adicionei "",dtype=object” por que estava dando erro return(cost*np.eye(3) + (1-cost)*r.dot(r.T) + np.sin(theta)*mat)

def rodrigues2bshapes(pose):

rod_rots = np.asarray(pose).reshape(22, 3)
mat_rots = [Rodrigues(rod_rot) for rod_rot in rod_rots]
bshapes = np.concatenate([(mat_rot - np.eye(3)).ravel()
                        for mat_rot in mat_rots[1:]])
return(mat_rots, bshapes)

############ def get_global_pose(global_pose, arm_ob, frame=None):

arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 0.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = -1.0

bone = arm_ob.pose.bones['m_avg_Pelvis']
# if frame is not None:
#     bone.keyframe_insert('rotation_quaternion', frame=frame)

root_orig = arm_ob.pose.bones['m_avg_root'].rotation_quaternion
mw_orig = arm_ob.matrix_world.to_quaternion()
pelvis_quat = Matrix(global_pose[0]).to_quaternion()

bone.rotation_quaternion = pelvis_quat
bone.keyframe_insert('rotation_quaternion', frame=frame)

pelvis_applyied = arm_ob.pose.bones['m_avg_Pelvis'].rotation_quaternion
bpy.context.view_layer.update()

rot_world_orig = root_orig @ pelvis_applyied @ mw_orig #pegar a rotacao em relacao ao mundo

return rot_world_orig

###############

apply trans pose and shape to character

def apply_trans_pose_shape(trans, body_pose, shape, ob, arm_ob, obname, scene, cam_ob, frame=None):

def apply_trans_pose_shape(trans, body_pose, arm_ob, obname, frame=None):

# transform pose into rotation matrices (for pose) and pose blendshapes

if self.option in [2,3]: #para WHAM ou slahmr

mrots, bsh = rodrigues2bshapes(body_pose)

else: #para 4d humans

mrots = body_pose

mrots, bsh = rodrigues2bshapes(body_pose)

mrots = body_pose

part_bones  = part_match_custom_less2

trans = Vector((trans[0],trans[1]-2.2,trans[2]))

trans = Vector((trans[0],trans[1]-high_from_floor,trans[2]))


# print('frame in apply pose:', frame)
arm_ob.pose.bones['m_avg_Pelvis'].location = trans
arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)


arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 0.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = -1.0



for ibone, mrot in enumerate(mrots):
     if ibone < 22: #incui essa parte por que no modelo que eu to usando nao tem bone para a mao
        bone = arm_ob.pose.bones['m_avg_'+part_bones['bone_%02d' % ibone]]
        bone.rotation_quaternion = Matrix(mrot).to_quaternion()

        if frame is not None:
            bone.keyframe_insert('rotation_quaternion', frame=frame)

import os def init_scene(scene, params, gender=‘male’, angle=0):

# path_fbx = os.path.join(path_code,smpl_model)

smpl_model = r”D:\AI_Stuff\GVHMR\basicModel_m_lbs_10_207_0_v1.0.2.fbx”

path_fbx = smpl_model
bpy.ops.import_scene.fbx(filepath=path_fbx, axis_forward='-Y', axis_up='-Z', global_scale=100)#, automatic_bone_orientation=True)

arm_obj = bpy.context.selected_objects[0]

arm_ob = bpy.context.selected_objects[0]

obj_gender = 'm'
obname = '%s_avg' % obj_gender
ob = bpy.data.objects[obname]
# arm_obj = 'Armature'

bpy.context.scene.source = arm_obj

print('success load')

# ob.data.use_auto_smooth = False  # autosmooth creates artifacts
bpy.ops.object.select_all(action='DESELECT')
bpy.ops.object.select_all(action='DESELECT')
cam_ob = ''
# ob.data.shape_keys.animation_data_clear()
# arm_ob = bpy.data.objects[arm_obj]

arm_ob = context.scene.source

arm_ob.animation_data_clear()

return(ob, obname, arm_ob, cam_ob)

qtd_frames = len(results[character][‘pose’])

params = [] object_name = ‘m_avg’ obj_gender = ‘m’ scene = bpy.data.scenes[‘Scene’] ob, obname, arm_ob, cam_ob= init_scene(scene, params, obj_gender)

qtd_frames = len(results[‘smpl_params_global’][‘transl’])

print(‘qtd frames: ‘,qtd_frames)

shape = results[character][‘betas’].tolist()

for fframe in range(0,qtd_frames): bpy.context.scene.frame_set(fframe) #print(‘data’,data) # trans = [0.0, 0.0, 1.521] trans = results[‘smpl_params_global’][‘transl’][fframe] # shape = data[1][‘smpl’][character][‘betas’] # global_orient = results[‘smpl_params_global’][‘global_orient’][fframe] # pelvis = fixed_pelvis_quat[fframe] # global_orient = np.array(Quaternion(pelvis).to_matrix()).reshape(1,3,3) # ##o trtamento abaixo nao deu certo # rotation_x = Matrix.Rotation(math.radians(180.0),3,‘X’) #rodar ao redor de X # rotation_y = Matrix.Rotation(math.radians(90.0),3,‘Y’) #rodar ao redor de X # global_orient = global_orient @ rotation_x @rotation_y # body_pose = results[‘smpl_params_global’][‘body_pose’][fframe] body_pose_fim = body_pose.reshape(int(len(body_pose)/3), 3) final_body_pose = np.vstack([global_orient, body_pose_fim]) # apply_trans_pose_shape(Vector(trans), final_body_pose, shape, obj,arm_ob, obname, scene, cam_ob, fframe) # # apply_trans_pose_shape(Vector(trans), final_body_pose, arm_ob, obname, fframe) bpy.context.view_layer.update()

arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.w = 1.0 arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.x = 0.0 arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.y = 0.0 arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.z = 0.0

arm_ob.pose.bones[‘m_avg_Pelvis’].constraints.new(‘COPY_LOCATION’)

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[“Copy Location”].target = armature_ref

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[0].target = arm_ob arm_ob.pose.bones[“m_avg_Pelvis”].constraints[0].subtarget = “m_avg_Pelvis”

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[“Copy Location”].subtarget = “m_avg_Pelvis”

arm_ob.pose.bones[‘m_avg_Pelvis’].constraints.new(‘COPY_ROTATION’)

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[“Copy Rotation”].target = armature_ref

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[1].target = arm_ob

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[“Copy Rotation”].subtarget = “m_avg_Pelvis”

arm_ob.pose.bones[“m_avg_Pelvis”].constraints[1].subtarget = “m_avg_Pelvis”

ChatGPT

Certainly! To modify your code based on the previous example, we’ll add the following:

1. Add a loop to process multiple files.

2. Add a try-except block to handle failures.

3. Check for already existing FBX files and skip processing if they already exist.

Here are the relevant code modifications:

---

1. Set the Input and Output Folders and Get a List of Files to Process

Replace your single file path with code that loops through all relevant files. Add this at the beginning of your script:

import os
import bpy
import pickle

# Define the input and output folders
input_folder = r'//wsl.localhost/Ubuntu/home/ulc/GVHMR/outputs/demo'  # Update this to your input folder
output_folder = r'C:/Users/Uncharted Limbo/Downloads/fbx_output'  # Update this to your output folder
os.makedirs(output_folder, exist_ok=True)

# Get a list of all subdirectories in the input folder
subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
           if os.path.isdir(os.path.join(input_folder, d))]

---

2. Loop Through the Files and Process Them with Error Handling

Wrap your processing code in a loop and add the try-except block, and check for existing FBX files:

for subdir in subdirs:
    # Find the .pkl file in the subdirectory
    pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]
    if not pkl_files:
        print(f"No .pkl file found in {subdir}, skipping.")
        continue  # No .pkl file in this subdirectory, skip

    # Assume only one .pkl file per subdirectory
    pkl_file = os.path.join(subdir, pkl_files[0])

    # Generate output .fbx file name based on subdirectory name
    folder_name = os.path.basename(subdir)
    output_file_name = folder_name + '.fbx'
    output_file = os.path.join(output_folder, output_file_name)

    # Check if the FBX file already exists
    if os.path.exists(output_file):
        print(f"FBX file {output_file} already exists, skipping.")
        continue  # Skip processing if the output file already exists

    try:
        # Load the data from the .pkl file
        with open(pkl_file, 'rb') as handle:
            results = pickle.load(handle)

        # Initialize the scene
        params = []
        object_name = 'm_avg'
        obj_gender = 'm'
        scene = bpy.data.scenes['Scene']
        ob, obname, arm_ob, cam_ob = init_scene(scene, params, obj_gender)

        # Process the frames
        qtd_frames = len(results['smpl_params_global']['transl'])
        print(f'Processing {pkl_file}, frames: {qtd_frames}')

        for fframe in range(0, qtd_frames):
            bpy.context.scene.frame_set(fframe)
            trans = results['smpl_params_global']['transl'][fframe]
            global_orient = results['smpl_params_global']['global_orient'][fframe]
            body_pose = results['smpl_params_global']['body_pose'][fframe]
            body_pose_fim = body_pose.reshape(int(len(body_pose)/3), 3)
            final_body_pose = np.vstack([global_orient, body_pose_fim])

            apply_trans_pose_shape(Vector(trans), final_body_pose, arm_ob, obname, fframe)
            bpy.context.view_layer.update()

        # Adjust root bone after processing
        arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 1.0
        arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = 0.0
        arm_ob.pose.bones['m_avg_root'].rotation_quaternion.y = 0.0
        arm_ob.pose.bones['m_avg_root'].rotation_quaternion.z = 0.0

        # Add constraints
        arm_ob.pose.bones['m_avg_Pelvis'].constraints.new('COPY_LOCATION')
        arm_ob.pose.bones["m_avg_Pelvis"].constraints[0].target = arm_ob
        arm_ob.pose.bones["m_avg_Pelvis"].constraints[0].subtarget = "m_avg_Pelvis"

        arm_ob.pose.bones['m_avg_Pelvis'].constraints.new('COPY_ROTATION')
        arm_ob.pose.bones["m_avg_Pelvis"].constraints[1].target = arm_ob
        arm_ob.pose.bones["m_avg_Pelvis"].constraints[1].subtarget = "m_avg_Pelvis"

        # Set the animation end frame
        bpy.context.scene.frame_end = qtd_frames - 1

        # Export the scene to FBX
        bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)
        print(f"FBX file saved to: {output_file}")

        # Clean the scene after export
        bpy.ops.object.select_all(action='SELECT')
        bpy.ops.object.delete()
        bpy.ops.outliner.orphans_purge(do_recursive=True)

    except Exception as e:
        print(f"Error processing {pkl_file}: {e}")
        # Optionally, log the error or handle it as needed

---

3. Ensure Your Functions are Properly Defined

Make sure that your init_scene, apply_trans_pose_shape, and any other functions used within the loop are defined above this code and can be called multiple times. They should be able to re-initialize the scene for each file.

---

Explanation of Changes:

• Looping Through Subdirectories:

  • The script now loops through each subdirectory in your input folder.
  • It looks for a .pkl file within each subdirectory.

• Checking for Existing FBX Files:

  • Before processing, it checks if an FBX file with the desired name already exists in the output folder.
  • If the file exists, it skips processing that subdirectory.

• Adding Try-Except Block:

  • The processing code is wrapped in a try-except block to catch and handle any exceptions.
  • If an error occurs, it prints an error message and continues with the next file.

• Cleaning the Scene:

  • After exporting the FBX file, the scene is cleaned to prepare for the next iteration.
  • This is done by deleting all objects and purging orphaned data blocks.

• Processing Each Frame:

  • For each frame in the animation, the script sets the frame, applies transformations, and updates the view layer.

---

Additional Notes:

• Adjust the Paths:

  • Update input_folder and output_folder with the actual paths you’re using.
  • Ensure the smpl_model variable points to the correct location of your SMPL model .fbx file.

• Function Definitions:

  • Ensure that all functions (init_scene, apply_trans_pose_shape, etc.) are correctly defined and compatible with this loop structure.
  • These functions should be capable of being called multiple times without retaining state from previous calls.

• Error Handling:

  • The try-except block catches any exceptions that may occur during processing.
  • You can enhance the error handling by logging errors to a file or taking additional actions as needed.

• Performance Considerations:

  • Processing multiple files can be time-consuming.
  • Consider running the script when it won’t interfere with other tasks.

---

Example Output Messages:

Processing //wsl.localhost/Ubuntu/home/ulc/GVHMR/outputs/demo/ACT_03-WIL_02_CENTER_Part11_Balancing_Act/hmr4d_results.pt.pkl, frames: 120
FBX file saved to: C:/Users/Uncharted Limbo/Downloads/fbx_output/ACT_03-WIL_02_CENTER_Part11_Balancing_Act.fbx
FBX file C:/Users/Uncharted Limbo/Downloads/fbx_output/Some_Other_Folder.fbx already exists, skipping.
Error processing //path/to/another/file.pkl: [Error details]

---

How to Integrate This into Your Script:

• Step 1: Place the modified code snippets into your existing script at the appropriate locations.
• Step 2: Ensure all variables and functions are properly defined.
• Step 3: Run the script within Blender’s scripting environment.

---

By incorporating these modifications, your script will be more robust and efficient, handling errors gracefully and avoiding unnecessary computations by skipping already processed files.

Let me know if you need any further assistance or additional changes!

You

Ok, the script now looks like this and it works. But what if, Instead of producing multiple fbx files, we collected all the animations in a single .fbx file, so that in Unity one could select which animation to apply?

import bpy import os import math import numpy as np from mathutils import Matrix, Vector, Quaternion, Euler import json import pickle

Change the variables here

############################### high_from_floor = 1.5 ##############################

Define the input and output folders

smpl_model = ‘C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx’ input_folder = r’//wsl.localhost/Ubuntu/home/ulc/GVHMR/outputs/demo’ output_folder = r’C:/Users/Uncharted Limbo/Downloads/GVHMR_fbx_output’ os.makedirs(output_folder, exist_ok=True)

SMPL model bone name mapping

part_match_custom_less2 = { ‘root’: ‘root’, ‘bone_00’: ‘Pelvis’, ‘bone_01’: ‘L_Hip’, ‘bone_02’: ‘R_Hip’, ‘bone_03’: ‘Spine1’, ‘bone_04’: ‘L_Knee’, ‘bone_05’: ‘R_Knee’, ‘bone_06’: ‘Spine2’, ‘bone_07’: ‘L_Ankle’, ‘bone_08’: ‘R_Ankle’, ‘bone_09’: ‘Spine3’, ‘bone_10’: ‘L_Foot’, ‘bone_11’: ‘R_Foot’, ‘bone_12’: ‘Neck’, ‘bone_13’: ‘L_Collar’, ‘bone_14’: ‘R_Collar’, ‘bone_15’: ‘Head’, ‘bone_16’: ‘L_Shoulder’, ‘bone_17’: ‘R_Shoulder’, ‘bone_18’: ‘L_Elbow’, ‘bone_19’: ‘R_Elbow’, ‘bone_20’: ‘L_Wrist’, ‘bone_21’: ‘R_Wrist’, ‘bone_22’: ‘L_Hand’, ‘bone_23’: ‘R_Hand’, }

INICIO --- Inseri para utilizar no WHAM

def Rodrigues(rotvec): theta = np.linalg.norm(rotvec) r = (rotvec/theta).reshape(3, 1) if theta > 0. else rotvec cost = np.cos(theta) mat = np.asarray([[0, -r[2], r[1]], [r[2], 0, -r[0]], [-r[1], r[0], 0]],dtype=object) #adicionei "",dtype=object” por que estava dando erro return(cost*np.eye(3) + (1-cost)*r.dot(r.T) + np.sin(theta)*mat)

def rodrigues2bshapes(pose):

rod_rots = np.asarray(pose).reshape(22, 3)
mat_rots = [Rodrigues(rod_rot) for rod_rot in rod_rots]
bshapes = np.concatenate([(mat_rot - np.eye(3)).ravel()
                        for mat_rot in mat_rots[1:]])
return(mat_rots, bshapes)

apply trans pose and shape to character

def apply_trans_pose_shape(trans, body_pose, arm_ob, obname, frame=None):

# transform pose into rotation matrices (for pose) and pose blendshapes

if self.option in [2,3]: #para WHAM ou slahmr

mrots, bsh = rodrigues2bshapes(body_pose)

else: #para 4d humans

mrots = body_pose

mrots, bsh = rodrigues2bshapes(body_pose)
part_bones  = part_match_custom_less2

trans = Vector((trans[0],trans[1]-high_from_floor,trans[2]))

arm_ob.pose.bones['m_avg_Pelvis'].location = trans
if frame is not None:
    arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)

arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 0.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = -1.0

for ibone, mrot in enumerate(mrots):
     if ibone < 22: #incui essa parte por que no modelo que eu to usando nao tem bone para a mao
        bone = arm_ob.pose.bones['m_avg_'+part_bones['bone_%02d' % ibone]]
        bone.rotation_quaternion = Matrix(mrot).to_quaternion()
        if frame is not None:
            bone.keyframe_insert('rotation_quaternion', frame=frame)

############ def get_global_pose(global_pose, arm_ob, frame=None):

arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 0.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = -1.0

bone = arm_ob.pose.bones['m_avg_Pelvis']
# if frame is not None:
#     bone.keyframe_insert('rotation_quaternion', frame=frame)

root_orig = arm_ob.pose.bones['m_avg_root'].rotation_quaternion
mw_orig = arm_ob.matrix_world.to_quaternion()
pelvis_quat = Matrix(global_pose[0]).to_quaternion()

bone.rotation_quaternion = pelvis_quat
bone.keyframe_insert('rotation_quaternion', frame=frame)

pelvis_applyied = arm_ob.pose.bones['m_avg_Pelvis'].rotation_quaternion
bpy.context.view_layer.update()

rot_world_orig = root_orig @ pelvis_applyied @ mw_orig #pegar a rotacao em relacao ao mundo

return rot_world_orig

###############

def init_scene(scene): """Initializes the Blender scene by clearing it and importing the SMPL model.""" bpy.ops.object.select_all(action=‘SELECT’) bpy.ops.object.delete()

# Ensure the FBX file exists
if not os.path.exists(smpl_model):
    raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='-Z', global_scale=100)

arm_ob = bpy.context.selected_objects[0]

obname = 'm_avg'
ob = bpy.data.objects[obname]
arm_obj = 'Armature'

ob.data.use_auto_smooth = False
ob.data.shape_keys.animation_data_clear()
arm_ob = bpy.data.objects[arm_obj]
arm_ob.animation_data_clear()

return ob, obname, arm_ob

def clean_scene(): """Cleans the Blender scene by deleting all objects.""" bpy.ops.object.select_all(action=‘SELECT’) bpy.ops.object.delete() # Optionally, remove unused data blocks bpy.ops.outliner.orphans_purge(do_recursive=True)

def process_pkl_to_fbx(pkl_file, output_file): """Processes a single PKL file and converts it to an FBX animation.""" # Load PKL data with open(pkl_file, ‘rb’) as pkl: data = pickle.load(pkl)

# Initialize Blender scene
scene = bpy.context.scene
ob, obname, arm_ob = init_scene(scene)

# Apply animation data
qtd_frames = len(data['smpl_params_global']['transl'])
print('qtd frames: ',qtd_frames)

for fframe in range(qtd_frames):
    scene.frame_set(fframe)
    trans = data['smpl_params_global']['transl'][fframe]
    global_orient = data['smpl_params_global']['global_orient'][fframe]

    body_pose = data['smpl_params_global']['body_pose'][fframe]
    body_pose_fim = body_pose.reshape(int(len(body_pose)/3), 3)
    final_body_pose = np.vstack([global_orient, body_pose_fim])

    apply_trans_pose_shape(Vector(trans), final_body_pose, arm_ob, obname, fframe)

# Set the animation end frame
scene.frame_end = qtd_frames - 1

arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 1.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = 0.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.y = 0.0
arm_ob.pose.bones['m_avg_root'].rotation_quaternion.z = 0.0

arm_ob.pose.bones['m_avg_Pelvis'].constraints.new('COPY_LOCATION')
arm_ob.pose.bones["m_avg_Pelvis"].constraints[0].target = arm_ob
arm_ob.pose.bones["m_avg_Pelvis"].constraints[0].subtarget = "m_avg_Pelvis"

arm_ob.pose.bones['m_avg_Pelvis'].constraints.new('COPY_ROTATION')
arm_ob.pose.bones["m_avg_Pelvis"].constraints[1].target = arm_ob
arm_ob.pose.bones["m_avg_Pelvis"].constraints[1].subtarget = "m_avg_Pelvis"

# Export to FBX
bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)

clean_scene()

def main(): """Main function to process the PKL file and export to FBX."""

# Ensure output folder exists
os.makedirs(output_folder, exist_ok=True)

# Get list of all subdirectories in the input folder
subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
           if os.path.isdir(os.path.join(input_folder, d))]

# Process each subdirectory
for subdir in subdirs:
    print(f"---------------- Processing {subdir} ------------------------")

    # Find the .pkl file in the subdirectory
    pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]

    if not pkl_files:
        print(f"No .pkl file found in {subdir}, skipping.")
        continue  # No .pkl file in this subdirectory, skip

    # Assume only one .pkl file per subdirectory
    pkl_file = os.path.join(subdir, pkl_files[0])

    # Generate output .fbx file name based on subdirectory name
    folder_name = os.path.basename(subdir)
    output_file_name = folder_name + '.fbx'
    output_file = os.path.join(output_folder, output_file_name)

    # Check if the .fbx file already exists
    if os.path.exists(output_file):
        print(f"FBX file {output_file} already exists, skipping.")
        continue  # Skip processing if the output file already exists

    try:
        # Convert PKL to FBX
        print(f"Processing {pkl_file}...")
        process_pkl_to_fbx(pkl_file, output_file)
        print(f"FBX file saved to: {output_file}")
    except Exception as e:
        clean_scene()
        print(f"Error processing {pkl_file}: {e}")
        # Optionally, you can log the error or handle it as needed

if name == “main”: main()

ChatGPT

Certainly! To collect all the animations into a single .fbx file, we’ll modify your script so that instead of exporting each animation separately, we:

1. Initialize the Blender scene only once.
2. Create a new action for each animation and store it in the same Blender scene.
3. Export all animations together into a single .fbx file.

This approach allows Unity to recognize each action as a separate animation clip within the same .fbx file, enabling you to select which animation to apply.

Below are the relevant code modifications:

---

1. Modify the main() Function

Instead of initializing and cleaning the scene for each .pkl file, we’ll initialize it once at the beginning. We’ll also create and assign a new action for each animation.

Modified main() Function:

def main():
    """Main function to process the PKL files and collect animations into a single FBX."""
    # Initialize the scene once
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Get list of all subdirectories in the input folder
    subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
               if os.path.isdir(os.path.join(input_folder, d))]

    # Process each subdirectory
    for subdir in subdirs:
        print(f"---------------- Processing {subdir} ------------------------")

        # Find the .pkl file in the subdirectory
        pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]

        if not pkl_files:
            print(f"No .pkl file found in {subdir}, skipping.")
            continue  # No .pkl file in this subdirectory, skip

        # Assume only one .pkl file per subdirectory
        pkl_file = os.path.join(subdir, pkl_files[0])

        # Generate action name based on subdirectory name
        folder_name = os.path.basename(subdir)
        action_name = folder_name  # Use the folder name as the action name

        try:
            # Convert PKL to action
            print(f"Processing {pkl_file}...")
            process_pkl_to_action(pkl_file, arm_ob, obname, action_name)
            print(f"Animation '{action_name}' added.")
        except Exception as e:
            print(f"Error processing {pkl_file}: {e}")
            # Optionally, you can log the error or handle it as needed

    # Export all animations to a single FBX file
    output_file = os.path.join(output_folder, 'all_animations.fbx')
    bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)
    print(f"All animations exported to: {output_file}")

2. Create a New Function process_pkl_to_action()

This function will process each .pkl file and create a new action in Blender for the animation.

New Function process_pkl_to_action():

def process_pkl_to_action(pkl_file, arm_ob, obname, action_name):
    """Processes a single PKL file and converts it to a Blender action."""
    # Load PKL data
    with open(pkl_file, 'rb') as pkl:
        data = pickle.load(pkl)

    # Create a new action for the armature
    action = bpy.data.actions.new(name=action_name)
    arm_ob.animation_data_create()
    arm_ob.animation_data.action = action

    # Apply animation data
    qtd_frames = len(data['smpl_params_global']['transl'])
    print('Number of frames: ', qtd_frames)

    for fframe in range(qtd_frames):
        frame = fframe
        trans = data['smpl_params_global']['transl'][fframe]
        global_orient = data['smpl_params_global']['global_orient'][fframe]

        body_pose = data['smpl_params_global']['body_pose'][fframe]
        body_pose_fim = body_pose.reshape(int(len(body_pose)/3), 3)
        final_body_pose = np.vstack([global_orient, body_pose_fim])

        apply_trans_pose_shape(Vector(trans), final_body_pose, arm_ob, obname, frame)

    # Set the action's frame range
    action.frame_range = (0, qtd_frames - 1)

    # Clear the current action so that it doesn't interfere with the next one
    arm_ob.animation_data.action = None

3. Adjust apply_trans_pose_shape() Function

Ensure that keyframes are added to the correct action by setting the current action before inserting keyframes.

Modified apply_trans_pose_shape() Function:

def apply_trans_pose_shape(trans, body_pose, arm_ob, obname, frame=None):
    """Applies translation, pose, and shape data to the SMPL model in Blender."""
    mrots, bsh = rodrigues2bshapes(body_pose)
    part_bones  = part_match_custom_less2

    trans = Vector((trans[0], trans[1] - high_from_floor, trans[2]))

    arm_ob.pose.bones['m_avg_Pelvis'].location = trans
    if frame is not None:
        arm_ob.pose.bones['m_avg_Pelvis'].keyframe_insert('location', frame=frame)

    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 0.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = -1.0

    for ibone, mrot in enumerate(mrots):
        if ibone < 22:
            bone = arm_ob.pose.bones['m_avg_' + part_bones['bone_%02d' % ibone]]
            bone.rotation_quaternion = Matrix(mrot).to_quaternion()
            if frame is not None:
                bone.keyframe_insert('rotation_quaternion', frame=frame)

4. Initialize the Scene Only Once

Modify the init_scene() function to ensure it can be called only once and set up the armature for multiple animations.

Ensure init_scene() is Defined Correctly:

def init_scene(scene):
    """Initializes the Blender scene by clearing it and importing the SMPL model."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()

    # Ensure the FBX file exists
    if not os.path.exists(smpl_model):
        raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

    bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='-Z', global_scale=100)

    arm_ob = bpy.context.selected_objects[0]

    obname = 'm_avg'
    ob = bpy.data.objects[obname]
    arm_obj = 'Armature'

    ob.data.use_auto_smooth = False
    ob.data.shape_keys.animation_data_clear()
    arm_ob = bpy.data.objects[arm_obj]
    arm_ob.animation_data_clear()

    return ob, obname, arm_ob

5. Remove Scene Cleaning After Each Animation

Since we’re collecting all animations into a single scene, we should not clean the scene after processing each animation.

Remove clean_scene() Calls:

• Remove any calls to clean_scene() in your code, as we’re no longer cleaning the scene after each animation.

---

Explanation of Changes

• Single Scene Initialization:

  • We initialize the scene once at the beginning to import the SMPL model.
  • This ensures that all animations are applied to the same armature.

• Creating New Actions:

  • For each animation, we create a new action using bpy.data.actions.new(name=action_name).
  • We assign this action to the armature using arm_ob.animation_data.action = action.
  • By doing this, all keyframes inserted during the processing of that animation are stored in the current action.

• Applying Animations:

  • The apply_trans_pose_shape() function remains mostly unchanged.
  • It inserts keyframes for each bone at each frame.
  • Since we’ve set the current action for the armature, these keyframes are stored in the correct action.

• Clearing Current Action:

  • After processing each animation, we clear the current action by setting arm_ob.animation_data.action = None.
  • This ensures that subsequent animations do not accidentally overwrite keyframes in the previous action.

• Exporting All Animations:

  • At the end of the script, we export the entire scene to a single .fbx file using bpy.ops.export_scene.fbx().
  • This .fbx file contains all actions (animations), which Unity can import as separate animation clips.

• No Scene Cleaning:

  • We removed any scene cleaning operations after processing each animation since we want to keep all animations in the scene.

---

Final Notes

• Unity Import:

  • When you import the resulting .fbx file into Unity, it should recognize all the actions as separate animation clips.
  • You can select and use these animations individually within Unity.

• Testing:

  • Before processing all animations, test the script with a couple of .pkl files to ensure everything works as expected.

• Memory Considerations:

  • Processing many animations in a single Blender scene may consume significant memory.
  • If you encounter performance issues, consider splitting the animations into multiple .fbx files or optimizing the data.

• Action Naming:

  • The actions are named after the subdirectory names.
  • Ensure that these names are unique and meaningful for easier identification in Unity.

---

Example Output Messages:

---------------- Processing /path/to/animation1 ------------------------
Processing /path/to/animation1/data.pkl...
Number of frames: 120
Animation 'animation1' added.
---------------- Processing /path/to/animation2 ------------------------
Processing /path/to/animation2/data.pkl...
Number of frames: 150
Animation 'animation2' added.
All animations exported to: C:/Users/Uncharted Limbo/Downloads/GVHMR_fbx_output/all_animations.fbx

---

By making these changes, your script will collect all animations into a single .fbx file, allowing you to select and use individual animations in Unity.

Let me know if you have any questions or need further assistance!

You

what about these? why did you remove them?

arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.w = 1.0 arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.x = 0.0 arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.y = 0.0 arm_ob.pose.bones[‘m_avg_root’].rotation_quaternion.z = 0.0

arm_ob.pose.bones['m_avg_Pelvis'].constraints.new('COPY_LOCATION')
arm_ob.pose.bones["m_avg_Pelvis"].constraints[0].target = arm_ob
arm_ob.pose.bones["m_avg_Pelvis"].constraints[0].subtarget = "m_avg_Pelvis"

arm_ob.pose.bones['m_avg_Pelvis'].constraints.new('COPY_ROTATION')
arm_ob.pose.bones["m_avg_Pelvis"].constraints[1].target = arm_ob
arm_ob.pose.bones["m_avg_Pelvis"].constraints[1].subtarget = "m_avg_Pelvis"

ChatGPT

You’re absolutely right, and I apologize for the oversight.

In my previous response, I omitted the lines that adjust the rotation of the 'm_avg_root' bone and add constraints to the 'm_avg_Pelvis' bone. These lines are important for ensuring the correct orientation of the root bone and for applying the necessary constraints to the pelvis bone, which can affect how the animation is interpreted in Unity.

Why These Lines Are Important:

• Root Bone Rotation: Setting the rotation of the 'm_avg_root' bone ensures that the character is oriented correctly in the scene. Without this, the character might appear rotated incorrectly.

• Constraints on Pelvis Bone: Adding 'COPY_LOCATION' and 'COPY_ROTATION' constraints to the 'm_avg_Pelvis' bone ensures that it follows the desired position and rotation, which can be crucial for the animation to play back correctly, especially when imported into other software like Unity.

Including Them in the Modified Script:

We should include these lines after the animation data has been applied for each action. Specifically, they should be added at the end of the process_pkl_to_action() function, after all frames have been processed.

Here’s the updated process_pkl_to_action() function with the necessary lines included:

---

def process_pkl_to_action(pkl_file, arm_ob, obname, action_name):
    """Processes a single PKL file and converts it to a Blender action."""
    # Load PKL data
    with open(pkl_file, 'rb') as pkl:
        data = pickle.load(pkl)

    # Create a new action for the armature
    action = bpy.data.actions.new(name=action_name)
    arm_ob.animation_data_create()
    arm_ob.animation_data.action = action

    # Apply animation data
    qtd_frames = len(data['smpl_params_global']['transl'])
    print('Number of frames: ', qtd_frames)

    for fframe in range(qtd_frames):
        frame = fframe
        trans = data['smpl_params_global']['transl'][fframe]
        global_orient = data['smpl_params_global']['global_orient'][fframe]

        body_pose = data['smpl_params_global']['body_pose'][fframe]
        body_pose_fim = body_pose.reshape(int(len(body_pose)/3), 3)
        final_body_pose = np.vstack([global_orient, body_pose_fim])

        apply_trans_pose_shape(Vector(trans), final_body_pose, arm_ob, obname, frame)

    # Set the action's frame range
    action.frame_range = (0, qtd_frames - 1)

    # Adjust root bone rotation
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 1.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = 0.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.y = 0.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.z = 0.0

    # Keyframe the root bone rotation
    arm_ob.pose.bones['m_avg_root'].keyframe_insert('rotation_quaternion', frame=0)
    arm_ob.pose.bones['m_avg_root'].keyframe_insert('rotation_quaternion', frame=qtd_frames - 1)

    # Add constraints to the Pelvis bone
    pelvis_bone = arm_ob.pose.bones['m_avg_Pelvis']

    # Check if constraints already exist to avoid duplication
    constraint_names = [constraint.name for constraint in pelvis_bone.constraints]
    if 'Copy Location' not in constraint_names:
        loc_constraint = pelvis_bone.constraints.new('COPY_LOCATION')
        loc_constraint.name = 'Copy Location'
        loc_constraint.target = arm_ob
        loc_constraint.subtarget = 'm_avg_Pelvis'

    if 'Copy Rotation' not in constraint_names:
        rot_constraint = pelvis_bone.constraints.new('COPY_ROTATION')
        rot_constraint.name = 'Copy Rotation'
        rot_constraint.target = arm_ob
        rot_constraint.subtarget = 'm_avg_Pelvis'

    # Clear the current action so that it doesn't interfere with the next one
    arm_ob.animation_data.action = None

---

Explanation of the Updates:

• Adjusting the Root Bone Rotation:

  arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 1.0
  arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = 0.0
  arm_ob.pose.bones['m_avg_root'].rotation_quaternion.y = 0.0
  arm_ob.pose.bones['m_avg_root'].rotation_quaternion.z = 0.0
  
  # Keyframe the root bone rotation
  arm_ob.pose.bones['m_avg_root'].keyframe_insert('rotation_quaternion', frame=0)
  arm_ob.pose.bones['m_avg_root'].keyframe_insert('rotation_quaternion', frame=qtd_frames - 1)

  • These lines reset the rotation of the 'm_avg_root' bone to the default orientation.
  • We insert keyframes at the first and last frames to ensure the rotation remains consistent throughout the animation.

• Adding Constraints to the Pelvis Bone:

  # Add constraints to the Pelvis bone
  pelvis_bone = arm_ob.pose.bones['m_avg_Pelvis']
  
  # Check if constraints already exist to avoid duplication
  constraint_names = [constraint.name for constraint in pelvis_bone.constraints]
  if 'Copy Location' not in constraint_names:
      loc_constraint = pelvis_bone.constraints.new('COPY_LOCATION')
      loc_constraint.name = 'Copy Location'
      loc_constraint.target = arm_ob
      loc_constraint.subtarget = 'm_avg_Pelvis'
  
  if 'Copy Rotation' not in constraint_names:
      rot_constraint = pelvis_bone.constraints.new('COPY_ROTATION')
      rot_constraint.name = 'Copy Rotation'
      rot_constraint.target = arm_ob
      rot_constraint.subtarget = 'm_avg_Pelvis'

  • We first retrieve the pelvis bone.
  • We check if the constraints already exist to prevent adding duplicates, which could cause issues.
  • We add 'COPY_LOCATION' and 'COPY_ROTATION' constraints to the pelvis bone, setting the target to the armature object and subtarget to the pelvis bone itself.

Why the Changes Are Placed Here:

• Including these adjustments within the process_pkl_to_action() function ensures that they are applied after the animation data is processed for each action.
• By keyframing the root bone rotation and adding constraints after the animation frames are applied, we ensure that these settings are consistent across all animations.

Adjusting the main() Function:

• Since we’re processing multiple animations in a single scene, we only need to set up the root bone rotation and pelvis constraints once. However, to ensure consistency, applying them after each animation ensures they are correctly set for each action.

Note on Constraints Duplication:

• We include checks to prevent adding the same constraints multiple times, which can happen when processing multiple animations.
• By checking if the constraint names already exist, we avoid adding duplicate constraints that could affect the animation playback.

---

Final Notes:

• Unity Compatibility: Including these lines ensures that the exported .fbx file will have the correct bone orientations and constraints, which is crucial for the animations to play back correctly in Unity.

• Testing: After making these changes, test the script with a few animations to verify that everything works as expected in both Blender and Unity.

• Script Structure: Ensure that all functions and variables are correctly defined and that the flow of the script allows for these settings to be applied appropriately.

---

Example of the Complete Flow:

1. Initialize Scene Once:

   • Call init_scene(scene) at the beginning of the main() function.

2. Process Each PKL File:

   • For each .pkl file, call process_pkl_to_action(pkl_file, arm_ob, obname, action_name).

3. Within process_pkl_to_action():

   • Load the animation data.
   • Create a new action for the armature.
   • Apply the animation frames.
   • Adjust the root bone rotation and keyframe it.
   • Add constraints to the pelvis bone if they don’t already exist.
   • Clear the current action to prepare for the next animation.

4. Export All Animations:

   • After processing all animations, export the scene to a single .fbx file containing all actions.

---

Let me know if you have any further questions or need additional assistance!

You

set the project framerate via the script

ChatGPT

Certainly! To set the project framerate via your script, you can modify the scene’s render settings in Blender using the bpy module. Specifically, you can set the fps attribute of the scene.render object. This ensures that your animations are processed and exported at the correct framerate, which is crucial for synchronizing animations in applications like Unity.

Below, I’ll show you how to integrate the framerate setting into your existing script. I’ll include only the relevant parts and explain where to place the code.

---

1. Set the Desired Framerate

First, define a variable at the beginning of your script to specify the desired framerate. This makes it easy to adjust the framerate later if needed.

#### Change the variables here
###############################
high_from_floor = 1.5
desired_framerate = 30  # Set your desired framerate here
##############################

---

2. Modify the init_scene() Function

Add the line to set the framerate within the init_scene() function, after you obtain the scene object. This ensures that the framerate is set before any animations are processed.

def init_scene(scene):
    """Initializes the Blender scene by clearing it and importing the SMPL model."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()

    # Ensure the FBX file exists
    if not os.path.exists(smpl_model):
        raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

    bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='-Z', global_scale=100)

    arm_ob = bpy.context.selected_objects[0]

    obname = 'm_avg'
    ob = bpy.data.objects[obname]
    arm_obj = 'Armature'

    ob.data.use_auto_smooth = False
    ob.data.shape_keys.animation_data_clear()
    arm_ob = bpy.data.objects[arm_obj]
    arm_ob.animation_data_clear()

    # Set the desired framerate
    scene.render.fps = desired_framerate  # Use the variable you set earlier

    return ob, obname, arm_ob

---

3. Alternatively, Set the Framerate in the main() Function

If you prefer, you can set the framerate in the main() function after initializing the scene. This might be useful if you want to manage scene settings centrally.

def main():
    """Main function to process the PKL files and collect animations into a single FBX."""
    # Initialize the scene once
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Set the desired framerate
    scene.render.fps = desired_framerate  # Set to your desired framerate

    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # ... rest of your code ...

---

4. Complete Example of the Modified Script

Here’s how you can integrate the framerate setting into your existing script. I’ve included only the relevant parts for brevity.

import bpy
import os
import math
import numpy as np
from mathutils import Matrix, Vector, Quaternion, Euler
import json
import pickle

#### Change the variables here
###############################
high_from_floor = 1.5
desired_framerate = 30  # Set your desired framerate here
##############################

# Define the input and output folders
smpl_model = 'C:/Users/Uncharted Limbo/Downloads/SMPL_maya/basicModel_m_lbs_10_207_0_v1.0.2.fbx'
input_folder = r'//wsl.localhost/Ubuntu/home/ulc/GVHMR/outputs/demo'
output_folder = r'C:/Users/Uncharted Limbo/Downloads/GVHMR_fbx_output'
os.makedirs(output_folder, exist_ok=True)

# Rest of your code...

def init_scene(scene):
    """Initializes the Blender scene by clearing it and importing the SMPL model."""
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()

    # Ensure the FBX file exists
    if not os.path.exists(smpl_model):
        raise FileNotFoundError(f"SMPL model FBX file not found at {smpl_model}")

    bpy.ops.import_scene.fbx(filepath=smpl_model, axis_forward='-Y', axis_up='-Z', global_scale=100)

    arm_ob = bpy.context.selected_objects[0]

    obname = 'm_avg'
    ob = bpy.data.objects[obname]
    arm_obj = 'Armature'

    ob.data.use_auto_smooth = False
    ob.data.shape_keys.animation_data_clear()
    arm_ob = bpy.data.objects[arm_obj]
    arm_ob.animation_data_clear()

    # Set the desired framerate
    scene.render.fps = desired_framerate  # Use the variable you set earlier

    return ob, obname, arm_ob

# Rest of your functions...

def main():
    """Main function to process the PKL files and collect animations into a single FBX."""
    # Initialize the scene once
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Optionally, set the framerate here if not set in init_scene()
    # scene.render.fps = desired_framerate

    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Process each subdirectory
    # ... rest of your code ...

if __name__ == "__main__":
    main()

---

5. Additional Notes

• Framerate Base (fps_base):

  • The fps_base property can be adjusted if you need more precise control over the framerate. The default value is 1.0.
  • For most standard framerates, you can leave fps_base at 1.0.

• Units and Time Settings:

  • If you need to adjust time units or other related settings, you can modify the scene.unit_settings and scene.render properties accordingly.

• Ensuring Consistency:

  • Make sure to set the framerate before processing any animations. This ensures that keyframes are aligned correctly with the intended timing.

---

Example Usage

After incorporating the changes, when you run your script, Blender’s project framerate will be set to the desired value, and all animations will be processed and exported at this framerate.

---

Verifying the Framerate in Unity

When you import the exported .fbx file into Unity:

1. Import Settings:

   • Unity will read the framerate from the .fbx file.
   • You can verify the animation’s framerate in the Animation Import Settings.

2. Adjusting in Unity:

   • If needed, you can override the framerate in Unity by adjusting the animation clip settings.

---

Summary

• Set the Desired Framerate:

  • Define desired_framerate at the beginning of your script.
  • Example: desired_framerate = 30

• Apply the Framerate to the Scene:

  • Use scene.render.fps = desired_framerate within your script.
  • Place this line after you have access to the scene object.

• Ensure Proper Placement:

  • Set the framerate before processing animations to ensure correct keyframe timing.

---

Let Me Know If You Need Further Assistance

If you have any questions or need help with additional modifications, feel free to ask!

You

How to set the name of the action/animation, so that in Unity each animation clip has a eaningful name?

ChatGPT

To set the name of the action (animation) in Blender so that each animation clip in Unity has a meaningful name, you need to assign the desired name to the action when you create it in Blender. Unity uses the action names from Blender to name the animation clips when importing an FBX file.

Here’s how you can modify your script to set the action names:

1. Determine the Desired Action Names:

   • Decide on the naming convention you want for your animations.
   • You can use the folder names, filenames, or any other metadata to generate meaningful action names.

2. Set the Action Name When Creating the Action:

   • When you create a new action in Blender, assign the desired name to it.
   • In your script, this is done using bpy.data.actions.new(name=action_name).

3. Ensure the Action Names are Unique and Meaningful:

   • Make sure each action name is unique to avoid conflicts.
   • Use names that make sense in the context of your project to make it easier to identify the animations in Unity.

---

Here’s How to Modify Your Script:

In your main() function, you can generate the action names based on the subdirectory names or any other criteria you prefer.

Modified main() Function:

def main():
    """Main function to process the PKL files and collect animations into a single FBX."""
    # Initialize the scene once
    scene = bpy.context.scene
    ob, obname, arm_ob = init_scene(scene)

    # Ensure output folder exists
    os.makedirs(output_folder, exist_ok=True)

    # Get list of all subdirectories in the input folder
    subdirs = [os.path.join(input_folder, d) for d in os.listdir(input_folder)
               if os.path.isdir(os.path.join(input_folder, d))]

    # Process each subdirectory
    for subdir in subdirs:
        print(f"---------------- Processing {subdir} ------------------------")

        # Find the .pkl file in the subdirectory
        pkl_files = [f for f in os.listdir(subdir) if f.endswith('.pkl')]

        if not pkl_files:
            print(f"No .pkl file found in {subdir}, skipping.")
            continue  # No .pkl file in this subdirectory, skip

        # Assume only one .pkl file per subdirectory
        pkl_file = os.path.join(subdir, pkl_files[0])

        # Generate action name based on desired criteria
        folder_name = os.path.basename(subdir)
        action_name = folder_name  # Or any other meaningful name you prefer

        try:
            # Convert PKL to action
            print(f"Processing {pkl_file}...")
            process_pkl_to_action(pkl_file, arm_ob, obname, action_name)
            print(f"Animation '{action_name}' added.")
        except Exception as e:
            print(f"Error processing {pkl_file}: {e}")
            # Optionally, you can log the error or handle it as needed

    # Export all animations to a single FBX file
    output_file = os.path.join(output_folder, 'all_animations.fbx')
    bpy.ops.export_scene.fbx(filepath=output_file, use_selection=False)
    print(f"All animations exported to: {output_file}")

Modified process_pkl_to_action() Function:

def process_pkl_to_action(pkl_file, arm_ob, obname, action_name):
    """Processes a single PKL file and converts it to a Blender action."""
    # Load PKL data
    with open(pkl_file, 'rb') as pkl:
        data = pickle.load(pkl)

    # Create a new action for the armature
    action = bpy.data.actions.new(name=action_name)
    arm_ob.animation_data_create()
    arm_ob.animation_data.action = action

    # Apply animation data
    qtd_frames = len(data['smpl_params_global']['transl'])
    print('Number of frames: ', qtd_frames)

    for fframe in range(qtd_frames):
        frame = fframe
        trans = data['smpl_params_global']['transl'][fframe]
        global_orient = data['smpl_params_global']['global_orient'][fframe]

        body_pose = data['smpl_params_global']['body_pose'][fframe]
        body_pose_fim = body_pose.reshape(int(len(body_pose)/3), 3)
        final_body_pose = np.vstack([global_orient, body_pose_fim])

        apply_trans_pose_shape(Vector(trans), final_body_pose, arm_ob, obname, frame)

    # Set the action's frame range
    action.frame_range = (0, qtd_frames - 1)

    # Adjust root bone rotation
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.w = 1.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.x = 0.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.y = 0.0
    arm_ob.pose.bones['m_avg_root'].rotation_quaternion.z = 0.0

    # Keyframe the root bone rotation
    arm_ob.pose.bones['m_avg_root'].keyframe_insert('rotation_quaternion', frame=0)
    arm_ob.pose.bones['m_avg_root'].keyframe_insert('rotation_quaternion', frame=qtd_frames - 1)

    # Add constraints to the Pelvis bone
    pelvis_bone = arm_ob.pose.bones['m_avg_Pelvis']

    # Check if constraints already exist to avoid duplication
    constraint_names = [constraint.name for constraint in pelvis_bone.constraints]
    if 'Copy Location' not in constraint_names:
        loc_constraint = pelvis_bone.constraints.new('COPY_LOCATION')
        loc_constraint.name = 'Copy Location'
        loc_constraint.target = arm_ob
        loc_constraint.subtarget = 'm_avg_Pelvis'

    if 'Copy Rotation' not in constraint_names:
        rot_constraint = pelvis_bone.constraints.new('COPY_ROTATION')
        rot_constraint.name = 'Copy Rotation'
        rot_constraint.target = arm_ob
        rot_constraint.subtarget = 'm_avg_Pelvis'

    # Clear the current action so that it doesn't interfere with the next one
    arm_ob.animation_data.action = None

Explanation:

• Assigning the Action Name:

  • We create the action with action = bpy.data.actions.new(name=action_name).
  • The action_name variable is set to the folder name or any other meaningful name you prefer.

• Using Meaningful Names:

  • By setting the action names appropriately, Unity will import the animations with these names, making it easier to identify and use them.

• Ensuring Unique Action Names:

  • It’s important that each action has a unique name to prevent conflicts.
  • Using the folder name or a combination of identifiers can help ensure uniqueness.

Example of Setting a Meaningful Action Name:

If you have a mapping or you can parse the action name from the filename, you can set it accordingly. For example:

# Extract a meaningful name from the filename
pkl_filename = os.path.basename(pkl_file)
action_name = os.path.splitext(pkl_filename)[0]  # Removes the file extension

# Alternatively, you can set a custom name
action_name = "WalkCycle"  # For example

Verification in Unity:

1. Import the FBX File:

   • Import the resulting all_animations.fbx file into your Unity project.

2. Check Animation Clips:

   • Select the imported FBX asset in the Unity Project window.
   • In the Inspector, go to the “Animations” tab.
   • You should see a list of animation clips with the names matching the action names you set in Blender.

3. Use the Animations:

   • You can now use these animation clips in your Animator Controller.
   • The meaningful names will help you identify and organize your animations.

Tips:

• Avoid Special Characters:

  • Use simple, alphanumeric names for actions to prevent any issues with file systems or Unity’s import process.

• Consistent Naming Convention:

  • Establish a consistent naming convention for your animations to maintain organization and clarity.

• Testing:

  • Test the import process with a few animations to ensure that the names appear as expected in Unity before processing all animations.

---

Summary:

• Set the action’s name property in Blender to the desired animation name.
• Ensure each action has a unique and meaningful name.
• When exported and imported into Unity, the action names will become the animation clip names.

By following these steps, you can control the names of the animation clips in Unity, making it easier to manage and utilize your animations within your project.

---

Let me know if you have any further questions or need additional assistance!

You

Create a Unity script which iterates all fbx models in an Assets folder, and fetches their animation clips in a list.

It then uses an integer to select a clip in runtime, and applies it to an Animator reference as the current clip

ChatGPT

Certainly! Below is a Unity C# script that fulfills your requirements.

This script will:

• Iterate over all FBX models in a specified folder within the Assets directory.
• Extract all animation clips from these FBX models and store them in a list.
• Allow you to select an animation clip using an integer index at runtime.
• Apply the selected animation clip to an Animator component on a GameObject.

Please note: Accessing the file system and asset database at runtime is limited in Unity. The AssetDatabase class is part of the UnityEditor namespace and cannot be used in a build or at runtime. To work around this, we’ll use a ScriptableObject to store references to the animation clips collected by an Editor script. At runtime, we’ll use this ScriptableObject to access the list of animation clips.

Below is the code for both the editor script and the runtime script.

---

1. Create a ScriptableObject to Hold the Animation Clips

First, create a ScriptableObject class to hold the list of animation clips.

Create a new C# script named AnimationClipList.cs and add the following code:

using UnityEngine;
using System.Collections.Generic;

[CreateAssetMenu(fileName = "AnimationClipList", menuName = "ScriptableObjects/AnimationClipList", order = 1)]
public class AnimationClipList : ScriptableObject
{
    public List<AnimationClip> animationClips;
}

Save this script in your Assets/Scripts folder.

---

2. Create an Editor Script to Collect Animation Clips

Next, we’ll create an editor script that scans a specified folder for FBX models and extracts their animation clips.

Create a new C# script in a folder named Editor (e.g., Assets/Scripts/Editor) called AnimationClipCollectorEditor.cs:

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

public class AnimationClipCollectorEditor : EditorWindow
{
    private string assetsFolderPath = "Assets/YourFBXFolder"; // Set your FBX folder path here
    private AnimationClipList animationClipList;

    [MenuItem("Tools/Animation Clip Collector")]
    public static void ShowWindow()
    {
        GetWindow(typeof(AnimationClipCollectorEditor), false, "Animation Clip Collector");
    }

    private void OnGUI()
    {
        GUILayout.Label("Animation Clip Collector", EditorStyles.boldLabel);

        assetsFolderPath = EditorGUILayout.TextField("FBX Folder Path:", assetsFolderPath);
        animationClipList = (AnimationClipList)EditorGUILayout.ObjectField("Animation Clip List Asset:", animationClipList, typeof(AnimationClipList), false);

        if (GUILayout.Button("Collect Animation Clips"))
        {
            CollectAnimationClips();
        }
    }

    private void CollectAnimationClips()
    {
        if (animationClipList == null)
        {
            Debug.LogError("Please assign an AnimationClipList ScriptableObject.");
            return;
        }

        string[] guids = AssetDatabase.FindAssets("t:Model", new[] { assetsFolderPath });
        List<AnimationClip> clips = new List<AnimationClip>();

        foreach (string guid in guids)
        {
            string assetPath = AssetDatabase.GUIDToAssetPath(guid);
            Object[] assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);

            foreach (Object asset in assets)
            {
                if (asset is AnimationClip clip)
                {
                    // Exclude editor-generated clips
                    if (!clip.name.Contains("__preview__"))
                    {
                        clips.Add(clip);
                    }
                }
            }
        }

        animationClipList.animationClips = clips;
        EditorUtility.SetDirty(animationClipList);
        AssetDatabase.SaveAssets();

        Debug.Log($"Collected {clips.Count} animation clips.");
    }
}

Instructions:

• Replace "Assets/YourFBXFolder" with the path to the folder containing your FBX models within the Assets directory.
• Save this script in the Assets/Scripts/Editor folder.

Usage:

1. In Unity, create a new AnimationClipList asset:

   • Right-click in your Project window.
   • Select Create > ScriptableObjects > AnimationClipList.
   • Name it MyAnimationClipList.

2. Open the Animation Clip Collector window:

   • Go to Tools > Animation Clip Collector.

3. In the window:

   • Set the FBX Folder Path to the folder containing your FBX models (e.g., Assets/YourFBXFolder).
   • Assign the Animation Clip List Asset to the MyAnimationClipList asset you just created.
   • Click on Collect Animation Clips.

4. The script will collect all animation clips from the FBX models in the specified folder and store them in the MyAnimationClipList asset.

---

3. Create the Runtime Script to Use the Animation Clips

Now, create a runtime script that will use the AnimationClipList asset to select and play animation clips at runtime.

Create a new C# script named AnimationClipSelector.cs:

using UnityEngine;

public class AnimationClipSelector : MonoBehaviour
{
    public AnimationClipList animationClipList; // Assign the AnimationClipList asset here
    public Animator animator; // Assign the Animator component
    public int clipIndex = 0; // The index of the animation clip to play

    void Start()
    {
        if (animationClipList == null || animationClipList.animationClips == null || animationClipList.animationClips.Count == 0)
        {
            Debug.LogError("AnimationClipList is empty or not assigned.");
            return;
        }

        if (animator == null)
        {
            Debug.LogError("Animator component is not assigned.");
            return;
        }

        PlayAnimationClip(clipIndex);
    }

    public void PlayAnimationClip(int index)
    {
        if (index < 0 || index >= animationClipList.animationClips.Count)
        {
            Debug.LogError("Clip index out of range.");
            return;
        }

        AnimationClip clip = animationClipList.animationClips[index];

        // Create a runtime animator controller if not already set
        if (animator.runtimeAnimatorController == null)
        {
            animator.runtimeAnimatorController = new AnimatorOverrideController();
        }

        // Create an override controller based on the current controller
        AnimatorOverrideController overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);

        // Create a new animation clip array
        AnimationClipPair[] clipPair = overrideController.animationClips
            .Select(c => new AnimationClipPair { originalClip = c, overrideClip = c })
            .ToArray();

        // Override the default animation with the selected clip
        if (clipPair.Length > 0)
        {
            clipPair[0].overrideClip = clip;
            overrideController.animationClips = clipPair.Select(p => p.overrideClip).ToArray();
        }
        else
        {
            // If no default clips, set the clip directly
            overrideController["DefaultAnimation"] = clip;
        }

        // Assign the override controller to the animator
        animator.runtimeAnimatorController = overrideController;

        // Play the animation
        animator.Play(overrideController.animationClips[0].name, 0, 0);
    }

    // Example of changing the clip at runtime
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Increment the clip index and loop back to zero
            clipIndex = (clipIndex + 1) % animationClipList.animationClips.Count;
            PlayAnimationClip(clipIndex);
        }
    }
}

Instructions:

• Attach this script to a GameObject in your scene.
• Assign the MyAnimationClipList asset to the animationClipList field in the inspector.
• Assign the Animator component of your character to the animator field.
• Set the clipIndex to the desired starting animation index.

Note:

• Ensure your Animator has a default state. If not, create an empty Animator Controller and assign it to the Animator component.
• The Update() method allows you to cycle through animations by pressing the Spacebar.

---

4. Create an Animator Controller

If you don’t already have an Animator Controller assigned to your Animator component:

1. Right-click in the Project window and select Create > Animator Controller.
2. Name it DefaultAnimatorController.
3. Assign this Animator Controller to the Animator component on your character.

---

5. Running the Script

• When you run the scene, the script will play the animation clip at the specified clipIndex.
• Press the Spacebar to cycle through the animation clips.

---

Additional Notes

• Runtime Limitations: Since Unity cannot access the AssetDatabase at runtime in builds, we use a ScriptableObject to store references to the animation clips.

• AnimationClipList Asset: The AnimationClipList asset acts as a container for your animation clips, making them accessible at runtime.

• AnimatorOverrideController: We use an AnimatorOverrideController to replace the default animation with the selected clip at runtime.

• Error Handling: The script includes basic error checking to ensure that the Animator and AnimationClipList are properly assigned.

---

Alternative Approach Using Resources Folder

If you prefer not to use an editor script and ScriptableObject, you can place your animation clips into a Resources folder and load them at runtime using Resources.LoadAll<AnimationClip>(). However, this requires manually organizing your animation clips and may not automatically extract them from FBX files.

---

Summary

By following the steps above, you can:

• Collect all animation clips from FBX models in a specified Assets folder.
• Store them in a ScriptableObject for runtime access.
• Select and apply an animation clip to an Animator component using an integer index at runtime.

---

Let me know if you have any questions or need further assistance!

You

instead of typing the assets path, i just want to be able to drag the folder

ChatGPT

Certainly! You can modify the editor script to allow you to drag and drop the folder instead of typing the assets path manually. We’ll achieve this by changing the assetsFolderPath from a string to a DefaultAsset reference, which can represent a folder in Unity. This way, you can easily assign the folder by dragging it into the field in the editor window.

Here’s the updated editor script:

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
using System.Linq;

public class AnimationClipCollectorEditor : EditorWindow
{
    private DefaultAsset assetsFolder; // Drag your folder here
    private AnimationClipList animationClipList;

    [MenuItem("Tools/Animation Clip Collector")]
    public static void ShowWindow()
    {
        GetWindow(typeof(AnimationClipCollectorEditor), false, "Animation Clip Collector");
    }

    private void OnGUI()
    {
        GUILayout.Label("Animation Clip Collector", EditorStyles.boldLabel);

        // Change from string to DefaultAsset for folder drag-and-drop
        assetsFolder = (DefaultAsset)EditorGUILayout.ObjectField("FBX Folder:", assetsFolder, typeof(DefaultAsset), false);
        animationClipList = (AnimationClipList)EditorGUILayout.ObjectField("Animation Clip List Asset:", animationClipList, typeof(AnimationClipList), false);

        if (GUILayout.Button("Collect Animation Clips"))
        {
            CollectAnimationClips();
        }
    }

    private void CollectAnimationClips()
    {
        if (animationClipList == null)
        {
            Debug.LogError("Please assign an AnimationClipList ScriptableObject.");
            return;
        }

        if (assetsFolder == null)
        {
            Debug.LogError("Please assign a folder containing FBX files.");
            return;
        }

        // Get the path of the folder
        string assetsFolderPath = AssetDatabase.GetAssetPath(assetsFolder);

        if (string.IsNullOrEmpty(assetsFolderPath))
        {
            Debug.LogError("Invalid folder path.");
            return;
        }

        // Find all models in the folder
        string[] guids = AssetDatabase.FindAssets("t:Model", new[] { assetsFolderPath });
        List<AnimationClip> clips = new List<AnimationClip>();

        foreach (string guid in guids)
        {
            string assetPath = AssetDatabase.GUIDToAssetPath(guid);
            Object[] assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);

            foreach (Object asset in assets)
            {
                if (asset is AnimationClip clip)
                {
                    // Exclude editor-generated clips and duplicates
                    if (!AnimationUtility.IsAnimatorController(asset) && !clip.name.Contains("__preview__"))
                    {
                        clips.Add(clip);
                    }
                }
            }
        }

        animationClipList.animationClips = clips;
        EditorUtility.SetDirty(animationClipList);
        AssetDatabase.SaveAssets();

        Debug.Log($"Collected {clips.Count} animation clips.");
    }
}

---

Explanation of Changes:

1. Changed assetsFolderPath from a string to DefaultAsset assetsFolder:

   • DefaultAsset can represent any asset, including folders.
   • This allows you to drag and drop a folder into the field in the editor window.

2. Updated the GUI (OnGUI method):

   • Replaced the text field for the folder path with an ObjectField that accepts DefaultAsset.
   • Now, you can drag and drop the folder containing your FBX files directly into the editor window.

3. Modified CollectAnimationClips method:

   • Added a null check for assetsFolder to ensure a folder is assigned.
   • Used AssetDatabase.GetAssetPath(assetsFolder) to get the path of the selected folder.
   • The rest of the method remains the same, finding all model assets (t:Model) in the folder and collecting their animation clips.

---

Usage Instructions:

1. Create the Script:

   • Save the updated script as AnimationClipCollectorEditor.cs in the Assets/Scripts/Editor folder (create the folder if it doesn’t exist).

2. Create the AnimationClipList Asset:

   • In Unity, right-click in the Project window.
   • Select Create > ScriptableObjects > AnimationClipList.
   • Name the asset (e.g., MyAnimationClipList).

3. Open the Animation Clip Collector Window:

   • In Unity’s menu bar, go to Tools > Animation Clip Collector.

4. Assign the FBX Folder and AnimationClipList Asset:

   • In the Animation Clip Collector window:

     • FBX Folder: Drag and drop the folder containing your FBX files into this field.
     • Animation Clip List Asset: Assign the MyAnimationClipList asset you created earlier.

     

5. Collect Animation Clips:

   • Click the Collect Animation Clips button.
   • The script will scan the folder and collect all animation clips from the FBX models.
   • A message in the console will indicate how many animation clips were collected.

6. Assign the AnimationClipList in Your Runtime Script:

   • In your scene, select the GameObject with the AnimationClipSelector script attached.
   • Assign the MyAnimationClipList asset to the animationClipList field.
   • Assign the Animator component to the animator field.

---

Updated Runtime Script (AnimationClipSelector.cs):

No changes are needed in your runtime script. It remains the same:

using UnityEngine;
using System.Linq;

public class AnimationClipSelector : MonoBehaviour
{
    public AnimationClipList animationClipList; // Assign the AnimationClipList asset here
    public Animator animator; // Assign the Animator component
    public int clipIndex = 0; // The index of the animation clip to play

    void Start()
    {
        if (animationClipList == null || animationClipList.animationClips == null || animationClipList.animationClips.Count == 0)
        {
            Debug.LogError("AnimationClipList is empty or not assigned.");
            return;
        }

        if (animator == null)
        {
            Debug.LogError("Animator component is not assigned.");
            return;
        }

        PlayAnimationClip(clipIndex);
    }

    public void PlayAnimationClip(int index)
    {
        if (index < 0 || index >= animationClipList.animationClips.Count)
        {
            Debug.LogError("Clip index out of range.");
            return;
        }

        AnimationClip clip = animationClipList.animationClips[index];

        // Create a runtime animator controller if not already set
        if (animator.runtimeAnimatorController == null)
        {
            animator.runtimeAnimatorController = new AnimatorOverrideController();
        }

        // Create an override controller based on the current controller
        AnimatorOverrideController overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);

        // Get all original clips and override them with the selected clip
        var overrides = new List<KeyValuePair<AnimationClip, AnimationClip>>();
        overrideController.GetOverrides(overrides);

        for (int i = 0; i < overrides.Count; i++)
        {
            overrides[i] = new KeyValuePair<AnimationClip, AnimationClip>(overrides[i].Key, clip);
        }

        overrideController.ApplyOverrides(overrides);

        // Assign the override controller to the animator
        animator.runtimeAnimatorController = overrideController;

        // Play the animation
        animator.Play(clip.name, 0, 0);
    }

    // Example of changing the clip at runtime
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Increment the clip index and loop back to zero
            clipIndex = (clipIndex + 1) % animationClipList.animationClips.Count;
            PlayAnimationClip(clipIndex);
        }
    }
}

---

Testing the Script:

• Run the Scene:

  • Press Play in the Unity Editor.
  • The character should play the animation clip corresponding to the clipIndex.

• Cycle Through Animations:

  • Press the Spacebar to increment the clipIndex and play the next animation.

• Change the clipIndex in the Inspector:

  • While the game is running, you can change the clipIndex value in the Inspector to select different animations.

---

Additional Notes:

• Nested Folders:

  • The script will search recursively in the selected folder, including all subfolders.

• Assigning the Animator Component:

  • Make sure your character or GameObject has an Animator component attached.
  • Assign this component to the animator field in the AnimationClipSelector script.

• Animator Controller:

  • The script uses an AnimatorOverrideController to play the selected animation clip.
  • If your Animator already has a controller, the script will override it at runtime.

• Error Handling:

  • The script includes error checks to ensure all required components and assets are assigned.
  • Check the console for any error messages if the animations are not playing.

---

Benefits of This Approach:

• User-Friendly:

  • Drag-and-drop interface simplifies selecting the folder containing your FBX files.
  • Reduces the chance of typos or incorrect paths.

• Dynamic Content Management:

  • Easily update the AnimationClipList by re-running the collector if you add new animations.

• Runtime Flexibility:

  • Change animations at runtime using the clipIndex, allowing for dynamic character behavior.

---

Summary:

• Editor Script:

  • Modified to allow dragging a folder into the editor window.
  • Collects animation clips from all FBX models in the selected folder.

• Runtime Script:

  • Uses the collected animation clips.
  • Allows selecting and playing animations using an integer index.

• Usage:

  • Create and assign the necessary assets.
  • Assign components and assets in the Inspector.
  • Run the scene and test the functionality.

---

Feel free to let me know if you have any questions or need further assistance!

You

what is the AnimationUtility.IsAnimatorController ?

ChatGPT

You’re absolutely correct to point out this issue. My apologies for the confusion.

The method AnimationUtility.IsAnimatorController does not exist in Unity’s API. This was an oversight in the code I provided.

The purpose of the line in question is to ensure that we only collect valid AnimationClip assets and exclude any unwanted assets like preview clips or other types of assets that might be included when loading all assets from a path.

Here’s the problematic line:

if (!AnimationUtility.IsAnimatorController(asset) && !clip.name.Contains("__preview__"))

Since AnimationUtility.IsAnimatorController doesn’t exist, we need to adjust the code to correctly filter out any assets that are not desired.

---

Updated Code with Corrections:

Modify the CollectAnimationClips method in AnimationClipCollectorEditor.cs:

private void CollectAnimationClips()
{
    if (animationClipList == null)
    {
        Debug.LogError("Please assign an AnimationClipList ScriptableObject.");
        return;
    }

    if (assetsFolder == null)
    {
        Debug.LogError("Please assign a folder containing FBX files.");
        return;
    }

    // Get the path of the folder
    string assetsFolderPath = AssetDatabase.GetAssetPath(assetsFolder);

    if (string.IsNullOrEmpty(assetsFolderPath))
    {
        Debug.LogError("Invalid folder path.");
        return;
    }

    // Find all models in the folder
    string[] guids = AssetDatabase.FindAssets("t:Model", new[] { assetsFolderPath });
    List<AnimationClip> clips = new List<AnimationClip>();

    foreach (string guid in guids)
    {
        string assetPath = AssetDatabase.GUIDToAssetPath(guid);
        Object[] assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);

        foreach (Object asset in assets)
        {
            if (asset is AnimationClip clip)
            {
                // Exclude editor-generated clips and duplicates
                if (!AssetDatabase.IsSubAsset(clip) && !clip.name.Contains("__preview__"))
                {
                    clips.Add(clip);
                }
            }
        }
    }

    animationClipList.animationClips = clips;
    EditorUtility.SetDirty(animationClipList);
    AssetDatabase.SaveAssets();

    Debug.Log($"Collected {clips.Count} animation clips.");
}

---

Explanation of Changes:

• Removed the Invalid Method:

  • Removed !AnimationUtility.IsAnimatorController(asset) since it doesn’t exist.

• Using AssetDatabase.IsSubAsset:

  • Added !AssetDatabase.IsSubAsset(clip) to filter out any sub-assets that are not the main asset. This helps to exclude any internal or editor-generated clips that we might not want.
  • Alternatively, you might consider using AssetDatabase.GetMainAssetTypeAtPath(assetPath) or check for specific asset types.

• Ensuring Correct Type:

  • Since we’re already checking if (asset is AnimationClip clip), we are only processing objects that are AnimationClip instances.

• Exclude Preview Clips:

  • The condition !clip.name.Contains("__preview__") helps to exclude any preview clips that Unity might generate internally.

---

Alternative Filtering Method:

If you want to ensure that you’re only collecting AnimationClips that are not part of an Animator Controller or any other unwanted assets, you can adjust the code further.

For example, you might check the hideFlags of the asset:

if (asset is AnimationClip clip)
{
    // Exclude editor-generated clips and hidden clips
    if ((clip.hideFlags & HideFlags.HideInHierarchy) == 0 && !clip.name.Contains("__preview__"))
    {
        clips.Add(clip);
    }
}

However, in most cases, the previous correction using AssetDatabase.IsSubAsset should suffice.

---

Understanding AssetDatabase.IsSubAsset:

• Main Asset vs. Sub-Asset:

  • In Unity, an FBX file is considered a main asset, and the objects inside it (like meshes, animations, etc.) are sub-assets.
  • Using AssetDatabase.IsSubAsset(asset) allows you to check if an asset is a sub-asset.

• Filtering:

  • By filtering out sub-assets or including them based on your needs, you can collect only the desired assets.

---

Final Notes:

• No Need to Check for Animator Controllers:

  • Since we’re loading assets from FBX files and only interested in AnimationClip assets, we can rely on the type check if (asset is AnimationClip clip).

• Excluding Unwanted Clips:

  • The check !clip.name.Contains("__preview__") helps to exclude any automatically generated preview clips that are not meant for use.

• Testing:

  • After making these changes, please test the script to ensure it collects the correct animation clips.

---

Complete Updated AnimationClipCollectorEditor.cs Script:

Here’s the complete updated script with the corrections:

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

public class AnimationClipCollectorEditor : EditorWindow
{
    private DefaultAsset assetsFolder; // Drag your folder here
    private AnimationClipList animationClipList;

    [MenuItem("Tools/Animation Clip Collector")]
    public static void ShowWindow()
    {
        GetWindow(typeof(AnimationClipCollectorEditor), false, "Animation Clip Collector");
    }

    private void OnGUI()
    {
        GUILayout.Label("Animation Clip Collector", EditorStyles.boldLabel);

        // Change from string to DefaultAsset for folder drag-and-drop
        assetsFolder = (DefaultAsset)EditorGUILayout.ObjectField("FBX Folder:", assetsFolder, typeof(DefaultAsset), false);
        animationClipList = (AnimationClipList)EditorGUILayout.ObjectField("Animation Clip List Asset:", animationClipList, typeof(AnimationClipList), false);

        if (GUILayout.Button("Collect Animation Clips"))
        {
            CollectAnimationClips();
        }
    }

    private void CollectAnimationClips()
    {
        if (animationClipList == null)
        {
            Debug.LogError("Please assign an AnimationClipList ScriptableObject.");
            return;
        }

        if (assetsFolder == null)
        {
            Debug.LogError("Please assign a folder containing FBX files.");
            return;
        }

        // Get the path of the folder
        string assetsFolderPath = AssetDatabase.GetAssetPath(assetsFolder);

        if (string.IsNullOrEmpty(assetsFolderPath))
        {
            Debug.LogError("Invalid folder path.");
            return;
        }

        // Find all models in the folder
        string[] guids = AssetDatabase.FindAssets("t:Model", new[] { assetsFolderPath });
        List<AnimationClip> clips = new List<AnimationClip>();

        foreach (string guid in guids)
        {
            string assetPath = AssetDatabase.GUIDToAssetPath(guid);
            Object[] assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);

            foreach (Object asset in assets)
            {
                if (asset is AnimationClip clip)
                {
                    // Exclude editor-generated clips and duplicates
                    if (!clip.name.Contains("__preview__"))
                    {
                        clips.Add(clip);
                    }
                }
            }
        }

        animationClipList.animationClips = clips;
        EditorUtility.SetDirty(animationClipList);
        AssetDatabase.SaveAssets();

        Debug.Log($"Collected {clips.Count} animation clips.");
    }
}

---

Usage Instructions:

1. Update the Script:

   • Replace the existing AnimationClipCollectorEditor.cs script with the corrected version above.

2. Recompile in Unity:

   • Unity should automatically recompile the scripts. If not, you can force it by making a small change or re-importing the script.

3. Run the Collector:

   • Open the Animation Clip Collector window from Tools > Animation Clip Collector.
   • Drag your FBX folder into the FBX Folder field.
   • Assign your AnimationClipList asset to the Animation Clip List Asset field.
   • Click Collect Animation Clips.

4. Verify the Collected Clips:

   • Check the AnimationClipList asset to ensure it has collected the correct animation clips.
   • You can view the clips in the Inspector by selecting the asset.

5. Proceed with Runtime Script:

   • Use the AnimationClipSelector script as previously described to select and play the animations at runtime.

---

Additional Information:

• Asset Types in Unity:

  • Unity assets can be various types, and when loading all assets from a path, you may encounter different types.
  • It’s important to check the asset type (if (asset is AnimationClip clip)) to ensure you’re only processing the desired assets.

• Animation Clips in FBX Files:

  • When you import an FBX file with animations, Unity generates AnimationClip assets as sub-assets of the FBX file.
  • These clips can be accessed and used in your projects.

• Understanding the Error:

  • The original use of AnimationUtility.IsAnimatorController might have been a confusion with checking if an asset is an AnimatorController.
  • Since we’re only interested in AnimationClip assets, we don’t need to check for AnimatorController types.

• AssetDatabase Class:

  • The AssetDatabase class provides methods for interacting with the Unity asset database in the Editor.
  • It allows you to load assets, find assets by type, and get asset paths.

---

Let Me Know If You Have Further Questions:

• If you have any more questions or need clarification on any part of the script, feel free to ask.
• I’m here to help ensure your project works as intended.

You

in the unity playback script, all these new object allocations seem redundant.

minimize new objects, keep only one clip in the animator, and only swap this

public void PlayAnimationClip(int index) { if (index < 0 || index >= animationClipList.animationClips.Count) { Debug.LogError(“Clip index out of range.”); return; }

    AnimationClip clip = animationClipList.animationClips[index];

    // Create a runtime animator controller if not already set
    if (animator.runtimeAnimatorController == null)
    {
        animator.runtimeAnimatorController = new AnimatorOverrideController();
    }

    // Create an override controller based on the current controller
    AnimatorOverrideController overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);

    // Get all original clips and override them with the selected clip
    var overrides = new List<KeyValuePair<AnimationClip, AnimationClip>>();
    overrideController.GetOverrides(overrides);

    for (int i = 0; i < overrides.Count; i++)
    {
        overrides[i] = new KeyValuePair<AnimationClip, AnimationClip>(overrides[i].Key, clip);
    }

    overrideController.ApplyOverrides(overrides);

    // Assign the override controller to the animator
    animator.runtimeAnimatorController = overrideController;

    // Play the animation
    animator.Play(clip.name, 0, 0);
}

ChatGPT

You’re absolutely right. The original PlayAnimationClip method creates new objects every time it’s called, which is inefficient and can lead to unnecessary memory allocations. To optimize the code, we can modify it to:

• Create the AnimatorOverrideController only once and reuse it.
• Keep a single animation clip in the animator and swap it as needed.
• Avoid creating new lists or objects within the PlayAnimationClip method.

Below is the optimized version of your script with explanations for each change.

---

Optimized AnimationClipSelector Script

using UnityEngine;

public class AnimationClipSelector : MonoBehaviour
{
    public AnimationClipList animationClipList; // Assign the AnimationClipList asset here
    public Animator animator; // Assign the Animator component
    public int clipIndex = 0; // The index of the animation clip to play

    private AnimatorOverrideController overrideController;

    void Start()
    {
        if (animationClipList == null || animationClipList.animationClips == null || animationClipList.animationClips.Count == 0)
        {
            Debug.LogError("AnimationClipList is empty or not assigned.");
            return;
        }

        if (animator == null)
        {
            Debug.LogError("Animator component is not assigned.");
            return;
        }

        if (animator.runtimeAnimatorController == null)
        {
            Debug.LogError("Animator does not have a runtime animator controller assigned.");
            return;
        }

        // Create the AnimatorOverrideController only once and assign it to the animator
        overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
        animator.runtimeAnimatorController = overrideController;

        PlayAnimationClip(clipIndex);
    }

    public void PlayAnimationClip(int index)
    {
        if (index < 0 || index >= animationClipList.animationClips.Count)
        {
            Debug.LogError("Clip index out of range.");
            return;
        }

        AnimationClip clip = animationClipList.animationClips[index];

        // Get the original animation clip from the override controller
        AnimationClip originalClip = overrideController.animationClips[0];

        // Swap the clip in the override controller
        overrideController[originalClip.name] = clip;

        // Play the animation
        animator.Play(originalClip.name, 0, 0);
    }

    // Example of changing the clip at runtime
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Increment the clip index and loop back to zero
            clipIndex = (clipIndex + 1) % animationClipList.animationClips.Count;
            PlayAnimationClip(clipIndex);
        }
    }
}

---

Explanation of Changes

1. Create and Reuse AnimatorOverrideController

• Previous Code:

  // Created a new AnimatorOverrideController every time PlayAnimationClip is called
  AnimatorOverrideController overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);

• Optimized Code:

  // Created once in Start() and reused
  overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
  animator.runtimeAnimatorController = overrideController;

  • Benefit: By creating the AnimatorOverrideController once in the Start() method and assigning it to the animator, we avoid creating a new instance every time we play a new animation clip.

2. Swap the Animation Clip Without Creating New Objects

• Previous Code:

  • Created new lists and key-value pairs to override clips.
  • Allocated new memory for these objects on each method call.

• Optimized Code:

  // Get the original animation clip from the override controller
  AnimationClip originalClip = overrideController.animationClips[0];
  
  // Swap the clip in the override controller
  overrideController[originalClip.name] = clip;

  • Benefit: By directly accessing and modifying the existing override, we eliminate the need to create new lists or objects. This minimizes memory allocations and improves performance.

3. Maintain a Single Animation Clip in the Animator

• Implementation:

  • Ensure that the Animator Controller assigned to your animator has a single animation state with a default clip.
  • This clip will be overridden at runtime with the desired animation clip.

  // In Start(), we set up the override controller with the default animator controller
  overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
  animator.runtimeAnimatorController = overrideController;

  • Benefit: Keeping only one clip in the animator simplifies the override process and reduces overhead.

4. Avoid Recreating Lists or Collections

• Previous Code:

  • Created new lists and collections within PlayAnimationClip().

• Optimized Code:

  • We no longer create any lists or collections inside PlayAnimationClip().
  • All operations are done using existing objects.

---

Usage Instructions

1. Animator Controller Setup:

   • Create an Animator Controller with a single state.
   • Assign any default animation clip to this state (it will be overridden at runtime).
   • Assign this Animator Controller to your character’s Animator component.

2. Script Assignment:

   • Attach the AnimationClipSelector script to your character or relevant GameObject.
   • Assign the AnimationClipList asset to the animationClipList field.
   • Assign the Animator component to the animator field.
   • Set the initial clipIndex if desired.

3. Running the Scene:

   • When you run the scene, the script will play the animation clip at the specified clipIndex.
   • Press the Spacebar to cycle through animations.

---

Benefits of the Optimized Code

• Reduced Memory Allocations:

  • By eliminating the creation of new objects in PlayAnimationClip(), we reduce garbage collection pressure and improve runtime performance.

• Simplified Logic:

  • The code is cleaner and easier to understand, focusing on swapping the clip without unnecessary overhead.

• Improved Performance:

  • Minimizing object allocations can lead to smoother gameplay, especially in scenarios where animations are swapped frequently.

---

Additional Considerations

• Thread Safety:

  • Unity’s main thread handles most operations, so thread safety isn’t a concern here.

• Animator Controller Complexity:

  • This approach assumes a simple animator controller. If your animator controller is more complex (e.g., with multiple states or parameters), you might need to adjust the logic accordingly.

• Animation State Names:

  • Ensure that the state name in your animator controller matches the originalClip.name. This is necessary because animator.Play() uses the state’s name to play the animation.

---

Example Animator Controller Setup

1. Create an Animator Controller:

   • Right-click in the Project window and select Create > Animator Controller.
   • Name it SingleStateAnimatorController.

2. Add a Single State:

   • Open the animator controller by double-clicking it.
   • In the Animator window, right-click and select Create State > Empty.
   • Assign a default animation clip to this state (any clip; it will be overridden).

3. Set State Name:

   • Name the state (e.g., DefaultState).

   • Ensure that this name is used when playing the animation:

     animator.Play("DefaultState", 0, 0);

   • Alternatively, you can retrieve the state’s name programmatically.

---

Final Optimized PlayAnimationClip Method

public void PlayAnimationClip(int index)
{
    if (index < 0 || index >= animationClipList.animationClips.Count)
    {
        Debug.LogError("Clip index out of range.");
        return;
    }

    AnimationClip clip = animationClipList.animationClips[index];

    // Swap the clip in the override controller
    overrideController["DefaultState"] = clip;

    // Play the animation
    animator.Play("DefaultState", 0, 0);
}

• Note: Replace "DefaultState" with the actual name of your animation state in the animator controller.

---

Conclusion

By modifying the PlayAnimationClip method to reuse objects and avoid unnecessary allocations, we’ve optimized the script to be more efficient. This approach ensures that only one clip is maintained in the animator, and we simply swap it out when needed, which aligns with your requirements.

---

Let me know if you have any questions or need further assistance!

You

let’s take a step back. I simply want to inject different animation clips into an object’s animator. what are all these fancy weird stuff…

keep it simple and efficient

ChatGPT

Understood, let’s simplify the approach.

If you want to inject different animation clips into an object’s Animator in a simple and efficient way, you can do the following:

1. Prepare Your Animator Controller:

   • Create an Animator Controller with a single state.
   • Name the state (e.g., "DefaultState").
   • Assign any default animation clip to this state (it will be overridden at runtime).
   • Assign this Animator Controller to the Animator component on your GameObject.

2. Create a Script to Swap Animation Clips:

   Here’s a simple script that allows you to swap animation clips at runtime:

   using UnityEngine;
   
   public class SimpleAnimationSwitcher : MonoBehaviour
   {
       public Animator animator;               // Assign the Animator component in the Inspector
       public AnimationClip[] animationClips;  // Assign the animation clips in the Inspector
       public int clipIndex = 0;               // The index of the animation clip to play
   
       private AnimatorOverrideController overrideController;
   
       void Start()
       {
           if (animator == null)
           {
               Debug.LogError("Animator component is not assigned.");
               return;
           }
   
           if (animationClips == null || animationClips.Length == 0)
           {
               Debug.LogError("No animation clips assigned.");
               return;
           }
   
           if (animator.runtimeAnimatorController == null)
           {
               Debug.LogError("Animator does not have a runtime animator controller assigned.");
               return;
           }
   
           // Create the AnimatorOverrideController once and assign it to the animator
           overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
           animator.runtimeAnimatorController = overrideController;
   
           // Play the initial animation clip
           PlayAnimationClip(clipIndex);
       }
   
       public void PlayAnimationClip(int index)
       {
           if (index < 0 || index >= animationClips.Length)
           {
               Debug.LogError("Clip index out of range.");
               return;
           }
   
           AnimationClip clip = animationClips[index];
   
           // Override the default animation clip with the selected clip
           overrideController["DefaultState"] = clip; // "DefaultState" is the name of the state in your Animator Controller
   
           // Play the animation
           animator.Play("DefaultState", 0, 0);
       }
   
       // Example of changing the clip at runtime
       void Update()
       {
           if (Input.GetKeyDown(KeyCode.Space))
           {
               // Increment the clip index and loop back to zero
               clipIndex = (clipIndex + 1) % animationClips.Length;
               PlayAnimationClip(clipIndex);
           }
       }
   }

   Explanation:

   • Animator Component: Assign your object’s Animator component to the animator field in the Inspector.
   • Animation Clips: Assign the animation clips you want to use to the animationClips array in the Inspector.
   • AnimatorOverrideController:
     • We create an AnimatorOverrideController based on the Animator’s existing controller.
     • This allows us to swap out the animation clip used in the state without creating new controllers each time.
   • PlayAnimationClip Method:
     • Overrides the animation clip in the "DefaultState" with the selected clip.
     • Plays the "DefaultState" to start the animation.
   • Efficiency:
     • The overrideController is created once in Start() and reused.
     • No unnecessary objects are created during runtime, keeping it simple and efficient.

3. Usage:

   • Assign Components:
     • Attach the SimpleAnimationSwitcher script to your GameObject.
     • Assign the Animator component and the animation clips in the Inspector.
   • Animator Controller:
     • Ensure your Animator Controller has a single state named "DefaultState".
     • Assign any default clip to this state; it will be overridden at runtime.
   • Runtime Control:
     • The script will play the animation clip at the specified clipIndex.
     • You can change the clipIndex in the Inspector or via script to switch animations.
     • In the provided example, pressing the Spacebar cycles through the animations.

Benefits of This Approach:

• Simplicity:
  • No need for complex editor scripts or asset management.
  • Uses built-in Unity components and straightforward scripting.
• Efficiency:
  • Minimizes object allocations by reusing the AnimatorOverrideController.
  • Swaps animation clips without creating new objects each time.
• Flexibility:
  • Easily expand the animationClips array to include more animations.
  • Control the animation selection via code or user input.

Notes:

• Animator Controller Setup:
  • The state name in your Animator Controller must match the string used in the script ("DefaultState").
  • If you use a different state name, update the script accordingly.
• Animation Clips:
  • Ensure that the animation clips you assign are compatible with the Animator’s avatar (if using humanoid animations).
• Animator Parameters:
  • This approach assumes a simple Animator Controller without parameters or transitions.
  • For more complex controllers, additional scripting may be required.

Example:

Suppose you have three animation clips: Idle, Walk, and Run.

• Assign them to the animationClips array in the order you prefer.
• Set clipIndex to 0 to start with the Idle animation.
• At runtime, pressing the Spacebar will cycle through Walk and Run.

Alternative: Using the Animation Component (Legacy)

If you prefer an even simpler method and are okay with using Unity’s legacy animation system, you can use the Animation component:

1. Add an Animation Component:

   • Remove the Animator component from your GameObject.
   • Add the Animation component instead.

2. Assign Animation Clips:

   • In the Animation component, add your animation clips to the list.

3. Simple Script to Play Animations:

   using UnityEngine;
   
   public class SimpleAnimationPlayer : MonoBehaviour
   {
       public Animation animationComponent;    // Assign the Animation component in the Inspector
       public string[] animationClipNames;     // Names of the animation clips
       public int clipIndex = 0;               // The index of the animation clip to play
   
       void Start()
       {
           if (animationComponent == null)
           {
               Debug.LogError("Animation component is not assigned.");
               return;
           }
   
           if (animationClipNames == null || animationClipNames.Length == 0)
           {
               Debug.LogError("No animation clip names assigned.");
               return;
           }
   
           PlayAnimationClip(clipIndex);
       }
   
       public void PlayAnimationClip(int index)
       {
           if (index < 0 || index >= animationClipNames.Length)
           {
               Debug.LogError("Clip index out of range.");
               return;
           }
   
           string clipName = animationClipNames[index];
           animationComponent.Play(clipName);
       }
   
       void Update()
       {
           if (Input.GetKeyDown(KeyCode.Space))
           {
               // Increment the clip index and loop back to zero
               clipIndex = (clipIndex + 1) % animationClipNames.Length;
               PlayAnimationClip(clipIndex);
           }
       }
   }

   Note:

   • The Animation component is considered legacy and is not recommended for new projects.
   • It’s suitable for simple cases and may be sufficient depending on your needs.

Conclusion

This simplified approach allows you to inject and switch between different animation clips efficiently, without unnecessary complexity. It leverages Unity’s built-in systems and keeps the code straightforward.

Let me know if you have any questions or need further assistance!

You

but what if the original animator had no clip to begin with ?

ChatGPT

Certainly! If your Animator component doesn’t have any clips or an Animator Controller assigned, you can handle this by creating a simple Animator Controller with a default state at runtime or in the Unity Editor. This allows you to inject different animation clips into your object efficiently.

Here’s how you can achieve this:

---

Option 1: Create an Animator Controller in the Editor

The simplest and most efficient approach is to create a basic Animator Controller in the Unity Editor and assign it to your Animator component. Then, you can swap the animation clips at runtime.

Steps:

1. Create a Basic Animator Controller:

   • In Unity, right-click in the Project window.
   • Select Create > Animator Controller.
   • Name it, for example, SimpleAnimatorController.

2. Add a Default State:

   • Double-click the SimpleAnimatorController to open it in the Animator window.
   • Right-click in the empty space and select Create State > Empty.
   • Name the state "DefaultState".
   • Do not assign any animation clip to this state.

   

3. Assign the Animator Controller to Your Animator:

   • Select your GameObject with the Animator component.
   • In the Inspector, assign the SimpleAnimatorController to the Controller field of the Animator component.

4. Use the Simplified Script:

   Here’s a simple and efficient script that swaps animation clips in the Animator:

   using UnityEngine;
   
   public class SimpleAnimationSwitcher : MonoBehaviour
   {
       public Animator animator;               // Assign the Animator component in the Inspector
       public AnimationClip[] animationClips;  // Assign the animation clips in the Inspector
       public int clipIndex = 0;               // The index of the animation clip to play
   
       private AnimatorOverrideController overrideController;
       private string stateName = "DefaultState";
   
       void Start()
       {
           if (animator == null)
           {
               Debug.LogError("Animator component is not assigned.");
               return;
           }
   
           if (animationClips == null || animationClips.Length == 0)
           {
               Debug.LogError("No animation clips assigned.");
               return;
           }
   
           if (animator.runtimeAnimatorController == null)
           {
               Debug.LogError("Animator does not have a runtime animator controller assigned.");
               return;
           }
   
           // Create the AnimatorOverrideController once and assign it to the animator
           overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
           animator.runtimeAnimatorController = overrideController;
   
           // Play the initial animation clip
           PlayAnimationClip(clipIndex);
       }
   
       public void PlayAnimationClip(int index)
       {
           if (index < 0 || index >= animationClips.Length)
           {
               Debug.LogError("Clip index out of range.");
               return;
           }
   
           AnimationClip clip = animationClips[index];
   
           // Override the default animation clip with the selected clip
           overrideController[stateName] = clip; // "stateName" is the name of the state in your Animator Controller
   
           // Play the animation
           animator.Play(stateName, 0, 0);
       }
   
       // Example of changing the clip at runtime
       void Update()
       {
           if (Input.GetKeyDown(KeyCode.Space))
           {
               // Increment the clip index and loop back to zero
               clipIndex = (clipIndex + 1) % animationClips.Length;
               PlayAnimationClip(clipIndex);
           }
       }
   }

   Instructions:

   • Attach the Script:
     • Attach the SimpleAnimationSwitcher script to your GameObject.
   • Assign the Animator Component:
     • Drag your Animator component into the animator field in the Inspector.
   • Assign Animation Clips:
     • Populate the animationClips array with the animation clips you want to use.
   • Set the State Name:
     • Ensure the stateName in the script matches the state name in your Animator Controller ("DefaultState").

Benefits:

• Simplicity:
  • No complex runtime creation of Animator Controllers.
  • Easy to set up and understand.
• Efficiency:
  • Minimal object allocations.
  • Reuses the AnimatorOverrideController without creating new instances.
• Flexibility:
  • Easily swap animation clips at runtime.
  • Control animations through code or user input.

---

Option 2: Create an Animator Controller at Runtime

If you prefer to create the Animator Controller programmatically because the Animator has no controller assigned, you can do so with some considerations.

Important: Unity’s AnimatorController class is part of the UnityEditor.Animations namespace, which cannot be used in builds (runtime). To work around this, you can:

• Use preprocessor directives to ensure that editor-only code doesn’t run in builds.
• However, creating Animator Controllers at runtime is not recommended due to these limitations.

Simplified Runtime Creation (Not Recommended for Builds):

using UnityEngine;
#if UNITY_EDITOR
using UnityEditor.Animations;
#endif

public class SimpleAnimationSwitcher : MonoBehaviour
{
    public Animator animator;               // Assign the Animator component in the Inspector
    public AnimationClip[] animationClips;  // Assign the animation clips in the Inspector
    public int clipIndex = 0;               // The index of the animation clip to play

    private AnimatorOverrideController overrideController;
    private string stateName = "DefaultState";

    void Start()
    {
        if (animator == null)
        {
            Debug.LogError("Animator component is not assigned.");
            return;
        }

        if (animationClips == null || animationClips.Length == 0)
        {
            Debug.LogError("No animation clips assigned.");
            return;
        }

        // Check if the Animator has a runtimeAnimatorController assigned
        if (animator.runtimeAnimatorController == null)
        {
#if UNITY_EDITOR
            // Create a new AnimatorController
            AnimatorController animatorController = AnimatorController.CreateAnimatorControllerAtPath("Assets/Temp.controller");

            // Remove the temporary controller from the Assets folder
            UnityEditor.AssetDatabase.DeleteAsset("Assets/Temp.controller");

            // Create a new state with a default clip
            AnimatorState state = animatorController.layers[0].stateMachine.AddState(stateName);
            state.motion = null; // No clip assigned

            // Assign the controller to the Animator
            animator.runtimeAnimatorController = animatorController;
#else
            Debug.LogError("Cannot create Animator Controller at runtime in builds. Please assign an Animator Controller in the Editor.");
            return;
#endif
        }

        // Create the AnimatorOverrideController once and assign it to the animator
        overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
        animator.runtimeAnimatorController = overrideController;

        // Play the initial animation clip
        PlayAnimationClip(clipIndex);
    }

    // Rest of the script remains the same...
}

Limitations:

• Editor-Only Code: The creation of the Animator Controller is wrapped in #if UNITY_EDITOR, which means it won’t run in builds.
• Not Suitable for Builds: Since we cannot create Animator Controllers at runtime in builds, this approach is not recommended for production.

Recommendation: Option 1 is the preferred method as it avoids these issues and keeps your code clean and efficient.

---

Alternative: Using Playables API

If you want to play animation clips without an Animator Controller, you can use Unity’s Playables API. This allows you to play animation clips directly using AnimationPlayableOutput and AnimationClipPlayable.

However, the Playables API is more complex and may not align with your request for simplicity.

---

Conclusion

To inject different animation clips into an object’s Animator efficiently when there’s no clip or Animator Controller assigned:

• Create a Simple Animator Controller in the Unity Editor:

  • With a single state and no assigned clip.
  • Assign it to your Animator component.

• Use a Script to Swap Animation Clips at Runtime:

  • Use an AnimatorOverrideController to override the clip in the Animator Controller.
  • Keep the script simple and efficient, avoiding unnecessary object allocations.

---

Summary of Steps

1. Animator Controller Setup:

   • Create an Animator Controller with a single state named "DefaultState".
   • Do not assign any clips to this state.
   • Assign the Animator Controller to your Animator component.

2. Script Setup:

   • Use the SimpleAnimationSwitcher script provided.
   • Assign the Animator component and animation clips in the Inspector.
   • Ensure the state name in the script matches the state in the Animator Controller.

3. Runtime Behavior:

   • The script overrides the animation clip in the Animator Controller at runtime.
   • You can switch between animation clips efficiently without creating new objects.

---

Feel free to let me know if you have any questions or need further assistance!

You

let’s have a look at playables

ChatGPT

Certainly! The Unity Playables API allows you to play animation clips directly on a GameObject without the need for an Animator Controller. This approach can be both simple and efficient, especially when you need to play or swap animation clips at runtime without setting up complex Animator Controllers.

Below, I’ll guide you through using the Playables API to:

• Play animation clips on a GameObject without an Animator Controller.
• Swap between different animation clips efficiently.
• Keep the implementation straightforward and easy to understand.

---

1. Understanding the Playables API

The Playables API is a powerful system in Unity that provides low-level control over animation playback. It allows you to create, blend, and control animations programmatically.

Key components:

• PlayableGraph: A graph that manages the flow of playables.
• AnimationPlayableOutput: The output node that sends animation data to the Animator.
• AnimationClipPlayable: A playable that plays an AnimationClip.

---

2. Setting Up the Script

We’ll create a script that:

• Creates a PlayableGraph.
• Plays animation clips using AnimationClipPlayable.
• Allows swapping between clips efficiently.

Script: AnimationClipPlayer.cs

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Animations;

public class AnimationClipPlayer : MonoBehaviour
{
    public AnimationClip[] animationClips;  // Assign your animation clips in the Inspector
    public int clipIndex = 0;               // The index of the animation clip to play

    private PlayableGraph playableGraph;
    private AnimationPlayableOutput playableOutput;
    private AnimationClipPlayable clipPlayable;

    void Start()
    {
        if (animationClips == null || animationClips.Length == 0)
        {
            Debug.LogError("No animation clips assigned.");
            return;
        }

        // Create the PlayableGraph
        playableGraph = PlayableGraph.Create("AnimationClipPlayerGraph");

        // Create the AnimationPlayableOutput and attach it to the Animator component
        playableOutput = AnimationPlayableOutput.Create(playableGraph, "AnimationOutput", GetComponent<Animator>());

        // Play the initial animation clip
        PlayAnimationClip(clipIndex);

        // Start the graph
        playableGraph.Play();
    }

    public void PlayAnimationClip(int index)
    {
        if (index < 0 || index >= animationClips.Length)
        {
            Debug.LogError("Clip index out of range.");
            return;
        }

        AnimationClip clip = animationClips[index];

        if (clip == null)
        {
            Debug.LogError("Animation clip is null.");
            return;
        }

        // If a clip is already playing, destroy it before creating a new one
        if (clipPlayable.IsValid())
        {
            clipPlayable.Destroy();
        }

        // Create a new AnimationClipPlayable
        clipPlayable = AnimationClipPlayable.Create(playableGraph, clip);

        // Connect the playable to the output
        playableOutput.SetSourcePlayable(clipPlayable);
    }

    void OnDisable()
    {
        // Destroy the PlayableGraph when the object is disabled
        playableGraph.Destroy();
    }

    // Example of changing the clip at runtime
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Increment the clip index and loop back to zero
            clipIndex = (clipIndex + 1) % animationClips.Length;
            PlayAnimationClip(clipIndex);
        }
    }
}

---

Explanation of the Script

• Public Variables:

  • animationClips: An array to hold the animation clips you want to play. Assign these in the Inspector.
  • clipIndex: The index of the current animation clip.

• Private Variables:

  • playableGraph: The PlayableGraph that manages the playables.
  • playableOutput: The output node that sends animation data to the Animator component.
  • clipPlayable: The current AnimationClipPlayable that’s playing.

• Start() Method:

  • Checks if animation clips are assigned.
  • Creates the PlayableGraph.
  • Creates the AnimationPlayableOutput and attaches it to the Animator component.
  • Calls PlayAnimationClip(clipIndex) to play the initial clip.
  • Starts the PlayableGraph.

• PlayAnimationClip(int index) Method:

  • Validates the index and retrieves the corresponding animation clip.
  • Destroys the previous clipPlayable if one exists.
  • Creates a new AnimationClipPlayable with the selected clip.
  • Connects the clipPlayable to the playableOutput.

• OnDisable() Method:

  • Ensures that the PlayableGraph is properly destroyed when the object is disabled to prevent memory leaks.

• Update() Method:

  • Example of how to change the animation clip at runtime by pressing the Spacebar.

---

3. Setting Up Your GameObject

1. Add an Animator Component:

   • Select your GameObject in the Hierarchy.
   • Add an Animator component if it doesn’t already have one.
   • Do not assign any Animator Controller to the Animator component.

2. Assign the Script:

   • Attach the AnimationClipPlayer script to your GameObject.

3. Assign Animation Clips:

   • In the Inspector, expand the AnimationClipPlayer component.
   • Set the Size of the animationClips array to the number of clips you have.
   • Drag and drop your animation clips into the array slots.

4. Set Initial Clip Index (Optional):

   • Set the clipIndex to specify which clip to play first.

---

4. Testing the Script

• Play the Scene:

  • Press the Play button in the Unity Editor.
  • The initial animation clip should play on your GameObject.

• Switching Clips:

  • Press the Spacebar to switch to the next animation clip.
  • The script cycles through the clips in the animationClips array.

---

5. Benefits of Using the Playables API

• No Animator Controller Needed:

  • Eliminates the need for an Animator Controller, simplifying your project.

• Direct Control:

  • Provides direct control over animation playback.

• Efficiency:

  • Swapping clips is efficient; no unnecessary object allocations after the initial setup.

• Flexibility:

  • You can blend, mix, or manipulate animations programmatically if needed.

---

6. Additional Features and Considerations

Blending Between Animations

If you want to blend between animations smoothly, you can use a Mixer in your PlayableGraph.

Example: Blending Animations

private AnimationMixerPlayable mixerPlayable;
private int currentClipIndex = -1;

void Start()
{
    if (animationClips == null || animationClips.Length == 0)
    {
        Debug.LogError("No animation clips assigned.");
        return;
    }

    playableGraph = PlayableGraph.Create("AnimationClipPlayerGraph");

    // Create the AnimationPlayableOutput
    playableOutput = AnimationPlayableOutput.Create(playableGraph, "AnimationOutput", GetComponent<Animator>());

    // Create the mixer with two inputs (for blending)
    mixerPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
    playableOutput.SetSourcePlayable(mixerPlayable);

    playableGraph.Play();

    // Play the initial animation clip
    PlayAnimationClip(clipIndex);
}

public void PlayAnimationClip(int index)
{
    if (index < 0 || index >= animationClips.Length)
    {
        Debug.LogError("Clip index out of range.");
        return;
    }

    if (currentClipIndex == index)
    {
        // Already playing this clip
        return;
    }

    AnimationClip clip = animationClips[index];

    if (clip == null)
    {
        Debug.LogError("Animation clip is null.");
        return;
    }

    // Create a new AnimationClipPlayable
    var newClipPlayable = AnimationClipPlayable.Create(playableGraph, clip);

    // Set weights for blending
    mixerPlayable.DisconnectInput(1);
    mixerPlayable.ConnectInput(1, newClipPlayable, 0);
    mixerPlayable.SetInputWeight(0, 0f);
    mixerPlayable.SetInputWeight(1, 1f);

    // Optionally, implement a coroutine to blend smoothly over time

    currentClipIndex = index;
}

Note:

• The above example shows how to use a mixer to blend between two animations.
• You might need to manage the blending weights over time to achieve smooth transitions.

Looping Animations

• By default, the AnimationClipPlayable will respect the looping settings of the animation clip.
• Ensure your animation clips are set to loop if you want continuous playback.

Controlling Playback Speed

• You can control the speed of the animation by setting the speed property on the AnimationClipPlayable:

  clipPlayable.SetSpeed(1.0f); // Normal speed
  clipPlayable.SetSpeed(0.5f); // Half speed
  clipPlayable.SetSpeed(2.0f); // Double speed

Pausing and Resuming Animations

• To pause the animation, you can pause the PlayableGraph:

  playableGraph.Stop();

• To resume:

  playableGraph.Play();

---

7. Clean Up Resources

Always ensure that you properly destroy the PlayableGraph when it’s no longer needed to prevent memory leaks.

void OnDisable()
{
    // Destroy the PlayableGraph when the object is disabled
    playableGraph.Destroy();
}

---

8. Summary

Using the Playables API allows you to:

• Play animations without an Animator Controller.
• Swap between animation clips efficiently.
• Have more control over animation playback.

Advantages:

• Simplicity: No need to set up Animator Controllers or states.
• Efficiency: Minimal overhead after initial setup.
• Flexibility: Ability to control, blend, and manipulate animations programmatically.

---

9. Complete Example Script

Here’s the complete script with optional features included:

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Animations;

public class AnimationClipPlayer : MonoBehaviour
{
    public AnimationClip[] animationClips;  // Assign your animation clips in the Inspector
    public int clipIndex = 0;               // The index of the animation clip to play

    private PlayableGraph playableGraph;
    private AnimationPlayableOutput playableOutput;
    private AnimationClipPlayable clipPlayable;

    void Start()
    {
        if (animationClips == null || animationClips.Length == 0)
        {
            Debug.LogError("No animation clips assigned.");
            return;
        }

        // Create the PlayableGraph
        playableGraph = PlayableGraph.Create("AnimationClipPlayerGraph");

        // Create the AnimationPlayableOutput and attach it to the Animator component
        Animator animator = GetComponent<Animator>();
        if (animator == null)
        {
            animator = gameObject.AddComponent<Animator>();
        }
        playableOutput = AnimationPlayableOutput.Create(playableGraph, "AnimationOutput", animator);

        // Play the initial animation clip
        PlayAnimationClip(clipIndex);

        // Start the graph
        playableGraph.Play();
    }

    public void PlayAnimationClip(int index)
    {
        if (index < 0 || index >= animationClips.Length)
        {
            Debug.LogError("Clip index out of range.");
            return;
        }

        AnimationClip clip = animationClips[index];

        if (clip == null)
        {
            Debug.LogError("Animation clip is null.");
            return;
        }

        // If a clip is already playing, destroy it before creating a new one
        if (clipPlayable.IsValid())
        {
            clipPlayable.Destroy();
        }

        // Create a new AnimationClipPlayable
        clipPlayable = AnimationClipPlayable.Create(playableGraph, clip);

        // Connect the playable to the output
        playableOutput.SetSourcePlayable(clipPlayable);
    }

    void OnDisable()
    {
        // Destroy the PlayableGraph when the object is disabled
        playableGraph.Destroy();
    }

    // Example of changing the clip at runtime
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // Increment the clip index and loop back to zero
            clipIndex = (clipIndex + 1) % animationClips.Length;
            PlayAnimationClip(clipIndex);
        }
    }
}

---

10. Final Notes

• No Animator Controller Required: The script checks for an Animator component and adds one if it doesn’t exist. No Animator Controller is needed.

• Compatibility: This approach works well with both Legacy and Humanoid animation clips, as long as the clips are compatible with the model.

• Extensibility: You can extend this script to include blending, speed control, and other advanced features as needed.

---

Feel free to ask if you have any questions or need further clarification on any part of the implementation!

You

what if I want to control the flow of playback manually. let’ say I want to increment at a 10-frame step, and do some calculations, and then move on

ChatGPT

Certainly! If you want to control the playback of an animation manually—such as incrementing the animation by 10 frames, performing some calculations, and then moving on—you can achieve this using the Playables API by controlling the time of the AnimationClipPlayable.

Here’s how you can:

• Manually control the playback time of the animation.
• Advance the animation in discrete steps (e.g., 10-frame increments).
• Perform calculations or logic at each step before proceeding.

---

1. Understanding Manual Control with Playables

By default, when you play an AnimationClipPlayable, it advances automatically according to the application’s delta time (Time.deltaTime). However, you can pause the PlayableGraph and manually set the time of the AnimationClipPlayable to control the animation flow precisely.

Key components:

• Pause the PlayableGraph: Prevents the animation from advancing automatically.
• Manually Set the Time: You can set the time of the AnimationClipPlayable to a specific value.
• Advance in Steps: Increment the time by fixed amounts (e.g., corresponding to 10 frames).
• Perform Calculations: Execute your logic at each step.

---

2. Implementing Manual Playback Control

Script: ManualAnimationController.cs

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Animations;

public class ManualAnimationController : MonoBehaviour
{
    public AnimationClip animationClip;   // Assign your animation clip in the Inspector
    public float frameRate = 30f;         // Frame rate of the animation clip
    public int frameStep = 10;            // Number of frames to advance per step

    private PlayableGraph playableGraph;
    private AnimationClipPlayable clipPlayable;
    private double currentTime = 0.0;

    void Start()
    {
        if (animationClip == null)
        {
            Debug.LogError("Animation clip is not assigned.");
            return;
        }

        // Create the PlayableGraph
        playableGraph = PlayableGraph.Create("ManualAnimationControllerGraph");

        // Create the AnimationPlayableOutput and attach it to the Animator component
        Animator animator = GetComponent<Animator>();
        if (animator == null)
        {
            animator = gameObject.AddComponent<Animator>();
        }
        var playableOutput = AnimationPlayableOutput.Create(playableGraph, "AnimationOutput", animator);

        // Create the AnimationClipPlayable
        clipPlayable = AnimationClipPlayable.Create(playableGraph, animationClip);
        clipPlayable.SetTime(currentTime);

        // Connect the playable to the output
        playableOutput.SetSourcePlayable(clipPlayable);

        // Pause the graph to prevent automatic playback
        playableGraph.Play();
        playableGraph.Stop();
    }

    public void AdvanceAnimationStep()
    {
        // Calculate the time increment based on frame rate and frame step
        double timeIncrement = frameStep / frameRate;

        // Advance the current time
        currentTime += timeIncrement;

        // Clamp the time to the duration of the clip
        if (currentTime > animationClip.length)
        {
            currentTime = animationClip.length;
        }

        // Set the time of the playable
        clipPlayable.SetTime(currentTime);

        // Evaluate the graph to update the animation
        playableGraph.Evaluate(0f); // Evaluate with zero delta time to apply changes immediately

        // Perform your calculations here
        PerformCalculations();
    }

    private void PerformCalculations()
    {
        // Insert your logic or calculations here
        Debug.Log($"Advanced to time: {currentTime:F2}s (Frame {(int)(currentTime * frameRate)})");
    }

    void OnDisable()
    {
        // Destroy the PlayableGraph when the object is disabled
        playableGraph.Destroy();
    }

    // Example of triggering the step advancement
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            AdvanceAnimationStep();
        }
    }
}

---

Explanation of the Script

• Public Variables:

  • animationClip: The animation clip to be played. Assign it in the Inspector.
  • frameRate: The frame rate of the animation clip (e.g., 30 FPS).
  • frameStep: The number of frames to advance each time.

• Private Variables:

  • playableGraph: The PlayableGraph that manages the playables.
  • clipPlayable: The AnimationClipPlayable instance.
  • currentTime: The current playback time of the animation.

• Start() Method:

  • Creates the PlayableGraph and sets up the AnimationClipPlayable.
  • Pauses the graph immediately after starting it to prevent automatic playback.

• AdvanceAnimationStep() Method:

  • Calculates the time increment based on frameStep and frameRate.
  • Advances currentTime by the calculated increment.
  • Clamps currentTime to the animation clip’s length to prevent exceeding the duration.
  • Sets the new time on the clipPlayable.
  • Evaluates the graph with zero delta time to apply changes immediately.
  • Calls PerformCalculations() to execute any required logic.

• PerformCalculations() Method:

  • Placeholder for your calculations or logic to be performed at each step.
  • Currently logs the current time and frame to the console.

• OnDisable() Method:

  • Destroys the PlayableGraph when the object is disabled.

• Update() Method:

  • Listens for the Spacebar key press to trigger AdvanceAnimationStep().

---

3. Using the Script

1. Add an Animator Component (if necessary):

   • Select your GameObject in the Hierarchy.
   • Add an Animator component if it doesn’t have one.
   • No Animator Controller is needed.

2. Assign the Script:

   • Attach the ManualAnimationController script to your GameObject.

3. Assign the Animation Clip:

   • In the Inspector, assign your animation clip to the animationClip field.

4. Set Frame Rate and Frame Step:

   • Set the frameRate to match your animation clip’s frame rate (commonly 30 FPS).
   • Set frameStep to 10 (or any number of frames you want to advance per step).

5. Run the Scene:

   • Press Play in the Unity Editor.
   • Press the Spacebar to advance the animation by 10 frames at a time.
   • Observe the animation updating and calculations being performed.

---

4. Performing Calculations at Each Step

The PerformCalculations() method is where you can insert any logic or calculations you need to perform after each step advancement.

Example:

private void PerformCalculations()
{
    // Get the current frame number
    int currentFrame = (int)(currentTime * frameRate);

    // Example calculation: Log the current frame
    Debug.Log($"Current Frame: {currentFrame}");

    // Insert your custom logic here
    // e.g., checking animation events, modifying other components, etc.
}

---

5. Additional Control and Features

Resetting the Animation

If you want to reset the animation back to the start after reaching the end:

if (currentTime >= animationClip.length)
{
    currentTime = 0.0;
}

Advancing Backwards

To step backward through the animation:

public void RewindAnimationStep()
{
    double timeDecrement = frameStep / frameRate;
    currentTime -= timeDecrement;

    if (currentTime < 0.0)
    {
        currentTime = 0.0;
    }

    clipPlayable.SetTime(currentTime);
    playableGraph.Evaluate(0f);

    PerformCalculations();
}

Trigger this method with another key press or input as desired.

Adjusting Frame Rate

Ensure that the frameRate variable matches the actual frame rate of your animation clip. You can retrieve the frame rate from the clip itself:

void Start()
{
    // ... existing code ...

    // Automatically set the frame rate based on the animation clip
    frameRate = animationClip.frameRate;

    // ... existing code ...
}

---

6. Example of Custom Control Flow

Suppose you want to advance the animation step, perform calculations, and then wait for a condition before moving on.

Implementing a Coroutine for Custom Control Flow

public IEnumerator AdvanceAndWait()
{
    while (currentTime < animationClip.length)
    {
        AdvanceAnimationStep();

        // Wait until a condition is met or for a fixed time
        yield return new WaitForSeconds(0.5f); // Wait for half a second
        // Or wait for a condition:
        // yield return new WaitUntil(() => someCondition == true);
    }
}

Start the coroutine:

void Start()
{
    // ... existing code ...

    StartCoroutine(AdvanceAndWait());
}

---

7. Integrating with Other Systems

You can integrate this manual animation control with other game systems, such as:

• Physics: Update physics-related components based on the current animation frame.
• Events: Trigger events at specific frames or times.
• AI Logic: Combine with AI decision-making processes.

---

8. Summary

By manually controlling the playback time of the animation, you have complete control over:

• When and how much to advance the animation.
• Performing custom calculations or logic at each step.
• Integrating animation flow with other gameplay systems.

Advantages:

• Precision Control: Advance the animation exactly as needed.
• Synchronization: Align calculations and logic precisely with animation frames.
• Flexibility: Implement custom control flows and conditions.

---

9. Important Considerations

• Performance:

  • Evaluating the graph with zero delta time (playableGraph.Evaluate(0f)) updates the animation immediately without advancing time.
  • Ensure that your calculations are optimized if called frequently.

• Frame Rate Consistency:

  • Animation clips may have different frame rates. Ensure frameRate matches the clip’s frame rate.

• Looping and Clamping:

  • Decide how you want to handle the end of the animation (loop, clamp, reset).

• Thread Safety:

  • Unity’s API is generally not thread-safe. Perform calculations and updates on the main thread.

---

10. Complete Example with Advanced Features

Here’s the complete script with additional features and comments:

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Animations;
using System.Collections;

public class ManualAnimationController : MonoBehaviour
{
    public AnimationClip animationClip;   // Assign your animation clip in the Inspector
    public float frameRate = 30f;         // Frame rate of the animation clip
    public int frameStep = 10;            // Number of frames to advance per step

    private PlayableGraph playableGraph;
    private AnimationClipPlayable clipPlayable;
    private double currentTime = 0.0;

    void Start()
    {
        if (animationClip == null)
        {
            Debug.LogError("Animation clip is not assigned.");
            return;
        }

        // Automatically set the frame rate based on the animation clip
        frameRate = animationClip.frameRate;

        // Create the PlayableGraph
        playableGraph = PlayableGraph.Create("ManualAnimationControllerGraph");

        // Create the AnimationPlayableOutput and attach it to the Animator component
        Animator animator = GetComponent<Animator>();
        if (animator == null)
        {
            animator = gameObject.AddComponent<Animator>();
        }
        var playableOutput = AnimationPlayableOutput.Create(playableGraph, "AnimationOutput", animator);

        // Create the AnimationClipPlayable
        clipPlayable = AnimationClipPlayable.Create(playableGraph, animationClip);
        clipPlayable.SetTime(currentTime);

        // Connect the playable to the output
        playableOutput.SetSourcePlayable(clipPlayable);

        // Pause the graph to prevent automatic playback
        playableGraph.Play();
        playableGraph.Stop();
    }

    public void AdvanceAnimationStep()
    {
        // Calculate the time increment based on frame rate and frame step
        double timeIncrement = frameStep / frameRate;

        // Advance the current time
        currentTime += timeIncrement;

        // Clamp or loop the time as desired
        if (currentTime > animationClip.length)
        {
            // Option 1: Clamp to the end
            currentTime = animationClip.length;

            // Option 2: Loop back to start
            // currentTime = 0.0;
        }

        // Set the time of the playable
        clipPlayable.SetTime(currentTime);

        // Evaluate the graph to update the animation
        playableGraph.Evaluate(0f); // Evaluate with zero delta time to apply changes immediately

        // Perform your calculations here
        PerformCalculations();
    }

    private void PerformCalculations()
    {
        // Get the current frame number
        int currentFrame = (int)(currentTime * frameRate);

        // Example calculation: Log the current frame
        Debug.Log($"Current Time: {currentTime:F2}s, Frame: {currentFrame}");

        // Insert your custom logic here
        // e.g., checking animation events, modifying other components, etc.
    }

    void OnDisable()
    {
        // Destroy the PlayableGraph when the object is disabled
        playableGraph.Destroy();
    }

    // Example of triggering the step advancement
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            AdvanceAnimationStep();
        }

        // Optional: Rewind with another key
        if (Input.GetKeyDown(KeyCode.Backspace))
        {
            RewindAnimationStep();
        }
    }

    public void RewindAnimationStep()
    {
        double timeDecrement = frameStep / frameRate;
        currentTime -= timeDecrement;

        if (currentTime < 0.0)
        {
            currentTime = 0.0;
        }

        clipPlayable.SetTime(currentTime);
        playableGraph.Evaluate(0f);

        PerformCalculations();
    }
}

---

Let me know if you have any questions or need further assistance!