Editor del Grafico di Animazione

L'Editor del Grafico di Animazione è uno strumento visivo basato su nodi che consente ad artisti tecnici e animatori di costruire logiche di animazione complesse direttamente all'interno di Roblox Studio. Fornendo un'interfaccia semplificata per creare comportamenti come gli alberi di miscelazione, rimuove la tradizionale dipendenza dalla scrittura manuale per il movimento dei personaggi.

Questo sistema funziona in tandem con il tuo flusso di lavoro di animazione esistente:

• Editor di Animazione: Continua a utilizzare l'Editor di Animazione come tuo strumento principale per la creazione di clip individuali e la messa a punto di fotogrammi chiave e curve.
• Editor del Grafico di Animazione: Usa questo strumento per prendere quelle clip e organizzarle in un albero logico per guidare comportamenti di gioco sofisticati.

Progettato per migliorare la collaborazione, il grafico visivo consente agli sviluppatori di ispezionare, eseguire il debug e comprendere rapidamente la logica creata dagli animatori. Mentre gli artisti si concentrano sul perfezionamento del movimento interattivo, gli sviluppatori possono comunque accedere ai nodi del grafico di animazione programmaticamente per un controllo diretto sulle animazioni e sugli stati miscelati.

Costruire un grafico

Per iniziare a costruire la logica per un personaggio animabile, accedi all'editor del grafico di animazione tramite la scheda Avatar nel nastro di Studio. I seguenti passaggi dimostrano come inizializzare un rig e costruire una rete di nodi di base utilizzando le animazioni di camminata e saluto predefinite.

Per un approfondimento sulle applicazioni pratiche, puoi esplorare il File di Riferimento del Grafico di Animazione, che contiene sia esempi fondamentali che complessi di implementazione.

Per creare il tuo grafico di animazione, simile all'esempio di base fornito nel riferimento, utilizza i seguenti passaggi:

1. In Studio, aggiungi un rig animabile navigando nella scheda Avatar e selezionando Personaggio ⟩ Il mio Avatar.

   

2. Apri l'Editor del Grafico di Animazione navigando su Editor Grafico nella scheda Avatar.

   

3. Seleziona il rig animabile nella vista 3D. Nella vista dell'editor grafico, seleziona Grafico nell'angolo in alto a sinistra e seleziona Nuovo per creare un nuovo grafico.

4. Nell'Editor del Grafico, fai clic con il tasto destro e seleziona Inserisci Nodo ⟩ Clip.

   

5. Nel nuovo nodo Clip, imposta l'ID dell'Animazione.

   1. Seleziona il menu a discesa ID Animazione.

   2. Per inviare un ID di asset di animazione specifico, fai clic su Importa.

      

   3. Nel campo ID Animazione, aggiungi l'animazione di camminata predefinita: 507777826.

   4. Seleziona Importa.

6. Aggiungi un altro nodo clip ripetendo i passaggi 4-5 utilizzando l'animazione di saluto predefinita: 507770239.

   

7. Nell'Editor del Grafico, fai clic con il tasto destro e seleziona Aggiungi.

   

8. Collega i nodi Clip al nodo Aggiungi trascinando il connettore di uscita in alto a destra al porto appropriato:

   1. Collega il nodo Clip con l'animazione di camminata al porto Base.
   2. Collega il nodo Clip con l'animazione di saluto al porto Additivo.

   

9. Dal nodo Aggiungi, collega il connettore di uscita in alto a destra al porto di uscita del Grafico Pose.

   

10. OPZIONALE

    Assegna un parametro alla tua variabile Speed.

    1. Fai clic e trascina il porto verde Speed in un'area vuota. Viene visualizzato un nuovo nodo parametro.

       

    2. Nell'angolo in alto a sinistra dell'editor grafico, utilizza il pannello dei parametri per modificare rapidamente i parametri nei tuoi nodi. Puoi anche accedervi programmaticamente.

       

11. Testa l'animazione premendo il pulsante di riproduzione.

    

12. Prova a testare vari pesi, velocità, modalità di riproduzione e altre animazioni. Per ulteriori informazioni sui nodi individuali, consulta il riferimento ai nodi.

Integrazione API

Creare e distribuire un Grafico di Animazione segue il pipeline di animazione standard di Roblox. Dopo aver selezionato un rig nell'Editor del Grafico di Animazione, viene creato un nuovo asset AnimationGraphDefinition. Questo asset funge da contenitore per i tuoi nodi, connessioni e parametri. Una volta che la tua logica è finalizzata, pubblichi il grafico per ricevere un ID Asset standard.

Nei tuoi script, interagisci con questi grafici caricandoli su un Animator come faresti con un'animazione tradizionale. Per guidare la logica interna del grafico, utilizza AnimationTrack:SetParameter() per passare valori in tempo reale, come la velocità di movimento o i booleani di stato, direttamente nelle variabili del grafico.

local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://123456789" -- Il tuo ID Grafico Pubblicato

local animationTrack = animator:LoadAnimation(animation)
animationTrack:Play()

-- Aggiornamenti dinamici dei parametri tramite RunService
game:GetService("RunService").Stepped:Connect(function(_, dt)
    local currentSpeed = humanoidRootPart.AssemblyLinearVelocity.Magnitude
    animationTrack:SetParameter("humanoidSpeed", currentSpeed)
end)

Riferimento ai nodi

Regole degli eventi globali

Per tutti i nodi e le transizioni, le seguenti regole si applicano per impostazione predefinita:

• Gli eventi si propagano verso l'alto dal loro nodo sorgente attraverso il grafico. Ogni evento porta un peso che rappresenta l'influenza della sua sorgente nella miscelazione finale. Se il peso raggiunge zero in qualsiasi punto, l'evento viene silenziato.
• I nodi senza logica di evento personalizzata passano tutti gli eventi attraverso invariati; i nodi che mescolano o selezionano tra gli input possono scalare il peso o bloccare eventi da input non primari (vedi sezione Evento per nodo).
• Gli eventi marker che raggiungono la parte superiore del grafico possono essere osservati tramite AnimationTrack:GetMarkerReachedSignal().

Transizioni

Diversi nodi nel Grafico di Animazione (come Seleziona, Selezione Prioritaria, Sequenza e Sequenza Casuale) gestiscono come le animazioni si mescolano quando si passa tra input attivi. Per prevenire ridondanze nel riferimento ai nodi, questi comportamenti sono definiti da gruppi di proprietà di transizione standardizzati.

Transizione predefinita

Il comportamento di miscelazione di base applicato al nodo ogni volta che passa a un nuovo input attivo.

• DefaultTransitionDuration (numero): Il tempo (in secondi) necessario per mescolarsi completamente nella nuova posa.
• DefaultTransitionCurve (Enum.PoseEasingStyle): La funzione di easing applicata durante la miscelazione. Attualmente supporta solo Enum.PoseEasingStyle.Linear e Enum.PoseEasingStyle.CubicV2.

Sovrascrittura della transizione

Proprietà di collegamento specifiche per input che sovrascrivono la transizione predefinita. Le sovrascritture di durata e curva si applicano quando il nodo transita verso quell'input, tranne per le transizioni BeforeFinished, che utilizzano le sovrascritture dell'input in uscita.

• TransitionOverrideDuration (numero): Sovrascrive la durata della transizione predefinita.
• TransitionOverrideCurve (Enum.PoseEasingStyle): Sovrascrive la curva di transizione predefinita. Attualmente supporta solo Enum.PoseEasingStyle.Linear e Enum.PoseEasingStyle.CubicV2.

Tempistica della transizione

Per i tipi di nodo sequenza, le seguenti impostazioni controllano quando la sequenza avanza al prossimo input:

• WaitFor (Enum.AnimationNodeWaitFor): Imposta la condizione per avanzare. Usa Enum.AnimationNodeWaitFor|Finished (predefinito) per attendere che l'input corrente finisca o completi un ciclo, oppure Enum.AnimationNodeWaitFor|Trigger per avanzare quando WaitForTrigger è true. Imposta il valore predefinito a livello di nodo con DefaultWaitFor, o sovrascrivilo per un input con TransitionOverrideWaitFor.

  • Quando (Enum.AnimationNodeTransitionWhen): Si applica quando Wait For è Enum.AnimationNodeWaitFor|Finished. Imposta il valore predefinito a livello di nodo con DefaultTransitionWhen, o sovrascrivilo per l'input in uscita con TransitionOverrideWhen.

    • Enum.AnimationNodeTransitionWhen|Finished (predefinito): Inizia a mescolare dopo che l'input corrente è terminato.
    • Enum.AnimationNodeTransitionWhen|BeforeFinished: Inizia a mescolare un intervallo di transizione prima che l'input corrente finisca, in modo che la miscelazione si sovrapponga alla fine della sua animazione. Ad esempio, una transizione di 0,2 secondi inizia durante gli ultimi 0,2 secondi dell'animazione.

RandomSequenceNode supporta anche DefaultTransitionWhen e TransitionOverrideWhen per controllare quando inizia la miscelazione.

Per le transizioni della macchina a stati, vedere Proprietà di transizione.

Replicazione

I parametri del grafico di animazione e lo stato interno del nodo si replicano automaticamente. La modalità di replicazione è determinata da Workspace.AuthorityMode al momento della creazione dello script Animate:

• In Enum.AuthorityMode.Automatic: I parametri impostati tramite AnimationTrack:SetParameter() si replicano automaticamente ad altri peer.
• In Enum.AuthorityMode.Server: Il server guida la simulazione completa del grafico. Tutti gli stati dei nodi, come il tempo trascorso per Enum.AnimationNodeType.ClipNode, e i parametri del grafico si replicano automaticamente dal server ai client. Il client del giocatore proprietario utilizza la previsione per una riproduzione locale fluida.

Esempi di Script Animate

Per generare script di esempio per guidare un grafico di animazione per un rig, utilizza Grafico -> Crea script Animate nell'Editor del Grafico di Animazione. Questo produce una gerarchia di script posizionata sotto StarterCharacterScripts (per personaggi giocatori) o direttamente sul rig (per NPC):

Animate (ModuleScript)
├── RunClient (LocalScript)
└── RunServer (Script, RunContext = Legacy)

Il Modulo Animate ModuleScript contiene la logica di caricamento del grafico. Gli script RunClient e RunServer lo invocano nel contesto appropriato. Gli script inclusi dipendono dal caso d'uso:

I seguenti attributi sono memorizzati nello script Animate e configurano il suo comportamento:

Replicazione dei parametri in modalità Automatica

Quando Workspace.AuthorityMode è Automatica:

• Il client proprietario guida i grafici dei personaggi giocatori; il server guida i grafici degli NPC.
• I parametri impostati tramite AnimationTrack:SetParameter() si replicano automaticamente ad altri peer. Più chiamate a SetParameter all'interno di un singolo frame vengono coalesciate (l'ultimo scrittore vince).
• Non è necessaria alcuna programmazione aggiuntiva per il trasporto dei parametri: il motore gestisce la replicazione internamente.
• Altri client vedono gli aggiornamenti dei parametri con un piccolo ritardo (un intervallo di invio più la latenza di rete).

Autorità del server

Quando Workspace.AuthorityMode è Server:

• Il server è autorevole per tutti i grafici: esegue la simulazione e replica l'intero stato del grafico.
• Cosa viene replicato: Sia i parametri che lo stato interno del nodo, incluso il tempo trascorso, le selezioni correnti, il progresso della transizione, i conteggi dei loop e i semi RNG. Questo assicura che tutti i client vedano un comportamento di animazione identico.
• Personaggi giocatori: Il server guida il grafico. Lo script RunClient del client proprietario abilita automaticamente Enum.PredictionMode sul Animator, quindi il giocatore locale vede un'animazione fluida e prevista che si riconcilia con il server in caso di discrepanza.
• NPC: Il server guida esclusivamente il grafico; i client osservano lo stato replicato senza simulazione locale.

Guidare i parametri

Utilizza AnimationTrack:SetParameter() da ogni script che esegue il grafico:

• NPC (qualsiasi modalità): Chiama SetParameter da RunServer (o qualsiasi Script del server con accesso al AnimationTrack).
• Personaggio giocatore in Enum.AuthorityMode.Server: Chiama SetParameter da entrambi RunServer e RunClient. Il server ha bisogno di parametri per guidare la simulazione autorevole, e il client proprietario ha bisogno degli stessi parametri per guidare la sua previsione locale.
• Personaggio giocatore in Enum.AuthorityMode.Automatic: Chiama SetParameter da RunClient (o qualsiasi LocalScript del client con accesso al AnimationTrack).

Lo script Animate generato include un blocco SetParameter commentato come punto di partenza. Decommentalo e modificalo per guidare i parametri dallo stato di gioco (velocità di movimento, stato umanoide, direzione di input, ecc.).