TUTORIAL RIG DI UNA SFERA IN STILE CARTOON


--------------------------------------------------------------------------------



Tempo fa ho visto un tutorial su questo argomento, ma alcune cose nel risultato finale non mi piacevano più di tanto, così...ho cercato di rifarlo a modo mio.

Si tratta del rigging di una sfera in stile cartoon, con tanto di stretch con possibilità di ruotare anche la direzione di stretch, in modo da poterla allungare o comprimere in qualsiasi direzione si voglia senza dover necessariamente ruotare anche l'oggetto.

Per questo esempio insieme alla sfera ho posizionato anche un toroide, in modo da far vedere quando la rotazione influisce sull'oggetto e quando invece solo sulla direzione di deformazione.

I controlli sono limitati al 'minimo sindacale', e, per la felicità di un mio amico, stavolta ho inserito anche un po' di immagini (ciao huberrrrrrrrrr).

Avremo un controllo per muovere , ruotare e scalare l'oggetto, uno per ruotare solamente la direzione di stretch e due controlli per lo stretch, che partono ai due poli della sfera.



Creo la sfera ed il toroide, per comodità li raggruppo e chiamo il gruppo g_Mesh:


Immagine inserita




Creiamo un controllo 'Main', che servirà per muovere e ruotare l'oggetto, quindi, facciamo un cubo di curve(formato da una curva continua),

scaliamolo un po' e chiamiamolo ctrl_Main, poi eseguiamo un delete history ed un freeze transformations.

Prendiamo g_Mesh e imparentiamolo a ctrl_Main.


Immagine inserita




Ora facciamo in modo di poter deformare l'oggetto...

Selezioniamo g_Mesh e andiamo su Create Deformers -> Lattice (dalla serie di menu Animation).



Immagine inserita



In base alle impostazioni che abbiamo nella creazione del lattice, potrebbe essere (come nel mio caso), troppo suddiviso,

quindi settiamo dalla sezione degli inputs nel channel box le tre divisions (S, T e U) tutte a 2, in modo che il nostro lattice sia un cubo con 8 punti e basta.



Immagine inserita



So già che il mio oggetto ha un raggio pari a 5, così selezioniamo sia il lattice che ffd1Base e nel channel box mettiamo scaleX, Y e Z a 10, così che il lattice sia grande quanto l'oggetto.



Immagine inserita



Nell'Attribute editor, alla tabella ffd1, selezioniamo dalla casella a discesa 'Outside Lattice' il valore 'All'.



Immagine inserita



Ora...la mesh dell'oggetto è controllata dal lattice, quindi, muovendo il ctrl_Main spostiamo l'oggetto(ma il lattice rimane fermo), ma anche muovendo il lattice spostiamo l'oggetto(e ctrl_Main rimane fermo)...quindi dobbiamo continuare...

Imparentiamo sia ffd1Lattice che ffd1Base sotto ctrl_Main...potremmo aspettarci, vista la frase precedente, di ottenere una doppia trasformazione sull'oggetto, ma ciò non avviene, perchè?

Perchè abbiamo imparentato anche ffd1Base, che è appunto la base da cui Maya calcola lo spostamento del lattice per poi applicarla alla mesh, quindi, imparentando tutti e due, applicheremo una trasformazione ad entrambi, e non ci saranno differenze tra il lattice e la base che Maya possa attribuire come deformazione alla mesh.


Immagine inserita


Facciamo click con il tasto destro sul lattice e selezioniamo dal menu 'Lattice point'.

Selezioniamo i 4 vertici superiori del lattice e poi menu Create Deformers -> Cluster ->[]

Nelle opzioni selezioniamo la casella 'relative' e premiamo 'Create'.


Immagine inserita


Rinominiamo il cluster UpperCluster, poi di nuovo tasto destro sul lattice...Lattice point e selezioniamo

gli altri 4 vertici, quelli in basso, premendo il tasto 'g' creiamo un altro cluster (LowerCluster).

Questi due clusters appena creati gestiranno il nostro stretch.


Immagine inserita


Ora, spostando i clusters, otterremo la deformazione


Immagine inserita



Creiamo due piramidi e posizioniamole in una posizione a noi comoda ai due poli della sfera, sopra e sotto, eseguiamo un delete history e un freeze transformations, poi chiamiamoli ctrl_UpperStretch e ctrl_LowerStretch


Immagine inserita


Selezioniamo prima ctrl_UpperStretch e poi UpperCluster ed eseguiamo un Point Constraint, mettendo il segno di spunta su Maintain Offset, visto che non è detto che il pivot point della piramide coincida con il cluster, eviteremo così uno spostamento non voluto.

Selezioniamo prima ctrl_LowerStretch e poi LowerCluster e premiamo 'g'.

Ora muovendo i due controlli deformeremo l'oggetto, ma muovendo ctrl_Main le piramidi rimangono dove sono...tutto funziona, ma è scomodo da animare, quindi, imparentiamo ctrl_UpperStretch e ctrl_LowerStretch a ctrl_Main.

Ora sì che otterremo una trasformazione non voluta...


Immagine inserita


Questo perchè muovendo ctrl_Main, spostiamo la mesh, ma spostiamo anche le due piramidi, che a loro volta muovono i due clusters, che comandano (anche loro) la mesh...dobbiamo fare in modo che i clusters non ricevano questo spostamento se non agiamo direttamente sulle piramidi...per ottenere questo ci verrà comodo il parametro 'relative' che abbiamo settato all'inizio ai clusters(nel caso ce ne fossimo dimenticati, possiamo sempre settarlo ora dall'attribute editor dei clusters).

Questo parametro fa sì che i clusters agiscano come deformatori solo quando variano i loro parametri(translate, rotate o scale), e non quando la loro 'trasformazione' nello spazio viene 'ereditata' da un parent.

Quindi, selezioniamo UpperCluster, premiamo ctrl + g, e rinominiamo il gruppo g_UpperCluster, lo stesso per LowerCluster, selezioniamolo, ctrl+g e rinominiamo g_LowerCluster.

Poi prendiamo i due gruppi e imparentiamoli a ctrl_Main.


Immagine inserita


Il nostro obiettivo ora è fare in modo di poter ruotare questo 'sistema' in modo che le due piramidi possano 'puntare' in altre direzioni e deformare l'oggetto da punti diversi.

Creiamo a tale scopo un cerchio, scaliamolo un po', rinominiamolo ctrl_Rotate e poi eseguiamo un delete history e un freeze transformations.

Imparentiamo questo controllo a ctrl_Main, in questo modo il controllo seguirà quello principale, poi, selezioniamo il lattice, la base, i due gruppi g_UpperCluster e g_LowerCluster, i due controlli ctrl_UpperStretch e ctrl_LowerStretch e imparentiamo il tutto a ctrl_Rotate(praticamente lasciamo fuori solo g_Mesh).



Immagine inserita

Sembrerebbe finita qui, ma provando a muovere i vari controlli ci accorgiamo di una cosa...deformando l'oggetto quest'ultimo non mantiene il volume...


Immagine inserita


Pensiamoci un attimo...abbiamo bisogno di un qualcosa che ci dica di quanto i due clusters si siano avvvicinati o allontanati per poi ricavare di quanto scalare nelle altre due direzioni l'oggetto...

Dobbiamo quindi creare un distance between node (possiamo farlo dall'hypershade, apriamolo poi menu Create -> General Utilities -> Distance Between) e rinominiamolo db.

Ora, il distance between node prende due oggetti, e ne calcola la distanza...problema, i due clusters hanno ambedue valori di translate uguali a 0, lo stesso dicasi dei due controlli stretch...allora ci creiamo due locators, loc_UpperCluster e loc_LowerCluster.

Una volta fatto selezioniamo prima ctrl_UpperStretch, poi loc_UpperCluster ed eseguiamo un point constraint, stavolta però lasciando DESELEZIONATA la casella mantain offset, così che il locator si 'auto-snapperà' al cluster.

Lo stesso per l'altro, cioè selezioniamo prima ctrl_LowerStretch, poi loc_LowerCluster e premiamo 'g'.


Immagine inserita


Iparentiamo pure loc_UpperCluster e loc_LowerCluster a ctrl_Rotate.

Ora i locators seguiranno i controlli stretch, proprio come i clusters.

Mediante il connection editor connettiamo loc_UpperCluster.translate con db.point1, e loc_LowerCluster.translate con db.point2.


Immagine inserita


In questo momento db.distance avrà la distanza iniziale tra i due controlli, ma come facciamo a sfruttarla per i nostri scopi?

dobbiamo ottenere questo:


Immagine inserita


e l'inverso



Immagine inserita


Lasciamo per un attimo visibile il lattice, i clusters e i locators...abbiamo questo:



Immagine inserita



Dobbiamo creare altri 4 clusters per ognuna delle 4 facce rimaste, quindi, selezioniamo 4 a 4 i points del lattice e via di create clusters (relative sempre selezionato)



Immagine inserita



Ora...i 4 nuovi clusters comandano la mesh insieme ai primi 2 già creati ed utilizzati; quando i due controlli per lo stretch si allontanano uno dall'altro, dobbiamo far convergere verso il centro i 4 clusters appena creati, così da 'strizzare' la mesh, al contrario, quando i primi due si avvicinano, dobbiamo allontanare i 4 per far allargare l'oggetto.

Come facciamo? non possiamo gestire il translate dei clusters, sarebbe da impazzire e limitativo, allora faremo così...creiamo 4 locators e 'snappiamoli' ai 4 nuovi clusters.



Immagine inserita



Raggruppiamo i 4 locators (g_loc_clusters)...Capita l'idea? ora, semplicemente scalando in x e z il gruppo i locators si avvicineranno o allontaneranno dal centro, quello che dobbiamo fare ora è eseguire un point constraint tra ogni locator e il cluster corrispondente.

Poi dobbiamo fare in modo che anche tutta questa nuova 'roba' segua il movimento sia del ctrl_Main che del ctrl_Rotate.

Basta imparentare g_loc_Clusters a ctrl_Rotate, mentre per i nuovi clusters dovremo prima raggrupparli tutti insieme(g_Clusters)poi imparentare il nuovo gruppo anch'esso a ctrl_Rotate.


Ecco come si presenta l'outliner (e la scena) dopo gli ultimi cambiamenti:



Immagine inserita



Bene, ora finiamo le varie connessioni per far sì che il tutto funzioni.

Aggiungiamo un attributo di tipo Float e di nome o_dist a g_loc_Clusters.

questo o_dist (original distance) manterrà la distanza che c'è ora, a rig azzerato tra i due controlli stretch.

Come la calcoliamo questa distanza? La abbiamo già, la sta tenendo per noi il nodo db creato in precedenza.

Per trasferirla a o_dist possiamo stabilire una connessione tramite connection editor tra db.distance e g_loc_Clusters.o_dist.

Possiamo tranquillamente ora togliere la connessione, il valore rimarrà in o_dist.

Apriamo ora l'hypershade e creiamo un multiply divide node (sapete come fare ormai, vero?) e chiamiamolo md.

Nell'attribute editor cambiamo la sua operation su divide.



Immagine inserita



Connettiamo g_loc_Clusters.o_dist a md.input1X e db.distance a md.input2X.



Immagine inserita



L'outputX di md conterrà ora il nostro valore di scale, connettiamolo sia a g_loc_Clusters.scaleX che a g_loc_Clusters.scaleZ.


Immagine inserita


Il rig è finito qui, diamogli una pulitina...

Da ctrl_UpperStretch e ctrl_LowerStretch possiamo bloccare e nascondere gli attributi di scale, rotate e visibility, in quanto verranno solo mossi,

da ctrl_Rotate blocchiamo e nascondiamo tutti gli attributi tranne che quelli di rotate e da ctrl_Main possiamo lasciare tutto tranne che visibility.



Direi che può bastare...ora divertitevi...

---
Questo articolo è stato importato automaticamente dal forum il 31/lug/2014
Per vedere il post originale e/o i commenti sul forum prima di quella data clicca qui