unity3d
attributen

Syntaxis

• [AddComponentMenu (string menuName)]
• [AddComponentMenu (string menuName, int order)]
• [CanEditMultipleObjects]
• [ContextMenuItem (stringnaam, stringfunctie)]
• [ContextMenu (stringnaam)]
• [CustomEditor (Type inspectedType)]
• [CustomEditor (Type inspectedType, bool editorForChildClasses)]
• [CustomPropertyDrawer (Type type)]
• [CustomPropertyDrawer (Type type, bool useForChildren)]
• [DisallowMultipleComponent]
• [DrawGizmo (GizmoType gizmo)]
• [DrawGizmo (GizmoType gizmo, Type drawnGizmoType)]
• [ExecuteInEditMode]
• [Header (string header)]
• [HideInInspector]
• [InitializeOnLoad]
• [InitializeOnLoadMethod]
• [MenuItem (string itemName)]
• [MenuItem (string itemName, bool isValidateFunction)]
• [MenuItem (string itemName, bool isValidateFunction, int prioriteit)]
• [Multiline (int lijnen)]
• [PreferenceItem (stringnaam)]
• [Bereik (float min, float max)]
• [RequireComponent (type type)]
• [RuntimeInitializeOnLoadMethod]
• [RuntimeInitializeOnLoadMethod (RuntimeInitializeLoadType loadType)]
• [SerializeField]
• [Ruimte (zweefhoogte)]
• [TextArea (int minLines, int maxLines)]
• [Tooltip (string-knopinfo)]

Opmerkingen

Algemene inspecteurskenmerken

[Header( "My variables" )]
public string MyString;

[HideInInspector]
public string MyHiddenString;

[Multiline( 5 )]
public string MyMultilineString;

[TextArea( 2, 8 )]
public string MyTextArea;

[Space( 15 )]
public int MyInt;

[Range( 2.5f, 12.5f )]
public float MyFloat;

[Tooltip( "This is a tip for MyDouble" )]
public double MyDouble;

[SerializeField]
private double myHiddenDouble;

Wanneer u over het label van een veld zweeft:

[Header( "My variables" )]
public string MyString;

De koptekst plaatst een vetgedrukt label met de tekst boven het toegekende veld. Dit wordt vaak gebruikt voor het labelen van groepen om ze te laten opvallen ten opzichte van andere labels.

[HideInInspector]
public string MyHiddenString;

HideInInspector voorkomt dat openbare velden worden weergegeven in het infovenster. Dit is handig voor toegang tot velden uit andere delen van code waar ze anders niet zichtbaar of veranderlijk zijn.

[Multiline( 5 )]
public string MyMultilineString;

Multiline maakt een tekstvak met een opgegeven aantal regels. Als u dit bedrag overschrijdt, wordt het vak niet uitgevouwen en wordt de tekst niet omwikkeld.

[TextArea( 2, 8 )]
public string MyTextArea;

TextArea maakt tekst met meerdere regels mogelijk met automatische tekstafhandeling en schuifbalken als de tekst het toegewezen gebied overschrijdt.

[Space( 15 )]
public int MyInt;

Spatie dwingt de inspecteur om extra ruimte toe te voegen tussen vorige en huidige items - nuttig bij het onderscheiden en scheiden van groepen.

[Range( 2.5f, 12.5f )]
public float MyFloat;

Bereik dwingt een numerieke waarde tussen een minimum en een maximum. Dit kenmerk werkt ook op gehele getallen en dubbele waarden, hoewel min en max als floats worden opgegeven.

[Tooltip( "This is a tip for MyDouble" )]
public double MyDouble;

Knopinfo geeft een aanvullende beschrijving wanneer het label van het veld wordt verplaatst.

[SerializeField]
private double myHiddenDouble;

SerializeField dwingt Unity om het veld te serialiseren - handig voor privévelden.

Component attributen

[DisallowMultipleComponent]
[RequireComponent( typeof( Rigidbody ) )]
public class AttributesExample : MonoBehaviour 
{
    [...]
}

[DisallowMultipleComponent]

Het kenmerk DisallowMultipleComponent voorkomt dat gebruikers meerdere instanties van deze component aan één GameObject toevoegen.

[RequireComponent( typeof( Rigidbody ) )]

Met het kenmerk RequireComponent kunt u een andere component (of meer) opgeven als vereisten voor wanneer deze component wordt toegevoegd aan een GameObject. Wanneer u dit component toevoegt aan een GameObject, worden de vereiste componenten automatisch toegevoegd (indien nog niet aanwezig) en kunnen die componenten niet worden verwijderd totdat degene die ze vereist, wordt verwijderd.

Runtime-kenmerken

[ExecuteInEditMode]
public class AttributesExample : MonoBehaviour 
{

    [RuntimeInitializeOnLoadMethod]
    private static void FooBar() 
    {
        [...]
    }

    [RuntimeInitializeOnLoadMethod( RuntimeInitializeLoadType.BeforeSceneLoad )]
    private static void Foo() 
    {
        [...]
    }

    [RuntimeInitializeOnLoadMethod( RuntimeInitializeLoadType.AfterSceneLoad )]
    private static void Bar() 
    {
        [...]
    }

    void Update() 
    {
        if ( Application.isEditor )
        {
            [...]
        } 
        else
        {
            [...]
        }
    }
}

[ExecuteInEditMode]
public class AttributesExample : MonoBehaviour 

Het kenmerk ExecuteInEditMode dwingt Unity om de magische methoden van dit script uit te voeren, zelfs wanneer de game niet wordt gespeeld.

De functies worden niet constant opgeroepen zoals in de afspeelmodus

• Update wordt alleen opgeroepen als er iets in de scène is veranderd.
• OnGUI wordt opgeroepen wanneer de gameweergave een gebeurtenis ontvangt.
• OnRenderObject en de andere rendering callback-functies worden bij elke herschilderen van de Scene View of Game View opgeroepen.

[RuntimeInitializeOnLoadMethod]
private static void FooBar()

[RuntimeInitializeOnLoadMethod( RuntimeInitializeLoadType.BeforeSceneLoad )]
private static void Foo() 

[RuntimeInitializeOnLoadMethod( RuntimeInitializeLoadType.AfterSceneLoad )]
private static void Bar() 

Met het kenmerk RuntimeInitializeOnLoadMethod kan een runtime-class-methode worden aangeroepen wanneer de game de runtime laadt, zonder enige interactie van de gebruiker.

U kunt opgeven of u de methode wilt gebruiken voor of na het laden van de scène (na is standaard). De volgorde van uitvoering wordt niet gegarandeerd voor methoden die dit kenmerk gebruiken.

Menu attributen

[AddComponentMenu( "Examples/Attribute Example" )]
public class AttributesExample : MonoBehaviour 
{
    [ContextMenuItem( "My Field Action", "MyFieldContextAction" )]
    public string MyString;

    private void MyFieldContextAction() 
    {
        [...]
    }

    [ContextMenu( "My Action" )]
    private void MyContextMenuAction() 
    {
        [...]
    }
}

Het resultaat van het kenmerk [AddComponentMenu]

Het resultaat van het kenmerk [ContextMenuItem]

Het resultaat van het kenmerk [ContextMenu]

[AddComponentMenu( "Examples/Attribute Example" )]
public class AttributesExample : MonoBehaviour 

Met het kenmerk AddComponentMenu kunt u uw component overal in het Component-menu plaatsen in plaats van het Component-> Scripts-menu.

[ContextMenuItem( "My Field Action", "MyFieldContextAction" )]
public string MyString;

private void MyFieldContextAction() 
{
    [...]
}

Met het kenmerk ContextMenuItem kunt u functies definiëren die kunnen worden toegevoegd aan het contextmenu van een veld. Deze functies worden bij selectie uitgevoerd.

[ContextMenu( "My Action" )]
private void MyContextMenuAction() 
{
    [...]
}

Met het kenmerk ContextMenu kunt u functies definiëren die kunnen worden toegevoegd aan het contextmenu van de component.

Editorattributen

[InitializeOnLoad]
public class AttributesExample : MonoBehaviour
{
    
    static AttributesExample() 
    {
        [...]
    }

    [InitializeOnLoadMethod]
    private static void Foo()
    {
        [...]
    }
}

[InitializeOnLoad]
public class AttributesExample : MonoBehaviour
{
    
    static AttributesExample() 
    {
        [...]
    }

Met het kenmerk InitializeOnLoad kan de gebruiker een klasse initialiseren zonder enige interactie van de gebruiker. Dit gebeurt wanneer de editor wordt gestart of opnieuw wordt gecompileerd. De statische constructor garandeert dat dit vóór alle andere statische functies wordt aangeroepen.

[InitializeOnLoadMethod]
private static void Foo()
{
    [...]
}

Met het kenmerk InitializeOnLoad kan de gebruiker een klasse initialiseren zonder enige interactie van de gebruiker. Dit gebeurt wanneer de editor wordt gestart of opnieuw wordt gecompileerd. De volgorde van uitvoering wordt niet gegarandeerd voor methoden die dit kenmerk gebruiken.

[CanEditMultipleObjects]
public class AttributesExample : MonoBehaviour 
{

    public int MyInt;

    private static string prefsText = "";

    [PreferenceItem( "My Prefs" )]
    public static void PreferencesGUI()
    {
        prefsText = EditorGUILayout.TextField( "Prefs Text", prefsText );
    }

    [MenuItem( "Attributes/Foo" )]
    private static void Foo()
    {
        [...]
    }

    [MenuItem( "Attributes/Foo", true )]
    private static bool FooValidate() 
    {
        return false;
    }
}

Het resultaat van het kenmerk [PreferenceItem]

Het resultaat van het kenmerk [MenuItem]

[CanEditMultipleObjects]
public class AttributesExample : MonoBehaviour 

Met het kenmerk CanEditMultipleObjects kunt u waarden van uw component over meerdere GameObjects bewerken. Zonder deze component ziet u uw component niet als normaal wanneer u meerdere GameObjects selecteert, maar in plaats daarvan ziet u het bericht "Bewerken van meerdere objecten niet ondersteund"

Dit kenmerk is bedoeld voor aangepaste editors die multi-bewerking ondersteunen. Niet-aangepaste editors ondersteunen automatisch meerdere bewerkingen.

[PreferenceItem( "My Prefs" )]
public static void PreferencesGUI()

Met het kenmerk PreferenceItem kunt u een extra item maken in het voorkeurenmenu van Unity. De ontvangstmethode moet statisch zijn om te kunnen worden gebruikt.

[MenuItem( "Attributes/Foo" )]
private static void Foo()
{
    [...]
}

[MenuItem( "Attributes/Foo", true )]
private static bool FooValidate() 
{
    return false;
}

Met het kenmerk MenuItem kunt u aangepaste menu-items maken om functies uit te voeren. Dit voorbeeld gebruikt ook een validatorfunctie (die altijd false retourneert) om uitvoering van de functie te voorkomen.

[CustomEditor( typeof( MyComponent ) )]
public class AttributesExample : Editor
{
    [...]
}

Met het kenmerk CustomEditor kunt u aangepaste editors maken voor uw componenten. Deze editors worden gebruikt voor het tekenen van uw component in het infovenster en moeten afkomstig zijn van de Editor-klasse.

[CustomPropertyDrawer( typeof( MyClass ) )]
public class AttributesExample : PropertyDrawer 
{
    [...]
}

Met het kenmerk CustomPropertyDrawer kunt u een aangepaste eigenschappenlade maken voor in de infovenster. U kunt deze laden gebruiken voor uw aangepaste gegevenstypen, zodat ze zichtbaar zijn in de infovenster.

[DrawGizmo( GizmoType.Selected )]
private static void DoGizmo( AttributesExample obj, GizmoType type )
{
    [...]
}

Met het kenmerk DrawGizmo kunt u aangepaste gadgets voor uw componenten tekenen. Deze gadgets worden getekend in de scèneweergave. U kunt beslissen wanneer u de gizmo wilt tekenen met behulp van de parameter GizmoType in het DrawGizmo-kenmerk.

De ontvangstmethode vereist twee parameters, de eerste is de component waarvoor de gizmo wordt getekend en de tweede is de status waarin het object zit dat de gizmo moet tekenen.