unity3d => Atributos

Sintaxis

[AddComponentMenu (string menuName)]
[AddComponentMenu (string menuName, int order)]
[CanEditMultipleObjects]
[ContextMenuItem (nombre de cadena, función de cadena)]
[ContextMenu (nombre de cadena)]
[CustomEditor (Type inspectedType)]
[CustomEditor (Type inspectedType, bool editorForChildClasses)]
[CustomPropertyDrawer (tipo de tipo)]
[CustomPropertyDrawer (tipo de tipo, bool useForChildren)]
[DisallowMultipleComponent]
[DrawGizmo (GizmoType gizmo)]
[DrawGizmo (GizmoType gizmo, Type drawnGizmoType)]
[ExecuteInEditMode]
[Encabezado (encabezado de cadena)]
[HideInInspector]
[InitializeOnLoad]
[InitializeOnLoadMethod]
[MenuItem (string itemName)]
[MenuItem (string itemName, bool isValidateFunction)]
[MenuItem (string itemName, bool isValidateFunction, int prioridad)]
[Multilínea (líneas int)]
[PreferenceItem (nombre de cadena)]
[Rango (flotar min, flotar max)]
[RequireComponent (tipo de tipo)]
[RuntimeInitializeOnLoadMethod]
[RuntimeInitializeOnLoadMethod (RuntimeInitializeLoadType loadType)]
[SerializeField]
[Espacio (altura de flotación)]
[TextArea (int minLines, int maxLines)]
[Tooltip (string tooltip)]

Observaciones

SerializeField

El sistema de serialización de Unity se puede usar para hacer lo siguiente:

Puede serializar campos públicos no estáticos (de tipos serializables)
Puede serializar campos no públicos no públicos marcados con el atributo [SerializeField]
No se pueden serializar campos estáticos
No se pueden serializar propiedades estáticas

Su campo, incluso si está marcado con el atributo SerializeField, solo se atribuirá si es de un tipo que Unity puede serializar, que son:

Todas las clases heredadas de UnityEngine.Object (por ejemplo, GameObject, Component, MonoBehaviour, Texture2D)
Todos los tipos de datos básicos como int, string, float, bool
Algunos tipos incorporados como Vector2 / 3/4, Quaternion, Matrix4x4, Color, Rect, LayerMask
Arreglos de un tipo serializable.
Lista de un tipo serializable
Enums
Estructuras

Atributos de inspector comunes

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

Al pasar el cursor sobre la etiqueta de un campo:

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

El encabezado coloca una etiqueta en negrita que contiene el texto sobre el campo atribuido. Esto se usa a menudo para etiquetar grupos para que se destaquen frente a otras etiquetas.

[HideInInspector]
public string MyHiddenString;

HideInInspector evita que los campos públicos se muestren en el inspector. Esto es útil para acceder a campos de otras partes del código donde no son visibles o mutables.

[Multiline( 5 )]
public string MyMultilineString;

Multiline crea un cuadro de texto con un número específico de líneas. Superar esta cantidad no expandirá el cuadro ni envolverá el texto.

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

TextArea permite texto de estilo multilínea con ajuste automático de texto y barras de desplazamiento si el texto supera el área asignada.

[Space( 15 )]
public int MyInt;

El espacio obliga al inspector a agregar espacio adicional entre los elementos anteriores y actuales, lo que es útil para distinguir y separar grupos.

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

El rango fuerza un valor numérico entre un mínimo y un máximo. Este atributo también funciona en enteros y dobles, aunque min y max se especifican como flotantes.

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

La información sobre herramientas muestra una descripción adicional cada vez que se mueve el cursor sobre la etiqueta del campo.

[SerializeField]
private double myHiddenDouble;

SerializeField obliga a Unity a serializar el campo, útil para campos privados.

Atributos del componente

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

[DisallowMultipleComponent]

El atributo DisallowMultipleComponent evita que los usuarios agreguen varias instancias de este componente a un GameObject.

[RequireComponent( typeof( Rigidbody ) )]

El atributo RequireComponent le permite especificar otro componente (o más) como requisitos para cuando este componente se agrega a un GameObject. Cuando agrega este componente a un GameObject, los componentes requeridos se agregarán automáticamente (si no están ya presentes) y esos componentes no podrán eliminarse hasta que se elimine el que los requiere.

Atributos de tiempo de ejecución

[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

El atributo ExecuteInEditMode obliga a Unity a ejecutar los métodos mágicos de este script incluso cuando el juego no se está ejecutando.

Las funciones no se llaman constantemente como en el modo de juego
La actualización solo se llama cuando algo en la escena cambia.
Se llama a OnGUI cuando la vista de juego recibe un evento.
OnRenderObject y las demás funciones de devolución de llamada de renderización se activan en cada repintado de la Vista de escena o Vista de juego.

[RuntimeInitializeOnLoadMethod]
private static void FooBar()

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

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

El atributo RuntimeInitializeOnLoadMethod permite llamar a un método de clase de tiempo de ejecución cuando el juego carga el tiempo de ejecución, sin ninguna interacción del usuario.

Puede especificar si desea que el método se invoque antes o después de la carga de la escena (después es predeterminado). El orden de ejecución no está garantizado para los métodos que utilizan este atributo.

Atributos del menú

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

El resultado del atributo [AddComponentMenu]

El resultado del atributo [ContextMenuItem]

El resultado del atributo [ContextMenu]

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

El atributo AddComponentMenu le permite colocar su componente en cualquier lugar del menú Componente en lugar del menú Componente-> Scripts.

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

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

El atributo ContextMenuItem le permite definir funciones que se pueden agregar al menú contextual de un campo. Estas funciones se ejecutarán tras la selección.

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

El atributo ContextMenu le permite definir funciones que se pueden agregar al menú contextual del componente.

Atributos del editor

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

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

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

El atributo InitializeOnLoad permite al usuario inicializar una clase sin ninguna interacción del usuario. Esto sucede cada vez que el editor se inicia o en una recompilación. El constructor estático garantiza que esto será llamado antes que cualquier otra función estática.

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

El atributo InitializeOnLoad permite al usuario inicializar una clase sin ninguna interacción del usuario. Esto sucede cada vez que el editor se inicia o en una recompilación. El orden de ejecución no está garantizado para los métodos que utilizan este atributo.

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

El resultado del atributo [PreferenceItem]

El resultado del atributo [MenuItem]

[CanEditMultipleObjects]
public class AttributesExample : MonoBehaviour

El atributo CanEditMultipleObjects le permite editar valores de su componente sobre múltiples GameObjects. Sin este componente, no verá su componente como normal cuando selecciona múltiples GameObjects, sino que verá el mensaje "No se admite la edición de objetos múltiples"

Este atributo es para que los editores personalizados admitan la edición múltiple. Los editores no personalizados admiten automáticamente la edición múltiple.

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

El atributo PreferenceItem te permite crear un elemento adicional en el menú de preferencias de Unity. El método de recepción debe ser estático para que se utilice.

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

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

El atributo MenuItem le permite crear elementos de menú personalizados para ejecutar funciones. Este ejemplo también utiliza una función de validador (que siempre devuelve falso) para evitar la ejecución de la función.

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

El atributo CustomEditor le permite crear editores personalizados para sus componentes. Estos editores se utilizarán para dibujar su componente en el inspector y deben derivarse de la clase Editor.

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

El atributo CustomPropertyDrawer le permite crear un cajón de propiedades personalizado en el inspector. Puede usar estos cajones para sus tipos de datos personalizados para que puedan verse en el inspector.

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

El atributo DrawGizmo le permite dibujar artilugios personalizados para sus componentes. Estos gizmos se dibujarán en la vista de escena. Puede decidir cuándo dibujar el gizmo usando el parámetro GizmoType en el atributo DrawGizmo.

El método de recepción requiere dos parámetros, el primero es el componente para dibujar el gizmo y el segundo es el estado en el que se encuentra el objeto que necesita el gizmo dibujado.

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

unity3d
Atributos

Buscar..