La character animation rappresenta l’anello di congiunzione tra un modello tridimensionale e l’animazione, Questo processo prevede la creazione di tutta una serie di controlli, mediante cui l’animatore può dar vita all’oggetto, senza per questo manipolarlo direttamente: è il character setup.

Per comprendere questo concetto, basti pensare all’animazione tradizionale delle marionette a filo. Quest’ultima è attaccata ad una tavoletta in legno, ed il burattinaio spostando e muovendo la suddetta è in grado di eseguire gesti ed azioni ben precise. Trasposto in digitale il burattino rappresenta l’elemento da animare, e la tavoletta in legno equivarrebbe ai controlli che l’animatore andrebbe a gestire.

Quando si pensa tuttavia alla character animation, non bisogna limitarsi all’animazione dei soli personaggi, perché la creazione di un character setup abbraccia qualunque tipo di elemento. Volendo citare Walt Disney è “l’illusione della vita”.

All’atto pratico il character setup può riguardare personaggi, camere, oggetti di qualunque tipo, e nell’esempio in questione verranno creati i controlli per replicare il funzionamento del pistone e biella in un motore.

La creazione di un character setup può prevedere diverse strade, tutte accomunabili tra loro.

Skeleton joint

Il joint è un elemento fittizio che non appare nel render, attraverso cui si può creare una sorta di esoscheletro, preposto a favorire il movimento. Tendenzialmente l’uso dei joints riguarda i personaggi, perché possono connettersi tra loro: in questo caso si parla di “catena di joints” (Fig. 1).

Anche qui basti pensare alle gambe e braccia, costituite da più ossa: ad ogni modo restando sul personaggio, l’obiettivo dei joint non è quello di replicare tutte le ossa di un corpo umano, ma favorire il movimento. Nel caso del braccio l’osso dell’ulna e del radio verrebbero accomunate sullo stesso joint: per cui la sua replica in digitale prevedrebbe solo l’uso di due joint, vale a dire uno per l’omero ed uno per ulna e radio assieme.

Kinematics

Si tratta di due modelli di cinematica, tramite cui i joints vengono trasformati nella rotazione. Può essere diretta ed inversa (Fig. 2): nel primo caso i joints vengono manipolati manualmente dall’animatore, mentre nel secondo caso la manipolazione avviene attraverso quello che è noto come IkHandle. Si tratta di un elemento fittizio, mediante cui s’indica il punto d’inizio e fine della catena di joint.

Clicca sull’immagine per la visualizzazione estesa.

Generalmente questa distinzione è più per i personaggi organici, ossia quando si crea il setup del braccio: subordinatamente all’animazione da replicare, l’animatore potrà trarre vantaggio da un metodo rispetto ad un altro passando attraverso uno switch.

Constraint

Come già il nome può far supporre, permette di creare una relazione di vincolo tra due elementi. Ne sono presenti di diverse tipologie, ed agiscono direttamente sulle trasformazioni (traslazione, rotazione e scala) e non solo.

Connection Editor

Prevede la relazione diretta tra due attributi. Questo tipo di relazione avviene a senso unico, in cui il valore viene trasferito da “A” verso “B”. Ad esempio si può connettere il TranslateX dell’elemento “A” al RotateY dell’elemento “B”: traslando l’elemento “A” sull’asse X, automaticamente il valore si trasferisce, perché connesso, alla rotazione dell’elemento “B”. Il trasferimento è quindi diretto, manipolabile comunque inserendo nel mezzo dei “nodi”.

Node Editor

In questo caso il discorso è più tecnico, perché prevede l’uso di nodi. Introduco, senza entrare troppo nello specifico il concetto di “dependency graph” (Fig. 3): ridotto all’essenziale ogni elemento in Maya è rappresentato con un “nodo”, ed ognuno possiede delle informazioni che possono essere in entrata ed in uscita. Volendo semplificare moltissimo il concetto, basti pensare ad una banale estrusione: il nodo dell’oggetto sopra cui si sta operando l’estrusione è connesso in entrata al nodo dell’estrusione stesso, e quest’ultimo è poi connesso al nodo che restituisce il risultato finale dell’estrusione sulla superficie.

Set Driven Key

Il vincolo che si crea è subordinato al verificarsi di determinate condizioni. Si tratta quindi di un determinato tipo di setup, che permette l’automatizzazione di alcuni processi in animazione. Volendo semplificare e contestualizzare il concetto, l’esempio potrebbe essere quello delle porte scorrevoli: la loro apertura e chiusura, che prevede la semplice traslazione su un asse, avviene solo quando un elemento (personaggio) è nelle sue immediate vicinanze o quando si sta allontanando da esse.

Analisi

Dopo questa veloce panoramica sugli strumenti offerti per la character animation, non resta che iniziare. Il primo passo è capire quale sia la strada migliore da intraprendere: la scelta non è mai casuale, perché deve considerare sia quello che s’intende replicare in termini di controllo per l’animatore, che anche i vantaggi e svantaggi degli strumenti che s’intende usare.

Riguardo al primo punto di analisi, la domanda da porsi è cosa voglio ottenere. Osservando il funzionamento di un qualunque motore, si evince che il movimento della biella e pistone è subordinato alla rotazione dell’albero motore. L’obiettivo da raggiungere è quindi quello di creare un controllo capace di ruotare l’albero motore, cui poi è subordinato il movimento della biella e pistone. La prima deve muoversi in modo rotatorio attorno all’albero motore, mentre il secondo trasla solo su un asse. Il pistone scorre quindi all’interno del cilindro con un movimento rettilineo, mentre la biella ruota attorno al punto in cui s’impernia con la manovella: a sua volta quest’ultima ruota su un punto fisso detto piede di manovella.

Volendo citare il movimento biella-manovella da wikipedia è un sistema per la trasformazione di moto rettilineo alternato in circolare e viceversa.

Riguardo al secondo punto ossia l’analisi dei vantaggi e svantaggi degli strumento, è un’attitudine che si acquisisce nel tempo, replicando e creando diversi setup: in questo contesto la scelta ricade sull’uso dei constraint.

Innanzitutto serve il modello di un motore: in questo tutorial ne sto usando uno gratuito, scaricabile direttamente dal sito di turbosquid a questo link. Il file ha estensione “max” perché proviene da 3DSMax: a questo link si può scaricare il suddetto ma in formato “fbx” (Fig. 4).

Preparazione della scena

Dopo aver importato il file in formato Fbx all’interno di una scena vuota, conviene organizzare gli oggetti perché, osservando nell’Outliner, sono tutti imparentati a livello gerarchico inferiore su un Locator rinominato “Default”. In aggiunta su quest’ultimo il RotateX ha valore di -90°. Questo tipo di struttura non è affatto congeniale allo scopo cui serve: l’ideale sarebbe scindere i vari elementi, così da poterli manipolare in maniera più funzionale e logica durante il processo di creazione del setup stesso.

Mentre si svolge questo passaggio, conviene assumere una nomenclatura adeguata, E’ chiaro che l’artista preposto al character setup non può conoscere i nomi di tutti gli elementi, per cui in questi casi si svolge una rapida ricerca sulla rete: mi sono imbattuto in questo sito, dove, oltre a spiegare il funzionamento meccanico, mostra in modo schematico i nomi delle varie parti (Fig. 5).

Adoperando l’Outliner selezionare tutti gli elementi contenuti in “Default” ed applicare Edit\Unparent: in alternativa si può usare Shift+p. Come risultato tutti gli oggetti perdono la relazione di dipendenza gerarchica col “Default” (nodo locator), per cui quest’ultimo si può tranquillamente rimuovere col tasto Canc.

Quando s’instaura una relazione di dipendenza gerarchica, com’era prima dell’unparent appunto, s’individuano due elementi: “padre” e “figlio”. L’uso delle dipendenze gerarchiche trasferisce i valori di trasformazione all’elemento figlio: avendo applicato l’Unparent il valore di -90 sul canale del RotateX è passato al figlio. Il fatto che gli oggetti ora abbiano questo valore già attribuito potrebbe creare dei problemi, subordinatamente al tipo di operazioni o connessioni che si andrebbero ad effettuare: di sicuro sarebbero comunque risolvibili, ma complicherebbero di più l’intero processo. Tendenzialmente quando si crea un character setup, l’ideale sarebbe iniziare con dei neutri ossia di 0 sulle trasformazioni (Fig. 6).

Conviene risolvere subito il problema ancor prima di agire coi vari strumenti di setup, semplicemente applicando sugli oggetti il Modify\Freeze Transformation su tutti e tre gli assi. Come risultato i canali di trasformazione del Translate e Rotate sono riportati a 0 per mentre ad 1 sullo Scale (Fig. 6).

Agendo quindi attraverso la selezione, bisogna individuare gli oggetti dell’albero motore per poi raggrupparli: su piattaforma Win avviene premendo Ctrl+g mentre su Mac è Cmd+g. In alternativa, dopo averli selezionati, basta applicare il comando Edit\Group.

A prescindere dalla strada intrapresa, si crea un gruppo: si tratta di un’entità fittizia che sta agendo da contenitore. Durante la creazione di un character setup, l’uso del “gruppo” acquisisce una funzione strategica: generando una relazione di dipendenza con gli elementi a lui figli, si possono trasferire le trasformazioni (traslazione, rotazione e scala) in maniera indiretta. In altre parole ruotando il gruppo, ruotano indirettamente tutti gli oggetti od elementi contenuti in esso.

Rinominare il gruppo in “Grp_albero_motore”.

Selezionare la singola biella e rinominarla in “Biella_01”: ripetere la stessa operazione anche sulle altre.

Selezionare il pistone corrispondente a “Biella_01” e tutti gli elementi di cui è composto: rinominarlo in “Pistone_01”. Ripetere la stessa operazione anche sugli altri.

Selezionare attraverso l’Outliner tutte le superfici restanti, e raggrupparle (Ctrl+g su Win oppure Cmd+g su piattaforma Mac): rinominare il gruppo in “Grp_altro”.

Per semplicità didattica il file di setup iniziale è scaricabile a questo link (Fig. 7). A questo punto con una nomenclatura unificata, sarà più semplice comprendere i vari passaggi, non prima però di aver avanzato qualche cenno preliminare sull’uso dei constraint, coadiuvati da esempi mirati.

Cenni preliminari sui constraint

Come ho già detto in apertura di articolo, consentono di creare una relazione di vincolo tra due elementi. Individuo quindi due elementi:

• Il vincolante ossia quello che si gestirà in animazione;
• Il vincolato, vale a dire l’elemento che subisce gli effetti del vincolo e che per tale motivo non sarà manipolato coi keyframe sui canali sopra cui ha subito il vincolo stesso.

Quando si usano i constraint, il tipo di correlazione che s’instaura, semplicemente trasferisce un valore di trasformazione.

Constraint Point

Instaura una relazione di vincolo sul canale della traslazione.

Scaricare la scena d’esempio a questo link: la scena mostra un cubo forato su quattro lati, ed una croce tubolare (Fig. 8). Su entrambe le superfici il pivot è stato collocato nel loro centro geometrico, e per facilitare la didattica, sono stati rispettivamente rinominati in “target” e “source”.

Selezionare il target (cubo) e mantenendo la pressione del tasto Shift aggiungere anche il source (croce): applicare il Constraint\Point accessibile dal menù set Rigging. Alle impostazioni di default il pivot della croce si allinea a quella del cubo: traslando quest’ultimo, la croce lo seguirà (Fig. 9).

Prima dell’applicazione del constraint, nelle sue proprietà si può eventualmente intervenire sul Maintain Offset e Constraint Axes: il primo preserva il distanziamento iniziale tra le superfici, mentre il secondo permette d’indicare il canale sopra cui agirà il vincolo.

Constraint Orient

Instaura una relazione di vincolo sul canale della rotazione.

Ho specificato volutamente che il trasferimento avviene in modo diretto, perché ad esempio, quando due elementi sono relazionati col vincolo dell’orientamento, manipolando il RotateX dell’elemento vincolante, lo stesso valore è in seguito trasferito all’omonimo canale ma sull’elemento vincolato.

Scaricare la scena d’esempio a questo link: la scena mostra due ingranaggi (Fig. 10). L’idea è di gestirne solo uno sulla rotazione, influenzando al contempo il movimento rotatorio del secondo.

Selezionare il target e mantenendo la pressione del tasto Shift, aggiungere anche il source_01: applicare il Constraint\Orient. Nelle sue proprietà assicurarsi che sia attivo il segno di spunta accanto alla voce Maintain Offset, e che il Constraint Axes sia configurato solo sull’asse Y.

Come risultato ruotando l’ingranaggio target ad esempio di 5°, si ottiene la medesima rotazione sia in segno che in valore sull’ingranaggio source (Fig. 11).

Sta accadendo perché la logica di base per questo tipo di constraint è trasferire il valore di trasformazione, esattamente nel modo in cui viene ricevuto.

Ovviamente nel caso specifico i due ingranaggi ruotando nella medesima direzione, restituiscono un risultato errato: il movimento in termini di valore è giusto, ma ad essere sbagliata è la direzione in cui sta avvenendo. Per l’esattezza il source dovrebbe ruotare in direzione opposta rispetto al target, ossia il valore che quest’ultimo riceve dovrebbe invertirsi nel segno.

Introduco il DG Nodes acronimo di dependency graph, che definisce l’insieme delle entità connesse tra loro denominate appunto “nodi”. Quest’ultimo rappresenta pertanto l’informazione di cui si compone, che fluisce in entrata (In) ed uscita (Out) attraverso il flusso dei nodi stesso. All’interno di ciascuno di essi le informazioni ricevute in entrata (Input) sono elaborate ed il risultato finale è reso disponibile nel relativo valore di uscita (Output).

E’ la construction history e rappresenta l’insieme di nodi che formano il grafico di dipendenza.

Ad esempio applicando il comando di estrusione (extrude) su una faccia poligonale, internamente si connette un nodo che comprende degli attributi, usati in seguito per regolare come debba avvenire l’estrusione stessa (Fig. 12).

Tornando alla gestione del constraint, Maya offre un comparto di nodi estremamente ampio a carattere matematico: tra essi sono presenti due nodi che permettono di variare il segno ad un valore. Parlo del nodo di Reverse e Multiply|Divide. Procedo con ordine, prendendo in esame quest’ultimo.

La gestione dei nodi prevede l’uso del Node Editor: si tratta di una finestra dedicata alla gestione nodale, e si accede ad essa dal menù Windows\Node Editor. Il nodo è descritto come un contenitore, e le diverse informazioni si connettono in modo dinamico attraverso operazioni di drag & drop (trascina e rilascia). Ridotto all’essenziale il flusso di lavoro si basa sul trascinamento di frecce colorate sui vari parametri di Input ed Output verso ciascuno di essi.

Nell’ambiente di lavoro selezionare la superficie del target ed assieme al tasto Shift aggiungere anche il source: nel Node Editor premere sull’icona dell’Output Connection Fig. 13). Si caricano nell’area lavoro i nodi, in cui è visibile il flusso di dati che dal target fluisce verso il source, passando per il nodo “orient constraint”. Selezionare questi tre nodi e premere il tasto “3”: la visualizzazione dei contenitori si espande, mostrando con esattezza i canali connesso attraverso il constraint.

Come ho anticipato poc’anzi, serve un nodo capace d’invertire il segno del valore prima che giunga al source. Premere il tasto Tab: si apre il campo di ricerca, E’ auto compilante, per cui basta iniziare a digitare “multip”, per vedere gradualmente filtrare l’elenco dei risultati. Confermare col tasto invio oppure premere su di esso col sinistro del mouse: in entrambi i casi nell’ambiente di lavoro del node editor si crea un nuovo nodo. Espandere anche su quest’ultimo la sua visualizzazione col tasto “3” (Fig. 14).

Bisogna frapporlo tra il nodo del constraint e quello della superficie source: non resta che eseguire le opportune connessioni. Porre il cursore del mouse sopra il canale Constraint Rotate Y del nodo di constraint, e, premendo il tasto sinistro del mouse, trascinarlo sopra l’InputInputX del Multiply|Divide. Non appena si rilascia il tasto del mouse s’instaura la connessione. In automatico si creerà anche un altro nodo, preposto a convertire la natura dei valori affinché possano essere compatibili ma al momento non interessa allo scopo: ad ogni modo non deve essere cancellato.

Lo slot dell’InputX (poteva tranquillamente essere anche l’InputY o l’InputZ) ospita in quest’istante il valore che proviene dal constraint: agendo in modo analogo, trascinare la linea di collegamento dall’Output\OtuputX del Multiply|Divide sul RotateY del source (Fig. 15).

Accedere alle sue proprietà: avendo passato i valori attraverso lo slot dell’InputX, si deve configurare la prima colonna. L’Input1X ospita il valore che proviene dal constraint, mentre L’Input2X è il valore che bisogna immettere. Dovendo invertire di segno il valore che giungerà poi al source, in questo campo bisogna digitare “-1” (Fig. 16).

Ruotando il target nel workspace, il source stavolta ruota in senso contrario: tuttavia il risultato ancora non è esatto. Ciò sarebbe stato qualora entrambi avessero avuto la stessa dimensione, mentre nel caso specifico sono di dimensioni differenti. Per l’esattezza il source è grande la metà rispetto al target: vuol dire quindi che quando il target compie un giro completo di 360°, il source lo ha compiuto doppio.

Il discorso è quindi prettamente matematico: nell’Input2X basta correggere il valore inserendo “-2” (Fig. 17). Come risultato il segno di valore che giunge al source s’inverte, e per rendersene conto basta ruotare sull’asse Y l’ingranaggio target: il vincolo sta restituendo il risultato atteso.

Constraint Scale

Instaura una relazione di vincolo sul canale della scala.

Constraint Aim

Instaura una relazione di vincolo sul canale della rotazione.

All’apparenza potrebbe sembrare identico al constraint orient, ma in questo caso agisce su tutti e tre gli assi simultaneamente restituendo un vettore.

Scaricare la scena d’esempio a questo link: la scena mostra una sfera, ed un cubo con una protuberanza conica solo su una faccia ed una pinna su un’altra faccia (Fig. 18). L’idea è di manipolare la sfera, affinché la punta del cono sia orientata sempre verso di essa mentre la pinna verso l’alto.

La sfera rappresenta quindi l’elemento che vincola (target) mentre quella del cubo corrisponderebbe all’elemento vincolato (source). Dopo aver individuato gli elementi, non resta che procedere alla corretta selezione, per poi applicare il comando Constraint\Aim.

Prima di applicarlo, mi soffermo per un istante sulle sue impostazioni. Quando si usa questo constraint, è necessario individuare due informazioni ben precise, che risiedono sul source: mi riferisco all’asse che deve allinearsi col target affinché lo punti sempre (aim vector), ed all’asse che dovrà allinearsi verso l’alto (up vector).

Il primo corrisponde alla zona del cubo in cui è presente la protuberanza conica, mentre il secondo corrisponde alla pinna. Sia l’Aim Vector che l’Up Vector sono composti da tre campi a valore, indicanti rispettivamente l’asse X, Y e Z: la loro configurazione determina la direzione dentro cui avverrà l’allineamento.

Per capire come configurare l’Aim Vector, bisogna selezionare il source ed attivare il Move Tool, accessibile velocemente premendo il tasto “w” (Fig. 19). In termini di coordinate globali l’Aim Vector corrisponde all’asse Y, perché è lungo quell’asse che c’è la protuberanza conica, Configurare pertanto il constraint nel seguente modo: [0,1,0].

Agendo in modo analogo si estrapola l’Up Vector: non può essere chiaramente lo stesso del precedente, altrimenti andrebbero in conflitto, e nell’esempio in questione corrisponde all’asse Z. L’Up Vector si configura quindi inserendo i seguenti valori: [0,0,1].

Il valore 1 è unitario, e nulla vieterebbe d’inserire anche valori frazionati: chiaramente a risentirne sarebbe l’orientamento, perché all’atto pratico si sta indicando un vettore. Configurando l’Aim ed Up Vector si sta indicando sia la direzione che il verso dell’allineamento.

Assicurarsi che sia disattivato il segno di spunta accanto alla voce Maintain Offset, e premere su Apply: se tutto è stato svolto correttamente, quando si muove liberamente la sfera, il cubo andrà sempre orientandosi. Mentre ciò accade, la punta è rivolta verso la sfera e la pinna sarà invece rivolta verso l’alto (Fig. 20). Nel caso in cui quest’ultima fosse verso il basso, nell’Attribute Editor (accessibile velocemente premendo Ctrl+a o Cmd+a su piattaforma Mac) basterà accedere alle proprietà del constraint, per correggere l’Up Vector da [0,0,1] a [0,0,-1].

Constraint Parent

Instaura una relazione di vincolo sulla traslazione e rotazione.

Torna utile soprattutto in animazione, quando un personaggio deve afferrare un oggetto: adoperando questo tipo di constraint, si può specificare il momento nell’arco temporale in cui l’elemento vincolato debba ereditare le trasformazioni (traslazione e rotazione) da parte dell’elemento vincolante.

Creazione del setup: albero motore

Dopo aver analizzato sommariamente l’uso dei constraint, e capito a livello basico il loro funzionamento, si può iniziare col creare il setup. Riprendo l’analisi dal file di setup iniziale scaricabile a questo link, dentro cui era stata attribuita una prima bozza di nomenclatura.

Il primo passo prevede la corretta posizione del pivot, affinché l’intero gruppo dell’albero motore possa ruotare correttamente attorno ad un punto fisso. Per estrapolarlo mi soffermo sulla manovella, in cui identifico la superficie del “mozzo” (Fig. 21). Ha una topologia a tratti irregolare ma, essendo di forma cilindrica, sarà facile individuarne il centro.

Applicare il Modify\Center Pivot: quest’ultimo si allinea al suo centro geometrico. Deve corrispondere al pivot del “grp_albero_motore”, e le strade attuabili sono molteplici: mi limito a fornire solo la più immediata.

Selezionare la superficie identificata come “mozzo”, ed accedere al suo Attribute Editor. Spostarsi nella scheda omonima, che per default è attiva, ed espandere la sezione Pivots\World Space. Annotare i valori sul piano XY (Fig. 22).

Selezionare il “grp_albero_motore” ed anche in questo caso, dopo aver aperto la finestra dell’Attribute Editor, spostarsi nella sezione Pivots\World Space. Immettere i valori precedentemente annotati.

Ad ogni modo senza doverli annotare realmente su carta, passando da una selezione ad un altra, si può eseguire rapidamente il copia|incolla del valore direttamente nel campo corrispondente.

Giunti sin qui per semplificare la gestione dell’albero motore, l’idea è di creare un controllo esterno. Il vantaggio che se ne trae, riguarda principalmente la velocità con cui si accederà allo stesso, rispetto il dover selezionare un gruppo attraverso l’Outliner oppure dall’ambiente di lavoro.

Creare una primitiva Circle dal menù Create\Nurbs: allinearla prendendo come riferimento il pivot dell’albero motore. Per eseguire correttamente questo passaggio, si possono riciclare i valori precedentemente estrapolati: nella fattispecie corrisponde a 2.7926.

Ruotarla di 90°, agendo sul canale del RotateX: rimuovere la sua construction history (Edit\Delete by Type\History) perché irrilevante allo scopo del tutorial. Rinominarlo in “ctrl_albero_motore” (Fig. 23).

Avendo manipolato i canali della traslazione e rotazione, conviene congelarli a valori neutri: si tratta di un passaggio molto spesso fondamentale per la corretta riuscita di un setup qualunque esso sia. Con la primitiva cerchio selezionata, applicare il Modify\Freeze Transformation: come risultato i canali del Translate e Rotate ritornano a 0, ed al contempo mantiene la sua posizione ed orientamento,

Giunti sin qui, l’idea è di veicolare la rotazione dell’albero motore sul cerchio: in altre parole ruotando quest’ultimo, l’albero motore ruoterà attorno ad un punto fisso che corrisponde al suo stesso pivot. Quest’operazione si risolve col Node Editor.

Dopo averlo aperto, si deve caricare il “ctrl_albero_motore” ed il “grp_albero_motore”. Come già svolto in precedenza, bisogna connettere due canali tra loro, affinché il valore venga veicolato verso l’elemento che interessa. Nell’esempio in questione la connessione riguarda il Rotate\RotateZ del “ctrl_albero_motore” coll’omonimo canale sul “grp_albero_motore” (Fig. 24).

Ruotando quindi il “ctrl_albero_motore” sulla rotazione Z, a ruotarsi sarà anche l’intero gruppo “grp_albero_motore”. Qualora il senso della rotazione dovesse essere invertito, basterà agire in modo analogo a quanto già svolto sul constraint orient, nel frapporre il nodo di Reverse.

A questo link è disponibile un file di work in progress.

Creazione del setup: biella – prima parte

La manovella e la biella sono incernierate tra loro in un punto detto “bottone”: quest’ultimo ruota in direzione oraria od antiorario ma sempre in accordo rispetto all’albero motore. Il primo passo riguarda la corretta posizione del pivot. Dopo aver individuato la superficie del “bottone”, centrare il pivot (Fig. 25): accedere al suo Attribute Editor, ed estrarre il valore di coordinata Y del pivot. Annotarlo.

Avanzo i problemi da risolvere. La biella segue il movimento rotatorio della manovella, restando incernierata ad essa su un punto fisso detto “testa di biella”: l’altra estremità è invece connessa al pistone in un punto detto “piede di biella” (Fig. 26). Il “bottone” e la “testa di biella” devono quindi corrispondere, affinché la biella possa compiere il suo movimento correttamente: mentre ciò avviene, bisogna assicurarsi che l’altra estremità resti connessa al pistone.

Riguardo al primo punto di analisi, serve un riferimento capace di estrapolare dei valori di coordinata dal movimento rotatorio della manovella. La scelta cade sul Locator: si tratta di un elemento fittizio che per tale natura non è visibile in rendering: crearlo dal menù Create ed allinearlo affinché il canale del TranslateY abbia il valore precedentemente estratto (Fig. 27).

Rinominarlo in “loc_reference_bottone”. L’idea è di usare il constraint per vincolare quest’ultimo al movimento rotatorio del “ctrl_albero_motore”: sarà il riferimento attraverso cui estrarre in seguito i valori di coordinata per il corretto movimento della biella. Procedo con ordine.

Selezionare il “loc_reference_bottone” ed applicare il Modify\Freeze Transformation: i valori di trasformazione diventano neutri. A seguire selezionare “ctrl_albero_motore” e col tasto Shift aggiungere alla selezione “loc_reference_bottone”: applicare il comando Constraint\Parent. Assicurarsi che nelle sue opzioni sia attivo il segno di spunta sulla voce Maintain Offset.

Come risultato quando si ruota il “ctrl_albero_motore”, per effetto del vincolo di parentela il “loc_reference_bottone” lo segue nel movimento rotatorio, ereditandone le trasformazioni. Più esattamente eredita i valori di traslazione, ubicati sul piano bidimensionale XY.

Semplifico ancor più il concetto, soprattutto per capire meglio il motivo della creazione del locator. Per un istante selezionare la biella, ed agendo col Move Tool traslarla simultaneamente sugli assi XY (Fig. 28): in linea teorica muovendola in modo circolare, si andrebbe a replicare manualmente il movimento che dovrebbe eseguire. E’ chiaro che in questo modo il movimento risulterebbe poco preciso. Adoperando invece il locator ossia il “loc_reference_bottone”, si possono attingere ai valori corretti di coordinata, affinché automaticamente la biella possa eseguire il giusto movimento rotatorio.

Nel passo successivo bisogna quindi veicolare i suddetti verso la biella, prendendo come fulcro la “testa di biella”: prima però è necessario regolare meglio la posizione del pivot sulla biella stessa.

Ad inizio paragrafo era stata usata la superficie del bottone, per individuare in termini di coordinata globale la posizione del punto detto “testa di biella”: ebbene questo valore deve essere riportato come pivot per la “biella_01” (Fig. 29). Si tratta di un’operazione risolvibile rapidamente nell’Attribute Editor, ed è stata già svolta diverse volte in precedenza: non mi soffermo più di tanto su quest’aspetto e proseguo.

Selezionare il “loc_reference_bottone” e col tasto Shift aggiungere alla selezione la superficie “biella_01”: applicare il comando Constraint\Point: assicurarsi innanzitutto che nelle sue opzioni il vincolo influenzi solo gli assi X ed Y (la loro scelta dipende dal modo in cui la stessa superficie è orientata nel workspace). Bisogna inoltre assicurarsi che sia attivo il segno di spunta sulla voce Maintain Offset, affinché dopo il vincolo la biella continui a preservare la sua reale posizione.

Come risultato, partendo dall’inizio, si ottiene quanto segue:

• ruotando il “ctrl_albero_motore” sulla rotazione Z, si ruota anche l’intero gruppo “grp_albero_motore”: il fulcro è sul “mozzo”.
• il “loc_reference_bottone” eredita le informazioni delle trasformazioni in termini di posizione, veicolate successivamente verso la biella. Il fulcro è sul “bottone”.

La prima parte di configurazione della biella è conclusa. A questo link è disponibile un file di work in progress.

Creazione del setup: pistone – biella

La biella ed il pistone sono imperniati tra loro in un punto detto “piede di biella”.

Adoperando l’Outliner, selezionare la superficie del “piede_di_biella_01”, che è accessibile come elemento figlio sul “pistone_01” (Fig. 30): applicare il Modify\Center Pivot, Com’è stato già svolto in precedenza, estrarre dall’Attribute Editor il valore di coordinata XY del pivot ed annotarlo. Trasferirlo sul “pistone_01”.

Allo stato attuale durante il movimento rotatorio, la biella è sempre orientata in verticale: essendo imperniata sul pistone, bisogna allinearla correttamente. Il punto in cui tale allineamento deve avvenire è il “piede di biella”, ossia laddove biella e pistone s’imperniano assieme.

Per allinearla correttamente si usa il vincolo di puntamento: procedo con ordine. Adoperando l’Outliner selezionare “pistone_01” e col tasto Shift aggiungere anche “biella_01”: quest’ultimo ricordo che ha il pivot nel punto detto “piede di biella”. Applicare il Constraint Aim, configurandolo come segue (Fig. 31):

• L’Aim Vector corrisponde all’asse Y della biella, per cui i campi del vettore si configurano inserendo [0,1,0];
• L’Up Vector corrisponde all’asse X della biella, quindi è [1,0,0];
• Assicurarsi che sia attivo il segno di spunta sulla voce Maintain Offset;
• Premere su Apply.

Come risultato la biella punta sempre verso il pistone, sebbene quest’ultimo sia ancora immobile: dovrà muoversi in modo rettilineo sull’asse Y, e mentre ciò avverrà, dovrà allinearsi sempre rispetto al “piede di biella”. Il tutto si traduce in un valore di coordinata Y, che deve giungere al “pistone_01”. Serve un riferimento: procedo con ordine.

Adoperando un Locator, usare il valore precedentemente estrapolato per il “piede di biella” per posizionarlo correttamente. Applicare il Modify\Freeze Transformation e rinominarlo in “loc_reference_piede_di_biella” (Fig. 32).

Il movimento biella-manovella trasforma i valori da un movimento rotatorio ad uno rettilineo, per cui questo locator sarà usato per estrarre i valori di coordinata Y durante il movimento rotatorio della biella.

Innanzitutto selezionare “biella_01” e col tasto Shift aggiungere anche “loc_reference_piede_di_biella”: applicare il Constraint\Parent, Assicurarsi che sia attivo il segno di spunta accanto alla voce Maintain Offset, e che il vincolo di parentela influenzi gli assi XY. Agendo in questo modo mentre la biella esegue il suo movimento rotatorio, i valori di coordinata XY sono passati al “loc_reference_piede_di_biella”, per cui resterà allineata allo stesso movimento rotatorio della biella.

Ora che il riferimento in termini di coordinate è stato creato, non resta che agire sul pistone. Selezionare il “loc_reference_piede_di_biella” e col tasto Shift aggiungere anche “pistone_01”: applicare il Constraint\Parent, Assicurarsi che sia attivo il segno di spunta accanto alla voce Maintain Offset, e che il vincolo di posizione influenzi stavolta solo l’asse Y proprio perché deve muoversi in modo rettilineo.

Come risultato, partendo dall’inizio, si ottiene quanto segue (Fig. 33):

• ruotando il “ctrl_albero_motore” sulla rotazione Z, si ruota anche l’intero gruppo “grp_albero_motore”: il fulcro è sul “mozzo”.
• il “loc_reference_bottone” eredita le informazioni delle trasformazioni in termini di posizione, veicolate successivamente verso la biella. Il fulcro è sul “bottone”.
• Mentre la biella esegue il suo movimento rotatorio, influenza la posizione sull’asse XY di “loc_reference_piede_di_biella”, verso cui il “pistone_01” ha un vincolo di posizione sempre sull’asse Y.

I valori di coordinata del movimento rotatorio sono stati trasformati in rettilineo: come risultato la biella punta sempre verso il pistone, mentre quest’ultimo si muove in modo rettilineo (Fig. 33). A questo link è disponibile un file di work in progress.

Giunti sin qui non resta che replicare i vincoli di trasformazione anche sugli altri elementi, per completare il setup.

Come risultato la biella punta sempre verso il pistone, mentre quest’ultimo si muove in modo rettilineo (Fig. 34).

Channel Control

Dopo aver terminato il setup, è buona regola ripulire i vari controlli creati dai canali che non servono. Nell’esempio in questione l’unico controllo è “ctrl_albero_motore”, perché dev’essere gestito solamente sul RotateZ. Si tratta di un’operazione che faciliterà in seguito l’animazione, soprattutto perché nel Graph Editor saranno presenti solo le curve di animazione interessate.

Selezionare “ctrl_albero_motore” e richiamare il comando Windows\General Editors\Channel Control. Si apre una finestra scissa in tre colonne:

• quella a sinistra mostra gli elementi visibili nel channel box, che per default possono ricevere keyframe;
• quella al centro mostra i canali che saranno nascosti dal channel box e che non potranno ricevere keyframe;
• quella a destra mostra i canali visibili nel channel box ma che non potranno ricevere keyframe.

Dalla colonna di sinistra selezionare tutti i canali eccetto RotateZ (Fig. 34).

Quest’operazione si attua col sinistro del mouse assieme al tasto Ctrl o Cmd su piattaforma Mac oppure col tasto Shift. La loro alternanza permette nel primo caso di eseguire delle selezioni specifiche di tipo additivo o sottrattivo, mentre nel secondo d’indicare un intervallo nella lista, dentro cui inglobare più elementi simultaneamente.

Premere sul pulsante Move>: le voci selezionate saranno rimosse in visibilità dal channel box.

La scena finale è accessibile a questo link.