L'idea è di creare un frattale a partire da un oggetto di base, creado di iterazione in iterazione dei figli del tutto identici all'originale se non per dimensione. È un buon esercizio mentale, senza contare che si può lavorare su di un concetto fondamentale, l'iterazione.
Creiamo un oggetto vuoto nella scena, ed assegnamo la classe "Frattale"
Dunque, vogliamo che il frattale parta da una certa mesh che gli assegneremo in partenza e, da lì, che calcoli e instanzi i figli. La classe dovrà avere dunque 2 variabili pubbliche MeshRenderer e MeshFilter.
Il componente MeshRenderer prende la geometria fornita dal componente MeshFilter e la renderizza alle coordinate fornite dalla Transform
Il componente MeshFilter prende una mesh dalle risorse del progetto (personalmente aggiunta o dalle primitive) e la passa al MeshRenderer per renderizzarla. È necessario perché definisce dinamicamente la mesh.
Assegnamo dall'Inspector un materiale creato ad hoc e scegliamo una mesh dalle primitive di Unity.
Basta mettere una texture (cioè un'immagine) in qualsiasi punto della cartella Assets del progetto, e trascinarla su di un oggetto all'interno della scena. Unity provvederà a creare automaticamente un materiale con quella texture.
Il metodo Start() viene chiamato da Unity dopo che l'oggetto è stato creato, attivato e prima che Update() venga chiamata per la prima volta per quell'oggetto specifico (se ha una funzione Update() definita).
Il metodo AddComponent() aggiunge un componente della classe T definita, attaccandola al gameObject a cui fa riferimento. Siccome ritorna un riferimento all'oggetto si può anche scrivere gameObject.AddComponent().mesh = Mesh_del_Frattale; per creare ed inizializzare la mesh.
Aggiungiamo dunque dei figli al frattale. Il modo più semplice con cui aggiungere dei figli ad un oggetto tramite script è tramite la sintassi:
"new" è un comando che viene usato per costruire una nuova instanza di un oggetto o di una struct. È seguito dal metodo costruttore, con lo stesso nome della classe di appartenenza.
Con tale sintassi, però, vengono istanziati infiniti oggetti Frattale, con il risultato di far bloccare il PC. Introduciamo quindi una variabile che definisce il numero massimo di iterazioni ed il numero corrente di iterazioni:
E le inizializziamo tramite il metodo di Unity Initialize():
this è una parola chiave che ritorna un riferimento all'oggetto corrente o, in alternativa, all'oggetto di cui si sta chiamando il metodo.
Initialize() viene chiamata subito dopo AddComponent(). L'ordine è Creazione Oggetto -> Creazione componente Frattale -> Awake() -> OnEnable() -> AddComponent() -> Initialize() -> Start().
Start viene chiamata al frame succesivo.
Vengono dunque creati, così, 4 figli nella gerarchia. Tuttavia noi vogliamo che gli oggetti siano figli dell'oggetto frattale principale. Cioè:
E lo facciamo tramite il comando transform.setParent(Genitore.transform); :
Tuttavia anche così i figli istanziati rimangono nella stessa posizione del padre. Introduciamo una variabile per gestire la scala dei figli e li posizioniamo sopra l'oggetto di Origine:
Il risultato:
Un vero frattale, però, ha figli anche nelle altre direzioni. Ristrutturiamo dunque il metodo Initialize() per includere la direzione nella quale istanziare i figli:
Il risultato:
Ora, il problema è che, ipotizzando di istanziare figli su tutte le 6 facce del cubo, si otterrebbe che in pochi frame si istanziano 6^4 = 1296 oggetti, con conseguente rallentamento ed impossibilità di vedere il frattale effettivamente "crescere". Poniamo dunque un intervallo tra una istanziazione e l'altra attraverso la creazione di un metodo IEnumerator e l'utilizzo di StartCoroutine(). Dunque:
Creare una coroutine in Unity vuol dire essenzialmente creare un iteratore. Quando si passa l'iteratore al metodo StartCoroutine(), il motore chiede il prossimo oggetto di quel metodo ad ogni frame successivo, finché il metodo termina. La parola chiave yield è quella che produce gli oggetti, tutto il resto è da considerare un effetto collaterale dell'iteratore. WaitForSeconds è usato per dare alla coroutine un comportamento controllato, ma in generale si comporta esattamente come iteratore.
Quando si utilizza la parola chiave yield in un'istruzione, si indica che il metodo, l'operatore o la funzione di accesso get in cui appare è un iteratore. Utilizzando yield per definire un iteratore, si elimina la necessità di una classe esplicita aggiuntiva (la classe che contiene lo stato per un'enumerazione, vedere IEnumerator per un esempio) quando si implementano i modelli IEnumerator e di IEnumerable per un tipo di raccolta personalizzato.
Bene, ma non benissimo. I figli vengono istanziati in piccole raffiche che causano ancora rallentamenti. Introduciamo dunque un ritardo randomico a WaitForSeconds in modo da distribuire la creazione dei figli in un certo intervallo di tempo:
C'è ancora un problema: i figli vengono instanziati all'interno del padre. Utilizzando la visuale Overdraw questo è piuttosto evidente:
Vogliamo dunque ruotare i figli nella direzione in cui si istanziano. Per fare questo rimuoviamo l'istanziazione a Vector3.down, e rimaniamo le altre, aggiungendo ad Initialize() un altro parametro per gestire la rotazione:
Il risultato:
Tuttavia questo fa rimanere una parte del frattale vuota. Dunque, ristrutturando brevemente e concisamente il codice possiamo fare in modo che l'istanziazione dei figli sia indicizzata:
tale risultato è raggiunto semplicemente aggiungendo dei vettori con la posizione e la rotazione dei figli come variabili private, ed aggiustando in modo consono Initialize(). Il risultato è identico a prima, ma ora possiamo aggiungere semplicemente le direzioni in cui vogliamo i figli:
Ed il risultato:
abbiamo ottenuto il frattale completo! Possiamo apportare infinite modifiche, da questo punto in poi: possiamo dare un colore diverso ad ogni componente, farli lampeggiare, aggiungere rotazioni extra ai figli, farli istanziare in modo asimmetrico...le possibilità sono legate solo alla fantasia (e pazienza!).
Nessun commento:
Posta un commento