ScriptedImporter.OnImportAsset

Parameters

Description

This method must be overriden by the derived class and is called by the Asset pipeline to import files.

using UnityEngine;
using UnityEditor.AssetImporters;
using System.IO;

[ScriptedImporter(1, "cube")]
public class CubeImporter : ScriptedImporter
{
    public float m_Scale = 1;

    public override void OnImportAsset(AssetImportContext ctx)
    {
        var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        var position = JsonUtility.FromJson<Vector3>(File.ReadAllText(ctx.assetPath));

        cube.transform.position = position;
        cube.transform.localScale = new Vector3(m_Scale, m_Scale, m_Scale);

        // 'cube' is a a GameObject and will be automatically converted into a Prefab
        // (Only the 'Main Asset' is elligible to become a Prefab.)
        ctx.AddObjectToAsset("main obj", cube);
        ctx.SetMainObject(cube);

        var material = new Material(Shader.Find("Standard"));
        ctx.DependsOnCustomDependency("StandardShaderDependencyHash");

        material.color = Color.red;

        // Assets must be assigned a unique identifier string consistent across imports
        ctx.AddObjectToAsset("my Material", material);

        // Assets that are not passed into the context as import outputs must be destroyed
        var tempMesh = new Mesh();
        DestroyImmediate(tempMesh);
    }
}

To use the Shader.Find() function in the above example, you need to write a custom dependency for the shader you want to find and regularly update it. This prevents the Shader.Find() function from bypassing other means of dependency checking. The below code is an example of how you might write a custom dependency for this purpose.

using UnityEditor;
using UnityEngine;

static class ShaderDependencyUpdater
{
    [InitializeOnLoadMethod]
    static void ShaderDependencyInit()
    {
        EditorApplication.update += ShaderDependencyUpdate;
    }
    static void ShaderDependencyUpdate()
    {
        var shader = Shader.Find("Standard");
        AssetDatabase.TryGetGUIDAndLocalFileIdentifier(shader, out var guid, out long id);
        var hash = new Hash128();
        hash.Append(guid);
        hash.Append(id);
        AssetDatabase.RegisterCustomDependency("StandardShaderDependencyHash", hash);
    }
}

You can declare artifact dependencies using either LazyLoadReference<T0> or regular Object references. Use AssetDatabase.TryGetGUIDAndLocalFileIdentifier to obtain the GUID from either type of reference.

LazyLoadReference<T0> is preferred for importer settings because it does not load the referenced asset when the importer is deserialized. Regular Object references can also be used, but they trigger loading the referenced asset immediately upon deserialization.

In both cases, the referenced asset may not yet have been imported, so always validate references.

using UnityEditor;
using UnityEditor.AssetImporters;
using UnityEngine;

public class MyImporter : ScriptedImporter
{
    public LazyLoadReference<AnimationClip> sourceClip;
    public LazyLoadReference<GameObject> sourcePrefab;
    public Texture2D sourceTexture;

    public override void OnImportAsset(AssetImportContext ctx)
    {
        // Declare artifact dependencies using LazyLoadReference
        if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(sourceClip.entityId, out string clipGuid, out long _))
        {
            if (GUID.TryParse(clipGuid, out GUID clipArtifactGuid))
            {
                ctx.DependsOnArtifact(clipArtifactGuid);
            }
        }

        if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(sourcePrefab.entityId, out string prefabGuid, out long _))
        {
            if (GUID.TryParse(prefabGuid, out GUID prefabArtifactGuid))
            {
                ctx.DependsOnArtifact(prefabArtifactGuid);
            }
        }

        // Declare artifact dependency using a regular Object reference
        if (!ReferenceEquals(sourceTexture, null))
        {
            if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(sourceTexture, out string textureGuid, out long _))
            {
                if (GUID.TryParse(textureGuid, out GUID textureArtifactGuid))
                {
                    ctx.DependsOnArtifact(textureArtifactGuid);
                }
            }
        }

        if (sourceClip.asset != null && sourcePrefab.asset != null && sourceTexture != null)
        {
            // Do import stuff..
        }
    }
}