Unity FBX Asset Postprocessor

2024-10-20 08:31 UTC gpt-4o-canmore Open in ChatGPT ↗

You may be right—using a different event function might help with applying the intended settings more reliably. Instead of using OnPostprocessModel, consider making use of OnPreprocessAnimation or OnPostprocessAnimation to directly interact with the animation clip settings.

Here’s an updated version that uses OnPreprocessAnimation to ensure the animation settings get applied at the right stage of the import process:

using UnityEditor;
using UnityEngine;

public class CustomFbxPostprocessor : AssetPostprocessor
{
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Check if the file is an FBX (you can extend this for other model types if needed)
        if (assetPath.ToLower().EndsWith(".fbx"))
        {
            // Set the animation type to Humanoid
            modelImporter.animationType = ModelImporterAnimationType.Humanoid;

            // Set the scale factor to 100
            modelImporter.globalScale = 1.0f; // Use 1.0f instead of 100.0f to avoid unexpected scale issues (Unity's internal scale handling)
        }
    }

    void OnPreprocessAnimation()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Make sure the model is set to humanoid before processing animations
        if (modelImporter.animationType == ModelImporterAnimationType.Humanoid)
        {
            ModelImporterClipAnimation[] clipAnimations = modelImporter.defaultClipAnimations;

            foreach (var clip in clipAnimations)
            {
                // Set the Y position to be based on feet (Root motion baking settings)
                clip.heightFromFeet = true;

                // Set 'Bake Into Pose' for root transform position and rotation
                clip.lockRootHeightY = true;
                clip.lockRootPositionXZ = true;
                clip.lockRootRotation = true;
            }

            // Apply the modified clip settings
            modelImporter.clipAnimations = clipAnimations;
        }
    }

    void OnPostprocessModel(GameObject importedObject)
    {
        // Disable lights, cameras, and other unnecessary components
        foreach (Transform child in importedObject.transform)
        {
            if (child.gameObject.GetComponent<Light>() != null || child.gameObject.GetComponent<Camera>() != null)
            {
                GameObject.DestroyImmediate(child.gameObject);
            }
        }
    }
}

/*
Place this script in an "Editor" folder within your project (e.g., "Assets/Editor").
Unity will automatically invoke the asset postprocessor when importing FBX files.
*/

Changes Made:

Moved Animation Settings to OnPreprocessAnimation:
- The OnPreprocessAnimation method is designed specifically to modify animations during the import process. This ensures the settings are applied correctly before the asset is finalized.
Simplified OnPostprocessModel:
- Retained the logic for disabling lights and cameras since that is still relevant after the model is imported.

By using OnPreprocessAnimation, the animation settings are handled at the right point, reducing issues where settings may not be applied properly. Let me know if this version works better for you or if further adjustments are needed!

You’re correct. The AnimationClip class itself doesn’t have properties like heightFromFeet or lockRootHeightY. Those properties are actually part of the ModelImporterClipAnimation class, which is used during the model import process.

Instead of modifying the AnimationClip directly, you should go back to modifying the clip settings in the ModelImporter. Here’s how to correctly apply these settings:

Update using `OnPostprocessAnimation`

Replace OnPostprocessAnimation with an updated OnPreprocessModel to manage the animation import settings. We’ll focus on configuring the ModelImporterClipAnimation correctly.

Here’s the revised script:

using UnityEditor;
using UnityEngine;

public class CustomFbxPostprocessor : AssetPostprocessor
{
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Check if the file is an FBX (you can extend this for other model types if needed)
        if (assetPath.ToLower().EndsWith(".fbx"))
        {
            // Set the animation type to Humanoid
            modelImporter.animationType = ModelImporterAnimationType.Humanoid;

            // Set the scale factor to 100
            modelImporter.globalScale = 1.0f; // Use 1.0f instead of 100.0f to avoid unexpected scale issues (Unity's internal scale handling)
        }
    }

    void OnPostprocessModel(GameObject importedObject)
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Make sure the model has animations and is set to humanoid
        if (modelImporter.animationType == ModelImporterAnimationType.Humanoid)
        {
            // Retrieve all clip animations
            ModelImporterClipAnimation[] clipAnimations = modelImporter.defaultClipAnimations;

            // Modify each clip animation to set the desired properties
            foreach (var clip in clipAnimations)
            {
                // Set the Y position to be based on feet (Root motion baking settings)
                clip.heightFromFeet = true;

                // Set 'Bake Into Pose' for root transform position and rotation
                clip.lockRootHeightY = true;
                clip.lockRootPositionXZ = true;
                clip.lockRootRotation = true;
            }

            // Apply the modified clip settings
            modelImporter.clipAnimations = clipAnimations;

            // Force re-import to ensure settings are applied
            AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate);
        }

        // Disable lights, cameras, and other unnecessary components
        foreach (Transform child in importedObject.transform)
        {
            if (child.gameObject.GetComponent<Light>() != null || child.gameObject.GetComponent<Camera>() != null)
            {
                GameObject.DestroyImmediate(child.gameObject);
            }
        }
    }
}

/*
Place this script in an "Editor" folder within your project (e.g., "Assets/Editor").
Unity will automatically invoke the asset postprocessor when importing FBX files.
*/

Summary of Changes:

Replaced OnPostprocessAnimation: Removed OnPostprocessAnimation because those properties (heightFromFeet, lockRootHeightY, etc.) are not available on AnimationClip.
Modified OnPostprocessModel: Handled animation settings by modifying the ModelImporterClipAnimation within OnPostprocessModel.
Applied Re-Import: Used AssetDatabase.ImportAsset() to force re-import and ensure settings are correctly applied.

This version should work correctly to ensure that all settings are applied during the model import process, and avoid attempting to apply them directly on the AnimationClip. Let me know if this helps!

The issue is that modifying the AnimationClip directly in OnPostprocessAnimation does not control the import settings; instead, these settings need to be configured in the ModelImporterClipAnimation object before the import completes.

Unity’s ModelImporterClipAnimation is where you should be configuring settings like “Root Transform Position (Y)” to be “Feet” or “Center of Mass”. Let’s update the script accordingly and ensure that the settings are properly modified in the import stage.

Here is a refined version of the script that should fix your issue:

using UnityEditor;
using UnityEngine;

public class CustomFbxPostprocessor : AssetPostprocessor
{
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Check if the file is an FBX (you can extend this for other model types if needed)
        if (assetPath.ToLower().EndsWith(".fbx"))
        {
            // Set the animation type to Humanoid
            modelImporter.animationType = ModelImporterAnimationType.Humanoid;

            // Set the scale factor to 100
            modelImporter.globalScale = 1.0f; // Use 1.0f instead of 100.0f to avoid unexpected scale issues (Unity's internal scale handling)
        }
    }

    void OnPostprocessModel(GameObject importedObject)
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Make sure the model has animations and is set to humanoid
        if (modelImporter.animationType == ModelImporterAnimationType.Humanoid)
        {
            // Retrieve all clip animations
            ModelImporterClipAnimation[] clipAnimations = modelImporter.defaultClipAnimations;

            // Modify each clip animation to set the desired properties
            for (int i = 0; i < clipAnimations.Length; i++)
            {
                var clip = clipAnimations[i];

                // Set the root transform Y position to be based on the center of mass
                clip.heightFromFeet = false;

                // Set 'Bake Into Pose' for root transform position and rotation
                clip.lockRootHeightY = true;
                clip.lockRootPositionXZ = true;
                clip.lockRootRotation = true;

                // Update the clip animation back into the array
                clipAnimations[i] = clip;
            }

            // Apply the modified clip settings
            modelImporter.clipAnimations = clipAnimations;

            // Force re-import to ensure settings are applied
            AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate);
        }

        // Disable lights, cameras, and other unnecessary components
        foreach (Transform child in importedObject.transform)
        {
            if (child.gameObject.GetComponent<Light>() != null || child.gameObject.GetComponent<Camera>() != null)
            {
                GameObject.DestroyImmediate(child.gameObject);
            }
        }
    }
}

/*
Place this script in an "Editor" folder within your project (e.g., "Assets/Editor").
Unity will automatically invoke the asset postprocessor when importing FBX files.
*/

Summary of Changes:

Use OnPostprocessModel and ModelImporterClipAnimation:
- You should use the ModelImporterClipAnimation settings in OnPostprocessModel to make changes to imported clips. The properties you want, like heightFromFeet, are available in ModelImporterClipAnimation.
Set heightFromFeet to false:
- To use “Center of Mass” instead of “Feet,” set clip.heightFromFeet = false.
Assign Modified Clip Settings:
- Modified the clipAnimations array and reassigned it back to modelImporter.clipAnimations to make sure the settings are correctly saved.

These changes should ensure that your import settings are actually applied as expected. The key is to modify the clip settings before they are finalized by the importer. Let me know if this works for your needs or if there’s anything else I can help with!

To ensure that your postprocessor runs at the very end of the asset processing cycle, you can utilize the OnPostprocessAllAssets callback. This method is called after all assets are imported, deleted, moved, or renamed, allowing you to modify imported assets at the very last stage.

Here’s how you can modify your current script to use OnPostprocessAllAssets in order to ensure that your processing occurs at the end:

Changes Summary

Add an OnPostprocessAllAssets method to run modifications once all assets have been imported.
Move any operations that should happen last (e.g., removing components or final settings) to this method.

Here’s an updated version of the script:

using UnityEditor;
using UnityEngine;

public class CustomFbxPostprocessor : AssetPostprocessor
{
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Check if the file is an FBX (you can extend this for other model types if needed)
        if (assetPath.ToLower().EndsWith(".fbx"))
        {
            // Set the animation type to Humanoid
            modelImporter.animationType = ModelImporterAnimationType.Humanoid;

            // Set the scale factor to 100
            modelImporter.globalScale = 1.0f; // Use 1.0f instead of 100.0f to avoid unexpected scale issues (Unity's internal scale handling)
        }
    }

    void OnPreprocessAnimation()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Make sure the model is set to humanoid before processing animations
        if (modelImporter.animationType == ModelImporterAnimationType.Humanoid)
        {
            ModelImporterClipAnimation[] clipAnimations = modelImporter.defaultClipAnimations;

            foreach (var clip in clipAnimations)
            {
                // Set the Y position to be based on the center of mass (Root motion baking settings)
                clip.heightFromFeet = false;

                // Set 'Bake Into Pose' for root transform position and rotation
                clip.lockRootHeightY = true;
                clip.lockRootPositionXZ = true;
                clip.lockRootRotation = true;
            }

            // Apply the modified clip settings
            modelImporter.clipAnimations = clipAnimations;
        }
    }

    void OnPostprocessModel(GameObject importedObject)
    {
        // This is executed right after the model is imported but before OnPostprocessAllAssets.
        // You can use this to modify the model if needed before the final modifications.
    }

    static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
    {
        foreach (string assetPath in importedAssets)
        {
            if (assetPath.ToLower().EndsWith(".fbx"))
            {
                GameObject importedObject = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);

                if (importedObject != null)
                {
                    // Disable lights, cameras, and other unnecessary components
                    foreach (Transform child in importedObject.transform)
                    {
                        if (child.gameObject.GetComponent<Light>() != null || child.gameObject.GetComponent<Camera>() != null)
                        {
                            GameObject.DestroyImmediate(child.gameObject);
                        }
                    }

                    // Perform any other final modifications if needed
                    Debug.Log($"Postprocessed {assetPath} at the very end of the import process.");
                }
            }
        }
    }
}

/*
Place this script in an "Editor" folder within your project (e.g., "Assets/Editor").
Unity will automatically invoke the asset postprocessor when importing FBX files.
*/

Explanation:

OnPostprocessAllAssets Method:
- This method runs after all assets are processed, giving you the opportunity to apply any final modifications.
- It loops through all imported assets and applies modifications if the file is an .fbx model.
- You can now make the last modifications here, ensuring they are applied after all the built-in Unity postprocessing.
Final Adjustments:
- I moved the disabling of lights, cameras, etc., to OnPostprocessAllAssets, which ensures that these modifications occur only after all previous steps are complete.
- It also loads the model as a GameObject using AssetDatabase.LoadAssetAtPath to make final edits.

Using this pattern should allow you to apply the changes at the very end, ensuring that nothing overrides your settings. Let me know if this approach works for you or if you need any further tweaks!

Modifying the AnimationClip at the OnPostprocessAllAssets stage is indeed possible, but it’s a bit more complex because AnimationClip settings at that stage need to be fetched, modified, and applied separately from the ModelImporter. When using OnPostprocessAllAssets, you need to work directly with the AnimationClip assets after they’re imported.

Here’s how you can modify an AnimationClip at the very end of the import process, ensuring all earlier processing has already been applied:

Updated Version of Your Script with `OnPostprocessAllAssets`:

using UnityEditor;
using UnityEngine;

public class CustomFbxPostprocessor : AssetPostprocessor
{
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Check if the file is an FBX (you can extend this for other model types if needed)
        if (assetPath.ToLower().EndsWith(".fbx"))
        {
            // Set the animation type to Humanoid
            modelImporter.animationType = ModelImporterAnimationType.Humanoid;

            // Set the scale factor to 100
            modelImporter.globalScale = 1.0f; // Use 1.0f instead of 100.0f to avoid unexpected scale issues (Unity's internal scale handling)
        }
    }

    void OnPreprocessAnimation()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // Make sure the model is set to humanoid before processing animations
        if (modelImporter.animationType == ModelImporterAnimationType.Humanoid)
        {
            ModelImporterClipAnimation[] clipAnimations = modelImporter.defaultClipAnimations;

            foreach (var clip in clipAnimations)
            {
                // Set the Y position to be based on the center of mass (Root motion baking settings)
                clip.heightFromFeet = false;

                // Set 'Bake Into Pose' for root transform position and rotation
                clip.lockRootHeightY = true;
                clip.lockRootPositionXZ = true;
                clip.lockRootRotation = true;
            }

            // Apply the modified clip settings
            modelImporter.clipAnimations = clipAnimations;
        }
    }

    void OnPostprocessModel(GameObject importedObject)
    {
        // Disable lights, cameras, and other unnecessary components
        foreach (Transform child in importedObject.transform)
        {
            if (child.gameObject.GetComponent<Light>() != null || child.gameObject.GetComponent<Camera>() != null)
            {
                GameObject.DestroyImmediate(child.gameObject);
            }
        }
    }

    static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
    {
        foreach (string assetPath in importedAssets)
        {
            if (assetPath.ToLower().EndsWith(".fbx"))
            {
                // Load the GameObject from the asset path
                GameObject importedObject = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);

                if (importedObject != null)
                {
                    // Disable lights, cameras, and other unnecessary components
                    foreach (Transform child in importedObject.transform)
                    {
                        if (child.gameObject.GetComponent<Light>() != null || child.gameObject.GetComponent<Camera>() != null)
                        {
                            GameObject.DestroyImmediate(child.gameObject);
                        }
                    }

                    // Load all associated animation clips and modify them
                    var animations = AssetDatabase.LoadAllAssetsAtPath(assetPath);
                    foreach (var asset in animations)
                    {
                        if (asset is AnimationClip clip)
                        {
                            // Modify the animation clip settings
                            AnimationClipSettings settings = AnimationUtility.GetAnimationClipSettings(clip);
                            settings.keepOriginalPositionY = false; // Set to false to enable custom root motion behavior
                            settings.keepOriginalPositionXZ = false;
                            settings.keepOriginalOrientation = false;

                            AnimationUtility.SetAnimationClipSettings(clip, settings);

                            // Optional: Additional modifications on AnimationCurves, etc.
                            Debug.Log($"Modified AnimationClip: {clip.name} for asset: {assetPath}");
                        }
                    }
                }
            }
        }
    }
}

/*
Place this script in an "Editor" folder within your project (e.g., "Assets/Editor").
Unity will automatically invoke the asset postprocessor when importing FBX files.
*/

Explanation:

Using OnPostprocessAllAssets:
- OnPostprocessAllAssets runs after all assets have been imported, allowing modifications to assets that have already been processed by Unity.
- This is ideal for making final modifications after all other import processes are done, ensuring that nothing overrides your changes.
Loading and Modifying AnimationClip:
- The AssetDatabase.LoadAllAssetsAtPath(assetPath) call is used to load all assets associated with the .fbx file. This includes the AnimationClip assets.
- AnimationUtility.GetAnimationClipSettings() retrieves the current settings for each AnimationClip.
- AnimationUtility.SetAnimationClipSettings() applies modified settings such as disabling root transform position Y (keepOriginalPositionY), position XZ, and rotation (keepOriginalOrientation).
Modification of AnimationClip Settings:
- The AnimationClipSettings structure allows you to configure how Unity handles root motion and transformations of imported animations.
- keepOriginalPositionY = false and similar settings let you override the default “Original” root motion behavior, allowing it to be baked in or based on the center of mass.

Things to Keep in Mind:

AnimationClip Settings Access: AnimationClipSettings is accessed through AnimationUtility, which allows you to modify root motion and other parameters after import.
AssetDatabase Use: Loading the assets with AssetDatabase.LoadAllAssetsAtPath() and modifying them after everything is imported ensures your changes are not overridden by Unity’s internal processes.
Root Motion Handling: Depending on your exact requirements, you may need to adjust additional AnimationClip properties or add custom curves to achieve your desired root motion behavior.

By using OnPostprocessAllAssets with careful attention to the AnimationClip settings, you can ensure that your modifications are applied last and persist through all stages of Unity’s import process.