Modellazione e animazione di entità

In questa guida, esamineremo le basi della creazione di un modello e della creazione di animazioni per Minecraft: Bedrock Edition. Come esempio, modelleremo e animeremo un piccolo robot, che è stato avviato nel'articolo Introduzione all’aggiunta di entità.

In questo tutorial imparerai quanto segue:

• Come creare un modello per un'entità utilizzando Blockbench.
• Come applicare texture e animazioni a un modello.

Requisiti

Prima di iniziare questo tutorial, ti consigliamo di completare i seguenti passaggi:

• Introduzione all’aggiunta di entità

Modello

I modelli di Minecraft utilizzano un formato specifico che utilizza JSON per definire la forma. Ogni modello utilizza una texture che può essere assegnata tramite i controller di rendering.

Per creare il modello e la texture, useremo Blockbench, un programma di modellazione 3D in grado di creare modelli per la Bedrock Edition di Minecraft.

Configurazione del modello

Quando apri Blockbench per la prima volta, vedrai un elenco di formati di modelli disponibili. Seleziona Modello Bedrock. Vedrai una finestra di dialogo sulle impostazioni di base per il progetto.

La parte importante è Nome geometria della creatura. Qui inseriremo un nome univoco per il modello. La migliore pratica è usare snake_case, quindi solo lettere minuscole, numeri e trattini bassi, nonché punti. Gli spazi e altri caratteri speciali non sono supportati. Per il nostro modello, inseriremo solo robot.

Per ora possiamo lasciare vuoto il campo del nome del file perché lo definiremo in seguito, quando esporteremo il modello. L'impostazione Box UV e la dimensione della texture possono anche essere lasciate come predefinite, perché le modificheremo in seguito. Il pulsante di conferma salverà queste impostazioni.

Struttura ossea

La prima cosa da considerare quando si realizza un modello è la struttura ossea. Le ossa sono la parte del modello che può essere animata e possono essere disposte in una gerarchia arbitrariamente profonda. Ogni osso di per sé è invisibile, ma può contenere cubi che daranno forma al modello.

Una buona pratica è usare un osso radice per ogni modello e metterci dentro tutto il resto. Ciò significa che in seguito sarai in grado di animare l'intero modello contemporaneamente, nonché parti specifiche di esso. Creare un nuovo gruppo in Blockbench. "Gruppi" e "Ossa" sono essenzialmente la stessa cosa in questo contesto.

Puoi fare clic con il pulsante destro del mouse sul gruppo o premere F2 per rinominarlo. Il nome di un osso dovrebbe essere snake_case (quindi includendo solo lettere minuscole, numeri e trattini bassi). Ogni nome di osso deve essere univoco, come riferimento futuro nelle animazioni.

Mentre costruiamo il modello nei passaggi seguenti, verifica che la struttura sia configurata correttamente. Puoi trascinare i gruppi per modificare l'ordine o rilasciarli in altri gruppi. Questo screenshot mostra la corretta struttura ossea del modello finito.

Forma

Ora puoi iniziare a creare la forma del modello. Crea nuovi cubi e usa gli strumenti di spostamento, ridimensionamento e rotazione per regolarlo. Un trucco per aggiungere cubi più velocemente consiste nel selezionare un cubo già posizionato e premere Ctrl + D (duplica) per ottenere una copia.

Puoi spostare i cubi in modo più preciso tenendo premuto Maiusc, Ctrl o entrambi contemporaneamente. A seconda dello stile di modellazione, può avere senso attenersi completamente alla griglia o spostare i cubi solo con incrementi di metà o di un quarto.

I modelli Bedrock Edition utilizzano la mappatura Box UV per impostazione predefinita. Ciò significa che la mappatura delle texture utilizzerà solo numeri interi e, se necessario, arrotonderà per difetto al numero inferiore. Per evitare facce allungate o invisibili, assicurati che le dimensioni dei cubi si attengano ai numeri interi.

Se stai lavorando su parti simmetriche come gli arti, creale prima sul lato destro e poi specularmente sul lato sinistro in un secondo momento. Puoi crearle specularmente prima o dopo aver creato la texture, a seconda che tu voglia la stessa texture su entrambi i lati o meno.

Quando crei le ossa per le parti mobili del modello, pensa sempre al punto attorno al quale deve ruotare la parte. Seleziona un osso e premi P per ottenere lo strumento Perno. Questo strumento ti consente di spostare il punto di rotazione dell'osso. Puoi anche usare questo strumento sui cubi se vuoi ruotarli attorno a un punto specifico.

Modelli di

texturizzazione

Una volta completata la forma del modello, puoi creare un modello di texture. Il modello è una texture che ha uno spazio univoco per ogni cubo e faccia del modello. Puoi anche mappare i cubi UV manualmente, ma la creazione di un modello lo fa a al posto tuo e trova il layout più efficiente in termini di spazio. Ricorda che a Minecraft non piacciono le immagini ad alta risoluzione.

Quando crei una texture, inserisci robot come nome della texture e seleziona l'opzione Modello. Nella finestra di dialogo del modello, seleziona la risoluzione. 16x è la risoluzione predefinita di Minecraft, ma puoi aumentarla, se lo desideri.

Colore di base

Una volta creato il modello, puoi passare alla scheda Paint in Blockbench. Questo rivelerà tutti gli strumenti a tua disposizione per modificare la texture. Seleziona lo strumento Secchio di vernice e imposta la modalità di riempimento accanto allo strumento su Cubo. Seleziona un colore nel pannello dei colori sulla destra. Ora puoi passare sui cubi e colorarli con i singoli colori di base.

Dettagli

Ora puoi iniziare a lavorare sulla texture. Se ti senti più a tuo agio a texturizzare con il programma di modifica delle immagini, ora puoi salvare la texture facendo clic sull'icona di salvataggio accanto alla texture. Quindi, puoi aprirla nel tuo editor di immagini. Tutte le modifiche compaiono in Blockbench non appena salvi la texture. Ma se preferisci lavorare direttamente sul modello, puoi utilizzare gli strumenti di disegno incorporati in Blockbench.

Ci sono alcuni trucchi per usare il pennello in Blockbench in modo più efficiente:

• Per dipingere aree più grandi, puoi aumentare la dimensione del pennello.
• Puoi dipingere direttamente nell'anteprima 3D oppure puoi dipingerlo nell'editor UV a sinistra.
• Se vuoi creare una linea retta, fai clic all'inizio della linea, quindi tieni premuto Maiusc alla fine della linea.
• Per essere certo di non perdere i punti coperti che potrebbero essere rivelati attraverso le animazioni, puoi nascondere i cubi. Basta fare clic sull'icona a forma di occhio nell'outliner.

Animazioni

Le animazioni possono animare la forma del tuo modello, ma possono anche riprodurre suoni ed effetti particellari. Nella sezione seguente, daremo un'occhiata a come aggiungere un'animazione alla tua entità, a come creare la tua animazione in Blockbench e, infine a come utilizzare i controller di animazione.

Uso delle animazioni predefinite

Il pacchetto di risorse di base contiene animazioni generiche a cui puoi fare riferimento nel tuo pacchetto senza effettivamente copiare i file. Queste animazioni possono essere un buon punto di partenza per entità simili a quelle di base, ma ovviamente le animazioni personalizzate sono molto più potenti. Puoi trovare tutte le animazioni di base nel pacchetto di risorse di base qui.

In questo esempio useremo l'animazione guarda verso. Questa animazione ruoterà l'osso della "testa". Ecco perché è importante che la testa del modello usi esattamente lo stesso nome.

Inoltre, l'entità avrà bisogno di un componente guarda verso nel suo file di comportamento. Questi sono i componenti dello sguardo della mucca. Puoi giocare con i numeri, se vuoi.

            "minecraft:behavior.look_at_player": {
                "priority": 7,
                "look_distance": 6,
                "probability": 0.02
            },
            "minecraft:behavior.random_look_around": {
                "priority": 9
            }

Ora che il comportamento è configurato, passeremo al file dell'entità client. Assicurati che la versione del formato per questo file sia impostata su 1.10.0 o successiva affinché funzioni.

Innanzitutto, colleghiamo l'animazione. Questa operazione viene eseguita nella sezione delle animazioni, nel tag di descrizione dell'entità. La seconda parte qui (animation.common.look_at_target) è l'identificatore globale dell'animazione. Questo nome è definito nel file di animazione ed è valido ovunque, in questo pacchetto o in qualsiasi altro. La prima parte (look_at_target) è il nome breve. Si tratta di come facciamo riferimento all'animazione all'interno del file di entità ed è valido solo nell'ambito di tale entità.

            "animations": {
                "look_at_target": "animation.common.look_at_target"
            }

Ora dobbiamo riprodurre l'animazione. Per le animazioni semplici che sono sempre attive mentre l'entità esiste, è sufficiente elencare il nome breve nell'array script/animazione del file dell'entità client.

            "scripts": {
                "animate": ["look_at_target"]
            }

Se ora testi il robot nel gioco, vedrai che girerà la testa e si guarderà intorno.

Creare un'animazione

Nella guida all'aggiunta di entità abbiamo creato una piccola animazione di guida per il robot. Ora creiamo ora un'animazione che parte quando il robot perde il terreno sotto i suoi piedi (ruota). Prima di creare un'animazione, controlla sempre se c'è un modo per attivarla. Possiamo facilmente attivare un'animazione di perdita di equilibrio, perché possiamo semplicemente usare la query Molang query.is_on_ground per testare quando il robot non tocca più terra.

È possibile creare animazioni semplici nell'editor di testo, ma Blockbench semplifica la creazione di animazioni più complesse basate su fotogrammi chiave. Apri il modello e passa alla scheda Anima nell'angolo in alto a destra. Crea una nuova animazione nel pannello Animazioni a sinistra e denominala animation.robot.sway. Puoi anche scegliere un nome più lungo o includere uno spazio dei nomi per garantire la compatibilità con altri componenti aggiuntivi. Ma tieni presente che gli identificatori di animazione supportano solo snake_case, stringhe e punti, ma non i due punti o i trattini.

Una volta configurata l'animazione, puoi iniziare ad animare. Seleziona l'osso radice della tua entità. Sposta il cursore del tempo nella cronologia su 0 secondi e fai clic sull'icona più accanto a Rotazione. In questo modo verrà creato un nuovo fotogramma chiave nella nuova posizione. Ora sposta il cursore su circa 0,2 secondi. Seleziona lo strumento Ruota e ruota leggermente l'intero robot verso sinistra. Verrà generato automaticamente un nuovo fotogramma chiave. Sul lato sinistro dello schermo puoi vedere i valori. Ruotalo di circa 10 gradi.

Ora vai avanti nel tempo di circa mezzo secondo e ruota l'osso della radice dall'altra parte. Infine, passa a 1 secondo e ruotalo di nuovo su 0.

Se ora sposti il cursore all'inizio e premi play, vedrai una breve animazione di oscillazione. Ora che sai come animare, puoi perfezionare l'animazione e, ad esempio, far oscillare un po' l'antenna.

Infine, premi Ctrl + S per salvare il modello e l'animazione. Salva l'animazione nella cartella animations del pacchetto di risorse come robot.animation.json.

Ora fai riferimento e riproduci l'animazione nel file dell'entità client come abbiamo fatto con l'animazione guarda verso. Ma ora riprodurremo l'animazione dell'oscillazione solo a condizione che il robot non tocchi terra. L'aspetto sarà qualcosa del genere:

            "animations": {
                "look_at_target": "animation.common.look_at_target",
                "sway": "animation.robot.sway"
            },
            "scripts": {
                "animate": [
                    "look_at_target",
                    {"sway":"!query.is_on_ground"}
                ]
            }

Se ora generi un robot e lo spingi verso un burrone, partirà l'animazione. Ma verrà riprodotta solo una volta.

Il motivo consiste nel fatto che la query nella sezione degli script è solo un valore di fusione per l'animazione. Definisce "quanto" viene riprodotta l'animazione, non quando viene riprodotta e quando no. Ecco perché l'animazione partirà se !query.is_on_ground è true/1, ma la riproduzione non si fermerà mai. Svanirà appena il valore è nuovamente false/0 e la volta successiva svanirà di nuovo nell'animazione. Non partirà nuovamente dall'inizio.

Possiamo usare questo comportamento abbastanza bene per animazioni statiche o in loop che non hanno né un inizio né una fine. Ma se vogliamo avviare l'animazione a ogni cambio di query, abbiamo bisogno di un approccio diverso. È qui che entrano in gioco i controller di animazione.

Controller di animazione

I controller di animazione funzionano con gli stati. Un controller di animazione può avere un numero illimitato di stati. Solo uno di questi stati è attivo ogni volta. Il controller può passare agli altri stati tramite le espressioni Molang. Ogni stato può riprodurre un set distinto di animazioni, suoni ed effetti particellari.

Ogni volta che l'entità viene caricata dal client, ad esempio quando si entra in un mondo, il controller di animazione parte in uno stato iniziale. Questo stato si chiama default per impostazione predefinita.

Per configurare il controller di animazione, crea una nuova cartella nel pacchetto di risorse denominata animation_controllers. All'interno della cartella, crea un nuovo file di chiamato robot.animation_controllers.json. Crea un controller di animazione come questo:

{
    "format_version": "1.10.0",
    "animation_controllers": {
        "controller.animation.robot.ground": {}
    }
}

Ora dobbiamo creare uno stato iniziale. Questo stato si chiama default per impostazione predefinita. Il controller di animazione partirà sempre in questo stato quando l'entità viene caricata. Ad esempio quando ti riunisci al mondo.

L'unico compito di questo stato è quello di passare allo stato di oscillazione una volta che l'entità non è più a terra. Useremo una transizione per questa operazione. Il controller passerà a quello stato non appena la query.is_on_ground non è più true.

{
    "format_version": "1.10.0",
    "animation_controllers": {
        "controller.animation.robot.ground": {
            "states": {
                "default": {
                    "transitions":[
                        {"swaying": "!query.is_on_ground"}
                    ]
                }
            }
        }
    }
}

Ora aggiungeremo lo stato di oscillazione. Questo stato riprodurrà l'animazione di oscillazione, dopodiché resetterà il controller tornando allo stato predefinito. Possiamo usare la query query.all_animations_finished per effettuare la transizione solo dopo che l'animazione è stata riprodotta. Questa query restituirà true solo dopo che tutte le animazioni dello stato attuale avranno terminato la riproduzione. Inoltre testeremo se l'entità è di nuovo a terra.

{
    "format_version": "1.10.0",
    "animation_controllers": {
        "controller.animation.robot.ground": {
            "states": {
                "default": {
                    "transitions":[
                        {"swaying": "!query.is_on_ground"}
                    ]
                },
                "swaying": {
                    "animations":[
                        "sway"
                    ],
                    "transitions":[
                        {"default": "query.all_animations_finished && query.is_on_ground"}
                    ]
                }
            }
        }
    }
}

Ora dobbiamo collegare il controller di animazione alla nostra entità. I controller di animazione possono essere collegati allo stesso modo delle animazioni nel file di entità client. Il controller è collegato nella sezione delle animazioni e riprodotto negli script.

            "animations": {
                "look_at_target": "animation.common.look_at_target",
                "sway": "animation.robot.sway",
                "ground": "controller.animation.robot.ground"
            },
            "scripts": {
                "animate": [
                    "look_at_target",
                    "ground"
                ]
            }

Se fai questo tipo di test nel gioco, l'animazione funzionerà più di una volta. Ma, a seconda della durata dell'animazione, potresti notare che se il robot perde il terreno due volte con un breve intervallo, la seconda volta non riprodurrà l'animazione. Questo perché la prima animazione non è ancora terminata, quindi il controller non è stato resettato allo stato predefinito.

Possiamo pensare a una soluzione diversa per risolvere questo problema. Rimuovendo la query all_animations_finished, usciremo dallo stato di oscillazione non appena l'entità atterra di nuovo. Se eseguiamo di nuovo il test, l'animazione si fermerà molto bruscamente.

Per evitare questa situazione, possiamo usare l'opzione blend_transition , che ci consente di uscire gradualmente dall'animazione in un tempo prestabilito. Questa è una delle proprietà più importanti dei controller di animazione e ci consente persino di creare una semplice transizione tra due pose fisse di un'entità.

In definitiva, la soluzione migliore dipende dal caso d'uso. In questo esempio, l'animazione scompare gradualmente quando il robot atterra di nuovo a terra.

                "swaying": {
                    "animations":[
                        "sway"
                    ],
                    "transitions":[
                        {"default": "query.is_on_ground"}
                    ],
                    "blend_transition":0.5
                }

E adesso?

Ora abbiamo imparato come creare un modello pronto per le animazioni e come texturizzarlo. Abbiamo anche collegato un'animazione esistente al modello e creato la nostra animazione in Blockbench.

Se desideri aggiungere altre funzionalità oltre all'aspetto dell'entità, dai un'occhiata al tutorial sui comportamenti delle entità.

Introduzione al comportamento delle entità