Editor Manual     Reference     Scripting  
Scripting > Editor Classes > Editor
Editor Inherits from ScriptableObject

Base class to derive custom Editors from. Use this to create your own custom inspectors and editors for your objects.

Note: This is an editor class. To use it you have to place your script in Assets/Editor inside your project folder. Editor classes are in the UnityEditor namespace so for C# scripts you need to add "using UnityEditor;" at the beginning of the script.

Consider a script MyPlayer with variables for armor, damage, and a reference to a gun GameObject:

// MyPlayer.js
// This is not an editor script.

var armor : int = 75;
var damage : int = 25;
var gun : GameObject;

function Update () {
// Update logic here...
}

Using a custom Editor, the apperance of the script in the Inspector can be changed, for example to look like this:


Custom editor in the Inspector.

You can attach the Editor to a custom component by using the CustomEditor attribute.

There are multiple ways to design custom Editors. If you want the Editor to support multi-object editing, you can use the CanEditMultipleObjects attribute. Instead of modifying script variables directly, it's advantageous to use the SerializedObject and SerializedProperty system to edit them, since this automatically handles multi-object editing, undo, and prefab overrides.

// Custom Editor using SerializedProperties.
// Automatic handling of multi-object editing, undo, and prefab overrides.
#pragma strict
@CustomEditor(MyPlayer)
@CanEditMultipleObjects
class MyPlayerEditor extends Editor {
var damageProp : SerializedProperty;
var armorProp : SerializedProperty;
var gunProp : SerializedProperty;

function OnEnable () {
// Setup the SerializedProperties
damageProp = serializedObject.FindProperty ("damage");
armorProp = serializedObject.FindProperty ("armor");
gunProp = serializedObject.FindProperty ("gun");
}

function OnInspectorGUI() {
// Update the serializedProperty - always do this in the beginning of OnInspectorGUI.
serializedObject.Update ();

// Show the custom GUI controls

EditorGUILayout.IntSlider (damageProp, 0, 100, new GUIContent ("Damage"));
// Only show the damage progress bar if all the objects have the same damage value:
if (!damageProp.hasMultipleDifferentValues)
ProgressBar (damageProp.intValue / 100.0, "Damage");

EditorGUILayout.IntSlider (armorProp, 0, 100, new GUIContent ("Armor"));
// Only show the armor progress bar if all the objects have the same armor value:
if (!armorProp.hasMultipleDifferentValues)
ProgressBar (armorProp.intValue / 100.0, "Armor");

EditorGUILayout.PropertyField (gunProp, new GUIContent ("Gun Object"));

// Apply changes to the serializedProperty - always do this in the end of OnInspectorGUI.
serializedObject.ApplyModifiedProperties ();
}

// Custom GUILayout progress bar.
function ProgressBar (value : float, label : String) {
// Get a rect for the progress bar using the same margins as a textfield:
var rect : Rect = GUILayoutUtility.GetRect (18, 18, "TextField");
EditorGUI.ProgressBar (rect, value, label);
EditorGUILayout.Space ();
}
}

Alternatively, if automatic handling of multi-object editing, undo, and prefab overrides is not needed, the script variables can be modified directly by the editor without using the SerializedObject and SerializedProperty system, as in the example below.

// Custom Editor the "old" way by modifying the script variables directly.
// No handling of multi-object editing, undo, and prefab overrides!
@CustomEditor (MyPlayer)
class MyPlayerEditor extends Editor {

function OnInspectorGUI () {
target.damage = EditorGUILayout.IntSlider ("Damage", target.damage, 0, 100);
ProgressBar (target.damage / 100.0, "Damage");

target.armor = EditorGUILayout.IntSlider ("Armor", target.armor, 0, 100);
ProgressBar (target.armor / 100.0, "Armor");

var allowSceneObjects : boolean = !EditorUtility.IsPersistent (target);
target.gun = EditorGUILayout.ObjectField ("Gun Object", target.gun, GameObject, allowSceneObjects);
}

// Custom GUILayout progress bar.
function ProgressBar (value : float, label : String) {
// Get a rect for the progress bar using the same margins as a textfield:
var rect : Rect = GUILayoutUtility.GetRect (18, 18, "TextField");
EditorGUI.ProgressBar (rect, value, label);
EditorGUILayout.Space ();
}
}

Variables
target

The object being inspected.

targets

An array of all the object being inspected.

serializedObject

A SerializedObject representing the object or objects being inspected.

Functions
DrawDefaultInspector

Draw the built-in inspector.

OnInspectorGUI

Implement this function to make a custom inspector.

Repaint

Repaint any inspectors that shows this editor.

HasPreviewGUI

Override this method in subclasses if you implement OnPreviewGUI.

GetPreviewTitle

Override this method if you want to change the label of the Preview area.

OnPreviewGUI

Implement this method in a subclass if you want to have a preview field in the inspector.

OnPreviewSettings

Override this method if you want to show custom controls in the preview header.

GetInfoString

Implement this method to show asset information on top of the asset preview.

Messages Sent
OnSceneGUI

Lets the Editor handle an event in the scene view.

Inherited members
Inherited Variables
name

The name of the object.

hideFlags

Should the object be hidden, saved with the scene or modifiable by the user?

Inherited Functions
GetInstanceID

Returns the instance id of the object.

ToString

Returns the name of the game object.

Inherited Messages Sent
OnEnable

This function is called when the object is loaded

OnDisable

This function is called when the scriptable object goes out of scope

OnDestroy

This function is called when the scriptable object will be destroyed.

Inherited Class Functions
CreateInstance

Creates an instance of a scriptable object with className.

operator bool

Does the object exist?

Instantiate

Clones the object original and returns the clone.

Destroy

Removes a gameobject, component or asset.

DestroyImmediate

Destroys the object obj immediately. It is strongly recommended to use Destroy instead.

FindObjectsOfType

Returns a list of all active loaded objects of Type type.

FindObjectOfType

Returns the first active loaded object of Type type.

operator ==

Compares if two objects refer to the same

operator !=

Compares if two objects refer to a different object

DontDestroyOnLoad

Makes the object target not be destroyed automatically when loading a new scene.