La Guida a Blender 4 [v2.0]

[CyberJabba]

11.6 - 'Curve Resolution' e considerazioni finali.

Concludiamo il Capitolo dedicato alle Curve parlando di due voci dedicate alla loro risoluzione.

Dopo aver creato e selezionato una curva ed esservi spostati nell 'Object Data Properties', subito dopo i tasti 2D e 3D, troverete infatti le voci 'Resolution Preview U' e 'Render U'. Come facilmente intuibile, queste due voci si riferisco nalla risoluzione della curva. Agendo su di esse infatti, potremo aumentare o diminuire la sua definizione, rispettivamente nella '3D view' e nel 'Rendering' finale. Di default, il valore della 'Resolution Preview U' è impostata a '12', mentre quella della 'Render U' a '0' e se non avete particolari esigenze, potete lasciare quest'ultima così. Con valore '0' infatti, la 'Render U' prenderà come valore direttamente quello impostato nella 'Resolution Preview U'. (Fig.226).

[/url]
Fig.226



Il valore di 'Resolution Preview U', ha però anche un altro fattore chiave. Quando convertiamo una 'Curva' in 'Mesh', il numero di facce e vertici di quest'ultima, saranno strettamente legati a questo valore.

Partendo infatti da una curva 'Bezier' (composta essenzialmente da due nodi, uno iniziale ed uno finale) e convertendola in Mesh con valore 'Resolution Preview U' pari a '12', il risultato sarà una linea curva composta da '12' segmenti (Edge) e '13' vertici. (Fig.227).


Fig.227



Di seguito un esempio di 'BezierCircle' con applicato in modalità 2D, un 'Fill Mode' di tipo 'Both' e un 'Extrude' pari a '1'... (Fig.228).


Fig.228

... e poi successivamente convertito in 'Mesh', prima con 'Resolution Preview U' pari a '12' e poi con 'Resolution Preview U' pari a '64'. (Fig.229)


Fig.229



Detto questo, non finirò mai di ribadire l'importanza delle curve in Blender e nella grafica 3D in generale. Le tipologie di utilizzo sono davvero molteplici, si va infatti dalla modellazione classica, all'uso abbinato ai 'Modifiers' (Modificatori), ai 'Constraint' (Costrittori), per finire all'animazione.



Di seguito alcuni lavori realizzati esclusivamente tramite l'utilizzo di curve. Fig.230


Fig.230

[CyberJabba]

12.1 - Introduzione ai 'Modificatori'.


Iniziamo questo nuovo Capitolo parlando finalmente dei 'Modifier', una serie di strumenti dedicati alla modifica non distruttiva degli oggetti presenti nella scena. Esiste un gran numero di 'Modificatori', divisi essenzialmente in 5 macrocategorie. (Fig.231)


Fig.231



Quelli di cui parleremo in questa guida però, almeno per il momento, saranno inizialmente dodici. Nello specifico, si tratta di otto modificatori appartenenti alla categoria 'Generate' e quattro appartenenti a quella 'Deform.'

Di seguito un'immagine riassuntiva dei modificatori che vedremo insieme. (Fig.232)


Fig.232



Per quanto riguarda la loro gestione vi rimando al Capitolo '10.5 - La Properties 'MODIFIERS'', in quanto l'argomento è stato già affrontato.

[CyberJabba]

12.2 - Il Modificatore 'Array' e introduzione agli oggetti 'Empty'.

Il modificatore 'Array' crea un 'Matrice' di oggetti partendo da quello iniziale, con ciascuna copia spostata nello spazio in diversi orientamenti possibili. E' utile per creare forme ripetitive (esempio un muro di mattoni) o per sviluppare oggetti di grandi dimensioni rapidamente. Per ogni oggetto possono essere applicati più modificatori 'Array' in cascata, come nel caso si voglia creare una matrice di mesh in tutte e tre le dimensioni.

Per inserire un modificatore 'Array' è sufficiente in modalità 'Object Mode' selezionare un oggetto e poi dopo essersi spostati nella 'Properties Modifier', premere il pulsante 'Add Modifier > Generate > Array'. (Fig.233)


Fig.233

Una volta aggiunto il modificatore, per creare un array composto da esempio tre soli oggetti, sarà sufficiente impostare 'Count' a '3' e agire nel menu 'Relative Offset', portando la voce 'Factor X' da '1' a '1.1', in modo da distanziare leggermente gli oggetti tra loro. (Fig.234)


Fig.234

E' possibile anche effettuare un 'Array' non lineare, agendo sulla voce 'Factor' e modificando i valori su tutti e tre gli assi. (Fig.235)


Fig.235



Come già anticipato, possiamo anche aggiungere più 'Array' in cascata e creare così una matrice a tre dimensioni. Vediamo come.

Partite dal modificatore 'Array' creato in precedenza e modificatelo portando il valore 'Count' a '10', le voci 'Factor X' a '1.1' e 'Y' e 'Z' a '0', poi duplicate il modificatore tramite il piccolo menu a comparsa. (Fig.236)


Fig.236

Nel modificatore appena duplicato, modificate nuovamente la voce 'Factor X' portandola a '0', 'Y' a '1.1' e 'Z' a '0'. (Fig.237)


Fig.237

Duplicate nuovamente il modificatore e questa volta impostate la voce 'Factor X' e 'Y' a '0' e quella 'Z' a '1.1'. Fatto questo, dovreste ritrovarvi in una situazione simile a quella mostrata in Fig.238.


Fig.238

In questo modo, l'array è stato effettuato in tutte e tre dimensione creando di fatto un cubo, composto dalla bellezza di 1000 cubi più piccoli (10x10x10).





Vediamo un altro utilizzo tipico del modificatore 'Array', quello comunemente chiamato anche 'Circular Array', cioè un 'Array' effettuato su base circolare. Con l'occasione introduciamo finalmente anche l'uso di un altro componente fondamentale di Blender e nella Grafica 3D in generale, l'oggetto 'Empty'.

L'Oggetto 'Empty', come dice il nome, è un oggetto vuoto e nonostante abbia caratteristiche comuni ad altri oggetti, la sua peculiarità è quella di essere completamente ignorato dal render finale. Proprio per questo, si presta a particolari utilizzi, diventando di fatto un oggetto di 'servizio'. Esistono più oggetti di tipo 'Empty', ma sostanzialmente quello che cambia è solo la loro forma e/o visualizzazione a schermo. L'oggetto 'Empty' per antonomasia è il 'Plane Axes', che una volta inserito nella scena, si presenterà come un crocino a tre dimensioni. Per aggiungerlo è sufficiente un 'Add > Empty > Plane Axis' (Ctrl A). (Fig.239)


Fig.239





Vediamo come funziona. Partendo dall'ultimo esempio, eliminate i due 'Array' duplicati precedentemente (Array.001 e Array.002) tramite le icone a forma di 'X', poste alla destra della finestra di ciascun modificatore. (Fig.240)


Fig.240

Disattivate il menu 'Relative Offset', impostate momentaneamente la voce 'Count' a '1' e tramite 'Add > Empty > Plane Axis' (Ctrl A) aggiungete l'oggetto 'Empty' nella scena. (Fig.240b)


Fig.240b

Selezionate il cubo, spostatelo leggermente di lato lungo l'asse '-Y' e spostate il suo 'Pivot Point' al centro della scena tramite 'RMB > Set Origin > Origin to 3D Cursor'. (Fig.241)


Fig.241

Attivate il menu 'Object Offset', caricate alla voce 'Object' l'oggetto 'Empty' appena creato  e portate la voce 'Count' a '12'. (Fig.242)


Fig.242

Adesso, dopo aver selezionato l'oggetto 'Empty', ruotatelo di '30°' lungo l'asse 'Z' e guardate cosa succede. Praticamente dovreste ritrovarvi in una situazione simile a quella di Fig.243.


Fig.243

Per fare ulteriori prove, spostate leggermente l'oggetto 'Empty' lungo l'asse 'Z', diminuite la sua rotazione a '20°' e aumentate il valore 'Count' a '36'. (Fig.244)


Fig.244

Di seguito un altro esempio dove è stato effettuato anche un 'resize' (sempre dell'oggetto 'Empty') (Fig.245)


Fig.245

Per quanto riguarda il modificatore 'Array' per il momento è tutto, fate altre prove in autonomia e scoprite tutte le varie possibilità offerte da questo potentissimo strumento.

[CyberJabba]

12.3 - Il Modificatore 'Bevel'.

Siamo giunti a parlare del modificatore 'Bevel' e sicuramente qualcuno di voi, dopo aver letto 'Bevel' avrà avuto un déjà-vu. Effettivamente il 'Bevel' è stato già trattato nel paragrafo  9.2 - Il comando 'Bevel' e come il suo omonimo, anche il modificatore ha lo stesso scopo, smussare gli angoli di una 'Mesh'.

In questo caso però, nonostante il comportamento sia del tutto analogo, c'è l'enorme differenza che mentre il primo era di tipo distruttivo, questo essendo un modificatore, permette modifiche di tipo non distruttivo e quindi di fatto, sia interattive, che reversibili nel tempo. Fatta questa breve premessa vediamo il suo funzionamento.



Con il cubo selezionato aggiungete il modificatore tramite 'Add Modifier > Generate > Bevel' ritrovandovi in una situazione simile a quella mostrata in Fig.246.


Fig.246

A questo punto, sarà possibile aumentare il grado di smussatura dei bordi tramite la voce 'Amount' e il numero delle sue suddivisioni tramite la voce 'Segments'. Già che ci siete, ricordatevi di abilitare l' 'Auto Smooth' tramite un 'RMB' sulla mesh. (Fig.247)


Fig.247

Nel menu 'Profile' attraverso la voce 'Shape' potrete variare la forma dello smusso. (Fig.248)


Fig.248

Passando dalla voce 'Superellipse' a quella 'Custom' sarete addirittura in grado creare un vostro profilo personalizzato. (Fig.249)


Fig.249



Avrete sicuramente notato come variando i parametri del modificatore, le modifiche vengano applicate a tutta la mesh, come fare quindi per circoscriverle solo a determinati elementi?

Per farlo dovrete passare prima in modalità 'Edit Mode' e dopo aver cambiato la voce del modificatore  'Limit Mode' in 'Weight' e selezionato gli 'Edge' interessati, agire sulla voce 'Bevel Weight' del menu 'Transform' della 'Sidebar'. Tutti gli 'Edge' interessati dal 'Weight' cambieranno colore in azzurro. (Fig.250)


Fig.250

Nel caso voleste applicare il 'Bevel' ai vertici anzichè agli spigoli, sarà sufficiente, sempre nella finestra del modificatore, spostare la selezione dalla voce 'Edges' a quella 'Vertices' e poi sempre nella 'Sidebar', invece di agire sulla voce 'Bevel Weight', modificare quella 'Mean Bevel Weight' poco più sopra. (Fig.251)


Fig.251



Per quanto riguarda il modificatore 'Bevel' è tutto, vi rimando al prossimo, il modificatore 'Boolean'.

[CyberJabba]

12.4 - Il Modificatore 'Boolean'.

Siamo giunti a parlare del modificatore 'Boolean' che utilizza gli operatori 'And', 'Or' e 'Not' per compiere operazioni di unione, sottrazione e intersezione su Mesh. Di seguito un esempio di funzionamento dei tre operatori booleani messi a confronto tramite l'utilizzo di due semplici figure geometriche. (Fig.252). Vediamo come utilizzare il modificatore 'Boolean'.


Fig.252



Partendo dalla scena di default, aggiungete una mesh di tipo 'UV Sphere' e spostatela come in Fig.253


Fig.253

Sempre con la mesh 'Sphere' selezionata, spostatevi nella 'Object Properties' e dopo aver aperto il menu 'Viewport Display', alla voce 'Display As' selezionate 'Bounds'. In questo modo, la mesh che utilizzeremo per effettuare le nostre operazioni booleane, non intralcerà la vista. In alternativa potete utilizzare anche la voce 'Wireframe', il concetto è il medesimo, utilizzate quindi quella che preferite. (Fig.254)


Fig.254

Adesso, dopo aver selezionato il cubo ed ed esservi spostati nella 'Modifiers Properties', aggiungete il modificatore 'Boolean' (Add Modifier > Generate > Boolean) e alla voce 'Object' selezionate l'unica mesh in elenco (Sphere). A questo punto dovreste trovarvi nella situazione mostrata in Fig.255.


Fig.255

L'operazione è conclusa e selezionando la sfera e spostandola nello spazio, dovreste già vedere il risultato in tempo reale. Fate le vostre prove e con l'occasione attivate anche l' 'Auto Smooth' ad entrambe le 'Mesh'. (Fig.256)


Fig.256



In calce, il risultato delle altre due operazioni booleane 'Union' ed 'Intersect' messe a confronto (Fig.257)


Fig.257

[CyberJabba]

12.5 - Il Modificatore 'Mirror'.

Il modificatore 'Mirror' specchia una mesh lungo gli assi locali X, Y e Z attraverso la sua stessa 'Origine'. Anche il modificatore 'Mirror', come quello 'Bevel', ha un suo omonimo della 'Edit Mode' e come in quel caso, la differenza sostanziale è che per mezzo del modificatore, è possibile effettuare modifiche non distruttive e quindi reversibili nel tempo.



Vediamo il suo funzionamento con un esempio pratico. Cancellate il cubo di default e inserite al suo posto una mesh di tipo 'Cylinder'. (Fig.258)


Fig.258

Con la mesh 'Cylinder' selezionata, aggiungete il modificatore 'Mirror' ('Add Modifier > Generate > Mirror').  (Fig.259)


Fig.259

Adesso, entrate in modalità 'Edit Mode' e dopo aver selezionato tutta la mesh, spostatela leggermente di lato, lungo l'asse 'X'. Il 'Mirror' è già in funzione. (Fig.260)


Fig.260

Proseguiamo con l'esempio. Selezionate una faccia della mesh ed estrudetela verso l'interno, lungo l'asse 'X', fino ad ottenere un risultato come in Fig.261. Come si può notare però, la faccia appena estrusa, prima interseca e poi oltrepassa quella del 'Mirror'.


Fig.261

Per ovviare questo inconveniente, selezionate la voce 'Clipping' del modificatore e muovete nuovamente la faccia lungo l'asse 'X' fino a farla coincidere con quella del 'Mirror'. Assicuratevi sia selezionata anche la voce 'Merge' in modo da fondere i vertici tra loro. (Fig.262)


Fig.262

Adesso riselezionate tutta la mesh (sempre in 'Edit Mode') e spostatela questa volta indietro, lungo l'asse 'Y', avendo cura alla voce 'Axis' del modificatore, di aggiungere anche il parametro 'Y'. In questo modo la mesh originale verrà specchiata su due assi e non più su uno. (Fig.263)


Fig.263

Riselezionate una faccia della mesh originale ed effettuate una nuova estrusione, assicurandovi anche in questo caso di aver abilitato la voce 'Clipping'. (Fig.264)


Fig.264

Ora selezionate la faccia superiore del cilindro d'origine e dopo aver effettuato un 'Insect' (i), selezionate tutte le facce del perimetro esterno (aiutatevi con il tasto 'Alt'). Successivamente, tramite il menu 'Select' (posto in alto a sinistra della 3D View), selezionate la voce 'Checker Deselect'. In questo modo, le facce verranno selezionate in maniera alternata(Fig.265)


Fig.265

Infine effettuate un 'Extrude' (E) verso l'alto. Dovreste ritrovarvi in una sistuazione simile a Fig.266.


Fig.266

Arrivati a questo punto, il funzionamento del modificatore 'Mirror' dovrebbe essere chiaro, specchiare modifiche ad una mesh lungo uno o più assi, il tutto in base alla posizione del 'Pivot Point' della mesh stessa. E' questo il motivo per cui tutti gli spostamenti della mesh sono stati effettuati in modalità 'Edit Mode'. In questo modo infatti, il 'Pivot Point' non ha seguito la mesh, ma è rimasto sempre ancorato al centro del mondo 3D. Ovviamente nulla vieta di fare la stessa cosa lavorando in 'Object Mode' e poi modificare il 'Pivot Point' manualmente,  ma nel primo caso, tutto risulta più piacevole e veloce.



Di seguito due esempi tipici di modellazione tramite l'utilizzo del modificatore 'Mirror' con 'Clipping' attivato. Fig.267


Fig.267

[CyberJabba]

12.6 - Il Modificatore 'Screw'.

Il modificatore 'Screw', letteralmente 'Vite', permette molteplici utilizzi, si va dalla semplice rotazione di una curva o di un profilo mesh a 360°, fino alla creazioni di molle e perchè no, filettature per viti. Vediamo come funziona.

Eliminate il cubo di default, aggiungete una Curva di tipo 'Path', ruotatela di '90°' lungo l'asse 'Y' e spostatevi in vista 'Front' (1). (Fig.268)


Fig.268

Adesso, dopo essere entrati in modalità 'Edit Mode', spostate i vertici e aggiungetene qualcuno per mezzo dei comandi 'Extrude' e 'Subdivide', cercando di ottenere una curva simile a quella mostrata in Fig.269.


Fig.269

Fatto questo, aggiungete il modificatore 'Screw' ('Add Modifier > Generate > Screw'), impostando alla voce 'Axis' l'asse 'X' e ottenendo un risultato simile a quello mostrato in figura Fig.270.


Fig.270

Come appena visto, attraverso l'uso del modificatore 'Screw' unito a quello di una semplice curva, è stato possibile creare un vaso in poco tempo e con pochissimo sforzo. Ovviamente questo è solo uno dei possibili utilizzi, vediamone altri insieme.



Cancellate tutto, inserite un curva di tipo 'Circle', ruotela di 90° lungo l'asse 'Y' e ridimensionatela di circa 2/3 (~0,33). Adesso entrate in modalità 'Edit Mode' e aiutandovi con il tasto 'Ctrl', spostate il 'Circle' lungo l'asse 'Y' di una casella. (Fig.271)


Fig.271

Aggiungete il modificatore e impostate le voci 'Screw' a '-3m', 'Iterations' a '5', 'Axis' sempre a 'X' e i valori 'Steps Viewport' e 'Render' a '32'. (Fig.272)


Fig.272

Complimenti, avete appena creato quella che è a tutti gli effetti una molla!



Vediamo adesso come ricreare una filettatura per una vite. Cancellate tutto ed inserite nella scena una mesh di tipo 'Plane' ('Add > Mesh > Plane'). Andate in vista 'Top' (7) e in modalità 'Edit Mode' selezionate i due vertici alla vostra destra, cancellateli e alla mesh rimasta applicate un 'Subdivide' ('RMB > Subdivide') con valore 'Numbers of Cuts' impostato a '3'. (Fig.273)


Fig.273

Selezionate il vertice centrale, spostatelo a sinistra e poi, dopo aver selezionato tutta la mesh (a), spostate quest'ultima sempre a sinistra. (Fig.274)


Fig.274

Adesso ruotatela di 90° lungo l'asse 'X'. Dovreste ritrovarvi in una situazione simile a quella mostrata in Fig.275.


Fig.275

Ora applicate il modificatore 'Screw' impostando le voci 'Screw' a '2m', 'Iterations' a '16', 'Axis' a 'Z' e le voci 'Steps Viewport' e 'Render' a '32'. (Fig.276)


Fig.276

La filettatura è pronta, lascio a voi il divertimento di ultimare la vite nel modo che più preferite.



Con questo ultimo esempio si conclude il paragrafo dedicato al modificatore 'Screw'. Vi invito a sperimentare in autonomia, giocando con i vari parametri e spostando/ruotando/modificando la mesh/curva originaria in modalità 'Edit Mode' e vedere i risultati.



Due esempi di utilizzo del modificatore 'Screw'. (Fig.277)


Fig.277

[CyberJabba]

12.7 - Il Modificatore 'Skin'.

Il modificatore 'Skin' (Pelle), utilizza gli spigoli e i vertici della mesh originale per creare una forma tridimensionale. È un modo rapido per generare mesh organiche di base o filamenti di vario genere e dimensioni, come ad esempio cavi e tubi. Come sempre vediamo un esempio pratico, in questo caso con la creazione di un semplice albero.

Partendo dal cubo di default, entrate in modalità 'Edit Mode' e cancellate tutti i vertici ad eccezione di uno. Per velocizzare l'operazione vi consiglio di selezionare un solo vertice e poi invertire la selezione (Ctrl i). (Fig.278)


Fig.278

Cancellati i vertici, spostate l'unico rimasto al centro del mondo 3D tramite il menu rapido '(Shift S)' utilizzando la voce 'Selection to Cursor'. (Fig.279)


Fig.279

Ora, selezionate l'unico vertice rimasto nella scena ed estrudetelo lungo l'asse 'Z' (EZ) (Fig.280)


Fig.280

Spostatevi in vista 'Top' (7) e procedete con altre estrusioni verso l'esterno, partendo sempre dallo stesso vertice estruso poco sopra. (Fig.281)


Fig.281

In vista 'Front' (1), spostate i nuovi vertici verso l'alto, lungo l'asse 'Z' (Fig.282)


Fig.282

Ritornate in vista 'Top' ed estrudete nuovamente altri vertici e selezionateli (Fig.283)


Fig.283

Tornate in vista 'Front' (1) e spostate anche questi verso l'alto, sempre lungo l'asse 'Z'. (Fig.284)


Fig.284

Adesso, alternando le viste 'Top e 'Front' sfalsateli leggermente, cercando di creare una forma meno regolare. (Fig.285)


Fig.285

Aggiungete il modificatore 'Skin' ('Add Modifier > Generate > Skin'), attivate la modalità di visualizzazione 'X-Ray' (Alt Z) e assicuratevi di aver selezionato tutti i vertici (a). (Fig.286)


Fig.286

Ora, tramite il menu 'Vertices Data' della 'Sidebar', utilizzando le voci 'Mean Radius X/Y', scalateli leggermente fino ad ottenere un risultato come mostrato in figura Fig.287. In alternativa utilizzate la schortcut 'Ctrl A' (consigliato)


Fig.287

Continuate a scalare in maniera selettiva fino ad ottenere un risultato simile a Fig.288


Fig.288

Finito, disattivate l 'X-Ray' (Alt Z) e applicate la voce 'Smooth Shading' , l'albero è pronto. (Fig.289)


Fig.289

Lascio a voi la possibilità di arricchirlo con una chioma.



Qui in basso, tre semplici mesh di base con applicato il modificatore 'Skin'. (Fig.290)


Fig.290



Di seguito un esempio dell'utilizzo del modificatore 'Skin', utilizzato per creare un piccolo soprammobile a forma di bicicletta.  (Fig.291)


Fig.291

[CyberJabba]

12.8 - Il Modificatore 'Solidify'.

Il modificatore 'Solidify' (Solidificare) prende la superficie di qualsiasi mesh e le aggiunge profondità e spessore. Vediamolo con un esempio.

Partendo dal cubo di default, entrate in modalità 'Edit Mode'. Tramite la selezione 'Facce' (3), effettuate una selezione della faccia superiore, anteriore e posteriore ed elimatele. (Fig.292)


Fig.292

Ora applicate il modificatore 'Solidify' ('Add Modifier > Generate > Solidify'). (Fig.293)


Fig.293

Entrate in vista 'Front' (1) e nella finestra del modificatore impostate la voce 'Thickness' a '0.2m' e attivate la voce 'Even thickness' per fixare l'offset dell'estrusione. (Fig.294)


Fig.294

Il modificatore è già operativo, dando 'corpo' ad una geometria che altrimenti non ne avrebbe avuto. Immaginate i possibili campi d'impiego. Potreste ad esempio creare un vaso, un bicchiere o qualsiasi altro recipiente tramite curve e poi dargli spessore velocemente grazie all'uso del 'Solidify'. Oppure partendo dalla piantina di un appartamento (magari in abbinamento col modificatore 'Boolean' per creare porte e finestre), alzare le pareti e renderla tridimensionale. Il tutto, senza dover mai ricorrere al comando 'Extrude'.





Vediamo insieme qualche possibile problematica e come risolverla. Disattivate momentaneamente il modificatore, selezionate la faccia in basso ed eliminatela. (Fig.295)


Fig.295

Entrate in modalità selezione 'Edge' (2), selezionate i due spigoli obliqui e premete 'F' in modo da creare una nuova faccia. Fatto questo riattivate il modificatore. (Fig.296)


Fig.296

Come si può vedere, c'è qualcosa che non va. E' stata creata una nuova faccia manualmente, quindi come sempre in questi casi, è buona abitudine controllare le normali.


Per farlo, sarà sufficiente attivare la voce 'Face Orientation' presente nel menu 'Overlays'. (Fig.297)


Fig.297

Noterete subito una bella 'Faccia' rossa, che sta li proprio ad indicare che è rivolta nel verso sbagliato.



Per risolvere, vi basterà selezionare tutta la mesh (a) e ricalcolare le normali tramite la combinazione 'Shift N'. (Fig.298)


Fig.298

La mesh è stata corretta e a questo punto potrete anche procedere alla disabilitazione della voce 'Face Orientation' del menu 'Overlays', in quanto non più necessaria.



Gli ultimi appunti per il modificatore 'Solidify', riguardano la voce 'Rim' (bordo), composta a sua volta da altre due voci, 'Fill' e 'Only Rim'.

Nel primo caso si parla di 'Fill' (riempimento) e come facilmente intuibile, attivando o disattivando questa opzione, si darà luogo o meno al riempimento lungo i bordi. (Fig.299)


Fig.299

Nel secondo caso invece, 'Only Rim', il riempimento avrà luogo solamente lungo il bordo. (Fig.300)


Fig.300



Con questo è tutto. Vi invito a sperimentare come al solito. Di seguito due esempi realizzati tramite l'utilizzo del modificatore 'Solidify', utilizzato per dare spessore agli oggetti. (Fig.301)


Fig.301

[CyberJabba]

12.9 - Il Modificatore 'Subdivide Surface' e il 'Vertex/Mean Crease'.

Il modificatore 'Subdivide Surface' viene utilizzato per suddividere le facce di una mesh. Consente di creare superfici complesse, partendo da mesh semplici e con pochi vertici. Come altri modificatori, l'ordine di esecuzione (ordine d'incolonnamento all'interno della 'Modifier Properties') ha un impatto importante sul risultato finale.

Partendo dal cubo di default, aggiungete il modificatore 'Subdivision Surface' ('Add Modifier > Generate > Subdivision Surface'), avendo cura di impostare entrambe le voci 'Levels Viewport' e 'Render' a '5' e attivando l' 'Auto Smoot'. La voce 'Levels Viewport' si occupa della visualizzazione del 'Subdivision' nella '3D View', mentre 'Render' quella del rendering finale.

Entrando in modalità 'Edit mode', quello che vedrete oltre la mesh generata dal modificatore, saranno le facce del cubo originale. Provate a spostarle e vedere l'effetto sulla mesh sottostante. (Fig.302)


Fig.302

Adesso entrate in modalità 'Vertex' (1), selezionatene uno a vostro piacimento e per mezzo della voce 'Vertex Crease' (piega), provate a variare il valore da '0' ad '1' e viceversa.
Andando in modalità 'Edge' (2), potete fare la stessa anche con gli spigoli. Selezionate quelli superiori e agendo questa volta sulla voce 'Mean Crease', impostatela '0.75'. Per gli spigoli potete utilizzare anche la comoda shortcut 'Shift E' (consigliato). (Fig.303)


Fig.303



Proseguiamo per mezzo di una piccola esercitazione.

Selezionate tutti gli spigoli (a) e riportate il valore 'Mean Crease' a '0'. Effettuate un 'Subdivide' ('RMB > Subdivide') con valore 'Number of Cuts' impostato a '3'. (Fig.304)


Fig.304

Selezionate gli 'Edge' perimetrali superiori e tramite la combinazione 'Shift E', impostate il 'Mean Crease' a '0.75'. (Fig.305)


Fig.305

Adesso in modalità 'Vertex', selezionate il vertice laterale centrale, effettuate un 'Bevel' (Shift Ctrl B) e successivamente, aiutandovi con il tasto 'Ctrl', effettuate un'estrusione lungo l'asse 'X' (E X). (Fig.306)


Fig.306

Tramite il comando 'Loop Cute and Slide' (Ctrl R), aggiungete tre suddivisioni come mostrato in figura. (Fig.307)


Fig.307

Dopo essere passati in modalità selezione 'Face', selezionate la faccia all'estremità della protuberanza ed effettuate prima un 'Insect' (i) e una nuova estrusione (E X) verso l'interno poi. (Fig.308)


Fig.308

Entrate in modalità 'Edge', selezionate i tre 'Loop' come in figura (aiutatevi entrando momentaneamente in modalità di visualizzazione 'X Ray' (Alt Z) ) e impostate la voce 'Mean Crease' a '0.5' (Shift E). (Fig.309)


Fig.309

Adesso in modalità 'Vertex', selezionate il vertice superiore centrale ed effettuate un nuovo 'Bevel' (Shift Ctrl B') . Successivamente, dopo essere passati in modalità 'Face', procedete alla sua estrusione lungo l'asse 'Z'. (Fig.310)


Fig.310

Tramite il comando 'Loop Cut and Slave' (Ctrl R), aggiungete all'estrusione appena creata tre nuove suddivisioni. (Fig.311)


Fig.311

Adesso selezionate la faccia superiore, effettuate un primo 'Extrude' più 'Scale' (E S) e dopo conferma, un altro 'Extrude' lungo l'asse 'Z'. (Fig.312)


Fig.312

Ancora con la faccia selezionata, entrate in modalità 'Edge' e impostate il valore 'Mean Crease' a '0.5'. A questo punto effettuate un 'Insect' (i) e successivamente una nuova estrusione verso il basso, lungo l'asse 'Z'. (Fig.313)


Fig.313

Spostatevi nella parte centrale della mesh, selezionate le quattro facce anteriori, le quattro posteriori ed eliminatele (x). Dopo essere passati in modalità 'Edge' selezionate i due 'Loop' di spigoli contrapposti. (Fig.314)


Fig.314

Ora, tramite il comando 'Bridge Edge Loop' ('RMB > Bridge Edge Loop') create le facce interne. Selezionate i due edge loop già precedentemente selezionati e impostate il 'Mean Crease' a '0.50'. (Fig.315)


Fig.315

L'esercitazione è finita. Per effettuare un controllo più accurato della mesh alla ricerca di errori, vi consiglio di cambiare il tipo di visualizzazione.
Nell'esempio sottostante ad esempio, tramite il menu 'Shading', alla voce 'Lighting' è stato scelto un 'MatCap' di tipo 'Metal_Carpaint.exr'. (Fig.316)


Fig.316



Con questo paragrafo si conclude la prima parte del capitolo dedicato ai modificatori di tipo 'Generate', dal prossimo cominceremo a parlare di quelli 'Deform'.

[CyberJabba]

12.10 - Il Modificatore 'Curve'.

Il modificatore 'Curve' è utilizzato per deformare un oggetto lungo una curva e spesso viene usato in abbinamento al modificatore 'Array'.

Partendo dal cubo di default, aumentate la scala lungo l'asse 'X' a '10' (S X 10). (Fig.317)


Fig.317

Entrate in modalità 'Edit Mode' e tramite il comando 'Loop Cut and Slide' (Ctrl R), aumentate le suddivisioni sempre lungo l' asse 'X' a '20'. (Fig.318)


Fig.318

A questo punto, in modalità 'Object Mode' aggiungete una curva di tipo 'Path', avendo cura di scalarla e spostarla in modo da sovrapporla al cubo. Per farlo aiutatevi entrando momentaneamente in modalità 'X Ray' (Alt Z) e attivando il 'Quad View' (Ctrl Alt Q). (Fig.319)


Fig.319

Selezionate il cubo, assegnate il modificatore 'Curve' ('Add Modifier > Deform > Curve') e nella finestra del modificatore, alla voce 'Curve Object', selezionate la curva 'NurbsPath'. Riposizionate questa volta il cubo alla curva, che nel frattempo si sarà spostato. (Fig.320)


Fig.320

Finito. Selezionando la curva ed entrando in modalità 'Edit Mode', tutte le modifiche effettuate ai suoi nodi si ripercuoteranno sulla mesh. (Fig.321)


Fig.321





Vediamo adesso l'uso del modificatore 'Curve' abbinato a quello 'Array':

Partendo da una nuova scena, cancellate il cubo di default ed inserite un toroide ('Add > Mesh > Torus'), impostando le voci 'Major Segments' a '16' e 'Minor Segments' a '8'. (Fig.322)


Fig.322

Entrate in modalità 'Edit Mode', duplicate i vertici (Shift D), spostateli leggermente lungo l'asse 'X' e ruotateli di 90° sempre lungo l'asse 'X' (R X 90). (Fig.323)


Fig.323


Passate in 'Object Mode' e dopo aver inserito una curva di tipo 'Path', ri-selezionate gli anelli e assegnate il modificatore 'Array' ('Add Modifier > Generate > Array'). Impostate la voce 'Fit Type' a 'Fit Curve' e nel campo 'Curve' caricate la curva 'NurbsPatch'. Diminuite leggermente anche il campo 'Factor X' dell'Offset Relativo, in modo da regolare in maniera ottimale la distanza tra gli anelli. (Fig.324)


Fig.324


Adesso aggiungete il modificatore 'Curve' ('Add Modifier > Deform > Curve') e alla voce 'Curve Object' selezionate sempre la curva 'NurbsPath'. (Fig.325


Fig.325


Finito. Selezionando la curva ed entrando in modalità 'Edit Mode', modificando la curva, l'oggetto la seguirà... esattamente come nell'esempio precedente (!).

Ma quindi la differenza qual'è? La differenza è che avendo inserito anche un modificatore di tipo 'Array' e avendo impostato la voce 'Fit Type' su 'Fit Curve', selezionando un nodo alle estremità della curva e procedendo per estrusioni, ora sarà possibile ottenere un risultato simile a quello mostrato in Fig.326.


Fig.326





Fixare la deformazione delle mesh lungo la curva:

Se non volete che le mesh vengano distorte lungo la curva, ma che ne seguano solamente il percorso, potete utilizzare un'altra mesh, imparentandola successivamente con la catena e assegnando i modificatori, non più alle due maglie, ma direttamente all'oggetto padre. Vediamo come.

Eliminate entrambi i modificatori e in modalità 'Object Mode', aggiungete una mesh di tipo 'Plane'. (Fig.327


Fig.327


Ora selezionate prima le due maglie della catena, poi il 'Plane' appena inserito e premete la combinazione 'Ctrl P'. Si aprirà il piccolo menu 'Set Parent to', scegliete 'Object'. (Fig.328


Fig.328

La parentela è stata assegnata. Ora selezionando il plane, tutte le modifiche nella 'Object Mode' riguarderanno anche le maglie della catena, in quanto diventate 'figlie' dell'oggetto 'padre', il plane appunto.



Con il 'Plane' selezionato, inserite nuovamente i due modificatori come già fatto in precedenza, ritrovandovi in una situazione simile a quella di Fig.329.


Fig.329



A questo punto, andate nella 'Object Properties', espandete il menu 'Instancing', selezionate 'Faces' e togliete la spunta alle voci 'Viewport' e 'Render' in modo da nascondere il plane. (Fig.330).


Fig.330

L'esercizio finisce qui.

Vi lascio dicendovi che dopo l'inserimento dell'oggetto plane (istanza), quasi sicuramente sarà necessario regolare nuovamente la voce del 'Relative Offset' del modificatore 'Array'. (Fig.331).


Fig.331

Con questo si chiude il paragrafo dedicato al modificatore 'Curve'.

[CyberJabba]

12.11 - Il Modificatore 'Displace'.

Il modificatore 'Displace' (Spostamento), viene utilizzato per modificare fisicamente la posizione dei vertici della mesh nello spazio per mezzo di immagini di tipo procedurale e/o raster.

Per poter lavorare correttamente, il 'Displace' necessità che la mesh sottostante abbia buona risoluzione. Per questo motivo, il modificatore 'Displace' viene spesso utilizzato in combinazione con quello 'Subdivision Surface'. Se ad esempio una semplice mesh di tipo 'Plane' non avesse facce e vertici da poter 'muovere', il modificatore 'Displace' non potrebbe produrre nessun risultato. Va da se che, maggiore sarà la complessità della mesh e maggiore la risoluzione dell'immagine, migliori saranno i risultati finali. Il rovescio della medaglia in questo caso, è che la scena verrà appesantita notevolmente, sia a carico di scheda grafica, che di risorse di sistema occupate. Attenzione quindi a non esagerare, cercando di trovare sempre il giusto compromesso.



Vediamo il funzionamento del modificatore 'Displace' per mezzo del solito esempio pratico. Partendo da una nuova scena, cancellate il cubo di default ed inserite una mesh di tipo 'Grid' ('Add > Mesh > Grid'). Assegnate un modificatore 'Subdivision Surface' ('Add Modifier > Generate > Subdivision Surface'), impostate le voci 'Levels Viewport' e 'Render' a '6' e il tipo di suddivisione su 'Simple' (in questo modo il perimetro della mesh non verrà deformato).
Assegnate un nuovo modificatore di tipo 'Displace', impostate la voce 'Strength' a '0.25', la 'Midlevel' a '0' e cliccate sul tasto 'New' per creare una nuova texture. (Fig.332)


Fig.332

Spostatevi nella 'Texture Properties' e alla voce 'Type' scegliete una texture di tipo procedurale 'Voronoi'. Finito, quello che vedete, è il risultato dello spostamento dei vertici della geometria 'Grid', per mezzo del modificatore 'Displace' e della texture 'Voronoi'. (Fig.333)


Fig.333

In Blender esistono un totale di 10 Texture procedurali utilizzabili tramite il modificatore 'Displace', di seguito l'elenco completo:


Fig.334



Abbiamo visto come utilizzare texture di tipo procedurale, ma il modificatore 'Displace' può accettare come texture, anche normali immagini o addirittura video.
Per caricare una 'DisplaceMap', sarà sufficiente alla voce 'Type', scegliere 'Image or Movie' e dopo aver premuto il tasto 'Open', procedere al suo caricamento. (Fig.335)


Fig.335

Qui sotto un esempio con 'Displace' e texture di tipo 'Image or Movie' applicata. Fig.336


Fig.336

Nel caso voleste fare le vostre prove, al seguente link vi lascio l'immagine utilizzata nell'esempio precedente. Comunque, una rapida ricerca sul web con le parole chiave 'DisplaceMap Download', dovrebbe restituirvi numerosi risultati utili.



Due esempi di 'Displace' applicato ad un piano e ad una sfera. (Fig.337)


Fig.337

[CyberJabba]

12.12 - Il Modificatore 'Lattice'.

Il modificatore 'Lattice', deforma un elemento in base alla 'gabbia reticolare' creata dall'oggetto 'Lattice'. Con una mesh avente un gran numero di vertici ad esempio, sarebbe difficile modificare rapidamente alcune sue porzioni. Grazie all'uso di una 'gabbia reticolare' invece, quest'ultima permetterà di deformarla con estrema semplicità. Gli elementi con cui il modificatore e l'oggetto 'Lattice' possono interagire sono mesh, curve e persino particelle.



Vediamo un esempio pratico, introducendo con la scusa, la gestione del testo in Blender.

Partendo da una nuova scena, cancellate il cubo di default e inserite un oggetto di tipo 'Text' ('Add > Text'). (Fig.338)


Fig.338

Entrate in modalità 'Edit Mode', cancellate il vecchio testo tramite il tasto 'Backspace' e inseritene uno a vostro piacimento. Se vi spostate nella 'Object Data Properties', noterete una certa somiglianza con quella delle 'Curve' viste nel capitolo precedente. In effetti, la gestione del testo è del tutto simile a quella delle curve 2D. Aprite il sottomenu 'Geometry' e aumentate il valore della voce 'Extrude' a '0.1'. (Fig.339)


Fig.339

Dopo essere tornati in modalità 'Object Mode', inserite un nuovo oggetto di tipo 'Lattice' ('Add > Lattice'). Sullo schermo apparirà un reticolato a forma di cubo. (Fig.340)


Fig.340

Passando momentaneamente in vista 'Quad View' (Ctrl Alt Q), spostate e ridimensionate l'oggetto 'Lattice' in modo da sovrapporlo all'oggetto 'Text'. (Fig.341)


Fig.341

Entrate nella 'Object Data properties' dell'oggetto 'Lattice' e aumentate il valore 'Resolution U' a '12'. (Fig.342)


Fig.342

Selezionate l'oggetto 'Text' e assegnate il modificatore 'Lattice' ('Add Modifier > Deform > Lattice'), avendo cura di inserire alla voce 'Object' l'oggetto 'Lattice' inserito in precedenza. (Fig.343)


Fig.343

Selezionate l'oggetto 'Lattice' e dopo essere passati in modalità 'Edit Mode', dalla vista 'Top', selezionate man mano i vertici e spostateli come in figura Fig.344


Fig.344

Di seguito il risultato finale.


Fig.345

Non c'è molto altro da dire, se non che aumentare e/o diminuire i valori 'Resolution U, V e W' dell'oggetto 'Lattice', per adattarlo in modo ottimale alla mesh sottostante, è sicuramente uno degli aspetti più importanti. Valori troppo alti annullerebbero in parte il valore aggiunto del modificatore stesso, mentre valori troppo bassi, potrebbero non essere sufficienti al raggiungimento della forma desiderata. Come sempre, vi invito a sperimentare ed esercitarvi.


Due esempi di modificatore 'Lattice' applicato a mesh.


Fig.346

[CyberJabba]

12.13 - Il Modificatore 'SimpleDeform'.

Il modificatore 'SimpleDeform'' consente di deformare un oggetto lungo un'asse specificato. La deformazione può essere di tipo 'rotazione' ('Twist'/'Bend') o di tipo 'ridimensionamento' ('Taper'/'Stretch'). Vediamolo in pratica.



Selezionate il cubo di default e scalatelo lungo l'asse 'Z' (S Z 15) (Fig.347)


Fig.347

Entrate in modalità 'Edit Mode' e tramite il comando 'Loop Cut and Slide' (Ctrl R), aumentate le suddivisioni lungo l'asse 'Z' a '15'. (Fig.348)


Fig.348

Ritornate in modalità 'Object Mode', assegnate il modificatore 'SimpleDeform' ('Add Modifier > Deform > SimpleDeform') e impostate il tipo di deformazione su 'Bend'. (Fig.349)


Fig.349

Come si può notare c'è un problema, la mesh non viene deformata correttamente. Questo perchè ad inizio paragrafo, il cubo è stato scalato lungo l'asse 'Z' e senza prima ripristinare le giuste proporzioni, il modificatore non potrà lavorare correttamente. Per risolvere, basterà effettuare un classico 'Apply Tranformation' del valore 'Scale' ('Ctrl A') e tutto tornerà a posto. (Fig.350)


Fig.350

Agendo sulla voce 'Angle' si modificherà il grado di deformazione, mentre tramite le caselle 'Axis', l'asse di riferimento. (Fig.351)


Fig.351



Potete anche aumentare il grado di controllo per mezzo di un oggetto 'Empty' ('Add > Empty > Plain Axes), inserendolo nella scena e poi avendo cura di caricarlo alla voce 'Origin' nella finestra del modificatore. (Fig.352)


Fig.352

Muovendo l'oggetto 'Empty' lungo l'asse 'Z' potrete decidere agevolmente l'origine della deformazione. (Fig.353)


Fig.353



Potete anche spingervi oltre per mezzo della creazione di un 'Vertex Group' (10.7 - La Properties 'OBJECT DATA MESH'), in modo da circoscrivere la deformazione solo ad una determinata porzione della mesh.

Entrate in modalità 'Edit Mode', spostatevi nella 'Object Data Properties' e create un nuovo 'Vertex Group'. (Fig.354)


Fig.354

Selezionate i vertici superiori e premete il pulsante 'Assign'. (Fig.355)


Fig.355

Tornate in modalità 'Object Mode' e nella finestra del modificatore, nella sezione 'Restrictions', selezionate il 'Vertex Group' appena creato. (Fig.356)


Fig.356

Ora, attraverso lo spostamento lungo l'asse 'Z' dell'oggetto 'Empty', vi basterà muoverlo fino ad ottenere il punto di deformazione ottimale. (Fig.357)


Fig.357



Di seguito altri risultati ottenuti giocando con la posizione dell'oggetto 'Empty', la voce 'Angle' e l'aggiunta di un modificatore 'Subdivision Surface'. (Fig.358)


Fig.358



In basso un confronto tra le quattro opzioni messe a disposizione dal modificatore 'SimpleDeform' (Twist, Bend, Taper e Stretch), applicate ad un cubo opportunamente suddiviso. (Fig.359)


Fig.359



Con questo modificatore 'SimpleDeform', si conclude il capitolo dedicato ai modificatori di base.

[CyberJabba]

13.1 - Introduzione al 'Texture Mapping'.

Il 'Texturing Mapping' è una tecnica introdotta a metà degli 70 che permetteva di proiettare una o più immagini su una superficie di un modello 3D, tecnica che da lì a poco avrebbe rivoluzionato il mondo del 3D. Fino ad allora infatti i rendering utilizzavano la sola tecnica di 'Shading' (Ombreggiatura), basata su un algoritmo che calcolava esclusivamente l'assorbimento (riflessione della luce), l'angolo di incidenza e l'angolo di visione. Per questo motivo, in quel periodo le immagini ottenute erano per lo più a scala di grigi o al massimo tonalità colore. (Fig.360)


Fig.360



Fatta questa breve premessa, possiamo dire che le Texture si dividono essenzialmente in due tipologie, quelle 'Procedurali', cioè generate matematicamente e quelle 'Raster', composte cioè da pixel. Le 'Raster' a loro volta, possono essere di tipo fotografico (la classica foto), oppure realizzate a mano per mezzo di programmi di fotoritocco (Photoshop/Gimp) e/o programmi di grafica vettoriale (Illustrator/Inkscape).

Di seguito esempi di Texture 'Procedurali' e 'Raster' messe a confronto. Nelle disegnate, una dipinta tramite tavoletta grafica in Gimp e l'altra realizzata in vettoriale tramite Inkscape. (Fig.361)


Fig.361



Tornando a Blender, quest'ultimo implementa dieci tipi di texture procedurali, richiamabili per mezzo del menu 'Add' (Shift A) direttamente dallo 'Shader Editor'. (Fig.362)


Fig.362

Stesso discorso per l'inserimento di 'Texture' di tipo immagine, questa volta utilizzando la voce 'Image Texture'. (Fig.363)


Fig.363



Una volta inserito un nodo 'Texture' (qualunque esso sia), sarà necessario connettere manualmente l'output 'Color' di quest'ultimo, all'input 'Base Color' del 'Node Shader' tramite semplice 'Drag and Drop'. Nel caso voleste invece scollegarlo, sarà sufficiente ripetere l'operazione inversa. (Fig.364)


Fig.364

Per eliminare un nodo invece, sarà sufficiente prima selezionarlo e poi premere il tasto 'X'.


Ultima cosa prima di chiudere questa breve introduzione alle 'Texture', è quella di ricordarvi che per poter visualizzare correttamente le 'Texture' applicate, dovrete sempre attivare prima o la vista 'Material Preview' o la vista 'Rendered'. Per farlo sarà sufficiente agire sulle opportune icone poste in alto a destra della '3D View', oppure in alternativa, utilizzare la shortcut da tastiera Z', in modo da far apparire prima il menu rapido dedicato e poi effettuare la scelta desiderata.


Fig.364