unity3d => attributi

Sintassi

[AddComponentMenu (string menuName)]
[AddComponentMenu (string menuName, int order)]
[CanEditMultipleObjects]
[ContextMenuItem (nome stringa, funzione stringa)]
[ContextMenu (nome stringa)]
[CustomEditor (Type inspectedType)]
[CustomEditor (Type inspectedType, bool editorForChildClasses)]
[CustomPropertyDrawer (Tipo tipo)]
[CustomPropertyDrawer (Tipo tipo, bool useForChildren)]
[DisallowMultipleComponent]
[DrawGizmo (GizmoType gizmo)]
[DrawGizmo (GizmoType gizmo, Type drawnGizmoType)]
[ExecuteInEditMode]
[Intestazione (intestazione stringa)]
[HideInInspector]
[InitializeOnLoad]
[InitializeOnLoadMethod]
[MenuItem (stringa itemName)]
[MenuItem (stringa itemName, bool isValidateFunction)]
[MenuItem (stringa itemName, bool isValidateFunction, int priority)]
[Multiline (int lines)]
[PreferenceItem (nome stringa)]
[Range (float min, float max)]
[RequireComponent (Type type)]
[RuntimeInitializeOnLoadMethod]
[RuntimeInitializeOnLoadMethod (RuntimeInitializeLoadType loadType)]
[SerializeField]
[Spazio (altezza del galleggiante)]
[TextArea (int minLines, int maxLines)]
[Descrizione comando (tooltip stringa)]

Osservazioni

SerializeField

Il sistema di serializzazione di Unity può essere usato per fare quanto segue:

Può serializzare campi non statici pubblici (di tipi serializzabili)
Può serializzare i campi non statici non pubblici contrassegnati con l'attributo [SerializeField]
Non è possibile serializzare i campi statici
Impossibile serializzare le proprietà statiche

Il tuo campo, anche se contrassegnato con l'attributo SerializeField, verrà attribuito solo se è di un tipo che Unity può serializzare, ovvero:

Tutte le classi ereditate da UnityEngine.Object (es. GameObject, Component, MonoBehaviour, Texture2D)
Tutti i tipi di dati di base come int, string, float, bool
Alcuni tipi built-in come Vector2 / 3/4, Quaternion, Matrix4x4, Color, Rect, LayerMask
Matrici di un tipo serializzabile
Elenco di un tipo serializzabile
Enums
Structs

Attributi comuni dell'ispettore

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

Quando si passa sopra l'etichetta di un campo:

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

L'intestazione posiziona un'etichetta in grassetto contenente il testo sopra il campo attribuito. Questo è spesso usato per etichettare i gruppi per farli risaltare rispetto ad altre etichette.

[HideInInspector]
public string MyHiddenString;

HideInInspector impedisce che i campi pubblici vengano mostrati nell'ispettore. Questo è utile per accedere ai campi da altre parti del codice dove non sono altrimenti visibili o mutabili.

[Multiline( 5 )]
public string MyMultilineString;

Multiline crea una casella di testo con un numero di righe specificato. Il superamento di questo importo non espanderà la scatola né avvolgerà il testo.

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

TextArea consente il testo in stile multilinea con il wordwrap automatico e le barre di scorrimento se il testo supera l'area assegnata.

[Space( 15 )]
public int MyInt;

Lo spazio costringe l'ispettore ad aggiungere ulteriore spazio tra gli elementi precedenti e attuali, utile per distinguere e separare i gruppi.

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

L'intervallo forza un valore numerico tra un minimo e un massimo. Questo attributo funziona anche su numeri interi e doppi, anche se min e max sono specificati come float.

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

Tooltip mostra una descrizione aggiuntiva ogni volta che l'etichetta del campo viene posizionata sopra il puntatore.

[SerializeField]
private double myHiddenDouble;

SerializeField forza Unity a serializzare il campo, utile per i campi privati.

Attributi del componente

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

[DisallowMultipleComponent]

L'attributo DisallowMultipleComponent impedisce agli utenti di aggiungere più istanze di questo componente a un GameObject.

[RequireComponent( typeof( Rigidbody ) )]

L'attributo RequireComponent consente di specificare un altro componente (o più) come requisiti per quando questo componente viene aggiunto a un oggetto GameObject. Quando aggiungi questo componente a un GameObject, i componenti richiesti verranno aggiunti automaticamente (se non già presenti) e tali componenti non potranno essere rimossi finché non verrà rimosso quello che li richiede.

Attributi di runtime

[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

L'attributo ExecuteInEditMode forza Unity ad eseguire i metodi magici di questo script anche mentre il gioco non è in esecuzione.

Le funzioni non vengono costantemente chiamate come nella modalità di riproduzione
L'aggiornamento viene chiamato solo quando qualcosa nella scena è cambiato.
OnGUI viene chiamato quando la vista di gioco riceve un evento.
OnRenderObject e le altre funzioni di callback di rendering sono richiamate su ogni ridisegno della vista scena o vista gioco.

[RuntimeInitializeOnLoadMethod]
private static void FooBar()

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

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

L'attributo RuntimeInitializeOnLoadMethod consente di chiamare un metodo di classe runtime quando il gioco carica il runtime, senza alcuna interazione da parte dell'utente.

È possibile specificare se si desidera che il metodo venga richiamato prima o dopo il caricamento della scena (dopo l'impostazione predefinita). L'ordine di esecuzione non è garantito per i metodi che utilizzano questo attributo.

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

Il risultato dell'attributo [AddComponentMenu]

Il risultato dell'attributo [ContextMenuItem]

Il risultato dell'attributo [ContextMenu]

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

L'attributo AddComponentMenu consente di posizionare il componente in qualsiasi punto del menu Componente invece del menu Componente-> Script.

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

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

L'attributo ContextMenuItem consente di definire funzioni che possono essere aggiunte al menu di scelta rapida di un campo. Queste funzioni saranno eseguite alla selezione.

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

L'attributo ContextMenu consente di definire le funzioni che possono essere aggiunte al menu di scelta rapida del componente.

Attributi dell'editor

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

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

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

L'attributo InitializeOnLoad consente all'utente di inizializzare una classe senza alcuna interazione da parte dell'utente. Ciò accade ogni volta che l'editor si avvia o su una ricompilazione. Il costruttore statico garantisce che questo verrà chiamato prima di qualsiasi altra funzione statica.

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

L'attributo InitializeOnLoad consente all'utente di inizializzare una classe senza alcuna interazione da parte dell'utente. Ciò accade ogni volta che l'editor si avvia o su una ricompilazione. L'ordine di esecuzione non è garantito per i metodi che utilizzano questo attributo.

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

Il risultato dell'attributo [PreferenceItem]

Il risultato dell'attributo [MenuItem]

[CanEditMultipleObjects]
public class AttributesExample : MonoBehaviour

L'attributo CanEditMultipleObjects consente di modificare i valori dal componente su più oggetti GameObjects. Senza questo componente non vedrai il tuo componente apparire come normale quando selezioni più GameObjects ma vedrai invece il messaggio "Modifica di più oggetti non supportata"

Questo attributo è per gli editor personalizzati che supportano il multi editing. Gli editor non personalizzati supportano automaticamente il multi editing.

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

L'attributo PreferenceItem ti consente di creare un oggetto extra nel menu delle preferenze di Unity. Il metodo di ricezione deve essere statico per poter essere utilizzato.

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

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

L'attributo MenuItem consente di creare voci di menu personalizzate per l'esecuzione delle funzioni. Questo esempio utilizza anche una funzione di convalida (che restituisce sempre false) per impedire l'esecuzione della funzione.

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

L'attributo CustomEditor ti consente di creare editor personalizzati per i tuoi componenti. Questi editor verranno utilizzati per disegnare il componente nell'ispettore e devono derivare dalla classe Editor.

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

L'attributo CustomPropertyDrawer consente di creare un cassetto delle proprietà personalizzate per nell'ispettore. Puoi usare questi cassetti per i tuoi tipi di dati personalizzati in modo che possano essere visti usati nell'ispettore.

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

L'attributo DrawGizmo ti consente di disegnare aggeggi personalizzati per i tuoi componenti. Questi aggeggi saranno disegnati nella vista scena. Puoi decidere quando disegnare il gizmo usando il parametro GizmoType nell'attributo DrawGizmo.

Il metodo di ricezione richiede due parametri, il primo è il componente per disegnare il gizmo e il secondo è lo stato in cui si trova l'oggetto che ha bisogno del disegno del gizmo.

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

unity3d
attributi

Ricerca…