unity3d
attribut

Syntax

• [AddComponentMenu (strängmenynamn)]
• [AddComponentMenu (strängmenynamn, int order)
• [CanEditMultipleObjects]
• [ContextMenuItem (strängnamn, strängfunktion)]
• [ContextMenu (strängnamn)]
• [CustomEditor (Type inspectedType)]
• [CustomEditor (Type inspectedType, bool editorForChildClasses)]
• [CustomPropertyDrawer (typstyp)]
• [CustomPropertyDrawer (Typ av typ, bool useForChildren)]
• [DisallowMultipleComponent]
• [DrawGizmo (GizmoType gizmo)]
• [DrawGizmo (GizmoType gizmo, Type DrawGizmoType)]
• [ExecuteInEditMode]
• [Header (stränghuvud)]
• [HideInInspector]
• [InitializeOnLoad]
• [InitializeOnLoadMethod]
• [MenuItem (strängobjektnamn)]
• [MenuItem (string itemName, bool isValidateFunction)]
• [MenuItem (string itemName, bool isValidateFunction, int prioritet)]
• [Multiline (int-rader)]
• [PreferenceItem (strängnamn)]
• [Range (float min, float max)]
• [RequireComponent (typstyp)]
• [RuntimeInitializeOnLoadMethod]
• [RuntimeInitializeOnLoadMethod (RuntimeInitializeLoadType loadType)]
• [SerializeField]
• [Utrymme (flottörhöjd)]
• [TextArea (int minLines, int maxLines)]
• [Tooltip (string tooltip)]

Anmärkningar

Gemensamma inspektörsattribut

[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;

När du håller muspekaren över etikett på ett fält:

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

Rubrik placerar en fet etikett som innehåller texten ovanför det tillskrivna fältet. Detta används ofta för märkningsgrupper för att få dem att sticker ut mot andra etiketter.

[HideInInspector]
public string MyHiddenString;

HideInInspector förhindrar att offentliga fält från visas i inspektören. Detta är användbart för att få åtkomst till fält från andra delar av koden där de inte på annat sätt är synliga eller muterbara.

[Multiline( 5 )]
public string MyMultilineString;

Multiline skapar en textlåda med ett specificerat antal rader. Om du överskrider det här beloppet kommer varken att utöka rutan eller släcka texten.

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

TextArea tillåter text i flera linjer med automatisk ordomslagning och rullningsfält om texten överskrider det tilldelade området.

[Space( 15 )]
public int MyInt;

Rymd tvingar inspektören att lägga till extra utrymme mellan tidigare och nuvarande artiklar - användbart för att skilja och skilja grupper.

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

Område tvingar ett numeriskt värde mellan ett minimum och ett maximum. Detta attribut fungerar också på heltal och dubbletter, även om min och max anges som flottörer.

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

Verktygstips visar en ytterligare beskrivning när fältets etikett hålls över.

[SerializeField]
private double myHiddenDouble;

SerializeField tvingar enhet att serialisera fältet - användbart för privata fält.

Komponentattribut

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

[DisallowMultipleComponent]

Attributet DisallowMultipleComponent förhindrar användare att lägga till flera instanser av denna komponent till ett GameObject.

[RequireComponent( typeof( Rigidbody ) )]

Attributet RequireComponent låter dig ange en annan komponent (eller mer) som krav för när denna komponent läggs till i en GameObject. När du lägger till denna komponent i ett GameObject läggs de nödvändiga komponenterna automatiskt till (om de inte redan finns) och dessa komponenter kan inte tas bort förrän den som kräver dem har tagits bort.

Runtime-attribut

[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 

Attributet ExecuteInEditMode tvingar Unity att köra skriptets magiska metoder även när spelet inte spelar.

Funktionerna kallas inte ständigt som i uppspelningsläge

• Uppdatering anropas bara när något i scenen förändrats.
• OnGUI anropas när Game View får ett evenemang.
• OnRenderObject och de andra återuppringningsfunktionerna kallas på varje ommålning av scenvyn eller spelvyn.

[RuntimeInitializeOnLoadMethod]
private static void FooBar()

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

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

Attributet RuntimeInitializeOnLoadMethod gör det möjligt att ringa en metod för runtime class när spelet laddar runtime, utan någon interaktion från användaren.

Du kan ange om du vill att metoden ska åberopas före eller efter scenbelastning (efter är standard). Utföringsordningen är inte garanterad för metoder som använder detta attribut.

Menyattribut

[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() 
    {
        [...]
    }
}

Resultatet av attributet [AddComponentMenu]

Resultatet av attributet [ContextMenuItem]

Resultatet av attributet [ContextMenu]

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

AddComponentMenu-attributet låter dig placera din komponent var som helst i menyn Komponent i stället för menyn Komponent-> Skript.

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

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

Attributet ContextMenuItem låter dig definiera funktioner som kan läggas till i fältets kontextmeny. Dessa funktioner kommer att köras vid val.

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

Attributet ContextMenu låter dig definiera funktioner som kan läggas till komponentens kontextmeny.

Editorattribut

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

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

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

Attributet InitializeOnLoad tillåter användaren att initiera en klass utan någon interaktion från användaren. Detta händer när redaktören startar eller vid en omkompilering. Den statiska konstruktören garanterar att detta kommer att kallas innan andra statiska funktioner.

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

Attributet InitializeOnLoad tillåter användaren att initiera en klass utan någon interaktion från användaren. Detta händer när redaktören startar eller vid en omkompilering. Utföringsordningen är inte garanterad för metoder som använder detta attribut.

[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;
    }
}

Resultatet av attributet [PreferenceItem]

Resultatet av attributet [MenuItem]

[CanEditMultipleObjects]
public class AttributesExample : MonoBehaviour 

Med CanEditMultipleObjects-attributet kan du redigera värden från din komponent över flera GameObjects. Utan den här komponenten ser du inte att din komponent ser ut som normalt när du väljer flera GameObjects men istället ser du meddelandet "Redigering av flera objekt stöds inte"

Detta attribut är för anpassade redaktörer för att stödja flera redigeringar. Icke-anpassade redaktörer stöder automatiskt flerredigering.

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

Attributet PreferenceItem låter dig skapa ett extra objekt i Unitys inställningsmeny. Mottagningsmetoden måste vara statisk för att den ska kunna användas.

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

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

Attributet MenuItem låter dig skapa anpassade menyalternativ för att utföra funktioner. Det här exemplet använder också en validatorfunktion (som alltid returnerar falsk) för att förhindra körning av funktionen.

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

CustomEditor-attributet låter dig skapa anpassade redigerare för dina komponenter. Dessa redaktörer kommer att användas för att rita din komponent i inspektören och måste härledas från klassen Editor.

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

Attributet CustomPropertyDrawer låter dig skapa en anpassad egenskapslåda för i inspektören. Du kan använda dessa lådor för dina anpassade datatyper så att de kan ses som används i inspektören.

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

Attributet DrawGizmo låter dig rita anpassade gizmos för dina komponenter. Dessa gizmos ritas i scenvyn. Du kan bestämma när du vill rita gizmo genom att använda parametern GizmoType i attributet DrawGizmo.

Mottagningsmetoden kräver två parametrar, den första är komponenten att dra gizmo för och den andra är tillståndet som objektet som behöver den dragna gizmo befinner sig i.