unity3d => prefabs

Syntaxis

public static Object PrefabUtility.InstantiatePrefab (Object target);
public static Object AssetDatabase.LoadAssetAtPath (string assetPath, Type type);
public static Object Object.Instantiate (Object origineel);
public static Object Resources.Load (stringpad);

Invoering

Prefabs zijn van het type activa waarmee een complete GameObject met zijn componenten, eigenschappen, gekoppelde componenten en geserialiseerde eigenschapswaarden kan worden opgeslagen. Er zijn veel scenario's waar dit handig is, waaronder:

Objecten in een scène dupliceren
Een gemeenschappelijk object delen over meerdere scènes
Een prefab eenmaal kunnen wijzigen en de wijzigingen toepassen op meerdere objecten / scènes
Dubbele objecten maken met kleine wijzigingen, terwijl de gemeenschappelijke elementen bewerkbaar zijn vanaf één basisprefab
GameObjects instantiëren tijdens runtime

Er is een vuistregel in Unity die zegt: "alles moet Prefabs zijn". Hoewel dit waarschijnlijk overdreven is, stimuleert het wel het hergebruik van code en het bouwen van GameObjects op een herbruikbare manier, die zowel geheugenefficiënt als een goed ontwerp is.

Prefabs maken

Om een prefab te maken, sleept u een game-object uit de scènehiërarchie naar de map Activa of de submap:

De naam van het spelobject wordt blauw, wat aangeeft dat deze is verbonden met een prefab .
Nu is dit object een prefabinstantie , net als een objectinstantie van een klasse.

Een prefab kan na instantiëring worden verwijderd. In dat geval wordt de naam van het eerder verbonden spelobject rood:

Prefab inspecteur

Als je een prefab in de hiërarchieweergave selecteert, merk je dat de infovenster enigszins verschilt van een gewoon spelobject:

Vetgedrukte eigenschappen betekenen dat hun waarden verschillen van de prefabwaarden. U kunt elke eigenschap van een geïnstantieerd prefab wijzigen zonder de oorspronkelijke prefab-waarden te beïnvloeden. Wanneer een waarde in een prefabinstantie wordt gewijzigd, wordt deze vetgedrukt en worden alle latere wijzigingen van dezelfde waarde in de prefab niet weerspiegeld in de gewijzigde instantie.

U kunt terugkeren naar de oorspronkelijke prefabwaarden door op de knop Terugdraaien te klikken. In de instantie worden ook waardewijzigingen doorgevoerd. Om een individuele waarde terug te zetten, kunt u er bovendien met de rechtermuisknop op klikken en op Waarde terugzetten naar Prefab drukken. Als u een component wilt terugdraaien, klikt u erop met de rechtermuisknop en drukt u op Terugzetten naar Prefab .

Als u op de knop Toepassen klikt, worden de prefab-eigenschapswaarden overschreven door de huidige spelobject-eigenschapswaarden. Er is geen knop "Ongedaan maken" of dialoogvenster bevestigen, dus wees voorzichtig met deze knop.

Select knop markeert verbonden prefab in de mappenstructuur van het project.

Prefabs instantiëren

Er zijn 2 manieren om prefabs te instantiëren: tijdens het ontwerp of de looptijd .

Ontwerptijdsturing

Het prefiëren van prefabs tijdens het ontwerpen is handig om visueel meerdere instanties van hetzelfde object te plaatsen (bijv. Bomen plaatsen bij het ontwerpen van een niveau van je spel ).

Om een prefab visueel te instantiëren, sleept u deze vanuit de projectweergave naar scènehiërarchie.

Als u een editor-extensie schrijft, kunt u ook een prefab direct programmeren door de PrefabUtility.InstantiatePrefab() -methode aan te roepen:

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

Runtime-instantiatie

Het instantiëren van prefabs tijdens runtime is handig om instanties van een object te maken volgens een logica (bijvoorbeeld elke 5 seconden een vijand uitzetten ).

Om een prefab te instantiëren, hebt u een verwijzing naar het prefab-object nodig. Dit kan worden gedaan door een public GameObject veld in uw MonoBehaviour script te hebben (en de waarde ervan in te stellen met behulp van de infovenster in de Unity Editor):

public class SomeScript : MonoBehaviour {
   public GameObject prefab; 
}

Of door het prefab in de map Resource te plaatsen en Resources.Load .

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

Als u eenmaal een verwijzing naar het prefab-object hebt, kunt u het instantiëren met de functie Instantiate overal in uw code (bijvoorbeeld in een lus om meerdere objecten te maken ):

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

Opmerking: Prefab term bestaat niet tijdens runtime.

Geneste prefabs

Geneste prefabs zijn momenteel niet beschikbaar in Unity. U kunt het ene prefab naar het andere slepen en dat toepassen, maar wijzigingen in het onderliggende prefab worden niet toegepast op de geneste.

Maar er is een eenvoudige oplossing - u moet aan het ouderlijk prefab een eenvoudig script toevoegen, waarmee een kind direct wordt gestart.

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

Ouder prefab: