unity3d
Les attributs

Syntaxe

• [AddComponentMenu (string nomMenu)]
• [AddComponentMenu (string menuName, int order)]
• [CanEditMultipleObjects]
• [ContextMenuItem (nom de chaîne, fonction de chaîne)]
• [ContextMenu (nom de chaîne)]
• [CustomEditor (Type inspectedType)]
• [CustomEditor (Type inspectedType, bool editorForChildClasses)]
• [CustomPropertyDrawer (type de type)]
• [CustomPropertyDrawer (type type, bool useForChildren)]
• [DisallowMultipleComponent]
• [DrawGizmo (GizmoType gizmo)]
• [DrawGizmo (gizmoType, type drawnGizmoType)]
• [ExecuteInEditMode]
• [En-tête (en-tête de chaîne)]
• [HideInInspector]
• [InitializeOnLoad]
• [InitializeOnLoadMethod]
• [MenuItem (string itemName)]
• [MenuItem (string itemName, bool isValidateFunction)]
• [MenuItem (string itemName, bool isValidateFunction, int priority)]
• [Multiligne (lignes int))
• [PreferenceItem (nom de chaîne)]
• [Plage (float min, float max)]
• [RequireComponent (type type)]
• [RuntimeInitializeOnLoadMethod]
• [RuntimeInitializeOnLoadMethod (RuntimeInitializeLoadType loadType)]
• [SerializeField]
• [Espace (hauteur du flotteur)]
• [TextArea (int minLines, int maxLines)]
• [Info-bulle (info-bulle de chaîne)]

Remarques

Attributs communs d'inspecteur

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

En survolant l'étiquette d'un champ:

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

En-tête place une étiquette en gras contenant le texte au-dessus du champ attribué. Ceci est souvent utilisé pour étiqueter les groupes afin de les différencier des autres labels.

[HideInInspector]
public string MyHiddenString;

HideInInspector empêche l'affichage des champs publics dans l'inspecteur. Ceci est utile pour accéder aux champs d'autres parties du code où ils ne sont pas visibles ou mutables.

[Multiline( 5 )]
public string MyMultilineString;

Multiline crée une zone de texte avec un nombre spécifié de lignes. Si vous dépassez ce montant, la boîte ne sera ni étendue ni enroulée.

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

TextArea permet un texte de style multiligne avec des barres de défilement et de retour automatique à la ligne si le texte dépasse la zone allouée.

[Space( 15 )]
public int MyInt;

L'espace oblige l'inspecteur à ajouter un espace supplémentaire entre les éléments précédents et actuels, ce qui facilite la distinction et la séparation des groupes.

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

Range force une valeur numérique entre un minimum et un maximum. Cet attribut fonctionne également sur les entiers et les doubles, même si min et max sont spécifiés comme des flottants.

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

L'infobulle affiche une description supplémentaire chaque fois que l'étiquette du champ est survolée.

[SerializeField]
private double myHiddenDouble;

SerializeField force Unity à sérialiser le champ - utile pour les champs privés.

Attributs de composant

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

[DisallowMultipleComponent]

L'attribut DisallowMultipleComponent empêche les utilisateurs d'ajouter plusieurs instances de ce composant à un seul GameObject.

[RequireComponent( typeof( Rigidbody ) )]

L'attribut RequireComponent vous permet de spécifier un autre composant (ou plusieurs) en tant que conditions requises pour l'ajout de ce composant à un GameObject. Lorsque vous ajoutez ce composant à un GameObject, les composants requis seront automatiquement ajoutés (s'ils ne sont pas déjà présents) et ces composants ne peuvent pas être supprimés tant que celui qui les nécessite n'est pas supprimé.

Attributs d'exécution

[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'attribut ExecuteInEditMode force Unity à exécuter les méthodes magiques de ce script même lorsque le jeu n'est pas en cours de lecture.

Les fonctions ne sont pas constamment appelées comme en mode lecture

• La mise à jour est uniquement appelée lorsque quelque chose a changé dans la scène.
• OnGUI est appelée lorsque la vue de jeu reçoit un événement.
• OnRenderObject et les autres fonctions de rappel de rendu sont appelées à chaque repeindre de la vue de la scène ou de la vue de jeu.

[RuntimeInitializeOnLoadMethod]
private static void FooBar()

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

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

L'attribut RuntimeInitializeOnLoadMethod permet d'appeler une méthode de classe d'exécution lorsque le jeu charge le moteur d'exécution, sans aucune interaction de l'utilisateur.

Vous pouvez spécifier si vous souhaitez que la méthode soit appelée avant ou après le chargement de la scène (la valeur par défaut est après). L'ordre d'exécution n'est pas garanti pour les méthodes utilisant cet attribut.

Attributs de menu

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

Le résultat de l'attribut [AddComponentMenu]

Le résultat de l'attribut [ContextMenuItem]

Le résultat de l'attribut [ContextMenu]

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

L'attribut AddComponentMenu vous permet de placer votre composant n'importe où dans le menu Component au lieu du menu Component-> Scripts.

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

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

L'attribut ContextMenuItem vous permet de définir des fonctions pouvant être ajoutées au menu contextuel d'un champ. Ces fonctions seront exécutées lors de la sélection.

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

L'attribut ContextMenu vous permet de définir des fonctions pouvant être ajoutées au menu contextuel du composant.

Attributs de l'éditeur

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

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

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

L'attribut InitializeOnLoad permet à l'utilisateur d'initialiser une classe sans aucune interaction de l'utilisateur. Cela se produit chaque fois que l'éditeur se lance ou sur une recompilation. Le constructeur statique garantit que cela sera appelé avant toute autre fonction statique.

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

L'attribut InitializeOnLoad permet à l'utilisateur d'initialiser une classe sans aucune interaction de la part de l'utilisateur. Cela se produit chaque fois que l'éditeur se lance ou sur une recompilation. L'ordre d'exécution n'est pas garanti pour les méthodes utilisant cet 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;
    }
}

Le résultat de l'attribut [PreferenceItem]

Le résultat de l'attribut [MenuItem]

[CanEditMultipleObjects]
public class AttributesExample : MonoBehaviour 

L'attribut CanEditMultipleObjects vous permet de modifier les valeurs de votre composant sur plusieurs GameObjects. Sans ce composant, vous ne verrez pas votre composant apparaître comme normal lors de la sélection de plusieurs GameObjects, mais à la place, vous verrez le message "Modification multi-objets non prise en charge"

Cet attribut est destiné aux éditeurs personnalisés pour prendre en charge la modification multiple. Les éditeurs non personnalisés prennent automatiquement en charge l'édition multiple.

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

L'attribut PreferenceItem vous permet de créer un élément supplémentaire dans le menu des préférences d'Unity. La méthode de réception doit être statique pour pouvoir être utilisée.

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

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

L'attribut MenuItem vous permet de créer des éléments de menu personnalisés pour exécuter des fonctions. Cet exemple utilise également une fonction de validation (qui renvoie toujours false) pour empêcher l'exécution de la fonction.

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

L'attribut CustomEditor vous permet de créer des éditeurs personnalisés pour vos composants. Ces éditeurs seront utilisés pour dessiner votre composant dans l'inspecteur et devront dériver de la classe Editor.

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

L'attribut CustomPropertyDrawer vous permet de créer un tiroir de propriétés personnalisé dans l'inspecteur. Vous pouvez utiliser ces tiroirs pour vos types de données personnalisés afin qu'ils soient visibles dans l'inspecteur.

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

L'attribut DrawGizmo vous permet de dessiner des gadgets personnalisés pour vos composants. Ces gadgets seront dessinés dans la vue de la scène. Vous pouvez décider quand dessiner le gizmo en utilisant le paramètre GizmoType dans l'attribut DrawGizmo.

La méthode de réception nécessite deux paramètres, le premier est le composant pour lequel dessiner le gizmo et le second est l'état dans lequel se trouve l'objet qui a besoin du gizmo dessiné.