Custom Editors

Om de ontwikkeling van applicaties te versnellen, maak je custom editors voor componenten die je vaak gebruikt. Deze pagina laat zien hoe je een eenvoudig script maakt om GameObjects te makenHet fundamentele object in Unity scènes, dat personages, rekwisieten, landschappen, camera’s, waypoints, en meer kan vertegenwoordigen. De functionaliteit van een GameObject wordt bepaald door de Components die eraan gekoppeld zijn. Meer info
Zie in Woordenlijst altijd kijken naar een punt.

1. Maak een C# script en noem het “”LookAtPoint”.
2. Open het script en vervang de inhoud door de onderstaande code.
3. Bind het script aan een GameObject in je SceneEen Scene bevat de omgevingen en menu’s van je spel. Denk aan elk uniek Scene bestand als een uniek level. In elke Scene plaats je je omgevingen, obstakels en decoraties, in wezen ontwerp en bouw je je spel in stukjes. Meer info
   Zie in Woordenlijst.

//C# Example (LookAtPoint.cs)using UnityEngine;public class LookAtPoint : MonoBehaviour{ public Vector3 lookAtPoint = Vector3.zero; void Update() { transform.LookAt(lookAtPoint); }}

Wanneer je in Speelmode komt, oriënteert het GameObject waar je het script aan hebt gekoppeld zich nu naar de coördinaten die je hebt ingesteld op de “Look At Point” eigenschap. Bij het schrijven van Editor scriptsEen stukje code waarmee je je eigen Componenten kunt maken, spelgebeurtenissen kunt triggeren, Component eigenschappen kunt wijzigen in de tijd en kunt reageren op gebruikersinvoer op elke manier die je maar wilt. Meer info
Zie in Woordenlijst, het is vaak handig om bepaalde scripts uit te laten voeren tijdens de Edit mode, terwijl uw applicatie niet draait. Om dit te doen, voeg je het ExecuteInEditMode attribuut toe aan de class, zoals dit:

//C# Example (LookAtPoint.cs)using UnityEngine;public class LookAtPoint : MonoBehaviour{ public Vector3 lookAtPoint = Vector3.zero; void Update() { transform.LookAt(lookAtPoint); }}

Als je nu het GameObject verplaatst in de Editor, of de waarden van “Look At Point” verandert in de InspectorEen Unity venster dat informatie weergeeft over het huidig geselecteerde GameObject, asset of project instellingen, zodat je de waarden kunt inspecteren en bewerken. Meer info
Zie in Woordenlijst, het GameObject werkt zijn rotatie bij zodat het kijkt naar het doelpunt in de wereldruimte.

Een aangepaste editor maken

Het bovenstaande demonstreert hoe je eenvoudige scripts kunt laten draaien tijdens edit-tijd, maar dit alleen stelt je niet in staat om je eigen Editor tools te maken. De volgende stap is het maken van een aangepaste editor voor het script dat je zojuist hebt gemaakt.

Wanneer je een script maakt in Unity, erft het standaard van MonoBehaviour, en is daarom een component die je kunt koppelen aan een GameObject. Wanneer je een component op een GameObject plaatst, toont de Inspector een standaard interface die je kunt gebruiken om elke publieke variabele te bekijken en te bewerken, bijvoorbeeld: een integer, een float, of een string.

Zo ziet de Inspector voor de LookAtPoint-component er standaard uit:

Een aangepaste editor is een apart script dat deze standaardindeling vervangt door de editor-besturingselementen die jij kiest.

Om de aangepaste editor voor het LookAtPoint-script te maken:

1. Maak een nieuw C#-script en noem het “LookAtPointEditor”.
2. Open het script en vervang de inhoud door de onderstaande code.

//C# Example (LookAtPointEditor.cs)using UnityEngine;using UnityEditor;public class LookAtPointEditor : Editor { SerializedProperty lookAtPoint; void OnEnable() { lookAtPoint = serializedObject.FindProperty("lookAtPoint"); } public override void OnInspectorGUI() { serializedObject.Update(); EditorGUILayout.PropertyField(lookAtPoint); serializedObject.ApplyModifiedProperties(); }}

Deze klasse moet erven van Editor. Het CustomEditor-attribuut informeert Unity voor welke component het als editor moet fungeren. Het CanEditMultipleObjects attribuut vertelt Unity dat je meerdere objecten kunt selecteren met deze editor en ze allemaal tegelijk kunt wijzigen.

Unity voert de code uit in OnInspectorGUI het geeft de editor weer in de Inspector. Je kunt hier elke GUI code in stoppen en het werkt op dezelfde manier als OnGUI doet, maar het wordt uitgevoerd in de Inspector. Editor definieert de target eigenschap die je kunt gebruiken om toegang te krijgen tot het GameObject dat je aan het inspecteren bent.

Dit is hoe de Inspector voor de LookAtPoint component eruit ziet met de nieuwe editor:

Dit lijkt er sterk op (hoewel het “Script” veld nu niet aanwezig is, omdat het editor script geen Inspector code toevoegt om het te tonen).

Maar nu u de controle hebt over hoe de Inspector wordt weergegeven in een Editor-script, kunt u elke code gebruiken die u maar wilt om de Inspector-velden op te maken, de gebruiker in staat te stellen de waarden aan te passen, en zelfs afbeeldingen of andere visuele elementen weer te geven. In feite zijn alle Inspectors die je ziet in de Unity Editor inclusief de meer complexe Inspectors zoals het terreinHet landschap in je scene. Een Terrain GameObject voegt een groot plat vlak toe aan je scène en je kunt het Terrain’s Inspector venster gebruiken om een gedetailleerd landschap te maken. Meer info
Zie in Woordenlijst systeem en animatie import instellingen, zijn allemaal gemaakt met dezelfde API waartoe je toegang hebt bij het maken van je eigen aangepaste editors.

Hier is een eenvoudig voorbeeld dat je editor script uitbreidt om een bericht te tonen dat aangeeft of het doelpunt boven of onder het GameObject is:

//C# Example (LookAtPointEditor.cs)using UnityEngine;using UnityEditor;public class LookAtPointEditor : Editor{ SerializedProperty lookAtPoint; void OnEnable() { lookAtPoint = serializedObject.FindProperty("lookAtPoint"); } public override void OnInspectorGUI() { serializedObject.Update(); EditorGUILayout.PropertyField(lookAtPoint); serializedObject.ApplyModifiedProperties(); if (lookAtPoint.vector3Value.y > (target as LookAtPoint).transform.position.y) { EditorGUILayout.LabelField("(Above this object)"); } if (lookAtPoint.vector3Value.y < (target as LookAtPoint).transform.position.y) { EditorGUILayout.LabelField("(Below this object)"); } }}

Dit is hoe de Inspector voor de LookAtPoint component eruit ziet met het bericht dat aangeeft of het doelpunt boven of onder het GameObject is.

Je hebt volledige toegang tot alle IMGUI-commando’s om elk type interface te tekenen, inclusief renderenHet proces van het tekenen van graphics naar het scherm (of naar een rendertextuur). Standaard rendert de hoofdcamera in Unity zijn beeld naar het scherm. Meer info
Zie in Woordenlijst Scènes met een CameraEen component die een beeld creëert van een bepaald gezichtspunt in je scène. De output wordt ofwel op het scherm getekend of vastgelegd als een textuur. Meer info
Zie in Woordenlijst binnen Editor vensters.

Scene View Toevoegingen

U kunt extra code toevoegen aan de Scene ViewEen interactieve kijk in de wereld die u aan het maken bent. Je gebruikt de Scene View voor het selecteren en positioneren van scenery, karakters, camera’s, lampen, en alle andere soorten Game Objects. Meer info
Zie in Woordenlijst. Om dit te doen, implementeer OnSceneGUI in uw aangepaste editor.

OnSceneGUI werkt net als OnInspectorGUI, behalve dat het in de Scene view draait. Om u te helpen uw eigen bewerkingscontroles te maken, kunt u de functies gebruiken die zijn gedefinieerd in de klasse Handles. Alle functies daarin zijn ontworpen voor het werken in 3D Scene views.

//C# Example (LookAtPointEditor.cs)using UnityEngine;using UnityEditor;public class LookAtPointEditor : Editor{ SerializedProperty lookAtPoint; void OnEnable() { lookAtPoint = serializedObject.FindProperty("lookAtPoint"); } public override void OnInspectorGUI() { serializedObject.Update(); EditorGUILayout.PropertyField(lookAtPoint); if (lookAtPoint.vector3Value.y > (target as LookAtPoint).transform.position.y) { EditorGUILayout.LabelField("(Above this object)"); } if (lookAtPoint.vector3Value.y < (target as LookAtPoint).transform.position.y) { EditorGUILayout.LabelField("(Below this object)"); } serializedObject.ApplyModifiedProperties(); } public void OnSceneGUI() { var t = (target as LookAtPoint); EditorGUI.BeginChangeCheck(); Vector3 pos = Handles.PositionHandle(t.lookAtPoint, Quaternion.identity); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(target, "Move point"); t.lookAtPoint = pos; t.Update(); } }}

Als je 2D GUI objecten wilt toevoegen (bijvoorbeeld: GUI of EditorGUI), moet je ze verpakken in calls naar Handles.BeginGUI() en Handles.EndGUI().