Aller au contenu principal

Animations de FreeMinecraftModels

FreeMinecraftModels importe les animations des fichiers .bbmodel et .fmmodel. Cette page présente les noms réservés, le mélange des animations, le minutage des images, l'interpolation, les modes de boucle, la cinématique inverse (IK) et la façon dont les modèles tournent.

Pour les règles de nommage des os et le reste du contrat d'importation, voir les Notes de création de modèles.

Animations d'état​

FreeMinecraftModels associe ces six noms d'animation en minuscules, ainsi que les quatre noms de nage et de chevauchée ci-dessous, à des états d'exécution automatiques. Tout le reste dans le modèle est une animation personnalisée.

Nom de l'animationBoucleQuand elle se joue
spawnnonUne seule fois, à la création du modèle. Quand elle se termine, le modèle passe à walk si son entité se déplace, sinon à idle
idleouiTant que l'entité n'a aucune vitesse horizontale. Fondu enchaîné vers walk lorsque la vitesse sur X ou Z devient non nulle
idle.longnonUne seule fois, après que le modèle a affiché idle sans rien d'autre en cours pendant une durée aléatoire comprise entre longIdleMinSeconds et longIdleMaxSeconds (15 à 30 secondes par défaut). Le modèle repasse ensuite en fondu enchaîné à idle et l'attente recommence
walkouiTant que la vitesse de l'entité sur X ou Z est non nulle. Fondu enchaîné vers idle lorsque les deux sont nulles
attacknonLorsqu'elle est déclenchée. Se joue une fois par-dessus idle ou walk, puis se termine
deathnonLors de removeWithDeathAnimation(). Apparaît en fondu depuis la pose actuelle. Quand elle se termine, le modèle rétrécit en 20 ticks puis est retiré

FMM ne déclenche lui-même attack que pour les Evokers, lorsque des crocs invoqués par l'Evoker apparaissent à moins de deux blocs de lui. Les autres plugins déclenchent les attaques via l'API. EliteMobs joue attack.melee et attack.ranged. Chaque nom qui commence par attack. est une attaque, jouée comme attack.

idle.long ne se joue qu'une fois, quel que soit le réglage de boucle de Blockbench. Se déplacer, une attaque ou une autre action, une animation personnalisée sur la couche de base et un joueur qui dirige le mob comme monture font tous recommencer l'attente, et les mêmes choses interrompent un idle.long en cours. Un modèle sans idle.long n'attend jamais. idle.long nécessite FreeMinecraftModels 2.15.0 ou plus récent ; les versions antérieures le traitent comme une animation personnalisée.

Quatre autres animations de base se jouent à la place de walk et idle pendant que le mob nage ou qu'un joueur le chevauche, dès que le modèle les possède :

  • Chevauchée. Un modèle sur un cheval sellé qu'un joueur dirige, comme un familier chevauché ou une monture /fmm mount, joue ride à la place de walk pendant qu'il se déplace, et idle.ride à la place de idle pendant qu'il est immobile. Un fichier de familier peut nommer d'autres animations avec riding.animation et riding.idleAnimation ; voir Chevauchée. Les plugins appellent getAnimationComponent().setRiddenAnimation(name) et setRiddenIdleAnimation(name), où null en désactive une. Un modèle sans ride marche sous son cavalier, et un modèle sans idle.ride joue idle.
  • Nage. Un modèle dont le mob nage, c'est-à-dire qu'il est dans l'eau sans toucher le sol, joue swim à la place de walk pendant qu'il se déplace, et idle.swim à la place de idle pendant qu'il se tient immobile. Un fichier de familier peut nommer d'autres animations avec swimming.animation et swimming.idleAnimation ; voir Nage. Les plugins appellent getAnimationComponent().setSwimAnimation(name) et setIdleSwimAnimation(name), où null en désactive une. Un modèle sans swim marche dans l'eau, et un modèle sans idle.swim joue idle pendant qu'il se tient immobile. Une monture qu'un joueur dirige joue aussi ses animations de chevauchée dans l'eau.

Les quatre nécessitent FreeMinecraftModels 2.15.0 ou plus récent.

Nommage​

Les noms d'animation sont en minuscules. Un point sépare un nom général d'un nom plus précis, et un tiret bas relie les mots à l'intérieur d'une même partie : idle.long est une sorte d'idle, et attack.melee une sorte d'attack. Chaque pose immobile s'écrit idle. suivi du nom du mouvement qu'elle met en pause :

En mouvementImmobile
Sur terrewalkidle, et de temps en temps idle.long
Dans l'eauswimidle.swim
Chevauchérideidle.ride

Lorsqu'un modèle n'a pas un nom à points, FMM joue à la place le nom jusqu'à son dernier point : attack pour attack.melee, idle pour idle.swim. Il en va de même pour les noms que jouent les scripts et les plugins : playAnimation et hasAnimation suivent tous deux cette règle.

Les modèles créés avant cela utilisaient long_idle, attack_melee et attack_ranged. FMM les trouve sous les nouveaux noms, et les nouveaux noms sous les anciens : les anciens modèles et les anciens plugins continuent donc de fonctionner sans modification.

Les noms à points, le repli et les anciennes graphies nécessitent FreeMinecraftModels 2.15.0 ou plus récent.

Règles qui découlent de la façon dont la machine à états est construite :

  • L'état de départ est spawn si le modèle en possède un, sinon idle. Un modèle qui n'a ni l'un ni l'autre affiche sa pose de repos jusqu'à ce qu'il se mette à marcher ou que quelque chose joue une animation.
  • Seules les animations qui existent dans le modèle sont utilisées. Un modèle avec un walk mais sans idle continue de marcher après avoir cessé de bouger.
  • La transition idle/walk lit la vitesse horizontale de l'entité sous-jacente : un mouvement uniquement vertical ne déclenche pas la marche. Les entités statiques et les déguisements n'ont pas d'entité sous-jacente utilisable à cette fin ; les props immobiles n'ont aucun mouvement horizontal. Leurs autres animations sont pilotées par les scripts, l'API ou le contrôleur de déguisement de FMM.
Pas d'état jump

Les entités modélisées ordinaires n'ont pas d'état de saut. Une animation nommée jump se comporte comme n'importe quelle autre animation personnalisée et doit être jouée par son nom. Les déguisements de joueurs font exception : leur contrôleur distinct joue jump lorsque le joueur saute.

Mélange des animations​

FMM joue les animations d'un modèle sur deux couches et les mélange en une seule pose à chaque tick, sur Java comme sur Bedrock.

CoucheCe qui s'y joue
Basespawn, idle, idle.long, walk, les animations de chevauchée et de nage, et death, ou une animation personnalisée jouée avec blend à false, qui prend le contrôle de toute la pose
Actionattack et chaque nom attack., comme attack.melee et attack.ranged, damaged, et les animations personnalisées jouées avec blend à true. Une action se joue par-dessus la couche de base : un modèle peut donc attaquer tout en marchant

Un os que l'animation de base ne contrôle pas par des images clés revient à sa pose de repos. Un os que l'action ne contrôle pas par des images clés garde sa pose de base.

Fondus​

ChangementFondu
Entre idle, idle.long, walk et les animations de chevauchée et de nageFondu enchaîné sur idleWalkBlendTicks, 5 ticks par défaut. Les deux animations continuent de jouer pendant le fondu
N'importe quelle animation vers deathFondu depuis la pose affichée par le modèle au tick précédent, action comprise, sur deathBlendTicks, 4 ticks par défaut
Tout autre changementInstantané

Les fondus accélèrent puis ralentissent au lieu de progresser à vitesse constante. Lorsqu'un nouveau changement idle/walk interrompt un fondu, le fondu suivant part de la pose que le modèle affichait. Les actions démarrent et se terminent sans fondu.

Override et poids de mélange​

FMM lit deux réglages dans les propriétés de chaque animation dans Blockbench.

Réglage BlockbenchEffet dans FMM
Override activéSur la couche d'action, les os que l'animation contrôle prennent sa pose et abandonnent la pose de base
Override désactivé (par défaut)Sur la couche d'action, la rotation et la position de l'animation s'ajoutent à la pose de base des os qu'elle contrôle, et son échelle multiplie l'échelle de base
Blend WeightRègle l'intensité d'application de l'animation, sur l'une ou l'autre couche. 1 (la valeur par défaut) applique les images clés telles qu'elles ont été créées. 0.5 applique la moitié de chaque rotation et position, et fait avancer l'échelle à mi-chemin entre 1 et la valeur de l'image clé

Activez Override lorsque les os contrôlés par une attaque doivent atteindre exactement la pose créée, quoi que fasse le cycle de marche. Laissez-le désactivé pour ajouter le mouvement de l'attaque à la marche, par exemple un coup de bras pendant que les jambes continuent de marcher. Sur Java, Override n'a aucun effet sur les animations de la couche de base, qui remplacent toujours la pose.

FMM ne lit Blend Weight que comme un simple nombre. Une expression Molang journalise Model <model>, animation <animation> has the blend weight '<value>'. FreeMinecraftModels only reads plain numbers and uses 1. FMM ne prend pas en charge les réglages Start Delay, Loop Delay et Anim Time Update de Blockbench. Une animation qui en définit un journalise un avertissement et se joue sans eux.

Quelle animation l'emporte​

  • Les animations personnalisées, damaged compris, l'emportent sur les animations intégrées. Tant que l'une d'elles se joue sur l'une ou l'autre couche, les demandes d'attaque sont ignorées. death interrompt tout.
  • Une nouvelle action remplace l'action en cours : une seconde attaque relance donc l'attaque, et une animation personnalisée jouée avec blend à true remplace une attaque en cours.
  • Une animation personnalisée jouée avec blend à false met fin à l'action en cours.
  • Tant qu'une animation personnalisée occupe la couche de base, FMM continue de suivre idle et walk en arrière-plan. Prendre la couche de base met fin à un spawn ou un idle.long en cours. Quand une animation personnalisée à lecture unique se termine, le modèle passe d'un coup à idle ou walk, selon son mouvement. Une demande explicite de idle ou walk met fin immédiatement à une animation personnalisée en boucle, et s'affiche après la fin d'une animation à lecture unique.
  • Une action à lecture unique se termine après sa dernière image. Si la couche de base n'a rien à afficher, par exemple sur un prop sans animation spawn ni idle, l'action garde sa dernière image : une porte ouverte de cette façon reste donc ouverte. Une animation personnalisée à lecture unique sur la couche de base garde aussi sa dernière image lorsque le modèle n'a ni idle ni walk vers lequel revenir.

Les déguisements utilisent un autre ensemble d'animations​

Un déguisement ajoute un contrôleur par tick qui demande les animations au même moteur de lecture. Ses cinq noms réservés sont attack, jump, sneak, walk, idle, évalués dans cet ordre de priorité lorsque le compte à rebours d'une animation à lecture unique est inactif. attack se joue sur la couche d'action, jump et sneak prennent le contrôle de la couche de base, et idle et walk sélectionnent les états intégrés. Il avertit la console si le modèle n'a pas d'idle. Consultez les déguisements des joueurs pour le tableau complet et la limite de durée de ces animations.

Animations personnalisées​

Toute animation dont le nom n'est pas l'un des noms d'état ci-dessus peut quand même être jouée par son nom :

modeledEntity.playAnimation("open", /* blend */ true, /* loop */ false);
modeledEntity.stopCurrentAnimations();
boolean exists = modeledEntity.hasAnimation("open");
context.prop:play_animation("open", true, false)
context.prop:stop_animation()
  • blend choisit la couche d'une animation personnalisée. true la joue sur la couche d'action, par-dessus idle ou walk, avec son Override Blockbench et son poids de mélange. false lui donne la couche de base : elle remplace alors toute la pose et met fin à l'action en cours. Voir Mélange des animations.
  • Les demandes sont mises en file d'attente et appliquées dans l'ordre au début du prochain tick du modèle. Chaque demande est exécutée ; une demande ultérieure n'annule pas une demande antérieure de la file.
  • loop s'applique aux animations personnalisées et à damaged. Les noms intégrés ignorent à la fois blend et loop : idle et walk bouclent toujours, tandis que spawn, death et les attaques ne se jouent qu'une fois. idle.long joué par son nom est une animation personnalisée comme les autres.
  • Les noms intégrés et les noms d'attaque sont reconnus quelle que soit la casse. Pour les autres noms, FMM cherche d'abord le nom exact, puis sa forme en minuscules, puis l'ancienne graphie d'un nom renommé, puis la partie générale d'un nom à points (voir Nommage). hasAnimation trouve les mêmes noms que ceux que joue playAnimation. Le modèle doit contenir le nom en minuscules pour qu'un état intégré fonctionne.
  • damaged se joue toujours sur la couche d'action, quelle que soit la valeur de blend.
  • playAnimation renvoie false pour un nom que le modèle ne possède pas et pour toute demande faite après celle de death. true signifie que la demande a été mise en file d'attente, pas qu'une image a été affichée : une attaque peut encore être ignorée à cause d'une animation personnalisée en cours.
  • stopCurrentAnimations() met fin à toutes les animations personnalisées et actions et fait passer le modèle d'un coup à idle, ou à sa pose de repos s'il n'a pas d'idle.
  • La mort est terminale : une fois death demandée, les nouvelles demandes de lecture renvoient false, les demandes en attente sont ignorées et stopCurrentAnimations() ne fait rien.

Cadence et durée​

  • Blockbench stocke la durée d'animation en secondes. FMM la convertit avec ceil(seconds x 20) : la durée est toujours un nombre entier de ticks, et les animations courtes sont arrondies vers le haut.
  • Un canal contenant uniquement des nombres est précalculé à l'importation dans un tableau plat d'images par tick, et la lecture consulte une image par tick. Un canal contenant une keyframe MoLang est à la place échantillonné à chaque tick pour chaque entité ; voir Keyframes MoLang.
  • Chaque animation en cours de lecture garde son propre compteur de ticks : la couche de base, la couche d'action et une animation en fondu avancent donc indépendamment. Les animations en boucle s'indexent avec counter % duration ; celles sans boucle se bloquent sur leur dernière image.
  • Les temps des images clés conservent leur position fractionnaire en ticks (20 x time, sans arrondi) : une image clé à 0,37 s contribue à l'interpolation entre ticks. Les images sont échantillonnées aux ticks entiers de 0 à duration - 1 ; une image clé placée exactement à la fin déclarée influence l'interpolation, mais n'est pas elle-même échantillonnée. Placez la pose finale avant cette limite si une image affichée doit l'atteindre.
  • Si deux keyframes du même canal tombent exactement au même instant, c'est la dernière dans l'ordre du fichier qui l'emporte.
  • Une keyframe dont le temps n'est pas un nombre fini interrompt cette piste et produit un unique avertissement Malformed animation timeline for model ... par animation, tandis que les autres animations du modèle continuent d'être converties.

Les animations de longueur nulle sont valides​

Une animation dont la longueur est 0 (ou négative) est traitée comme une pose statique intentionnelle — un choix de création courant pour le mobilier et les autres props qui ont besoin d'une entrée « aucune animation » nommée. Elle est ignorée silencieusement, sans avertissement, et ne produit aucune image.

Modes de boucle​

Le réglage de boucle de Blockbench détermine l'animation exportée pour Bedrock :

Mode de boucle BlockbenchExport Bedrock
loop"loop": true
once"loop": false
hold"loop": "hold_on_last_frame"

La lecture Java utilise la règle de boucle de l'état intégré ou l'argument loop passé à une animation personnalisée. Elle ne détermine pas sa règle à partir de ce champ Blockbench : la lecture peut donc différer entre Java et Bedrock si ces réglages ne concordent pas.

Types d'interpolation​

Chaque keyframe porte l'un de quatre types d'interpolation : linear, catmullrom (Lissé dans Blockbench), bezier et step. Tout ce qui sort de cet ensemble échoue à l'analyse et est signalé comme une timeline malformée.

FMM joue le segment entre deux keyframes comme l'aperçu de Blockbench, à partir des types des deux keyframes, vérifiés dans cet ordre :

  1. Une keyframe step garde sa valeur jusqu'à la keyframe suivante.
  2. Une keyframe linear suivie d'une keyframe linear ou step s'interpole en ligne droite.
  3. Lorsque l'une des deux keyframes est catmullrom, le segment suit une courbe de Catmull-Rom passant par la keyframe qui précède le segment, les deux keyframes du segment et la keyframe qui le suit, de sorte que le mouvement traverse chaque keyframe au lieu de s'y arrêter. Un voisin manquant répète l'extrémité du segment. Dans une animation dont le mode de boucle Blockbench est loop, avec au moins trois keyframes sur le canal, la courbe se poursuit à travers la boucle, la dernière keyframe étant traitée comme la première à nouveau.
  4. Sinon, l'une d'elles est bezier : le segment suit la poignée droite de la keyframe de départ et la poignée gauche de la keyframe d'arrivée, en temps et en valeur. Une keyframe enregistrée sans poignées les a à 0,1 seconde de chaque côté, sans décalage de valeur. Le temps d'une poignée est maintenu à l'intérieur du segment.

Avant sa première keyframe, un canal garde la valeur de cette keyframe, et après sa dernière keyframe il garde celle de la dernière.

Une keyframe avec des valeurs pre et post distinctes est atteinte avec sa valeur pre et quittée avec sa valeur post. Sur un segment lissé, une telle keyframe termine aussi la courbe de son côté. Une valeur post que FMM ne peut pas lire est ignorée.

Ces règles s'appliquent aux canaux précalculés, aux canaux MoLang sur Java et aux pistes précalculées de l'export Bedrock. Elles nécessitent FreeMinecraftModels 2.15.0 ou plus récent. De la FreeMinecraftModels 2.3.0 à la 2.14.2, chaque segment était interpolé selon le seul type de la keyframe d'arrivée : catmullrom ralentissait jusqu'à l'arrêt à chaque keyframe, bezier utilisait des points de contrôle fixes 0.42 et 0.58 quelles que soient ses poignées, ce qui se jouait presque en ligne droite, et une keyframe step sautait à sa valeur à mi-chemin du segment qui y menait. Les valeurs pre et post distinctes étaient fusionnées en la valeur pre. Les modèles avec des keyframes lissées, step ou Bézier bougent donc différemment après la mise à jour, d'une manière plus proche de ce que leur auteur voyait dans Blockbench.

Canaux animés​

Trois canaux sont précalculés par os : rotation, position et échelle. Points importants pour la création :

  • Les valeurs de position sont divisées par 16 (pixels Blockbench vers blocs).
  • Les valeurs de rotation sont converties en radians.
  • Les format_version 5 et ultérieures de Blockbench inversent le signe des rotations X et Y ainsi que de la position X. FMM compense automatiquement en fonction de la version de format déclarée, donc ne corrigez pas cela à la main — mais ne mélangez pas non plus une déclaration v5 avec des données au format v4.
  • Un os sans keyframe sur un canal conserve sa valeur de repos pour ce canal. Un os que l'animation de la couche de base ne contrôle pas du tout est réinitialisé à rotation 0,0,0, translation 0,0,0, échelle 1,1,1 ; un os que l'action ne contrôle pas garde la pose de base.
  • Les points de données des keyframes peuvent être écrits sous forme de chaînes dans le .bbmodel. Une chaîne qui est un nombre est lue comme ce nombre, et une chaîne vide devient 1 pour l'échelle et 0 sinon. Toute autre chaîne est une expression MoLang ; voir Keyframes MoLang.
  • Une keyframe avec deux points de données, les valeurs pre et post distinctes de Blockbench, est atteinte avec le premier et quittée avec le second. Voir Types d'interpolation.

Keyframes MoLang​

Une valeur de keyframe écrite sous forme d'expression MoLang, comme math.sin(query.anim_time * 360) * 10, est évaluée pour chaque entité pendant la lecture de l'animation.

  • Un canal, c'est-à-dire la rotation, la position ou l'échelle d'un os, ou la position d'un contrôleur d'IK, qui contient au moins une keyframe MoLang n'est pas précalculé. Chaque entité l'échantillonne à chaque tick, avec la même interpolation et la même conversion d'unités que les canaux précalculés. Les keyframes numériques de ce canal conservent leurs valeurs.
  • Ces requêtes sont disponibles, aussi avec le préfixe court q. :
RequêteValeur
query.anim_timeSecondes écoulées dans cette animation. Une animation en boucle repart de 0 à chaque boucle
query.life_timeSecondes écoulées depuis la création du modèle
query.modified_distance_movedBlocs parcourus horizontalement par l'entité
query.is_moving1 tant que l'entité se déplace horizontalement, sinon 0
  • Les autres requêtes et les variables inconnues valent 0. Une variable v. conserve sa valeur sur cette entité entre deux évaluations, et une valeur temp. (t.) ne dure que le temps d'une expression.
  • Les expressions utilisent les mêmes opérateurs et fonctions mathématiques que le MoLang des particules.
  • Un programme de plusieurs instructions sans return prend la valeur de sa dernière ligne, comme l'aperçu de Blockbench. v.a = 10; v.b = v.a * 3; v.b + 5 donne 35. Une dernière ligne qui est une affectation vaut 0. Le MoLang des particules conserve la règle de Bedrock, où un programme sans return vaut 0.
  • Une expression que FMM ne peut pas analyser journalise une seule fois au chargement Failed to parse the keyframe expression '<expression>' in animation <animation> for model <model>: <reason>. That value plays as 0.
  • Un résultat qui n'est pas un nombre fini donne 0.
  • Un segment lissé évalue aussi les keyframes situées de part et d'autre pour façonner sa courbe. Ces évaluations ne conservent aucune des variables qu'elles assignent : les assignations d'une keyframe ne prennent donc effet que pendant les ticks des segments qu'elle commence ou termine.

Les joueurs Bedrock évaluent ces canaux sur leur propre client : l'export Bedrock écrit les keyframes du canal telles que créées, voir Export Bedrock.

Ce qui n'est pas animé​

  • L'os hitbox. Les pistes d'animation qui le ciblent sont purement et simplement ignorées.
  • Les images clés de son et d'instructions de timeline des pistes d'effets de Blockbench. FMM n'importe que les images clés de particules d'une piste d'effets ; voir Particules. Jouez plutôt les sons depuis un script Lua ou depuis votre propre plugin.
  • Les os qui n'ont pas pu être résolus par leur nom. Une piste pointant vers un os manquant journalise Failed to get bone <name> from model <model>! et est ignorée.

Cinématique inverse (IK)​

Les null objects de Blockbench servent de contrôleurs d'IK. FMM résout les chaînes à l'exécution avec FABRIK (Forward And Backward Reaching Inverse Kinematics), plafonné à 10 itérations avec une tolérance de 0.001.

Comment tout cela s'articule :

  1. Un null object avec ik_source (os racine) et ik_target (os terminal ou locator) définit une chaîne. La détection examine la hiérarchie et prend aussi en charge les recherches entre frères et vers les descendants ; des cibles sœurs au niveau racine produisent une chaîne contenant seulement l'os source.
  2. Seules les images clés de position du null object pilotent l'IK. Elles deviennent un décalage par image ajouté à la position de repos de l'os ou du locator cible. Le solveur n'utilise pas la position de repos stockée du contrôleur comme origine de la cible. La rotation et l'échelle ne pilotent pas l'IK.
  3. À chaque tick, chaque chaîne suit l'animation en cours de lecture la plus haute qui la pilote : l'action, puis l'animation de base, puis une animation en fondu sortant. Le décalage cible de cette animation est appliqué et la chaîne est résolue. Une chaîne qu'aucune animation en cours ne pilote est réinitialisée : une pose IK n'est donc pas reportée sur une animation qui ne l'utilise pas.
  4. lock_ik_target_rotation est lu et stocké, mais le solveur actuel ne l'applique pas.

Les chaînes qui ne peuvent pas être résolues sont ignorées avec un avertissement console nommé — voir les Notes de création de modèles pour les messages exacts et les contraintes de création.

Export Bedrock​

Chaque modèle converti écrit également un fichier d'animation Bedrock dans animations/<model_id>.animation.json à l'intérieur du bundle généré :

  • Les identifiants d'animation sont animation.fmm.<model_id>.a_<hex>, où <hex> correspond aux octets UTF-8 du nom de l'animation écrits en hexadécimal. Deux noms qui ne diffèrent que par des caractères interdits par Bedrock reçoivent donc des identifiants distincts.
  • animation_length est la durée en secondes, avec un plancher à 0.05 afin qu'une animation d'un seul tick reste valide.
  • Le mode de boucle est mappé comme indiqué dans le tableau Modes de boucle.
  • Un modèle sans aucune animation reçoit tout de même une entrée idle inerte afin que la définition d'entité Bedrock reste valide.
  • La géométrie exclut hitbox, les os de nom générés fmm_nametag_bone_* et les points de monture m_ ; les ancrages tag_ créés par l'auteur restent présents. L'exporteur d'animations écrit les pistes précalculées sans appliquer le même filtre d'os visuels : n'animez donc pas un os de monture exclu en espérant voir sa géométrie.
  • L'export Bedrock utilise les images précalculées de rotation, position et échelle des os. Il n'y incorpore pas les rotations produites à l'exécution par le solveur IK ; vérifiez séparément sur Bedrock les modèles qui dépendent de l'IK.
  • Un canal d'os contenant une keyframe MoLang est écrit tel que créé, expressions et nombres confondus, et les clients Bedrock l'évaluent. Un programme de plusieurs instructions est écrit avec return avant sa dernière ligne, de sorte que Bedrock joue la même valeur que Java. À partir de la 2.14.2, il reçoit aussi le ; final que Bedrock exige. Ses keyframes s'interpolent linéairement sur Bedrock, quelle que soit l'interpolation choisie, et seules leurs valeurs pre sont écrites. Sur un modèle dont le format_version est 5 ou supérieur, la rotation X et Y et la position X sont envoyées inversées, un nombre par son opposé et un programme avec sa valeur de retour inversée, de sorte que Bedrock joue la même pose que Java.
  • Un modèle exporté est suspendu à un os freeminecraftmodels_lean dont le pivot se situe au milieu de ses cubes. Il montre aux joueurs Bedrock l'inclinaison de l'orientation de déplacement et le centrage grâce à quatre propriétés d'entité entières, freeminecraftmodels:lean_x, lean_y, lean_z et body_offset. Un modèle de plus de 672 animations, en comptant celles générées qui masquent un os saddle ou fish, n'a pas de place pour ces propriétés, n'obtient pas d'os d'inclinaison et reste droit sur ses pieds sur Bedrock.
  • Un contrôleur d'animation est généré par animation, commuté par une propriété d'entité : c'est ainsi que FMM joue une animation précise sur un client Bedrock. FMM commute à la fois l'animation de base et l'action, comme les couches Java.
  • Un modèle avec un os nommé saddle, quelle que soit la casse, reçoit une animation de plus, freeminecraftmodels_hide_saddle, après les siennes, et un modèle avec un os nommé fish reçoit freeminecraftmodels_hide_fish ensuite. Chacune réduit à une taille nulle son os et les os qui en dépendent, et ne se joue que pendant que le serveur masque l'os : la selle d'un familier chevauchable tant qu'il n'est pas sellé, et le poisson d'un familier pêcheur tant qu'il ne rapporte pas de prise à la maison. Cela nécessite FreeMinecraftModels 2.15.0 ou plus récent.
  • Une animation avec Override activé est écrite avec "override_previous_animation": true, et un poids de mélange différent de 1 avec "blend_weight". Les animations de base idle, walk, spawn et death viennent en premier dans la liste animate de l'entité, de sorte que les actions se superposent à elles.
  • Le blend_transition des contrôleurs reprend les durées de fondu de Java : idle et walk entrent et sortent en fondu sur idleWalkBlendTicks, death entre en fondu sur deathBlendTicks, et toute autre animation bascule instantanément, idle.long et les animations de chevauchée et de nage comprises. Ces durées sont écrites lors de la génération du pack : un changement de configuration n'atteint donc les joueurs Bedrock qu'après la régénération du pack.
  • Les images clés de particules deviennent la timeline particle_effects de l'animation, que les clients Bedrock jouent donc nativement. Voir Particules.
Disponibilité selon la version

Ces changements nécessitent FreeMinecraftModels 2.16.0 :

  • Un modèle n'a plus d'os d'inclinaison au-delà de 532 animations au lieu de 672, en comptant toujours les animations de masquage générées.
  • La rotation X et Y et la position X à keyframes sont jouées de la même façon sur Bedrock et sur Java. De la 2.8.0 à la 2.15.0, les pistes précalculées de chaque modèle, et les canaux MoLang d'un modèle dont le format_version est 5 ou supérieur, sortaient avec ces axes en miroir. Un mouvement qui oscille également autour de zéro avait le même aspect, mais une pose maintenue d'un côté se pliait de l'autre sur Bedrock, comme un coude plié vers l'arrière. Les joueurs Bedrock voient la correction une fois le pack régénéré et le nouveau pack pris par leur client.

Voir Sortie du resource pack pour savoir où le bundle atterrit sur le disque.

Inertie de rotation​

Lorsque weightedTurning est activé (par défaut), un modèle appliqué à un mob tourne vers l'orientation du mob avec de l'inertie au lieu de s'y aligner d'un coup. À chaque tick, sa vitesse de rotation varie au plus de la valeur d'accélération, jusqu'au plafond de vitesse, et il ralentit assez tôt pour s'arrêter exactement sur la nouvelle orientation. Le mob lui-même tourne et marche comme avant. Les os du modèle, sa hitbox, ses locators et sa présentation Bedrock utilisent tous l'orientation du modèle.

Les deux limites dépendent de la taille du modèle :

  • La taille est la racine cubique du volume de l'os hitbox (largeur x profondeur x hauteur, en blocs), multipliée par l'attribut scale du mob. Un modèle sans os hitbox utilise à la place la racine cubique de la boîte englobante du mob. Les tailles inférieures à 0.25 comptent pour 0.25
  • La vitesse maximale est turnSpeedCap divisé par la racine carrée de la taille, et jamais plus de 90 degrés par tick
  • L'accélération est turnAcceleration divisé par la taille

Avec les valeurs par défaut turnSpeedCap: 30 et turnAcceleration: 6 :

HitboxTailleVitesse maximale (degrés par tick)Accélération (degrés par tick, à chaque tick)
0.5 x 0.5 x 0.50.542.412
1 x 1 x 11306
2 x 2 x 2221.23
4 x 4 x 44151.5

Autres règles :

  • Un modèle tourne instantanément lorsqu'un joueur monte directement son mob ou s'assoit sur l'un de ses sièges m_, afin que la vue du cavalier et le modèle restent ensemble.
  • Un modèle sur un cheval sellé que dirige un joueur, comme celui d'un /fmm mount, fait face à la direction du cavalier, et sa tête reste à l'horizontale au lieu de suivre le regard du cavalier vers le haut ou le bas.
  • Les os de tête h_ suivent la tête du mob et peuvent devancer le corps, plus lent, d'au plus 75 degrés.
  • Un modèle qui meurt garde l'orientation qu'il avait. Un modèle dont la synchronisation de mouvement est désactivée garde sa propre orientation.
  • Les entités statiques, les props et les déguisements de joueurs n'utilisent pas l'inertie de rotation.

Orientation de déplacement​

Un modèle dynamique peut s'incliner selon son déplacement en plus de faire face à sa direction. Les marcheurs restent à l'horizontale, mais les créatures volantes et nageuses ne devraient généralement pas le rester. Les familiers règlent cela depuis la section orientation de leur fichier de familier. Les plugins appellent DynamicEntity#setTravelOrientation(TravelOrientation). Les modèles sont UPRIGHT par défaut.

StyleInclinaison
UPRIGHTAucune. Le modèle ne fait que faire face à sa direction
TOP_FIRSTLe haut mène, comme une méduse : il s'incline dans son déplacement, se couche sur le côté en croisière et se retourne pour plonger
FRONT_FIRSTL'avant mène, comme un oiseau ou un poisson : il tangue dans les montées et les plongées et s'incline dans les virages, jusqu'à 45 degrés d'inclinaison latérale
RéglageDéfautSignification
startSpeed0.6Blocs par seconde en dessous desquels le modèle reste droit, afin que la dérive au repos et le balancement ne le fassent pas pencher
fullSpeed4.0Blocs par seconde auxquels il s'aligne complètement sur son déplacement. Entre les deux, il s'incline en partie
maxTilt180Inclinaison maximale, en degrés, de 0 à 180
turnSpeed180Degrés par seconde dont son inclinaison peut varier
  • L'inclinaison fait tourner le modèle entier autour du milieu de ses cubes, après son orientation et ses animations : chaque os, locator et point de monture la suit.
  • La vitesse provient du mouvement de l'entité, lissé sur quelques ticks. Un déplacement de plus de 2,5 blocs en un tick compte comme une téléportation et n'incline pas le modèle.
  • Un modèle peut s'incliner autrement pendant que son mob nage, c'est-à-dire lorsqu'il est dans l'eau sans toucher le sol. Les familiers le règlent avec swimming.orientation (voir Nage), et les plugins avec DynamicEntity#setSwimOrientation(TravelOrientation), où null incline comme sur terre. Pendant qu'il nage, l'inclinaison suit aussitôt la vitesse propre du mob, freinée seulement par turnSpeed, plutôt que la vitesse lissée : le nez d'un nageur pointe donc vers le haut pendant qu'il monte et vers le bas pendant qu'il plonge. Cela nécessite FreeMinecraftModels 2.15.0 ou plus récent.
  • Le modèle se redresse progressivement lorsqu'il s'arrête, pendant qu'il meurt, pendant qu'un joueur le chevauche et lorsque sa synchronisation de mouvement est désactivée.
  • Les joueurs Bedrock voient l'inclinaison grâce à l'os d'inclinaison exporté (voir Export Bedrock). Elle change par paliers, au rythme des ticks du serveur, sans lissage côté client. Après la première régénération du pack avec l'os d'inclinaison, redémarrez le serveur une fois pour que le pont Bedrock enregistre les nouvelles propriétés d'entité.

Centrage sur le corps​

ModeledEntity#setCenteredOnBody(true) dessine un modèle avec le milieu de ses cubes sur le milieu de son entité, au lieu de le poser sur les pieds de l'entité. Une créature volante ou nageuse dont le modèle est bien plus grand que son corps caché se déplace, tourne et s'incline alors autour de ce corps. La plaque de nom de repli, la boîte de clic et la hitbox suivent le modèle. Les os hitbox et de plaque de nom ne comptent pas dans le calcul du milieu.

Il est désactivé par défaut. Les familiers l'activent pour les espèces FLYING et AQUATIC, et leur clé centerOnBody remplace cette valeur. Les joueurs Bedrock voient aussi le modèle centré, grâce au même os d'inclinaison. La boîte de collision propre à l'entité Bedrock commence toujours à ses pieds.

Jouer des animations depuis d'autres systèmes​

AppelantPoint d'entrée
Plugin (Java)ModeledEntity#playAnimation(String, boolean blend, boolean loop) / #stopCurrentAnimations() / #hasAnimation(String)
Script Lua de propcontext.prop:play_animation(name, blend, loop) / context.prop:stop_animation()
Toute table d'entité Luaentity.model:play_animation(name, blend, loop) / entity.model:stop_animations() (disponible lorsque entity.is_modeled vaut true)

Consultez le guide de l'API pour les développeurs et Lua : API des props pour les interfaces associées.

Les valeurs Lua par défaut diffèrent : context.prop:play_animation(name) utilise blend=true, loop=true, tandis que entity.model:play_animation(name) utilise false, false. Passez explicitement les deux booléens lorsque cette distinction compte.

Dépannage​

Mon animation ne se joue jamais automatiquement. La machine à états partagée reconnaît les noms minuscules spawn, idle, idle.long, walk, swim, idle.swim, ride, idle.ride, attack et death, et traite chaque nom attack. et damaged comme des actions. Le mouvement pilote les transitions idle/walk, la nage et un cavalier qui dirige font intervenir les animations de nage et de chevauchée, et idle.long attend une période calme d'inactivité ; les attaques et la mort nécessitent toujours leur déclencheur à l'exécution. Voir Animations d'état. Les autres noms exigent un appel explicite à playAnimation / play_animation, sauf les noms supplémentaires sélectionnés par le contrôleur de déguisement.

Mon modèle ne fait strictement rien. Il n'a probablement ni animation spawn ni animation idle : il affiche donc sa pose de repos jusqu'à ce qu'il marche ou que quelque chose joue une animation. Ajoutez une animation idle.

Mon attaque a l'air bizarre pendant que le modèle marche. Avec Override désactivé, l'attaque s'ajoute à la pose de marche de chaque os qu'elle contrôle. Activez Override dans les propriétés Blockbench de l'attaque pour que ces os prennent la pose de l'attaque, ou contrôlez moins d'os par des images clés. Voir Override et poids de mélange.

Mon modèle passe d'idle à walk trop lentement ou trop brusquement. Modifiez idleWalkBlendTicks. 0 bascule instantanément.

Mon idle.long se joue trop souvent, trop rarement ou jamais. Modifiez longIdleMinSeconds et longIdleMaxSeconds. L'attente ne compte que lorsque le modèle affiche un simple idle : se déplacer, les attaques, les animations personnalisées et les cavaliers la font recommencer. longIdleMaxSeconds: 0 désactive idle.long.

Mon animation lissée, step ou Bézier bouge différemment après une mise à jour. FreeMinecraftModels 2.15.0 et les versions plus récentes jouent ces keyframes comme l'aperçu de Blockbench ; voir Types d'interpolation. Vérifiez l'animation dans l'aperçu de Blockbench : c'est le mouvement que FMM joue désormais.

Mon gros modèle tourne trop lentement. La vitesse de rotation diminue avec la taille ; voir Inertie de rotation. Augmentez turnSpeedCap et turnAcceleration, vérifiez que l'os hitbox n'est pas plus grand que prévu, ou définissez weightedTurning: false.

La console affiche ... FreeMinecraftModels does not support these ... ou ... has the blend weight .... FMM joue cette animation sans les réglages Start Delay, Loop Delay et Anim Time Update de Blockbench, et ne lit Blend Weight que comme un simple nombre. Videz ces champs ou remplacez l'expression Molang par un nombre.

Mon animation se joue mais rien ne bouge. Vérifiez la longueur de l'animation. Une animation de longueur nulle est traitée comme une pose statique et est ignorée silencieusement, par conception.

Sur Bedrock, toutes les animations d'un modèle s'arrêtent, y compris l'animation de repos, alors que Java les joue. Bedrock rejette un programme MoLang contenant un ; ou une affectation s'il ne se termine pas par ;, et une seule keyframe rejetée arrête toutes les animations de l'entité. FreeMinecraftModels 2.13.0 à 2.14.1 écrivent de tels programmes sans le ; final, et la 2.14.2 l'ajoute. Mettez à jour, ou, sur ces versions, terminez vous-même le programme de la keyframe par ; dans Blockbench. Java le joue de la même façon.

Une keyframe MoLang reste immobile à 0. Cherchez Failed to parse the keyframe expression dans la console. Un programme dont la dernière ligne est une affectation vaut 0 ; terminez-le par la valeur voulue, ou par return. Les requêtes autres que les quatre listées sous Keyframes MoLang valent 0.

Les rotations sont en miroir. Vérifiez meta.format_version dans le .bbmodel. FMM inverse le signe des rotations X/Y pour la version de format 5 et ultérieures ; un fichier qui déclare une version mais contient les données de l'autre ressortira en miroir.

La console affiche Malformed animation timeline for model .... Une piste de cette animation n'a pas pu être lue ou interpolée. L'avertissement se déclenche une fois par animation et nomme l'os ou le contrôleur d'IK concerné ; les autres animations du modèle sont tout de même converties.

Les sons de ma timeline Blockbench ne font rien. Les images clés de son ne sont pas importées. Déclenchez les sons depuis un script Lua ou votre propre plugin. Les images clés de particules sont importées ; si elles ne s'affichent pas, voir Particules.