unity3d => Préfabriqués

Syntaxe

objet statique public PrefabUtility.InstantiatePrefab (Object target);
objet statique public AssetDatabase.LoadAssetAtPath (string assetPath, type type);
objet objet statique public.Instantiate (objet d'origine);
public static Object Resources.Load (chemin de chaîne);

introduction

Les préfixes sont un type d'actif qui permet de stocker un objet GameObject complet avec ses composants, propriétés, composants associés et valeurs de propriété sérialisées. Il existe de nombreux scénarios où cela est utile, notamment:

Dupliquer des objets dans une scène
Partage d'un objet commun sur plusieurs scènes
Pouvoir modifier une pièce préfabriquée une seule fois et appliquer les modifications à plusieurs objets / scènes
Créer des objets dupliqués avec des modifications mineures, tout en ayant les éléments communs modifiables à partir d'une base préfabriquée
Instanciation de GameObjects à l'exécution

Il y a une règle de base dans l'Unité qui dit "tout devrait être préfabriqué". Bien que cela soit probablement exagéré, cela encourage la réutilisation du code et la création de GameObjects de manière réutilisable, ce qui est à la fois efficace en termes de mémoire et de conception.

Créer des préfabriqués

Pour créer un préfabriqué, faites glisser un objet de jeu de la hiérarchie de la scène dans le dossier ou sous-dossier Assets :

Le nom de l'objet du jeu devient bleu, indiquant qu'il est connecté à un préfabriqué .
Maintenant, cet objet est une instance préfabriquée , tout comme une instance d'objet d'une classe.

Un préfabriqué peut être supprimé après instanciation. Dans ce cas, le nom de l'objet de jeu précédemment connecté devient rouge:

Inspecteur préfabriqué

Si vous sélectionnez un préfabriqué dans la vue hiérarchique, vous remarquerez que son inspecteur diffère légèrement d'un objet de jeu ordinaire:

contre

Les propriétés en gras signifient que leurs valeurs diffèrent des valeurs préfabriquées. Vous pouvez modifier toute propriété d'un préfabriqué instancié sans affecter les valeurs préfabriquées d'origine. Lorsqu'une valeur est modifiée dans une instance préfabriquée, elle devient en gras et toute modification ultérieure de la même valeur dans le préfabriqué ne sera pas répercutée dans l'instance modifiée.

Vous pouvez revenir aux valeurs préfabriquées d'origine en cliquant sur le bouton Rétablir , qui reflétera également les changements de valeur dans l'instance. De plus, pour rétablir une valeur individuelle, vous pouvez cliquer avec le bouton droit de la souris et appuyer sur Rétablir la valeur dans Préfab . Pour rétablir un composant, cliquez dessus avec le bouton droit de la souris et appuyez sur Revenir sur Préfab .

Un clic sur le bouton Appliquer remplace les valeurs de propriété préfabriquées par les valeurs de propriété d'objet de jeu actuelles. Il n'y a pas de bouton "Annuler" ou de dialogue de confirmation, donc manipulez ce bouton avec soin.

Le bouton Sélectionner met en évidence le préfabriqué connecté dans la structure de dossiers du projet.

Préfabrication

Il y a deux façons d'instancier les préfabriqués: pendant la conception ou l' exécution .

Instanciation du temps de conception

L'instanciation des préfabriqués au moment de la conception est utile pour placer plusieurs instances du même objet (par exemple, placer des arbres lors de la conception d'un niveau de votre jeu ).

Pour instancier visuellement un préfabriqué, faites-le glisser de la vue du projet vers la hiérarchie de la scène.

Si vous écrivez une extension d'éditeur , vous pouvez également instancier une méthode PrefabUtility.InstantiatePrefab() appelant par programmation:

GameObject gameObject = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath("Assets/MainCamera.prefab", typeof(GameObject)));

Instanciation du runtime

L'instanciation de préfabriqués à l'exécution est utile pour créer des instances d'un objet en fonction d'une logique (par exemple, générer un ennemi toutes les 5 secondes ).

Pour instancier un préfabriqué, vous avez besoin d'une référence à l'objet préfabriqué. Cela peut être fait en ayant un champ public GameObject dans votre script MonoBehaviour (et en définissant sa valeur à l'aide de l'inspecteur dans l'éditeur Unity):

public class SomeScript : MonoBehaviour {
   public GameObject prefab; 
}

Ou en plaçant le préfabriqué dans le dossier Resource et en utilisant Resources.Load :

GameObject prefab = Resources.Load("Assets/Resources/MainCamera");

Une fois que vous avez une référence à l'objet préfabriqué, vous pouvez l'instancier en utilisant la fonction Instantiate n'importe où dans votre code (par exemple, dans une boucle pour créer plusieurs objets ):

GameObject gameObject = Instantiate<GameObject>(prefab, new Vector3(0,0,0), Quaternion.identity);

Remarque: Le terme préfabriqué n'existe pas au moment de l'exécution.

Préfabriqués imbriqués

Les préfabriqués imbriqués ne sont pas disponibles dans Unity pour le moment. Vous pouvez faire glisser un préfabriqué vers un autre et l'appliquer, mais les modifications apportées au préfabriqué enfant ne seront pas appliquées à celui qui est imbriqué.

Mais il existe une solution de contournement simple: vous devez ajouter au parent prefab un script simple, qui instanciera un enfant.

using UnityEngine;

public class ParentPrefab : MonoBehaviour {

    [SerializeField] GameObject childPrefab;
    [SerializeField] Transform childPrefabPositionReference;

    // Use this for initialization
    void Start () {
        print("Hello, I'm a parent prefab!");
        Instantiate(
            childPrefab, 
            childPrefabPositionReference.position, 
            childPrefabPositionReference.rotation, 
            gameObject.transform
        );
    }
}

Parent préfabriqué: