AssetImporterEditor

説明

Default editor for all asset importer settings.

Use the default editor to edit the import settings for assets. You can define a custom import settings editor for a specific asset type. To do this, create a new class that inherits from AssetImporterEditor and uses a CustomEditorAttribute that refers to a ScriptedImporter.

The following example shows how to make a custom ScriptedImporterEditor for a ScriptedImporter with a custom layout.

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

[CustomEditor(typeof(TransformImporter))]
[CanEditMultipleObjects]
public class TransformImporterEditor : ScriptedImporterEditor
{
    // Stored SerializedProperty to draw in OnInspectorGUI.
    SerializedProperty m_GenerateChild;

    public override void OnEnable()
    {
        base.OnEnable();
        // Once in OnEnable, retrieve the serializedObject property and store it.
        m_GenerateChild = serializedObject.FindProperty("generateChild");
    }

    public override void OnInspectorGUI()
    {
        // Update the serializedObject in case it has been changed outside the Inspector.
        serializedObject.Update();

        // Draw the boolean property.
        EditorGUILayout.PropertyField(m_GenerateChild);

        // Apply the changes so Undo/Redo is working
        serializedObject.ApplyModifiedProperties();

        // Call ApplyRevertGUI to show Apply and Revert buttons.
        ApplyRevertGUI();
    }
}

[ScriptedImporter(0, ".transform")]
public class TransformImporter : ScriptedImporter
{
    public bool generateChild;

    public override void OnImportAsset(AssetImportContext ctx)
    {
        GameObject root = ObjectFactory.CreateGameObject(Path.GetFileNameWithoutExtension(ctx.assetPath));
        if (generateChild)
        {
            GameObject child = ObjectFactory.CreateGameObject("child");
            child.transform.SetParent(root.transform);
        }
        ctx.AddObjectToAsset("main", root);
        ctx.SetMainObject(root);
    }
}

The following example demonstrates a specific case where the user cannot change settings and the Apply/Revert buttons are hidden with needsApplyRevert.

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

[CustomEditor(typeof(EmptinessImporter))]
[CanEditMultipleObjects]
public class EmptinessImporterEditor : ScriptedImporterEditor
{
    //Let the parent class know that the Apply/Revert mechanism is skipped.
    protected override bool needsApplyRevert => false;

    public override void OnInspectorGUI()
    {
        // Draw some information
        EditorGUILayout.HelpBox("Because this Importer doesn't have any settings, the Apply/Revert buttons are hidden.", MessageType.None);
    }
}

[ScriptedImporter(0, ".emptiness")]
public class EmptinessImporter : ScriptedImporter
{
    public override void OnImportAsset(AssetImportContext ctx)
    {
        GameObject root = ObjectFactory.CreateGameObject(Path.GetFileNameWithoutExtension(ctx.assetPath));
        ctx.AddObjectToAsset("main", root);
        ctx.SetMainObject(root);
    }
}

The following example shows how to use extraDataType to read or save settings that are not part of the ScriptedImporter serialization, in the custom AssetImporterEditor.

using System;
using System.IO;
using UnityEditor;
using UnityEditor.Experimental.AssetImporters;
using UnityEngine;
using Object = UnityEngine.Object;

[CustomEditor(typeof(BooleanImporter))]
[CanEditMultipleObjects]
public class BooleanImporterEditor : ScriptedImporterEditor
{
    // Property to show in the custom OnInspectorGUI.
    SerializedProperty m_BooleanProperty;

    // override extraDataType to return the type that will be used in the Editor.
    protected override Type extraDataType => typeof(BooleanClass);

    // override InitializeExtraDataInstance to set up the data.
    protected override void InitializeExtraDataInstance(Object extraTarget, int targetIndex)
    {
        var boolean = (BooleanClass)extraTarget;
        // Read the boolean value from the text file and fill the extraTarget object with the data.
        string fileContent = File.ReadAllText(((AssetImporter)targets[targetIndex]).assetPath);
        if (!bool.TryParse(fileContent, out boolean.boolean))
        {
            boolean.boolean = false;
        }
    }

    protected override void Apply()
    {
        base.Apply();
        // After the Importer is applied, rewrite the file with the custom value.
        for (int i = 0; i < targets.Length; i++)
        {
            string path = ((AssetImporter)targets[i]).assetPath;
            File.WriteAllText(path, ((BooleanClass)extraDataTargets[i]).boolean.ToString());
        }
    }

    public override void OnEnable()
    {
        base.OnEnable();
        // In OnEnable, retrieve the importerUserSerializedObject property and store it.
        m_BooleanProperty = extraDataSerializedObject.FindProperty("boolean");
    }

    public override void OnInspectorGUI()
    {
        // Note: you don't need to call serializedObject.Update or serializedObject.ApplyModifiedProperties
        // because you are not changing the target (serializedObject) itself.

        // Update the importerUserSerializedObject in case it has been changed outside the Inspector.
        extraDataSerializedObject.Update();

        // Draw the boolean property.
        EditorGUILayout.PropertyField(m_BooleanProperty);

        // Apply the changes so Undo/Redo is working.
        extraDataSerializedObject.ApplyModifiedProperties();

        // Call ApplyRevertGUI to show Apply and Revert buttons.
        ApplyRevertGUI();
    }
}

public class BooleanClass : ScriptableObject
{
    public bool boolean;
}

[ScriptedImporter(0, ".boolean")]
public class BooleanImporter : ScriptedImporter
{
    public override void OnImportAsset(AssetImportContext ctx)
    {
        string fileContent = File.ReadAllText(ctx.assetPath);
        var booleanObj = ObjectFactory.CreateInstance<BooleanClass>();
        if (!bool.TryParse(fileContent, out booleanObj.boolean))
        {
            booleanObj.boolean = false;
        }
        ctx.AddObjectToAsset("main", booleanObj);
        ctx.SetMainObject(booleanObj);
        Debug.Log("Imported Boolean value: " + booleanObj.boolean);
    }
}

You can also use ScriptedImporter settings and extraData in the same AssetImporterEditor:

using UnityEditor;
using UnityEditor.Experimental.AssetImporters;

[CustomEditor(typeof(SomeScriptedImporter))]
[CanEditMultipleObjects]
public class SomeImporterEditor : ScriptedImporterEditor
{
    // ...

    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        extraDataSerializedObject.Update();

        // Use propertyDrawers and custom GUI for any property from both serializedObject and extraDataSerializedObject.

        extraDataSerializedObject.ApplyModifiedProperties();
        serializedObject.ApplyModifiedProperties();

        ApplyRevertGUI();
    }
}

[ScriptedImporter(0, ".someFile")]
public class SomeScriptedImporter : ScriptedImporter
{
    public override void OnImportAsset(AssetImportContext ctx)
    {
        // ...
    }
}

変数

Public 関数

Protected 関数

継承メンバー