[CustomEditor]

In Unity, the [ CustomEditor ] attribute is used in C# scripts to customize the appearance and functionality of the Inspector window for a specific component or MonoBehaviour. It allows you to create a custom editor script that provides a specialized user interface for modifying the properties of a particular script or component.

By default, Unity automatically generates a standard inspector for each component, displaying all public variables and properties. However, with [CustomEditor], you can override this default behavior and create a custom editor to enhance the editing experience.

Here’s a simplified example that demonstrates the basic usage of [CustomEditor]:

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(MyScript))]
public class MyScriptEditor : Editor
{
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector(); // Draws the default inspector for the target script
        EditorGUILayout.HelpBox("This is a custom editor message!", MessageType.Info);
    }
}

public class MyScript : MonoBehaviour
{
    // No variables defined in this example
}

In this example, we have a script named “MyScript.cs” that is attached to a GameObject. We want to create a custom editor for this script.

The “MyScriptEditor” class is marked with the [CustomEditor] attribute, specifying that it provides a custom editor for the “MyScript” component. The class inherits from the base “Editor” class provided by Unity.

Inside the “OnInspectorGUI()” method, we call “DrawDefaultInspector()” to display the default inspector for the target script. This ensures that the default properties and fields are still shown in the Inspector.

Additionally, we use “EditorGUILayout.HelpBox()” to display a simple message box in the Inspector. In this example, the message says “This is a custom editor message!” and is styled as an information box.

To use this example:

1. Create a new C# script named “MyScript.cs” in your Unity project.
2. Copy and paste the above code into “MyScript.cs”.
3. Save the script and return to the Unity Editor.
4. Attach the “MyScript” script to a GameObject in your scene.
5. Unity will automatically generate an Inspector for the “MyScript” component.
6. The custom editor will display the default inspector contents, followed by the custom message box.

Feel free to modify the custom editor to add more customizations or functionality based on your requirements.

Why are we using [CustomEditor(typeof())] ?

The [CustomEditor(typeof())] attribute is used in Unity to associate a custom editor script with a specific type of script or component. It tells Unity that the custom editor script should be used to customize the appearance and functionality of the Inspector window for the specified type.

Let’s break down the syntax:

– [CustomEditor] is an attribute used in C# to define a custom editor for a script or component in Unity.

– typeof() is a C# operator that returns the System.Type object representing the specified type. It allows you to pass the type of script or component for which you want to create a custom editor.

So, when you write [CustomEditor(typeof(MyScript))] for example, you are telling Unity to associate the custom editor script (the one that has this attribute) with the “MyScript” component type. This means that when a GameObject in the Unity Editor has a “MyScript” component attached to it, the custom editor script will be used to customize the Inspector window for that component.

By associating the custom editor script with a specific type, you can override the default Inspector behavior and provide a tailored editing experience for that specific script or component.

Note that the custom editor script should be placed in an Editor folder within your Unity project to ensure it is only used within the Editor environment and not included in the build.

why are we using public class MyScriptEditor : Editor and not public class MyScriptEditor : monobehaviour ?

In Unity, when creating a custom editor script, we inherit from the base class `Editor`, not `MonoBehaviour`. Here’s why:

1. Purpose: The purpose of a custom editor script is to customize the appearance and functionality of the Inspector window for a specific script or component. It doesn’t represent a behavior or functionality of a GameObject like a MonoBehaviour does. Therefore, we don’t need to inherit from MonoBehaviour.

2. Editor scripts vs. MonoBehaviour: Editor scripts are used to extend the functionality of the Unity Editor itself, allowing you to create custom tools, inspectors, and workflows. They are executed within the Unity Editor and have access to the UnityEditor namespace. On the other hand, MonoBehaviour scripts are attached to GameObjects and are executed at runtime in the game.

3. Base class: The `Editor` class provided by Unity is specifically designed for creating custom editor scripts. It provides various methods and properties that allow you to interact with the Inspector and customize its behavior. Inheriting from `Editor` gives you access to these built-in functionalities.

By inheriting from `Editor`, we can override methods like `OnInspectorGUI()` to define the custom UI for the Inspector and add additional functionality specific to the custom editor. If we were to inherit from MonoBehaviour, we wouldn’t have access to the necessary methods and properties required for creating a custom editor.

Therefore, when creating custom editor scripts in Unity, we always inherit from the `Editor` class to define the behavior of the custom editor within the Unity Editor environment.

What is public override void OnInspectorGUI() for?

Here’s the reason for using `public override void OnInspectorGUI()`:

1. Method Override: By using `override`, we are indicating that we want to override the base implementation of the `OnInspectorGUI()` method provided by the `Editor` class. This allows us to replace the default behavior of the Inspector GUI with our custom implementation.

2. Customization of Inspector GUI: The `OnInspectorGUI()` method is called by Unity’s Editor system when drawing the Inspector for the associated script or component. By overriding this method, we can define our own custom GUI layout, fields, buttons, labels, and other UI elements specific to our script or component.

3. Placement of Custom UI Elements: Inside the `OnInspectorGUI()` method, we can use various layout and GUI functions provided by Unity’s `EditorGUILayout` class to add and organize custom UI elements within the Inspector window. These functions allow us to display and modify properties, fields, and other data of the associated script or component.

By overriding the `OnInspectorGUI()` method and providing our own custom implementation, we can create a tailored user interface within the Inspector window that enhances the editing experience for the script or component.

Remember, `OnInspectorGUI()` is just one of the many methods available in the `Editor` class for creating custom editor scripts. There are other methods you can override or use to handle specific events or behaviors within the custom editor.

Why do we use DrawDefaultInspector() ?

The `DrawDefaultInspector()` function is used within a custom editor script’s `OnInspectorGUI()` method to display the default Inspector GUI for the associated script or component. It allows you to include the standard Unity-generated Inspector elements alongside your custom UI.

Here’s why we use `DrawDefaultInspector()`:

1. Retaining Default Functionality: By calling `DrawDefaultInspector()`, we ensure that the default Inspector layout and functionality provided by Unity are still present. This includes displaying public fields, properties, and other serialized variables defined in the associated script or component.

2. Compatibility with Updates: Unity’s default Inspector behavior may change or new features may be added in future updates. By using `DrawDefaultInspector()`, your custom editor script will automatically adapt to these changes and remain compatible with future versions of Unity.

3. Consistency with Default Inspectors: `DrawDefaultInspector()` ensures that your custom editor script maintains a consistent look and behavior with other default Inspector windows. This can be beneficial for users who are already familiar with Unity’s default Inspector layout and expect a similar experience.

4. Easy Maintenance: If you make changes to the associated script or component (e.g., adding or modifying serialized variables), those changes will automatically be reflected in the default Inspector when using `DrawDefaultInspector()`. This helps reduce the maintenance overhead of manually updating the custom editor script for each change.

By using `DrawDefaultInspector()` within your custom editor script’s `OnInspectorGUI()` method, you can combine your custom UI elements with the default Inspector elements, creating a cohesive and familiar editing experience for the associated script or component.

Why did we use EditorGUILayout.HelpBox() ?

In the provided example, we used `EditorGUILayout.HelpBox()` to display a custom message box within the Inspector window of the associated script or component.

Here’s the reason for using `EditorGUILayout.HelpBox()`:

1. Informational Messages: The `HelpBox()` function allows you to display informational messages or hints within the Inspector window. It is commonly used to provide additional context or instructions to the user when editing the associated script or component.

2. Visual Distinction: By using a `HelpBox` with a specific message and `MessageType`, you can visually distinguish the message from other UI elements in the Inspector. Different `MessageType` options (e.g., Info, Warning, Error) provide different visual styles, allowing you to highlight the importance or urgency of the message.

3. Customizing User Experience: Adding a custom message box can improve the user experience by providing relevant information, tips, or warnings specific to the script or component being edited. It can help users understand the purpose, usage, or any special considerations associated with the script or component.

In the provided example, we used `EditorGUILayout.HelpBox()` with the message “This is a custom editor message!” and the `MessageType.Info`. This creates a simple information box with a blue background color and an “i” icon, indicating that it provides general information.

You can customize the message, message type, and even the appearance of the box further based on your specific needs. The `HelpBox()` function offers different message types such as Info, Warning, and Error, allowing you to communicate different levels of importance or urgency to the users.