la classe GameObject

Classe de base pour toutes les entités dans les scènes Unity. De nombreuses variables de la classe GameObject ont été supprimées. Pour y accéder, par exemple à GameObject.renderer en C#, utilisez plutôt GetComponent‹Renderer›(). En javascript, utilisez GetComponent‹Renderer›().

Propriétés

activeInHierarchyLe GameObject est-il actif dans la scène ?
activeSelfL'état actif local de ce GameObject. (Lecture seulement)
isStaticÉditeur uniquement, API qui spécifie si un objet de jeu est statique.
layerLa couche dans laquelle se trouve l'objet de jeu. Une couche se situe dans la plage [0 ... 31].
sceneScène dans laquelle le GameObject fait partie.
tagLa balise de cet objet de jeu.
transformLe Transform attaché à ce GameObject.

Constructeurs

GameObjectCrée un nouvel objet de jeu, nommé "name".

Méthodes publiques

AddComponentAjoute une classe de composant nommée className à l'objet de jeu.
BroadcastMessageAppelle la méthode nommée methodName sur chaque MonoBehaviour de cet objet de jeu ou de ses enfants.
CompareTagCet objet de jeu est-il marqué avec une balise ?
GetComponentRenvoie le composant de type Type si l'objet du jeu en a un attaché, null si ce n'est pas le cas.
GetComponentInChildrenRenvoie le composant de type Type dans le GameObject ou l'un de ses enfants en utilisant la recherche en profondeur.
GetComponentInParentRetourne le composant de type Type dans le GameObject ou l'un de ses parents.
GetComponentsRenvoie tous les composants du type Type dans le GameObject.
GetComponentsInChildrenRenvoie tous les composants du type Type dans le GameObject ou l'un de ses enfants.
GetComponentsInParentRenvoie tous les composants du type Type dans le GameObject ou l'un de ses parents.
SendMessageAppelle la méthode nommée methodName sur chaque MonoBehaviour dans cet objet de jeu.
SendMessageUpwardsAppelle la méthode nommée methodName sur chaque MonoBehaviour dans cet objet de jeu et sur chaque ancêtre du behaviour.
SetActiveActive/désactive le GameObject.

Méthodes statiques

CreatePrimitiveCrée un objet de jeu avec un mesh renderer primitif et un collider approprié.
FindTrouve un GameObject par son nom et le renvoie.
FindGameObjectsWithTagRenvoie une liste de GameObject actifs marqué avec une balise. Renvoie un tableau vide si aucun GameObject n'a été trouvé.
FindWithTagRenvoie un GameObject actifs marqué avec une balise. Renvoie null si aucun GameObject n'a été trouvé.

Membres hérités

Propriétés

hideFlagsL'objet doit-il être caché, sauvegardé avec la scène ou modifiable par l'utilisateur ?
nameLe nom de l'objet.

Méthodes publiques

GetInstanceIDRetourne l'ID d'instance de l'objet.
ToStringRenvoie le nom de l'objet du jeu.

Méthodes statiques

DestroySupprime un gameobject, un composant ou un asset.
DestroyImmediateDétruit l'objet obj immédiatement. Il est fortement recommandé d'utiliser Destroy à la place.
DontDestroyOnLoadRend la cible de l'objet non détruite automatiquement lors du chargement d'une nouvelle scène.
FindObjectOfTypeRenvoie le premier objet chargé actif du type Type.
FindObjectsOfTypeRenvoie une liste de tous les objets chargés actifs du type Type.
InstantiateClone l'objet original et renvoie le clone.

Opérateurs

boolL'objet existe-t-il ?
operator !=Compare si deux objets se réfèrent à un objet différent.
operator ==Compare deux références d'objet pour voir si elles se rapportent au même objet.

GameObject.activeInHierarchy

public bool activeInHierarchy;

Le GameObject est-il actif dans la scène ?

Cela vous permet de savoir si un gameObject est actif dans le jeu. C'est le cas si sa propriété GameObject.activeSelf est activée, ainsi que celle de tous ses parents.

//Ce script montre comment l'état activeInHierarchy change en fonction de l'état actif du parent du GameObject

using UnityEngine;

public class ActiveInHierarchyExample : MonoBehaviour
{
    //Joindre ces éléments dans l'inspecteur
    public GameObject m_ParentObject, m_ChildObject;
    //Utilisez ceci pour obtenir les données de bascule
    bool m_Activate;

    void Start()
    {
        //Désactive le parent GameObject et bascule
        m_Activate = false;
    }

    void Update()
    {
        //Active le GameObject que vous attacher en fonction de la sortie
        m_ParentObject.SetActive(m_Activate);
    }

    void OnGUI()
    {
        //Activez cette option pour activer et désactiver le parent GameObject
        m_Activate = GUI.Toggle(new Rect(10, 10, 100, 30), m_Activate, "Activate Parent GameObject");

        if (GUI.changed)
        {
            //Affiche le statut de l'état actif du GameObject dans la console
            Debug.Log("Child GameObject Active : " + m_ChildObject.activeInHierarchy);
        }
    }
}

Contrairement à GameObject.activeSelf, cela vérifie également si des GameObjects parent affectent l'état actuellement actif du GameObject.

Lorsqu'un GameObject parent est désactivé, ses enfants sont généralement marqués comme actifs même s'ils ne sont pas visibles, ils sont donc toujours actifs selon GameObject.activeSelf. Cependant, GameObject.activeInHierarchy assure que cela ne se produit pas en vérifiant à la place que le GameObject n'a pas été désactivé par un membre de sa hiérarchie.

//Ce script montre à quel point activeInHierarchy diffère de activeSelf. Utiliser la bascule pour modifier les états actifs de l'objet parent et de l'enfant GameObject. Cela permet de sortir l'état du GameObject de l'enfant dans la console.
//Il montre aussi comment activeSelf renvoie que l'objet GameObject enfant est actif lorsque le parent ne l'est pas, alors que l'objet activeInHierarchy affiche l'objet GameObject enfant inactif.

using UnityEngine;

public class ActiveInHierarchyExample : MonoBehaviour
{
    public GameObject m_ParentObject, m_ChildObject;
   //Utilisez ceci pour obtenir les données de bascule
    bool m_ActivateParent, m_ActivateChild;
    //Utilisez-les pour décider si la console a besoin d'être mise à jour
    bool m_HierarchyOutput, m_SelfOutput;

    void Start()
    {
        //Désactiver les objets parents et enfants des GameObjects
        m_ActivateParent = false;
        m_ActivateChild = false;
        //Script Ables pour sortir l'état actuel du GameObject vers la console
        m_HierarchyOutput = false;
        m_SelfOutput = false;
    }

    void Update()
    {
        //Active le GameObject que vous attachez en fonction de la sortie
        m_ParentObject.SetActive(m_ActivateParent);
        m_ChildObject.SetActive(m_ActivateChild);

        //Recherche si le GameObject est actif dans le jeu et vérifie si cet état a été envoyé à la console
        if (m_HierarchyOutput == false)
        {
           //Produit l'état de l'activité du GameObject s'il n'a pas déjà été produit
            Debug.Log("Object Active : " + m_ChildObject.activeInHierarchy);
            //L'état du GameObject est déjà sorti, donc pas besoin de le refaire
            m_HierarchyOutput = true;
        }
        //Vérifie si le GameObject assigné est actif malgré le statut parent du GameObject
        if (m_ChildObject.activeSelf && m_SelfOutput == false)
        {
            //Afficher le message si le GameObject est toujours actif
            Debug.Log("Child Active, parent might not be");
            //Vous n'avez plus besoin d'afficher le message
            m_SelfOutput = true;
        }
    }

    void OnGUI()
    {
        //Active et désactive le parent du GameObject
        m_ActivateParent = GUI.Toggle(new Rect(10, 10, 100, 30), m_ActivateParent, "Activate Parent GameObject");
        //Active et désactive l'enfant du GameObject
        m_ActivateChild = GUI.Toggle(new Rect(10, 40, 100, 30), m_ActivateChild, "Activate Child GameObject");


        //Si une modification est détectée avec la bascule, la console émet des mises à jour
        if (GUI.changed)
        {
            m_SelfOutput = false;
            m_HierarchyOutput = false;
        }
    }
}

GameObject.activeSelf

public bool activeSelf;

L'état actif local de ce GameObject. (Lecture seulement)

Cela renvoie l'état actif local de ce GameObject, qui est défini à l'aide de GameObject.SetActive. Notez qu'un objet GameObject peut être inactif car un parent n'est pas actif, même si cela renvoie true. Cet état sera alors utilisé une fois que tous les parents sont actifs.Utilisez GameObject.activeInHierarchy si vous voulez vérifier si le GameObject est réellement traité comme actif dans la scène.

GameObject.isStatic

public bool isStatic;

Éditeur uniquement, API qui spécifie si un objet de jeu est statique.

Renvoie true si l'un des drapeaux statiques est défini, en définissant ce paramètre sur true définit tous les drapeaux statiques (Voir aussi: GameObjectUtility.SetStaticEditorFlags).

GameObject.layer

public int layer;

La couche dans laquelle se trouve l'objet de jeu. Une couche se situe dans la plage [0 ... 31]. Les Layers peuvent être utilisés pour le rendu sélectif des caméras ou en ignorant les raycasts.

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        gameObject.layer = 2;
    }
}

GameObject.scene

public SceneManagement.Scene scene;

Scène dans laquelle le GameObject fait partie.

GameObject.tag

public string tag;

La balise de cet objet de jeu.

Une balise (tag) peut être utilisée pour identifier un objet de jeu. Les balises doivent être déclarées dans le gestionnaire de balises et de calques avant de les utiliser.

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        gameObject.tag = "Player";
    }
}

GameObject.transform

public Transform transform;

Le Transform attaché à ce GameObject.

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public GameObject other;
    void Example() {
        other.transform.Translate(1, 1, 1);
    }
}

GameObject

public GameObject();

public GameObject(string name);

public GameObject(string name, params Type[] components);

Crée un nouvel objet de jeu, nommé "name".

Paramètres

nameLe nom avec lequel l'objet GameObject est créé.
componentsUne liste de composants à ajouter au GameObject lors de la création.

Le Transform est toujours ajoutée à l'objet GameObject en cours de création. La création d'un GameObject sans arguments de script ajoutera le Transform mais rien d'autre. De même, la version avec juste un seul argument de chaîne ajoute simplement ceci et le Transform. Enfin, la troisième version permet de spécifier le nom mais aussi de passer des composants sous forme de tableau.

// Crée un objet de jeu nommé "Player"
// et y ajoute un rigidbody et une box collider.

using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        GameObject player;
        player = new GameObject("Player");
        player.AddComponent();
        player.AddComponent();
    }
}

GameObject.AddComponent

public Component AddComponent(string className);

Ajoute une classe de composant nommée className à l'objet de jeu.


public Component AddComponent(Type componentType);

Ajoute une classe de composant de type componentType à l'objet de jeu. C# : Les utilisateurs peuvent utiliser une version générique.

using UnityEngine;
using System.Collections;

public class AddComponentExample : MonoBehaviour
{
    void Start()
    {
        SphereCollider sc = gameObject.AddComponent(typeof(SphereCollider)) as SphereCollider;
    }
}

Notez qu'il n'y a pas RemoveComponent(), pour supprimer un composant, utilisez Object.Destroy.


public T AddComponent();

Version générique. Voir la page des fonctions génériques pour plus de détails.

C#using UnityEngine;
using System.Collections;

public class AddComponentExample : MonoBehaviour
{
    void Start()
    {
        SphereCollider sc = gameObject.AddComponent() as SphereCollider;
    }
}

GameObject.BroadcastMessage

public void BroadcastMessage(string methodName, object parameter = null, SendMessageOptions options = SendMessageOptions.RequireReceiver);

Appelle la méthode nommée methodName sur chaque MonoBehaviour de cet objet de jeu ou de ses enfants.

La méthode de réception peut choisir d'ignorer le paramètre en ayant zéro paramètres. Si les options sont définies sur SendMessageOptions.RequireReceiver, une erreur est imprimée lorsque le message n'est détecté par aucun composant.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void ApplyDamage(float damage) {
        print(damage);
    }
    void Example() {
        gameObject.BroadcastMessage("ApplyDamage", 5.0F);
    }
}

GameObject.CompareTag

public bool CompareTag(string tag);

Cet objet de jeu est-il marqué avec une balise ?

Paramètres

tagLe tag à comparer.
C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void OnTriggerEnter(Collider other) {
        if (other.gameObject.CompareTag("Player"))
            Destroy(other.gameObject);
        
    }
}

GameObject.GetComponent

public Component GetComponent(Type type);

Renvoie le composant de type Type si l'objet du jeu en a un attaché, null si ce n'est pas le cas.

Paramètres

typeLe type de composant à récupérer.

GetComponent est la principale méthode d'accès aux autres composants. Avec javascript, le type d'un script est toujours le nom du script vu dans la vue du projet. Vous pouvez accéder aux composants intégrés ou aux scripts avec cette fonction.

C#using UnityEngine;

public class GetComponentExample : MonoBehaviour
{
    void Start()
    {
        HingeJoint hinge = gameObject.GetComponent(typeof(HingeJoint)) as HingeJoint;

        if (hinge != null)
            hinge.useSpring = false;
    }
}


public T GetComponent();

Version générique. Voir la page des fonctions génériques pour plus de détails.

C#using UnityEngine;

public class GetComponentGenericExample : MonoBehaviour
{
    void Start()
    {
        HingeJoint hinge = gameObject.GetComponent();

        if (hinge != null)
            hinge.useSpring = false;
    }
}


public Component GetComponent(string type);

Paramètres

typeLe type de composant à récupérer.

Renvoie le composant avec le type de nom si l'objet du jeu en a un attaché, null si ce n'est pas le cas.

Il est préférable d'utiliser GetComponent avec un Type au lieu d'une chaîne pour des raisons de performances. Parfois, vous pourriez ne pas être capable d'accéder au type, par exemple lorsque vous essayez d'accéder à un script C# depuis Javascript. Dans ce cas, vous pouvez simplement accéder au composant par nom au lieu de type.

C#using UnityEngine;

public class GetComponentNonPerformantExample : MonoBehaviour
{
    void Start()
    {
        HingeJoint hinge = gameObject.GetComponent("HingeJoint") as HingeJoint;

        if (hinge != null)
            hinge.useSpring = false;
    }
}

GameObject.GetComponentInChildren

public Component GetComponentInChildren(Type type);

public Component GetComponentInChildren(Type type, bool includeInactive);

Renvoie le composant de type Type dans le GameObject ou l'un de ses enfants en utilisant la recherche en profondeur.

Paramètres

typeLe type de composant à récupérer.

Retourne

ComponentUn composant du type correspondant, s'il est trouvé.

Un composant est renvoyé uniquement s'il est trouvé sur un GameObject actif.

C#using UnityEngine;

public class GetComponentInChildrenExample : MonoBehaviour
{
   // Désactiver le ressort sur le premier composant HingeJoint trouvé sur n'importe quel objet enfant

    void Start()
    {
        HingeJoint hinge = gameObject.GetComponentInChildren(typeof(HingeJoint)) as HingeJoint;

        if (hinge != null)
            hinge.useSpring = false;
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            HingeJoint hingeInactive = gameObject.GetComponentInChildren(typeof(HingeJoint), true) as HingeJoint;

            if (hingeInactive != null)
                hingeInactive.useSpring = false;
        }
    }
}


public T GetComponentInChildren(bool includeInactive = false);

Retourne

TUn composant du type correspondant, s'il est trouvé.

Version générique. Voir la page des fonctions génériques pour plus de détails.

C#using UnityEngine;

public class GetComponentInChildrenExample : MonoBehaviour
{
    // Désactiver le ressort sur le premier composant HingeJoint trouvé sur n'importe quel objet enfant

    void Start()
    {
        HingeJoint hinge = gameObject.GetComponentInChildren();

        if (hinge != null)
            hinge.useSpring = false;
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            HingeJoint hingeInactive = gameObject.GetComponentInChildren(true) as HingeJoint;

            if (hingeInactive != null)
                hingeInactive.useSpring = false;
        }
    }
}

GameObject.GetComponentInParent

public Component GetComponentInParent(Type type);

Retourne le composant de type Type dans le GameObject ou l'un de ses parents.

Paramètres

typeType de composant à trouver.

Récursive jusqu'à ce qu'il trouve un composant valide. Renvoie null si aucun composant trouvé. Seul le composant des GameObjects actifs est renvoyé.

C#using UnityEngine;
using System.Collections;

public class GetComponentInParentExample : MonoBehaviour
{
    // Désactiver le ressort sur le premier composant HingeJoint trouvé sur n'importe quel objet parent

    void Start()
    {
        HingeJoint hinge = gameObject.GetComponentInParent(typeof(HingeJoint)) as HingeJoint;

        if (hinge != null)
            hinge.useSpring = false;
    }
}


public T GetComponentInParent();

Retourne le composant ‹T› dans le GameObject ou l'un de ses parents. Récursive jusqu'à ce qu'il trouve un composant valide. Renvoie null si aucun composant trouvé. Seul le composant des GameObjects actifs est renvoyé.

C#using UnityEngine;
using System.Collections;

public class GetComponentInParentExample : MonoBehaviour
{
     // Désactiver le ressort sur le premier composant HingeJoint trouvé sur n'importe quel objet parent

    void Start()
    {
        HingeJoint hinge = gameObject.GetComponentInParent();

        if (hinge != null)
            hinge.useSpring = false;
    }
}

GameObject.GetComponents

public Component[] GetComponents(Type type);

Renvoie tous les composants du type Type dans le GameObject.

Paramètres

typeLe type de composant à récupérer.
C#// Désactive le ressort sur tous les HingeJoints de cet objet de jeu
using UnityEngine;

public class GetComponentsExample : MonoBehaviour
{
    // Désactive le ressort sur tous les HingeJoints de cet objet de jeu

    void Start()
    {
        Component[] hingeJoints;

        hingeJoints = GetComponents(typeof(HingeJoint));

        foreach (HingeJoint joint in hingeJoints)
            joint.useSpring = false;
    }
}


public T[] GetComponents();

Version générique. Voir la page des fonctions génériques pour plus de détails.

C#// Désactive le ressort sur tous les HingeJoints de cet objet de jeu
using UnityEngine;

public class GetComponentsExample : MonoBehaviour
{
    // Désactive le ressort sur tous les HingeJoints de cet objet de jeu

    void Start()
    {
        HingeJoint[] hingeJoints;

        hingeJoints = GetComponents();

        foreach (HingeJoint joint in hingeJoints)
            joint.useSpring = false;
    }
}


public void GetComponents(Type type, List results);

Paramètres

typeLe type de composant à récupérer.
resultsListe pour recevoir les résultats.

Renvoie tous les composants du type Type dans le GameObject dans les résultats de liste. Notez que les résultats sont de type Component, pas le type du composant récupéré.

C#// Désactive le ressort sur tous les HingeJoints de cet objet de jeu
using UnityEngine;
using System.Collections.Generic;

public class GetComponentsExample : MonoBehaviour
{
    // Désactive le ressort sur tous les HingeJoints de cet objet de jeu

    void Start()
    {
        // Disable the spring on all HingeJoints in this game object
        List hingeJoints = new List();

        GetComponents(typeof(HingeJoint), hingeJoints);

        foreach (HingeJoint joint in hingeJoints)
            joint.useSpring = false;
    }
}


public void GetComponents(List results);

Paramètres

resultsListe de type T pour recevoir les résultats.

Renvoie tous les composants du type Type dans le GameObject dans les résultats de la liste.

C#// Désactive le ressort sur tous les HingeJoints de cet objet de jeu
using UnityEngine;
using System.Collections.Generic;

public class GetComponentsExample : MonoBehaviour
{
   // Désactive le ressort sur tous les HingeJoints de cet objet de jeu

    void Start()
    {
        // Disable the spring on all HingeJoints in this game object
        List hingeJoints = new List();

        GetComponents(hingeJoints);

        foreach (HingeJoint joint in hingeJoints)
            joint.useSpring = false;
    }
}

GameObject.GetComponentsInChildren

public Component[] GetComponentsInChildren(Type type, bool includeInactive = false);

Renvoie tous les composants du type Type dans le GameObject ou l'un de ses enfants.

Paramètres

typeLe type de composant à récupérer.
includeInactiveLes composants des objets GameObject inactifs doivent-ils être inclus dans l'ensemble trouvé ?

La recherche de composants s'effectue récursivement sur des objets enfants, ce qui inclut les enfants d'enfants, etc.

C#using UnityEngine;

public class GetComponentsInChildrenExample : MonoBehaviour
{
    void Start()
    {
        Component[] hingeJoints;

        hingeJoints = GetComponentsInChildren(typeof(HingeJoint));

        if (hingeJoints != null)
        {
            foreach (HingeJoint joint in hingeJoints)
                joint.useSpring = false;
        }
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            Component[] hingesInactive = GetComponentsInChildren(typeof(HingeJoint), true);

            foreach (HingeJoint joint in hingesInactive)
                joint.useSpring = false;
        }
    }
}


public T[] GetComponentsInChildren();

public T[] GetComponentsInChildren(bool includeInactive);

Paramètres

includeInactiveLes GameObjects inactifs devraient-ils être inclus dans l'ensemble trouvé ?

Retourne

T[]Une liste de tous les composants trouvés correspondant au type spécifié.

Version générique. Voir la page des fonctions génériques pour plus de détails.

C#using UnityEngine;

public class GetComponentsInChildrenExample : MonoBehaviour
{
    void Start()
    {
        HingeJoint[] hingeJoints;

        hingeJoints = GetComponentsInChildren();

        if (hingeJoints != null)
        {
            foreach (HingeJoint joint in hingeJoints)
                joint.useSpring = false;
        }
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            HingeJoint[] hingesInactive = GetComponentsInChildren(true);

            foreach (HingeJoint joint in hingesInactive)
                joint.useSpring = false;
        }
    }
}


public void GetComponentsInChildren(List results);

public void GetComponentsInChildren(bool includeInactive, List results);

Paramètres

resultsListe pour recevoir les composants trouvés.
includeInactiveLes GameObjects inactifs devraient-ils être inclus dans l'ensemble trouvé ?

Renvoie tous les composants trouvés dans les résultats de la liste.

C#using UnityEngine;
using System.Collections.Generic;

public class GetComponentsInChildrenExample : MonoBehaviour
{
    void Start()
    {
        List hingeJoints = new List();

        GetComponentsInChildren(false, hingeJoints);

        if (hingeJoints != null)
        {
            foreach (HingeJoint joint in hingeJoints)
                joint.useSpring = false;
        }
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            List hingesInactive = new List();

            GetComponentsInChildren(true, hingesInactive);

            foreach (HingeJoint joint in hingesInactive)
                joint.useSpring = false;
        }
    }
}

GameObject.GetComponentsInParent

public Component[] GetComponentsInParent(Type type, bool includeInactive = false);

Renvoie tous les composants du type Type dans le GameObject ou l'un de ses parents.

Paramètres

typeLe type de composant à récupérer.
includeInactiveLes composants inactifs doivent-ils être inclus dans l'ensemble trouvé ?

La recherche de composants est effectuée récursivement sur des objets parents, ce qui inclut les parents des parents, etc.

C#using UnityEngine;

public class GetComponentsInParentExample : MonoBehaviour
{
    void Start()
    {
        Component[] hingeJoints;

        hingeJoints = GetComponentsInParent(typeof(HingeJoint));

        if (hingeJoints != null)
        {
            foreach (HingeJoint joint in hingeJoints)
                joint.useSpring = false;
        }
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            Component[] hingesInactive = GetComponentsInParent(typeof(HingeJoint), true);

            foreach (HingeJoint joint in hingesInactive)
                joint.useSpring = false;
        }
    }
}


public T[] GetComponentsInParent();

public T[] GetComponentsInParent(bool includeInactive);

Paramètres

includeInactiveLes composants inactifs doivent-ils être inclus dans l'ensemble trouvé ?

Version générique. Voir la page des fonctions génériques pour plus de détails.

C#using UnityEngine;

public class GetComponentsInParentExample : MonoBehaviour
{
    void Start()
    {
        HingeJoint[] hingeJoints;

        hingeJoints = GetComponentsInParent();

        if (hingeJoints != null)
        {
            foreach (HingeJoint joint in hingeJoints)
                joint.useSpring = false;
        }
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            HingeJoint[] hingesInactive = GetComponentsInParent(true);

            foreach (HingeJoint joint in hingesInactive)
                joint.useSpring = false;
        }
    }
}


public void GetComponentsInParent(bool includeInactive, List results);

includeInactiveLes composants inactifs doivent-ils être inclus dans l'ensemble trouvé ?
resultsListe contenant les composants trouvés.

Trouve des composants dans GameObject ou ses parents, et les renvoye dans les résultats de la liste.

C#using UnityEngine;
using System.Collections.Generic;

public class GetComponentsInParentExample : MonoBehaviour
{
    void Start()
    {
        List hingeJoints = new List();

        GetComponentsInParent(false, hingeJoints);

        if (hingeJoints != null)
        {
            foreach (HingeJoint joint in hingeJoints)
                joint.useSpring = false;
        }
        else
        {
            // Réessaye en recherchant des GameObjects inactifs
            List hingesInactive = new List();

            GetComponentsInParent(true, hingesInactive);

            foreach (HingeJoint joint in hingesInactive)
                joint.useSpring = false;
        }
    }
}

GameObject.SendMessage

public void SendMessage(string methodName, object value = null, SendMessageOptions options = SendMessageOptions.RequireReceiver);

Appelle la méthode nommée methodName sur chaque MonoBehaviour dans cet objet de jeu.

Paramètres

methodNameLe nom de la méthode à appeler.
valueUne valeur de paramètre optionnelle à transmettre à la méthode appelée.
optionsFaut-il une erreur si la méthode n'existe pas sur l'objet cible ?

La méthode de réception peut choisir d'ignorer l'argument en ayant zéro paramètres. Si les options sont définies sur SendMessageOptions.RequireReceiver, une erreur est imprimée si le message n'est détecté par aucun composant.

Notez que les messages ne seront pas envoyés aux objets inactifs (c'est-à-dire ceux qui ont été désactivés dans l'éditeur ou avec la fonction SetActive).

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void ApplyDamage(float damage) {
        print(damage);
    }
    void Example() {
        gameObject.SendMessage("ApplyDamage", 5.0F);
    }
}

GameObject.SendMessageUpwards

public void SendMessageUpwards(string methodName, object value = null, SendMessageOptions options = SendMessageOptions.RequireReceiver);

Appelle la méthode nommée methodName sur chaque MonoBehaviour dans cet objet de jeu et sur chaque ancêtre du behaviour.

Paramètres

methodNameLe nom de la méthode à appeler.
valueUne valeur de paramètre optionnelle à transmettre à la méthode appelée.
optionsFaut-il une erreur si la méthode n'existe pas sur l'objet cible ?

La méthode de réception peut choisir d'ignorer l'argument en ayant zéro paramètres. Si les options sont définies sur SendMessageOptions.RequireReceiver, une erreur est imprimée si le message n'est détecté par aucun composant.

Notez que les messages ne seront pas envoyés aux objets inactifs (c'est-à-dire ceux qui ont été désactivés dans l'éditeur ou avec la fonction SetActive).

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void ApplyDamage(float damage) {
        print(damage);
    }
    void Example() {
        gameObject.SendMessageUpwards("ApplyDamage", 5.0F);
    }
}

GameObject.SetActive

public void SetActive(bool value);

Active/désactive le GameObject.

Paramètres

valueActive ou désactive l'objet.

Notez qu'un objet GameObject peut être inactif car un parent n'est pas actif. Dans ce cas, appeler SetActive() ne l'activera pas, mais seulement définit l'état local du GameObject, qui peut être vérifié en utilisant GameObject.activeSelf. Cet état sera alors utilisé une fois que tous les parents sont actifs.

La désactivation d'un GameObject désactivera tous les composants, désactivant les renderers, les colliders, les rigidbodies, les scripts, etc. Par exemple, les scripts que vous avez attachés au GameObject n'auront plus Update().

Voir également : GameObject.activeSelf, GameObject.activeInHierarchy.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        gameObject.SetActive(false);
    }
}

Un autre exemple

C#// Active et désactive un GameObject.
// La fonction GUI implémente deux boutons.
// Notez que ce script doit être attaché à un GameObject qui n'est pas désactivé.

using UnityEngine;

public class Buttons : MonoBehaviour
{
    public GameObject GO;

    void OnGUI()
    {
        if (GUI.Button(new Rect(10, 10, 100, 30), "Enable"))
        {
            Debug.Log("Enable: " + GO.name);
            GO.SetActive(true);
        }
        if (GUI.Button(new Rect(10, 50, 100, 30), "Disable"))
        {
            Debug.Log("Disable: " + GO.name);
            GO.SetActive(false);
        }
    }
}

GameObject.CreatePrimitive

public static GameObject CreatePrimitive(PrimitiveType type);

Crée un objet de jeu avec un mesh renderer primitif et un collider approprié.

Paramètres

typeLe type d'objet primitif à créer.
C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Start() {
        GameObject plane = GameObject.CreatePrimitive(PrimitiveType.Plane);
        GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        cube.transform.position = new Vector3(0, 0.5F, 0);
        GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        sphere.transform.position = new Vector3(0, 1.5F, 0);
        GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule);
        capsule.transform.position = new Vector3(2, 1, 0);
        GameObject cylinder = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
        cylinder.transform.position = new Vector3(-2, 1, 0);
    }
}

Remarque: CreatePrimitive peut échouer lors de l'exécution. Cela se produira si votre projet ne fait pas référence aux composants suivants : MeshFilter, MeshRenderer, et BoxCollider ou SphereCollider lors de l'exécution. La méthode recommandée pour éviter ce blocage consiste à déclarer les propriétés privées de ces types. Le système de décompression reconnaîtra leur utilisation qui les inclut dans la construction afin de ne pas supprimer ces composants.

GameObject.Find

public static GameObject Find(string name);

Trouve un GameObject par son nom et le renvoie.

Cette fonction renvoie uniquement les GameObjects actifs. Si aucun objet GameObject avec ce nom ne peut être trouvé, null est renvoyé. Si le nom contient un caractère '/', il traverse la hiérarchie comme un nom de chemin.

Pour des raisons de performances, il est recommandé de ne pas utiliser cette fonction à chaque frame. Mettez plutôt en cache le résultat dans une variable membre au démarrage. ou utilisez GameObject.FindWithTag.

Note: Si vous souhaitez trouver un objet GameObject, il est souvent plus facile d'utiliser Transform.Find.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public GameObject hand;
    void Example() {
        hand = GameObject.Find("Hand");
        hand = GameObject.Find("/Hand");
        hand = GameObject.Find("/Monster/Arm/Hand");
        hand = GameObject.Find("Monster/Arm/Hand");
    }
}

GameObject.Find est utile pour connecter automatiquement des références à d'autres objets au moment du chargement; par exemple, à l'intérieur de MonoBehaviour.Awake ou MonoBehaviour.Start.

Un modèle commun est d'assigner un GameObject à une variable dans MonoBehaviour.Start, et d'utiliser la variable dans MonoBehaviour.Update.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    private GameObject hand;
    void Start() {
        hand = GameObject.Find("/Monster/Arm/Hand");
    }
    void Update() {
        hand.transform.Rotate(0, 100 * Time.deltaTime, 0);
    }
}

GameObject.FindGameObjectsWithTag

public static GameObject[] FindGameObjectsWithTag(string tag);

Renvoie une liste de GameObject actifs marqué avec une balise. Renvoie un tableau vide si aucun GameObject n'a été trouvé.

Paramètres

tagLe nom du tag à rechercher dans les GameObjects.

Les tags doivent être déclarées dans le gestionnaire de balises avant de les utiliser. Une exception UnityException sera levée si la balise n'existe pas ou si une chaîne vide ou null est transmise en tant que balise.

C#// Instancie respawnPrefab à l'emplacement de tous les objets du jeu marqués "Respawn".

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    public GameObject respawnPrefab;
    public GameObject[] respawns;
    void Start()
    {
        if (respawns == null)
            respawns = GameObject.FindGameObjectsWithTag("Respawn");

        foreach (GameObject respawn in respawns)
        {
            Instantiate(respawnPrefab, respawn.transform.position, respawn.transform.rotation);
        }
    }
}

Un autre exemple

C#// Trouve le nom de l'ennemi le plus proche

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    public GameObject FindClosestEnemy()
    {
        GameObject[] gos;
        gos = GameObject.FindGameObjectsWithTag("Enemy");
        GameObject closest = null;
        float distance = Mathf.Infinity;
        Vector3 position = transform.position;
        foreach (GameObject go in gos)
        {
            Vector3 diff = go.transform.position - position;
            float curDistance = diff.sqrMagnitude;
            if (curDistance < distance)
            {
                closest = go;
                distance = curDistance;
            }
        }
        return closest;
    }
}

Un autre exemple, testant un tableau vide

C#// Recherche des objets de jeu avec une balise non utilisée

function Start () {
    var gos : GameObject[];
    gos = GameObject.FindGameObjectsWithTag("fred");

    if (gos.length == 0) {
        Debug.Log("No game objects are tagged with fred");
    }
}

GameObject.FindWithTag

public static GameObject FindWithTag(string tag);

Renvoie un GameObject actifs marqué avec une balise. Renvoie null si aucun GameObject n'a été trouvé.

Paramètres

tagLe tag à rechercher.

Les balises doivent être déclarées dans le gestionnaire de balises avant de les utiliser. Une exception UnityException sera levée si la balise n'existe pas ou si une chaîne vide ou null est transmise en tant que balise.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    public GameObject respawnPrefab;
    public GameObject respawn;
    void Start()
    {
        if (respawn == null)
            respawn = GameObject.FindWithTag("Respawn");

        Instantiate(respawnPrefab, respawn.transform.position, respawn.transform.rotation);
    }
}

Object.hideFlags

public HideFlags hideFlags;

L'objet doit-il être caché, sauvegardé avec la scène ou modifiable par l'utilisateur ?

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {

    // Crée un matériau explicitement créé et détruit par le composant.
    // Resources.UnloadUnusedAssets ne le déchargera pas et ne sera pas modifiable par l'inspecteur.
    private Material ownedMaterial;
    void OnEnable() {
        ownedMaterial = new Material(Shader.Find("Diffuse"));
        ownedMaterial.hideFlags = HideFlags.HideAndDontSave;
        GetComponent().sharedMaterial = ownedMaterial;
    }

    // Les objets créés en tant que masquer et non enregistrer doivent être explicitement détruits par le propriétaire de l'objet.
    void OnDisable() {
        DestroyImmediate(ownedMaterial);
    }
}

Object.name

public string name;

Le nom de l'objet. Les composants partagent le même nom avec l'objet de jeu et tous les composants associés.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    public GameObject exampleOne;
    public GameObject exampleTwo;
    public GameObject exampleThree;

    void Start()
    {
        //Définit le nom de GameObject One.
        exampleOne.name = "Ben";
        //Définit le nom de GameObject Two.
        exampleTwo.name = "Ryan";
        //Définit le nom de GameObject Three.
        exampleThree.name = "Oscar";

        //Affiche leurs noms dans la console.
        Debug.Log("Les noms de ces trois objets sont " + exampleOne.name + exampleTwo.name + exampleThree.name);
    }
}

Object.GetInstanceID

public int GetInstanceID();

Retourne l'ID d'instance de l'objet. L'identifiant d'instance d'un objet est toujours garanti unique.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        print(GetInstanceID());
    }
}

Object.ToString

public string ToString();

Renvoie le nom de l'objet du jeu.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        Debug.Log(gameObject);
    }
}

Object.Destroy

public static void Destroy(Object obj, float t = 0.0F);

Supprime un gameobject, un composant ou un asset.

Paramètres

objL'objet à détruire.
tLa durée optionnelle de délai avant de détruire l'objet.

L'objet obj sera détruit maintenant ou si un temps est spécifié t secondes à partir de maintenant. Si obj est un composant, il supprimera le composant du GameObject et le détruit. Si obj est un GameObject, il va détruire le GameObject, tous ses composants et tous les transform des enfants du GameObject. La destruction réelle de l'objet est toujours retardée jusqu'à la fin de la boucle de mise à jour en cours, mais sera toujours effectuée avant le rendu.

C#// Commentaireusing UnityEngine;

public class ScriptExample : MonoBehaviour
{
    void DestroyGameObject()
    {
        Destroy(gameObject);
    }

    void DestroyScriptInstance()
    {
        // Supprime cette instance de script de l'objet de jeu
        Destroy(this);
    }

    void DestroyComponent()
    {
        // Enlève le rigidbody de l'objet du jeu
        Destroy(GetComponent());
    }

    void DestroyObjectDelayed()
    {
        // Tue l'objet du jeu dans 5 secondes après le chargement de l'objet
        Destroy(gameObject, 5);
    }

    // Lorsque l'utilisateur appuie sur Ctrl, il supprimera le composant BoxCollider de l'objet de jeu
    void Update()
    {
        if (Input.GetButton("Fire1") && GetComponent())
        {
            Destroy(GetComponent());
        }
    }
}

Destroy est hérité de la classe de base UnityEngine.Object. Les utilisateurs Javascript doivent envisager d'appeler UnityEngine.Object.Destroy, plutôt que Object.Destroy pour éviter que les références soient résolues dans la classe .Net System.Object.

Object.DestroyImmediate

public static void DestroyImmediate(Object obj, bool allowDestroyingAssets = false);

Détruit l'objet obj immédiatement. Il est fortement recommandé d'utiliser Destroy à la place.

Paramètres

objL'objet à détruire.
allowDestroyingAssetsDéfini sur true pour autoriser la destruction des assets.

Cette fonction ne doit être utilisée que lors de l'écriture du code de l'éditeur car la destruction retardée ne sera jamais invoquée en mode d'édition. Dans le code du jeu, vous devriez utiliser Object.Destroy à la place. Destroy est toujours retardé (mais exécuté dans le même cadre). Notez également que vous ne devez jamais parcourir les tableaux et détruire les éléments que vous parcourez. Cela causera de sérieux problèmes (comme une pratique de programmation générale, pas seulement dans Unity).

Object.DontDestroyOnLoad

public static void DontDestroyOnLoad(Object target);

Rend la cible de l'objet non détruite automatiquement lors du chargement d'une nouvelle scène.

Lors du chargement d'un nouveau niveau, tous les objets de la scène sont détruits, les objets du nouveau niveau sont chargés. Pour conserver un objet pendant le chargement du niveau, appelez DontDestroyOnLoad dessus. Si l'objet est un composant ou un objet de jeu, sa hiérarchie de transformation entière ne sera pas non plus détruite.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Awake() {
        DontDestroyOnLoad(transform.gameObject);
    }
}

Object.FindObjectOfType

public static Object FindObjectOfType(Type type);

Renvoie le premier objet chargé actif du type Type.

Paramètres

typeLe type d'objet à trouver.

Retourne

ObjectUn tableau d'objets correspondant au type spécifié, exprimés en tant qu'objets.

Veuillez noter que cette fonction est très lente. Il n'est pas recommandé d'utiliser cette fonction à chaque frame. Dans la plupart des cas, vous pouvez utiliser le modèle singleton à la place.

C#using UnityEngine;
using System.Collections;

// Rechercher un objet de type GUITexture,
// Si trouvé, imprime son nom,
// sinon imprime un message qui dit qu'il n'a pas été trouvé.
public class ExampleClass : MonoBehaviour
{
    void Start()
    {
        GUITexture texture = (GUITexture)FindObjectOfType(typeof(GUITexture));
        if (texture)
            Debug.Log("GUITexture object found: " + texture.name);
        else
            Debug.Log("No GUITexture object could be found");
    }
}

Object.FindObjectsOfType

public static Object[] FindObjectsOfType(Type type);

Renvoie une liste de tous les objets chargés actifs du type Type.

Paramètres

typeLe type d'objet à trouver.

Retourne

Object[]Le tableau d'objets trouvés correspondant au type spécifié.

Il ne renverra aucun assets (meshes, textures, prefabs, ...) ou d'objets inactifs. Veuillez noter que cette fonction est très lente. Il n'est pas recommandé d'utiliser cette fonction à chaque frame. Dans la plupart des cas, vous pouvez utiliser le modèle singleton à la place.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void OnMouseDown() {
        HingeJoint[] hinges = FindObjectsOfType(typeof(HingeJoint)) as HingeJoint[];
        foreach (HingeJoint hinge in hinges) {
            hinge.useSpring = false;
        }
    }
}

Object.Instantiate

public static Object Instantiate(Object original);

public static Object Instantiate(Object original, Transform parent);

public static Object Instantiate(Object original, Transform parent, bool instantiateInWorldSpace);

public static Object Instantiate(Object original, Vector3 position, Quaternion rotation);

public static Object Instantiate(Object original, Vector3 position, Quaternion rotation, Transform parent);

Clone l'objet original et renvoie le clone.

Paramètres

originalUn objet existant dont vous voulez faire une copie.
positionPosition pour le nouvel objet.
rotationOrientation du nouvel objet.
parentParent qui sera assigné au nouvel objet.
instantiateInWorldSpaceAffiche true lorsque vous affectez un objet parent pour conserver la position mondiale de l'objet, au lieu de définir sa position par rapport au nouveau parent. Affiche false pour définir la position de l'objet par rapport à son nouveau parent.

Retourne

ObjectLe clone instancié.

Cette fonction effectue une copie d'un objet de la même manière que la commande Dupliquer dans l'éditeur. Si vous clonez un GameObject, vous pouvez également spécifier sa position et sa rotation (valeurs par défaut à la position et la rotation d'origine du gameobject). Si vous clonez un composant, le GameObject auquel il est attaché sera également cloné, toujours avec une position et une rotation optionnelles.

Lorsque vous clonez un GameObject ou un composant, tous les objets et composants enfants seront également clonés avec leurs propriétés définies comme celles de l'objet original.

Par défaut, le parent du nouvel objet sera nul, il ne sera donc pas un "frère" de l'original. Cependant, vous pouvez toujours définir le parent en utilisant les méthodes surchargées. Si un parent est spécifié et qu'aucune position ou rotation n'est spécifiée, la position et la rotation de l'original seront utilisées pour la position locale et la rotation de l'objet cloné, ou sa position et sa rotation dans le monde si le paramètre instanciateInWorldSpace est true. Si la position et la rotation sont spécifiées, elles seront utilisées comme position et rotation de l'objet dans l'espace mondial.

Le statut actif d'un GameObject au moment du clonage sera transmis, donc si l'original est inactif, le clone sera également créé dans un état inactif.

C#// Instancie 10 copies de prefabs à 2 unités les unes des autres

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    public Transform prefab;
    void Start()
    {
        for (int i = 0; i < 10; i++)
        {
            Instantiate(prefab, new Vector3(i * 2.0F, 0, 0), Quaternion.identity);
        }
    }
}

Instantiate est le plus souvent utilisé pour instancier des projectiles, des Ennemis IA, des explosions de particules ou des remplacements d'objets détruits.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Rigidbody projectile;
    void Update() {
        if (Input.GetButtonDown("Fire1")) {
            Rigidbody clone;
            clone = Instantiate(projectile, transform.position, transform.rotation) as Rigidbody;
            clone.velocity = transform.TransformDirection(Vector3.forward * 10);
        }
    }
}

Instantiate peut également cloner des instances de script directement. La hiérarchie complète de l'objet de jeu sera clonée et l'instance de script clonée sera renvoyée.

C#using UnityEngine;
using System.Collections;

public class Missile : MonoBehaviour
{
    public int timeoutDestructor;

    // ...autre code...
}


public class ExampleClass : MonoBehaviour
{
    // Instancier un préfab avec un script Missile attaché
    public Missile projectile;

    void Update()
    {
        // Ctrl a été pressé, lance un projectile
        if (Input.GetButtonDown("Fire1"))
        {
            // Instancie le projectile à la position et la rotation de ce transform
            Missile clone = (Missile)Instantiate(projectile, transform.position, transform.rotation);

           // Régle le timeout de missiles sur 5
            clone.timeoutDestructor = 5;
        }
    }
}

Après avoir cloné un objet, vous pouvez également utiliser GetComponent pour définir des propriétés sur un composant spécifique attaché à l'objet cloné.


public static T Instantiate(T original);

public static T Instantiate(T original, Transform parent);

public static T Instantiate(T original, Transform parent, bool worldPositionStays);

public static T Instantiate(T original, Vector3 position, Quaternion rotation);

public static T Instantiate(T original, Vector3 position, Quaternion rotation, Transform parent);

Paramètres

originalObjet de type T dont vous voulez faire un clone.

Retourne

TObjet de type T.

Vous pouvez également utiliser Generics pour instancier des objets. Voir la page des fonctions génériques pour plus de détails.

Dans cet exemple, nous instancions à nouveau notre objet Missile, mais en utilisant Generics, nous n'avons pas besoin de lancer le résultat :

C#using UnityEngine;

public class InstantiateGenericsExample : MonoBehaviour
{
    public Missile missile;

    void Start()
    {
        Missile missileCopy = Instantiate(missile);
    }
}

Object.bool

L'objet existe-t-il ?

Les deux exemples ci-dessous donnent le même résultat.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        if (rigidbody)
            Debug.Log("Rigidbody attaché à ce transform");
        
    }
}

... c'est la même chose ...

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        if (rigidbody != null)
            Debug.Log("Rigidbody attaché à ce transform");
        
    }
}

Object.operator !=

public static bool operator !=(Object x, Object y);

Compare si deux objets se réfèrent à un objet différent.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Transform target;
    void Update() {
        if (target != transform)
            print("Un autre objet");
        
    }
}

Object.operator ==

public static bool operator ==(Object x, Object y);

Compare deux références d'objet pour voir si elles se rapportent au même objet.

Paramètres

xLe premier objet.
yL'objet à comparer au premier.
C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Collider target;
    void OnTriggerEnter(Collider trigger) {
        if (trigger == target)
            print("Nous touchons le déclencheur cible");
        
    }
}

Sortez tôt s'il n'y a pas de cible.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Transform target;
    void Update() {
        if (target == null)
            return;
        
    }
}

Soyez prudent lorsque vous comparez avec null.

C#
GameObject go = new GameObject();
Debug.Log (go == null); // false

Object obj = new Object();
Debug.Log (obj == null); // true

L'instanciation d'un GameObject l'ajoute à la scène afin qu'elle soit complètement initialisée (!destroyed). L'instanciation d'un objet UnityEngine.Object simple n'a pas de sémantique de ce type, donc elle reste dans l'état 'destroy' qui compare true à null.

les réactions

Pour laisser un avis, vous devez être inscrit et connecté

Se connecter