ВЕРСИИ (1437)

v4.1.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v4.1.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v3.2.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v3.2.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v3.2.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v3.2.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v3.3.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v3.3.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v1.1.2 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - N/A ### Developer Notes - N/A

v1.1.1 ### Additions - N/A ### Fixes - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. - Fixed a bug with animated textures and glow animated textures. ### Changes - N/A ### Developer Notes - N/A

v1.1.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits (arrows, snowballs, eggs and ghast fireballs) and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitbox outlines can be toggled by holding F3 and pressing B, colored by role and damage multiplier. Beta has no entity box view, so this is AzureLib's own toggle. - In single player, hitboxes are read directly from the rendered pose. In multiplayer, clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed (and reported in multiplayer), so checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor and AzureLib armor. ### Fixes - Fixed animated textures causing large frame-time spikes and heavy memory churn. Each frame change re-decoded the texture pixel by pixel and re-created its GPU storage, for both the base texture and its glow mask. Frames are now decoded once and uploaded into storage allocated a single time, so frame changes no longer allocate memory. - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - The server's attack and interact distance check now measures to an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. - AzureLib now sends packets from client to server on a second OSL Networking channel, `azurelib:serverbound`. Multiplayer hitboxes need AzureLib on the server. ### Developer Notes - `AzHitboxHolder#onHitboxHit(AzHitboxHit, Entity, int)` runs at the start of `MobEntity#damage(Entity, int)` on the server (or in the single player world) and returns the damage to apply. The entity is the attacking player for melee or the projectile itself for projectiles. The default rounds `amount * damageMultiplier()`. - `AzHitboxHolder#onHitboxInteract(AzHitboxHit, PlayerEntity)` runs on both sides before `Entity#interact(PlayerEntity)` and item use. Return `true` to consume the click. - In multiplayer, server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses. - Added `AzureLibNetwork#registerServerbound` and `AzureLibNetwork#sendToServer` with `AzServerboundPacket`. In single player, `sendToServer` handles the packet immediately with the local player. - Added `AzArmorRendererPipelineContext#setVisiblePartOverride`, which limits an armor render to the bone matching one base model part.

v1.1.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits (arrows, snowballs, eggs and ghast fireballs) and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitbox outlines can be toggled by holding F3 and pressing B, colored by role and damage multiplier. Beta has no entity box view, so this is AzureLib's own toggle. - In single player, hitboxes are read directly from the rendered pose. In multiplayer, clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed (and reported in multiplayer), so checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor and AzureLib armor. ### Fixes - Fixed animated textures causing large frame-time spikes and heavy memory churn. Each frame change re-decoded the texture pixel by pixel and re-created its GPU storage, for both the base texture and its glow mask. Frames are now decoded once and uploaded into storage allocated a single time, so frame changes no longer allocate memory. - Fixed Molang variable assignments incorrectly reading the right-hand expression as the assignment target, preventing v. and t. variables from being assigned correctly. ### Changes - The server's attack and interact distance check now measures to an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. - AzureLib now sends packets from client to server on a second StationAPI channel, `azurelib:serverbound`. Multiplayer hitboxes need AzureLib on the server. ### Developer Notes - `AzHitboxHolder#onHitboxHit(AzHitboxHit, Entity, int)` runs at the start of `LivingEntity#damage(Entity, int)` on the server (or in the single player world) and returns the damage to apply. The entity is the attacking player for melee or the projectile itself for projectiles. The default rounds `amount * damageMultiplier()`. - `AzHitboxHolder#onHitboxInteract(AzHitboxHit, PlayerEntity)` runs on both sides before `Entity#interact(PlayerEntity)` and item use. Return `true` to consume the click. - In multiplayer, server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses. - Added `AzureLibNetwork#registerServerbound` and `AzureLibNetwork#sendToServer` with `AzServerboundPacket`. In single player, `sendToServer` handles the packet immediately with the local player. - Added `AzArmorRendererPipelineContext#setVisiblePartOverride`, which limits an armor render to the bone matching one base model part.

v1.1.1 ### Additions - Added ReachFix compatibility for AzureLib entity hitboxes. With ReachFix installed, attacking or interacting with an AzureLib entity now respects its bone hitboxes when checking reach on the server, instead of only the vanilla bounding box. ### Fixes - Fixed a conflict with ReachFix where AzureLib's server-side reach mixin could stop `NetHandlerPlayServer` from transforming, or be skipped entirely, depending on load order. - Fixed log spam caused by the embedded Mixin library's `module-info.class` being packaged into the AzureLib jar. ### Changes - AzureLib's vanilla `processUseEntity` reach mixin is now turned off when ReachFix is detected, and ReachFix's own range check is extended instead. Behavior without ReachFix is unchanged. ### Developer Notes - N/A

v4.1.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye, trims and enchantment glint), NeoForge custom armor textures, tints and models, and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - Fixed missing packet/mixin required for config values to sync from server. - Fixed sendToEntitiesTrackingChunk using blockpos instead of chunk pos on NeoForge. ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v4.1.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye, trims and enchantment glint), NeoForge custom armor textures, tints and models, and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - Fixed missing packet/mixin required for config values to sync from server. - Fixed sendToEntitiesTrackingChunk using blockpos instead of chunk pos on NeoForge. ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v3.2.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye, trims and enchantment glint), NeoForge custom armor textures, tints and models, and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - N/A ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v3.2.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye, trims and enchantment glint), NeoForge custom armor textures, tints and models, and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - N/A ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v3.2.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye, trims and enchantment glint), NeoForge custom armor textures, tints and models, and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - N/A ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v3.2.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye, trims and enchantment glint), NeoForge custom armor textures, tints and models, and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - N/A ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v3.3.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye and enchantment glint) and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - N/A ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v3.3.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye and enchantment glint) and AzureLib armor. - Morph compatibility with Walkers and ReMorphed. AzureLib entities now animate when a player is morphed into them instead of standing in their idle pose. - Animations driven by Molang queries work with no changes. - Mods that pick clips in their entity tick, from `MoveAnalysis`, or from server AI can hook in with `AzMorphable` or `AzMorphCompat.register` / `registerNamespace`. See the Morph Compatibility docs page. - Use `AzMorphCompat.isMorphCopy` to skip spawn animations on morphs, and `AzMorphCompat.exclude` to opt a type out. - Walkers is optional; nothing runs unless it is installed. ### Fixes - N/A ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v1.1.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye and enchantment glint) and AzureLib armor. ### Fixes - Fixed animated textures causing large frame-time spikes and heavy memory churn. Each frame change re-decoded the texture pixel by pixel and re-created its GPU storage, for both the base texture and its glow mask. Frames are now decoded once and uploaded into storage allocated a single time, so frame changes no longer allocate memory. ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v1.1.0 ### Additions - Added bone hitboxes. Entities can now define hitboxes that follow bones in their model, rotate with them, and stay in sync with whatever animation is playing. Implement `AzHitboxHolder` and return an `AzHitboxSet` to use them. - Hitboxes can fit a bone's cubes automatically or use an explicit size, offset and inflate in Blockbench pixels, and several hitboxes can share one bone. - Hitboxes have three roles. - `COMBAT` hitboxes take crosshair targeting, projectiles and damage. - `INTERACT` hitboxes can be right-clicked to trigger custom logic without affecting combat. - `ANCHOR` hitboxes can't be hit and exist only to track a bone's position. - Melee hits, projectile hits and right-clicks report which hitbox they landed on, so damage can be scaled per hitbox (headshots, armoured plates, weak points). - Hitboxes are drawn with F3 + B, colored by role and damage multiplier. - Clients report animated poses to the server, so server-side checks such as projectiles and AI attacks line up with what players see. - Entities that a nearby player isn't looking at still have their hitboxes posed and reported, so server-side checks keep working behind the camera. - Added a Bone Hitboxes page to the docs. - First-person item arms now render the player's worn chestplate sleeve, supporting vanilla armor (including dye and enchantment glint) and AzureLib armor. ### Fixes - Fixed animated textures causing large frame-time spikes and heavy memory churn. Each frame change re-decoded the texture pixel by pixel and re-created its GPU storage, for both the base texture and its glow mask. Frames are now decoded once and uploaded into storage allocated a single time, so frame changes no longer allocate memory. ### Changes - The server's attack reach check now includes an entity's hitboxes, so parts that stick out past the vanilla bounding box (tails, weapons) can be hit from as far as they reach. - Entities using an `AzEntityRenderer` that have hitboxes now run their animator while off-screen within 64 blocks of a player. Keyframe events, including sound keyframes, will fire for those entities even when they aren't visible. ### Developer Notes - `AzHitboxHolder#onHitboxHit` runs on the server at the start of `LivingEntity#hurt` and returns the damage to apply. `AzHitboxHolder#onHitboxInteract` runs on both sides before `mobInteract`. - Server-side poses only exist while a player within 64 blocks has the entity loaded. With no player nearby, hitbox queries return nothing and projectiles fall back to the vanilla bounding box, so server logic that reads hitboxes should keep a fallback. - Reported poses are bounds-checked but come from clients. A modified client can shift a mob's hitboxes within `maxReach` and `maxHalfExtent`. Use `AzHitboxSet.Builder#clientOnly()` where that isn't acceptable. - Added `AzRendererPipeline#modelRenderer()`, `AzEntityRenderer#poseOffscreen` and `AzEntityModelRenderer#poseBonesOffscreen`. The entity transforms and bone matrix tracking in `AzEntityModelRenderer` were moved into private methods shared by the on-screen and off-screen paths. Behavior is unchanged for subclasses.

v4.0.14 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v4.0.14 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v4.0.6 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v4.0.6 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v4.0.14 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v4.0.14 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.1.23 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.1.23 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.1.24 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.1.24 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.2.23 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.2.23 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.2.23 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v3.2.23 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v1.0.7 ### Additions - `AzItemIdentity`, the single utility for reading, creating and clearing an item stack's AzureLib id (`resolve`, `getOrCreate`, `peek`, `hasPersistentId`, `clear`). ### Fixes - Item stacks are no longer given an `az_id` UUID when they are constructed. Creative tabs, recipe outputs and JEI's ingredient list now see NBT-free stacks, so AzureLib items match their JEI entries and recipes again, and crafted copies of a recipe output no longer share one id. - Item and armor animators are no longer lost on garbage collection while the stack is still being rendered, which could restart idle animations or cut off triggered ones mid-play. - Stacks without an id now keep one stable animator while rendered, instead of a new animator (and a new random id) every frame. - `AzCommand#sendForItem` no longer throws a `NullPointerException` when the stack has no NBT. ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. - A stack gets its persistent id on the server when it first ticks in an entity's inventory, or on its first server-side dispatch (`AzCommand#sendForItem`) if it never does. Rendering never writes NBT; stacks without an id are keyed by a transient, per-instance id. - Item animators now expire after 120 seconds without being rendered or dispatched to, instead of being weakly held. - Creative "pick block" clones have their copied id removed rather than replaced, and get their own the next time one is assigned. - Adding or swapping only the `az_id` on a held stack no longer plays the re-equip animation. - Removed `ItemStackMixin_AzItemStackIdentityRegistry` and `ItemMixin_EnsureCraftHasID`; added `ItemStackMixin_AzAssignIdInInventory` and the client mixin `ItemMixin_AzIdentityReequip`. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree. - Only register items that use triggered animations in `AzIdentityRegistry`. Registered items get a unique `az_id` once they sit in an inventory, so stackable items registered there stop merging. - When dispatching for a stack that never sits in an inventory (such as a mob's held item), call `sendForItem` on the server with the actual stack, not a copy: that stack is the one that receives the id. - Code that read `az_id` directly from NBT should use `AzItemIdentity.peek` (maybe null until an id is assigned) or `AzItemIdentity.getOrCreate` on the server. - Existing stacks that already carry an `az_id` keep it.

v1.0.8 ### Additions - `AzItemIdentity`, the single utility for reading, creating and clearing an item stack's AzureLib id (`resolve`, `getOrCreate`, `peek`, `hasPersistentId`, `clear`). ### Fixes - Item stacks are no longer given an `az_id` UUID when they are constructed. Creative tabs, recipe outputs and JEI's ingredient list now see NBT-free stacks, so AzureLib items match their JEI entries and recipes again, and crafted copies of a recipe output no longer share one id. - Item and armor animators are no longer lost on garbage collection while the stack is still being rendered, which could restart idle animations or cut off triggered ones mid-play. - Stacks without an id now keep one stable animator while rendered, instead of a new animator (and a new random id) every frame. - `AzCommand#sendForItem` no longer throws a `NullPointerException` when the stack has no NBT. ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. - A stack gets its persistent id on the server when it first ticks in an entity's inventory, or on its first server-side dispatch (`AzCommand#sendForItem`) if it never does. Rendering never writes NBT; stacks without an id are keyed by a transient, per-instance id. - Item animators now expire after 120 seconds without being rendered or dispatched to, instead of being weakly held. - Creative "pick block" clones have their copied id removed rather than replaced, and get their own the next time one is assigned. - Adding or swapping only the `az_id` on a held stack no longer plays the re-equip animation. - Removed `ItemStackMixin_AzItemStackIdentityRegistry` and `ItemMixin_EnsureCraftHasID`; added `ItemStackMixin_AzAssignIdInInventory`. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree. - Only register items that use triggered animations in `AzIdentityRegistry`. Registered items get a unique `az_id` once they sit in an inventory, so stackable items registered there stop merging. - When dispatching for a stack that never sits in an inventory (such as a mob's held item), call `sendForItem` on the server with the actual stack, not a copy: that stack is the one that receives the id. - Code that read `az_id` directly from NBT should use `AzItemIdentity.peek` (maybe null until an id is assigned) or `AzItemIdentity.getOrCreate` on the server. - Existing stacks that already carry an `az_id` keep it.

v1.0.2 ### Additions - N/A ### Fixes - Fixed textures without an animation-frame method repeatedly retrying a failed reflective lookup every frame. The failed lookup is now cached, so these textures no longer throw an exception on every render. ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. - Reduced rendering overhead in the buffer source. Vertices are now written once, already in their final draw layout, with lighting, hurt tint and glint colour applied up front, so drawing a batch is a single bulk copy instead of a second pass over every vertex. Normals are normalized once per quad instead of once per vertex, and glint batches are filled once for both passes. - Bone rotation and scaling no longer allocate matrices. Each bone's rotation is now applied as one combined rotation instead of up to three separate ones, which removes nearly all of the garbage rendering used to create per frame. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree. - Added `PoseStack#rotateZYX(rz, ry, rx)`, which applies the same rotation as calling `mulPose` for Z, then Y, then X, in a single step. `RenderUtils.rotateMatrixAroundBone` and `rotateMatrixAroundCube` now use it. - `PoseStack#scale(1, 1, 1)` is now a no-op. - Added in-place `Matrix4f#multiplyWithScale` and `Matrix4f#multiplyRotation`, and `Matrix3f#mulScale` and `Matrix3f#mulRotation`. `Matrix4f#multiply(Quaternion)` and `Matrix3f#mul(Quaternion)` now work in place instead of allocating a temporary matrix. - `AzBufferSource`'s public API is unchanged; custom `VertexConsumer` usage needs no updates.

v1.0.2 ### Additions - N/A ### Fixes - N/A ### Changes - Improved animation performance on models with many bones. The bone cache now walks bones in a fixed array and skips any bone that has fully eased back to its bind pose, so its cost scales with the animated bones instead of the whole model. - Bones scaled to zero on every axis, along with everything under them, are no longer rendered, instead of being drawn as collapsed geometry. ### Developer Notes - `AzCachedBoneUpdateUtil` has new overloads that take an `AzBoneSnapshot` directly and return whether the channel is at rest. The existing `Map` overloads still work and delegate to them. - Added `AzBoneCache#invalidateBoneArrays()`. Call it if you replace or remove entries in `getBoneSnapshotsByName()` directly; changing a snapshot's values doesn't need it. - While a bone is scaled to zero on all three axes, its descendants don't update their tracked matrices and per-bone render layers aren't called for that subtree.

v1.0.6 ### Additions - N/A ### Fixes - Fixed a black box appearing beside the potion effect panel in inventory screens while an AzureLib item was held on the cursor. AzureLib left GL blend disabled after rendering a GUI item, so the transparent part of the effect background drew as opaque black. ### Changes - `AzItemGuiRenderUtil` now restores the GL state vanilla's GUI item rendering leaves behind after drawing an AzureLib item: blend on with `SRC_ALPHA`/`ONE_MINUS_SRC_ALPHA`, alpha func `GREATER 0.1`, depth on, colour reset to white, and the block atlas rebound. ### Developer Notes - Any GUI code drawn after an AzureLib item (potion effects, tooltips, other mods' overlays) now sees the same GL state it would after a vanilla item.

v4.0.13 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v4.0.13 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v4.0.5 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v4.0.5 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v4.0.13 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v4.0.13 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.1.22 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.1.22 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.1.23 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.1.23 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.2.22 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.2.22 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.2.22 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v3.2.22 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v1.0.5 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v1.0.7 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet.

v1.0.1 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. - Fixed a `NoSuchMethodError` crash when rendering any AzureLib model with Starac installed. `AzBufferSource` used LWJGL 2-only `glNormalPointer`/`glColorPointer` overloads that Starac doesn't provide; all vertex pointers now use the `(size, type, stride, ByteBuffer)` overloads, which exist in both LWJGL 2 and LWJGL 3. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet. - AzureLib does not depend on Starac; it works with or without it. When adding GL calls, prefer overloads that exist in both LWJGL 2 and LWJGL 3 (such as the `(size, type, stride, ByteBuffer)` pointer forms) over LWJGL 2-only convenience overloads.

v1.0.1 ### Additions - Added `AzAnimator#onFirstAnimate(T)`, a hook that runs once on an animator's first `animate()` call, right before its controllers update. Commands dispatched here apply on that same frame, making it the reliable place to start spawn/initial animations. - Added `AzAnimator#getOrCreateContext(K, T)`, which binds the animatable to the context when it is created. - Added `AzPendingDispatches`, which queues animation commands sent to an entity or block entity before its animator exists and replays them once the animator is created. - Added `AzIdentifiableItemStackAnimatorCache#dispatchOrQueue`, which does the same for item stacks per `AzItemAnimatorView`. ### Fixes - Fixed animatables rendering in their bind pose (T-pose) for a frame when a transition finished, most noticeably on controllers with a transition length of 0. The transition state now hands off to the play state and applies keyframes in the same update. - Fixed `AzAnimationTimer` adding the full absolute render time to `animTime` on its first tick, which made controllers treat transitions as instantly finished. - Fixed animation commands being silently dropped when they arrived before the animatable had been rendered (entity, block entity, and item stack dispatch packets, and client-side dispatch). - Fixed "Unable to create animation queue: animatable is null" when a command was dispatched before an animator's first `animate()` call, which left the controller with nothing to play. - Fixed a `NoSuchMethodError` crash when rendering any AzureLib model with legacy-lwjgl3 installed. `AzBufferSource` used LWJGL 2-only `glNormalPointer`/`glColorPointer` overloads that legacy-lwjgl3 doesn't provide; all vertex pointers now use the `(size, type, stride, ByteBuffer)` overloads, which exist in both LWJGL 2 and LWJGL 3. ### Changes - `AzProvider` now binds the animatable to the animation context on creation and flushes pending dispatches after registering controllers, both when creating an animator and when rebuilding it on a model change. - Item stack dispatches (server packet and `AzCommand#sendForItem` on the client) now go through `dispatchOrQueue` instead of skipping stacks with no animator yet. ### Developer Notes - Use `onFirstAnimate` to start an entity's initial animation instead of keying off `tickCount == 0`. A freshly spawned entity is not guaranteed to render before its first client tick, especially on the first spawn after loading a world. - Commands sent before an animatable's first render are now replayed when its animator is created rather than discarded, so server-sent spawn animations will now play where they previously did not. - Queued item stack commands expire after 10 seconds. A command with no view is queued separately for each view that has no animator yet. - AzureLib does not depend on legacy-lwjgl3; it works with or without it. When adding GL calls, prefer overloads that exist in both LWJGL 2 and LWJGL 3 (such as the `(size, type, stride, ByteBuffer)` pointer forms) over LWJGL 2-only convenience overloads.

v1.0.0 ### Additions - `AzEntityRendererRegistry` and `AzBlockEntityRendererRegistry` (replace StationAPI's renderer register events). Register from `client-init`; works before or after the dispatchers exist. - `AzEntityRegistry` and `AzBlockEntityRegistry` (replace StationAPI's entity / block entity register events). Register from `init` on both sides; name/id clashes throw. ### Fixes - N/A ### Changes - Ported from Babric + StationAPI to Ornithe (gen2) + OSL, Java 8. - Networking uses OSL's Networking API (`azurelib:packet` channel) instead of StationAPI message packets. - Item stack identity is stored in AzureLib's own per-stack data (saved with the stack, kept by `copy()`); clients adopt the server's id from the item dispatch packet. - Held block items now use Beta's biped hand placement (no Arsenic renderer). ### Developer Notes - All vanilla member access goes through `platform/mc/Mc` and `McClient`, annotated with MCP names. See `PORTING.md`.

v1.0.0 ### Additions - N/A ### Fixes - N/A ### Changes - Ported from the 1.7.10 Forge branch to Beta 1.7.3 on Babric + StationAPI. ### Developer Notes - N/A

v4.0.4 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by introducing a custom lightmap-enabled render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now uses a custom `az_glowing_layer` render type built with `RenderSetup` and `RenderPipelines.ENTITY_TRANSLUCENT`, enabling lightmap and overlay support.

v4.0.4 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by introducing a custom lightmap-enabled render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now uses a custom `az_glowing_layer` render type built with `RenderSetup` and `RenderPipelines.ENTITY_TRANSLUCENT`, enabling lightmap and overlay support.

v4.0.12 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by introducing a custom lightmap-enabled render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now uses a custom `az_glowing_layer` render type built with `RenderSetup` and `RenderPipelines.ENTITY_TRANSLUCENT`, enabling lightmap and overlay support.

v4.0.12 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by introducing a custom lightmap-enabled render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now uses a custom `az_glowing_layer` render type built with `RenderSetup` and `RenderPipelines.ENTITY_TRANSLUCENT`, enabling lightmap and overlay support.

v3.1.21 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.1.21 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.1.22 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.1.22 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.2.21 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.2.21 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.2.21 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v3.2.21 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. - Fixed glowmask rendering on block entities with Iris shaders by enabling the lightmap state for AzureLib's custom emissive render type. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`. - `AzAbstractTexture` now adds `RenderStateShard.LIGHTMAP` to the `az_glowing_layer` composite render state; the existing overlay and transparency states remain unchanged.

v1.0.4 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`.

v1.0.6 ### Additions - N/A ### Fixes - Fixed auto-glowing layers using incomplete full-bright lighting by switching to `LightTexture.FULL_BRIGHT`. ### Changes - N/A ### Developer Notes - `AzAutoGlowingLayer#getPackedLight` now returns `LightTexture.FULL_BRIGHT` instead of `LightTexture.FULL_SKY`.

v1.0.5 ### Additions - N/A ### Fixes - Fixed AzureLib items rendered in the hotbar or inventory having inverted lighting, and changing the lighting of every item rendered after them in the same slot row (blocks, spawn eggs). - Fixed AzureLib entities rendering with dark or inverted shading when a bone is scaled non-uniformly by an animation (for example, a squash or stretch). - Fixed bones scaled to 0 by an animation turning their child bones black. - Fixed items rendered in the hotbar or inventory after an AzureLib item turning darker on 1.7.10, because the AzureLib item's render was switching off the GUI item lighting. ### Changes - N/A ### Developer Notes - `AzItemGuiRenderUtil#renderInGui` no longer resets the item lights for the default GUI lighting, since the hotbar or container has already set them. Items using `useEntityGuiLighting()` now set and restore their lights under an identity model-view, so the light direction no longer depends on the item's GUI transform (RenderItem's Y flip and the display rotation). - `AzBufferSource` now normalizes every vertex normal before uploading. 1.12.2 packs normals into signed bytes and does not normalize them on the GPU, so non-unit normals from a non-uniform scale overflowed and flipped. Normals that are zero-length or not finite fall back to `(0, 1, 0)`. - `PoseStack#scale` no longer updates the normal matrix when any axis is 0, which previously filled the matrix with infinities for the bone and all of its children. - On 1.7.10, `AzItemRendererAdapter` now saves the GL lighting state with `glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT)` before an `INVENTORY` render and restores it afterward. Previously it ended with `RenderHelper.disableStandardItemLighting()`, which also turned off `GL_LIGHT0`, `GL_LIGHT1` and `GL_COLOR_MATERIAL`. Forge only re-enables `GL_LIGHTING` after an `IItemRenderer`, so every slot rendered afterward was left with ambient lighting only.

v1.0.3 ### Additions - N/A ### Fixes - Fixed AzureLib items rendered in the hotbar or inventory having inverted lighting, and changing the lighting of every item rendered after them in the same slot row (blocks, spawn eggs). - Fixed AzureLib entities rendering with dark or inverted shading when a bone is scaled non-uniformly by an animation (for example, a squash or stretch). - Fixed bones scaled to 0 by an animation turning their child bones black. ### Changes - N/A ### Developer Notes - `AzItemGuiRenderUtil#renderInGui` no longer resets the item lights for the default GUI lighting, since the hotbar or container has already set them. Items using `useEntityGuiLighting()` now set and restore their lights under an identity model-view, so the light direction no longer depends on the item's GUI transform (RenderItem's Y flip and the display rotation). - `AzBufferSource` now normalizes every vertex normal before uploading. 1.12.2 packs normals into signed bytes and does not normalize them on the GPU, so non-unit normals from a non-uniform scale overflowed and flipped. Normals that are zero-length or not finite fall back to `(0, 1, 0)`. - `PoseStack#scale` no longer updates the normal matrix when any axis is 0, which previously filled the matrix with infinities for the bone and all of its children.

v1.0.2 ### Additions - N/A ### Fixes - Fixed AzureLib armor rendering in the wrong place on players and mobs when an AzureLib entity was wearing the same armor item. The chestplate would float above the wearer's head. - Fixed arm, leg and boot pieces of AzureLib armor on AzureLib entities being placed at the wrong position (for example, gauntlets rendering at the entity's feet), depending on the order the entity's bones rendered in. ### Changes - N/A ### Developer Notes - Each armor item shares one `AzArmorModel` across every wearer. `AzArmorLayer` used to leave that shared model's biped parts posed with the entity's bone pivots and rotations, and vanilla's `ModelBiped#setRotationAngles` never resets `bipedBody`'s rotation point or the arms' Y rotation point. That stale state then leaked into the next wearer. - `AzArmorModel#render` now resets every biped part to the default `ModelBiped` pose before calling `setRotationAngles`, so the vanilla armor layer path always starts from a clean pose. - `AzArmorLayer` now saves the biped pose of every armor model it uses during an entity's render and restores it in `render(context)` once the model pass is finished. Subclasses that override `render` must call `super.render(context)`. - `AzArmorLayer` now caches each entity's posed biped parts per armor model and applies that cache before each piece renders. `applyBaseTransformations` positions every armor bone from every biped part, so each piece now sees this entity's full pose rather than default or leftover values. The cache is weakly keyed on the entity.

v1.0.4 ### Additions - N/A ### Fixes - Fixed AzureLib armor rendering in the wrong place on players and mobs when an AzureLib entity was wearing the same armor item. The chestplate would float above the wearer's head. - Fixed arm, leg and boot pieces of AzureLib armor on AzureLib entities being placed at the wrong position (for example, gauntlets rendering at the entity's feet), depending on the order the entity's bones rendered in. ### Changes - N/A ### Developer Notes - Each armor item shares one `AzArmorModel` across every wearer. `AzArmorLayer` used to leave that shared model's biped parts posed with the entity's bone pivots and rotations, and vanilla's `ModelBiped#setRotationAngles` never resets `bipedBody`'s rotation point or the arms' Y rotation point. That stale state then leaked into the next wearer. - `AzArmorModel#render` now resets every biped part to the default `ModelBiped` pose before calling `setRotationAngles`, so the vanilla armor layer path always starts from a clean pose. - `AzArmorLayer` now saves the biped pose of every armor model it uses during an entity's render and restores it in `render(context)` once the model pass is finished. Subclasses that override `render` must call `super.render(context)`. - `AzArmorLayer` now caches each entity's posed biped parts per armor model and applies that cache before each piece renders. `applyBaseTransformations` positions every armor bone from every biped part, so each piece now sees this entity's full pose rather than default or leftover values. The cache is weakly keyed on the entity.

v3.1.21b ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - Fixed broken packet in 3.1.21 ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.1.21b ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - Fixed broken packet in 3.1.21 ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.2.20b ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - Fixed broken packet in 3.2.20 ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.2.20b ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - Fixed broken packet in 3.2.20 ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.11 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.11 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.3 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.3 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.11 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.11 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.1.20 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.1.20 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.1.21 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.1.21 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.2.20 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.2.20 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.2.20 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v3.2.20 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<ItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(ItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v1.0.1 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<AzItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(AzItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions. -

v1.0.3 ### Additions - Added separate first-person animators for items. Item renderers built with `useSeparateFirstPersonAnimator()` give the first-person hands their own animator, so first person and third person can play different animations on the same item stack at the same time (for example, an aimed fire in first person while other players see a hip fire). - Added `AzCommand#sendForItemFirstPerson`, `AzCommand#sendForItemThirdPerson` and `AzCommand#sendForItem(Entity, ItemStack, AzItemAnimatorView)` to play a command on only one view. ### Fixes - N/A ### Changes - `AzCommand#sendForItem(Entity, ItemStack)` now plays on every animator the stack has. For renderers that don't use a separate first-person animator this is the same single animator as before. ### Developer Notes - Added `AzItemAnimatorView` (`DEFAULT`, `FIRST_PERSON`). While an item renders, the view for its display context is the current view on the render thread, so `AzAnimatorAccessor` lookups on an `ItemStack` during rendering (render layers, `AzProvider`, custom pipeline code) return that view's animator. Outside of rendering they return the `DEFAULT` animator. - Added `AzItemRendererConfig.Builder#setAnimatorViewProvider(Function<AzItemDisplayContext, AzItemAnimatorView>)` for custom context-to-view mappings. `AzItemRendererConfig#animatorView(AzItemDisplayContext)` returns the view used for a context. - `AzIdentifiableItemStackAnimatorCache` now stores animators per view. The existing `add(ItemStack, AzItemAnimator)` and `getOrNull(UUID)` still use `DEFAULT`; new overloads take an `AzItemAnimatorView`, and `forEach(UUID, AzItemAnimatorView, Consumer)` runs on one view or, with `null`, every view. - `ClientUtils#getCurrentAnimationController` and `#getCurrentAnimationTick` read the `DEFAULT` animator when called outside of rendering. To read the first-person animator, use `AzIdentifiableItemStackAnimatorCache.getInstance().getOrNull(uuid, AzItemAnimatorView.FIRST_PERSON)`. - `AzItemStackDispatchCommandPacket` has a new optional view field, which changes its network format. Clients and servers must run matching AzureLib versions.

v4.0.2 - Backported all animations/rendering improvements from 26.3 - Backported all missing features as well.

v4.0.2 - Backported all animations/rendering improvements from 26.3 - Backported all missing features as well.

v1.0.2 - Fixed animated items rendering with incorrect rotations, positioning, and scaling when held by entities. - Fixed item display transforms not being applied correctly in the block and item render layer. - Improved compatibility with custom animated items rendered in entity hands.

v1.0.1 - Fixed a crash at start up due to mixin weirdness that is 1.7.10.

v1.0.0 - Initial Forge 1.7.10 backport of AzureLib (from the 1.12.2 backport).

v1.0.0 -Initial Forge 1.12.2 backport of the AzureLib.

v4.0.10 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v4.0.10 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v4.0.10 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v4.0.10 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.1.19 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.1.19 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.1.20 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.1.20 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.2.19 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.2.19 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.2.19 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v3.2.19 ### Additions - Animation LOD now works. Past `animLodDistance`, entities update their animations once every `animLodTickInterval` ticks and hold their pose in between, instead of animating every frame. ### Fixes - Fixed animation LOD having no effect. The LOD decision was computed but ignored, so distant entities still animated every frame. - Fixed models and animations that could briefly go missing during a resource reload (F3+T or changing resource packs in-world). The caches were filled in place on a background thread while the game was still rendering from them; they are now loaded separately and swapped in once the reload finishes. - Fixed models and animations from removed resource packs staying loaded until restart. - Fixed one geo model that failed to bake stopping every remaining model from loading. The broken model is now logged and skipped. - Fixed a crash when an animation file `includes` a file that is missing or failed to load. The animation is now logged as missing instead. - Fixed bone LOD being able to hide bones on the shared model template before an entity had its own copy, which newly spawned entities could then inherit. - Fixed per-entity LOD state never being released after entities unloaded. ### Changes - Changed LOD to be DISABLED by default when a render doesn't call `withLodConfig`. ### Developer Notes - `AzResourceCache#loadResources` now returns `CompletableFuture<Map<ResourceLocation, T>>` and no longer takes a `BiConsumer`. `AzBakedAnimationCache#loadAnimations` and `AzBakedModelCache#loadModels` return the loaded map; publish it with the new `apply(Map)`. Namespaces in `EXCLUDED_NAMESPACES` are now skipped before loading instead of after. - Added `AzEntityRenderer#shouldAnimateThisFrame()` and the overridable `updateLod(...)`. Custom entity model renderers that override `render` should check `shouldAnimateThisFrame()` before calling `handleAnimation`, or animation LOD won't apply to them. - LOD is opt-in: renderers that never call `withLodConfig` don't use bone or animation LOD. Pass `AzLodConfig.DEFAULT` for the built-in preset (one animation update every 2 ticks past 48 blocks; bones deeper than depth 3 hidden past 40 blocks) or build your own with `AzLodConfig.builder()`.

v4.0.9 ### Additions - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes, which noticeably cuts animation cost for models with many bones. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v4.0.9 ### Additions - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes, which noticeably cuts animation cost for models with many bones. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v4.0.9 ### Additions - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes, which noticeably cuts animation cost for models with many bones. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v4.0.9 ### Additions - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes, which noticeably cuts animation cost for models with many bones. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.1.18 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.1.18 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.1.19 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.1.19 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.2.18 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.2.18 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.2.18 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v3.2.18 ### Additions - Large groups of animated entities are now cheaper to render: - Bones no longer allocate a new pose every frame. Each bone used to create a new `PoseStack` pose, matrix and normal matrix every frame for every entity on screen; the pose is now saved and restored in place. This roughly halves render-thread allocation and makes garbage collection pauses about half as frequent. - Animations no longer look up every animated bone by name every frame. Each controller resolves its animation's bones once and reuses them until the animation or model changes. - Bone LOD no longer walks every bone of every nearby entity each frame when no bones are hidden. - Animated textures no longer use reflection, and no longer throw and catch an exception, on every render of every textured model. ### Fixes - Fixed animation transitions stopping for every remaining bone when one bone had no snapshot or animation queue, instead of skipping just that bone. ### Developer Notes - Added `AzModelRenderer#saveBonePose` and `restoreBonePose`, which replace `PoseStack#pushPose` / `popPose` around each bone. The entity and block entity model renderers use them; the item and armor model renderers no longer push their own pose per bone. Custom model renderers that override `renderRecursively` should do the same, since `pushPose` allocates on every call in this version. - Added `AzBoneAnimationQueueCache#resolveQueues(AzBakedAnimation)`, which returns each bone animation's queue by index, cached per animation and model. - `AnimatableTexture#setAndUpdate` handles AzureLib's own textures with a plain type check. For other texture classes it still calls `setAnimationFrame(int)` when they have one, but looks the method up once per class instead of on every call. - Bone LOD now tracks which baked models currently have LOD-hidden bones, so un-hiding only runs when something was actually hidden.

v4.0.8 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. - Fixed the entity and block entity geometry caches never hitting: their keys included each instance's position. Bone visibility is now part of the entity cache key. - A missing glowmask no longer draws the whole model a second time with an empty texture. ### Performance - Vertex recordings are sized from the previous frame, handed to submit without copying, and pooled per frame instead of allocated per animatable. - The auto-glowing layer reuses the main model pass instead of re-rendering the model (when no bone overrides are in use), and only submits quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks. - The entity and block entity geometry caches switch themselves off per type when they aren't getting hits, and probe periodically. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Entity and block entity renderers reuse their extraction pose stack instead of allocating one per render. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. - Removed a per-quad texture size lookup for bones without a texture override. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `AzCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack, and `renderCubesOfBone` no longer pushes and pops it per cube. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - `AzEntityGeometryCache.CacheKey` and `AzBlockEntityGeometryCache.CacheKey` no longer have position components. - `AzBufferSource` recordings are only valid until the end of the frame; their arrays are reused after that. - New: `AzBufferSource#mirror` (with an optional `QuadFilter`), `AzGlowCoverage`, and `AzAutoGlowingLayer#canReuseModelPass` / `#glowFilter` for subclasses that draw their glow differently.

v4.0.8 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. - Fixed the entity and block entity geometry caches never hitting: their keys included each instance's position. Bone visibility is now part of the entity cache key. - A missing glowmask no longer draws the whole model a second time with an empty texture. ### Performance - Vertex recordings are sized from the previous frame, handed to submit without copying, and pooled per frame instead of allocated per animatable. - The auto-glowing layer reuses the main model pass instead of re-rendering the model (when no bone overrides are in use), and only submits quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks. - The entity and block entity geometry caches switch themselves off per type when they aren't getting hits, and probe periodically. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Entity and block entity renderers reuse their extraction pose stack instead of allocating one per render. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. - Removed a per-quad texture size lookup for bones without a texture override. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `AzCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack, and `renderCubesOfBone` no longer pushes and pops it per cube. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - `AzEntityGeometryCache.CacheKey` and `AzBlockEntityGeometryCache.CacheKey` no longer have position components. - `AzBufferSource` recordings are only valid until the end of the frame; their arrays are reused after that. - New: `AzBufferSource#mirror` (with an optional `QuadFilter`), `AzGlowCoverage`, and `AzAutoGlowingLayer#canReuseModelPass` / `#glowFilter` for subclasses that draw their glow differently.

v3.1.17 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.1.17 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.1.18 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.1.18 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.2.17 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.2.17 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.2.17 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v3.2.17 ### Additions - Added the `math.min_angle(value)` Molang function, which wraps an angle in degrees into the range [-180, 180). - Added `AzProfiler` stage hooks (`mod.azure.azurelib.profiling`) for external profiling tools. No cost when no listener is installed. ### Fixes - Fixed `math.copy_sign`, `math.sign`, `math.inverse_lerp` and all 30 `math.ease_*` Molang functions failing to resolve. They were only registered under their bare names, so the `math.`-prefixed forms used by Blockbench and Bedrock animations parsed to 0. ### Performance - The auto-glowing layer only draws quads whose UVs cover glowing pixels in the glowmask, including animated glowmasks, and skips the pass entirely when the glowmask has nothing visible. - Zero-area faces (the edges of flat cubes) are no longer baked or rendered. - Cube pivot rotations are baked once at load instead of being applied to the pose stack for every cube every frame. - Flat-cube normal fixes are precomputed per cube; bone, cube and layer loops no longer allocate iterators. - Glowmask texture paths are cached instead of rebuilt every frame. ### Developer Notes - The fixed Molang functions are now registered only under their `math.` names, matching the existing classic functions. Expressions that called them without the prefix (e.g. `ease_in_quad(0, 1, t)`) must be updated to use `math.ease_in_quad(0, 1, t)`. - `GeoCube` has two new record components, `transform` and `normalFlips`. The six-argument constructor still works; code that deconstructs the record with a pattern needs updating. - `AzModelRenderer#renderCube` no longer modifies the pose stack. Overrides of `renderCube` that change the pose stack must push and pop it themselves. - New: `AzQuadFilter`, `AzRendererPipelineContext#quadFilter` / `#setQuadFilter`, `AzGlowCoverage`, and `AzAutoGlowingLayer#glowFilter` for subclasses that draw their glow differently.

v4.0.7 ### Additions - Restored the in-game config screen for AzureLib's config API on 26.3, including config group selection, nested object screens, array editing (add/remove elements), and confirmation dialogs for "Use default config" and "Rollback changes". - Added a color picker for `@Configurable.Gui.ColorValue` string fields, with RGB and ARGB slider dialogs. - Added ModMenu integration on Fabric and mod list config buttons on NeoForge for every mod that registers configs through AzureLib. ### Fixes - Fixed the Fabric ModMenu entrypoint pointing to a missing `ModMenuIntegration` class. - Fixed editing array config elements in the GUI overwriting the stored default values. - Fixed color values written from the color picker dropping leading zeros (e.g. `#0000FF` was saved as `#FF`). ### Developer Notes - Added `ConfigurationClient` with `getConfigScreen`, `getConfigScreenByGroup` and `getScreenForGroup` for opening config screens from your own code. - Added `DisplayAdapters.registerCustom(Class, DisplayAdapter)` to override how a config value type is displayed in the GUI. - `@ValueUpdateCallback` validation warnings and errors are now shown in the config screen. - Mod list config buttons are registered per config group, so the `@Config` group (defaults to the config id) must match your mod ID.

v4.0.7 ### Additions - Restored the in-game config screen for AzureLib's config API on 26.3, including config group selection, nested object screens, array editing (add/remove elements), and confirmation dialogs for "Use default config" and "Rollback changes". - Added a color picker for `@Configurable.Gui.ColorValue` string fields, with RGB and ARGB slider dialogs. - Added ModMenu integration on Fabric and mod list config buttons on NeoForge for every mod that registers configs through AzureLib. ### Fixes - Fixed the Fabric ModMenu entrypoint pointing to a missing `ModMenuIntegration` class. - Fixed editing array config elements in the GUI overwriting the stored default values. - Fixed color values written from the color picker dropping leading zeros (e.g. `#0000FF` was saved as `#FF`). ### Developer Notes - Added `ConfigurationClient` with `getConfigScreen`, `getConfigScreenByGroup` and `getScreenForGroup` for opening config screens from your own code. - Added `DisplayAdapters.registerCustom(Class, DisplayAdapter)` to override how a config value type is displayed in the GUI. - `@ValueUpdateCallback` validation warnings and errors are now shown in the config screen. - Mod list config buttons are registered per config group, so the `@Config` group (defaults to the config id) must match your mod ID.

v4.0.6 ### Additions - Ported first-person arm rendering from 1.21.1. Items with `leftArm` and/or `rightArm` bones now render the player's own arms, skin and sleeves included, in place of those bones while an animation is playing in first person. Anything parented to the arm bones still renders, so held parts and attachments follow the player's arms. Skipped when the First-person Model mod is installed, since it handles arms itself. ### Fixes - Fixed AzureLib items crashing when `disableAnimationInContexts` or `enableAnimationInContexts` was used, and fixed item renderers never knowing which display context they were rendering in (first person, GUI, ground, ...). Since 26.x, Minecraft no longer tells special item renderers the display context, so it is now captured from the item's render state. ### Developer Notes - New `AzItemDisplayContextCapture` exposes the display context of the item currently being rendered, captured by a new `ItemStackRenderState` mixin. `AzItemRendererConfig#shouldAnimateInContext` now treats a `null` context as `ItemDisplayContext.NONE`. - First-person arms are rendered by `AzItemArmRenderUtil`. Since 1.21.2, the player model's sleeves are child parts of its arms, so each arm is drawn in two passes: the arm as solid skin, then only its sleeve as translucent skin, keeping the player's sleeve visibility settings.

v4.0.6 ### Additions - Ported first-person arm rendering from 1.21.1. Items with `leftArm` and/or `rightArm` bones now render the player's own arms, skin and sleeves included, in place of those bones while an animation is playing in first person. Anything parented to the arm bones still renders, so held parts and attachments follow the player's arms. Skipped when the First-person Model mod is installed, since it handles arms itself. ### Fixes - Fixed AzureLib items crashing when `disableAnimationInContexts` or `enableAnimationInContexts` was used, and fixed item renderers never knowing which display context they were rendering in (first person, GUI, ground, ...). Since 26.x, Minecraft no longer tells special item renderers the display context, so it is now captured from the item's render state. ### Developer Notes - New `AzItemDisplayContextCapture` exposes the display context of the item currently being rendered, captured by a new `ItemStackRenderState` mixin. `AzItemRendererConfig#shouldAnimateInContext` now treats a `null` context as `ItemDisplayContext.NONE`. - First-person arms are rendered by `AzItemArmRenderUtil`. Since 1.21.2, the player model's sleeves are child parts of its arms, so each arm is drawn in two passes: the arm as solid skin, then only its sleeve as translucent skin, keeping the player's sleeve visibility settings.

v3.2.16 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.2.16 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.2.16 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.2.16 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.1.17 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.1.17 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.1.16 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v3.1.16 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides rendering with the model's main texture, and leaking into the bones rendered after them (wrong UVs or missing parts) unless every bone was given an override. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change.

v4.0.5 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides (`setBoneTextureOverrideProvider`) being ignored, so overridden bones still rendered with the model's main texture. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change. - Bones with a texture override now render with the model's render type rebuilt for the override texture (`entityCutout`, `entityTranslucent`, `entityTranslucentEmissive` and `armorCutoutNoCull` are recognized; anything else falls back to `entityCutout`). Subclasses can change this through `AzModelRenderer#retargetRenderType`, and `setBoneRenderTypeOverrideProvider` still takes precedence.

v4.0.5 ### Additions - Animations are now cheaper to play, especially with many bones or long animations: - Each controller remembers which keyframe every bone was on last frame and continues from there, instead of searching the bone's keyframes (and allocating a new array to do it) every frame. This works the same playing forwards, reversed and in `PING_PONG`; bigger jumps like looping back to the start fall back to a binary search over keyframe times calculated once when the animation loads. - Sampling keyframes no longer creates any objects. Values are written straight into the bone's animation slots instead of a new `AzAnimationPoint` per axis. - Linear keyframes skip the easing system entirely. - Easing curves are built once and reused instead of being rebuilt for every keyframe every frame. Curves that don't take an argument (sine, quad, cubic, quart, quint, expo, circ) are built when AzureLib loads. Curves with an argument (back, elastic, bounce, step) are resolved once per keyframe when the animation loads, so playback doesn't look them up at all. - Easing math no longer boxes every value into a `Double`. - Keyframe event checks (sounds, particles, custom instructions), bone animation lookups and bone/keyframe hashing no longer allocate every frame. - The auto glowing layer can now tint emissive textures. Pass a color, or a function of the render context for tints that change or pulse, straight to `AzAutoGlowingLayer`: - `.addRenderLayer(new AzAutoGlowingLayer<>(Color.RED))` - `.addRenderLayer(new AzAutoGlowingLayer<>(context -> isAngry(context.animatable()) ? 0xFFFF4040 : 0xFFFFFFFF))` - Added a large set of Bedrock Molang queries. See the Supported Queries list in the docs for the full set and what each returns. - Entity state: `is_alive`, `is_moving`, `is_in_lava`, `head_is_in_water`, `is_fire_immune`, `is_invisible`, `is_silent`, `is_sneaking`, `is_sprinting`, `is_swimming`, `is_gliding`, `is_sleeping`, `is_riding`, `has_rider`, `is_leashed`, `is_tamed`, `is_sitting`, `has_gravity`, `has_collision`, `is_spectator`, `is_local_player`, `is_first_person`. - Movement and rotation: `vertical_speed`, `body_x_rotation`, `body_y_rotation`, `cardinal_facing_2d`, `model_scale`, `swim_amount`, `death_ticks`. - Items and equipment: `item_in_use_duration`, `item_remaining_use_duration`, `item_max_use_duration`, `has_head_gear`, `equipment_count`, `player_level`, `max_durability`, `remaining_durability`. - World: `day`, `time_stamp`, `moon_brightness`, `frame_alpha`, `client_max_render_distance`. - Bedrock names for existing queries: `head_x_rotation` (`head_pitch`), `head_y_rotation` (`head_yaw`), `blocking` (`is_blocking`) and `is_onfire` (`is_on_fire`). - Added Molang query functions, which take arguments: `query.position(axis)`, `position_delta(axis)`, `movement_direction(axis)`, `is_item_equipped(hand)`, `has_armor_slot(slot)`, `armor_damage_slot(slot)`, `heightmap(x, z)`, `above_top_solid(x, z)`, `camera_distance_range_lerp(near, far)`, `all(...)`, `any(...)`, `approx_eq(...)` and `in_range(value, min, max)`. ### Fixes - Fixed `easeInQuint` using the same curve as `easeInQuart`. - Fixed transitions into a reversed animation blending towards the second-to-last keyframe instead of the last frame, causing a small pop when the transition ended. Transitions now blend to exactly the pose the animation starts on, easing included. - Fixed custom easing types registered with uppercase letters in their name through `AzEasingTypeRegistry#register(String, Function)` never being found by animation files. - Fixed `AzKeyframe#equals` treating two different keyframes as equal if their hash codes happened to match. - Fixed `query.is_on_fire` always being 0. It was registered but never set. - Fixed `query.moon_phase` returning a fraction that grew through the day instead of a whole number, so checks like `query.moon_phase == 4` almost never matched. - Fixed bone texture overrides (`setBoneTextureOverrideProvider`) being ignored, so overridden bones still rendered with the model's main texture. - Fixed the auto glowing layer leaving full-bright lighting on the render context, so any layer rendered after it was also full-bright. ### Developer Notes - **Behavior change:** animations using `easeInQuint` now ease in more sharply, matching `easeOutQuint`, `easeInOutQuint` and the standard quint curve. - Added `AzKeyframeChannel`, an immutable, baked view of one axis of keyframes with keyframe start/end times and easing curves resolved once. `locate(tick, hint)` does a cached lookup starting from a previous index, `search(tick)` does a binary search, and `transformer(index)` returns a keyframe's baked easing curve. Get them from `AzKeyframeStack#xChannel()`, `yChannel()` and `zChannel()`. - `AzKeyframeStack` is now a final class instead of a record so it can hold its channels. Its constructors, accessors, `from`, `getLastKeyframeTime()`, `equals` and `hashCode` work the same as before. Channels are snapshots of the keyframe lists: a stack built from lists bakes them right away, and a stack made with the no-argument constructor bakes them the first time they're used, so its lists can be filled before then. Changing a list after its channel is baked has no effect on playback. - `AzKeyframeExecutor` and `AzKeyframeTransitioner` no longer use `AzAbstractKeyframeExecutor#getAnimationPointAtTick` or `getCurrentKeyframeLocation`. Both are kept (deprecated, and now allocation-free) for compatibility, but overriding them no longer changes how animations are sampled. The new protected helpers are `prepareKeyframeCursors`, `resetKeyframeCursors`, `locateKeyframe`, `writeChannel` and `sampleValue`. - Easing types registered with `AzEasingTypeRegistry#register(String, Function)` now cache the curves they build, once per argument value, so the function must return the same curve for the same argument. All built-in easings already do. - Custom easing code should call `Double2DoubleFunction#get(double)` instead of `apply(Double)`, which boxes both the input and the result. - Added `AzBoneAnimationQueue#addNextRotation`, `addNextPosition` and `addNextScale` overloads that take the target values as plain doubles. The `AzAnimationPoint` versions are kept. - `AzAutoGlowingLayer` has new constructors taking a `Color` or a `ToIntFunction<AzRendererPipelineContext<K, T>>`, and a protected `getGlowColor(context)` hook for subclasses. The tint is an ARGB color multiplied with the renderer's own color, so the default (no tint) renders exactly as before. Tints work best on white or grey `_glowing` textures. The glow layer now also restores the context's render color after rendering, so a tint never leaks into later layers. - **Behavior change:** `query.moon_phase` now returns a whole number from 0 to 7. Animations that relied on the old fractional value will step once per day instead of changing smoothly. - Molang query functions can be registered with `MolangParser.INSTANCE.registerFunction(name, FunctionClass)`. Names are normalized, so animations can call them with `q.` or `query.`. Query functions that read game state should extend `ContextQueryFunction`, which reads the current `MolangQueryContext` and is never folded to a constant when animations load. - New `MolangQueryContext` (in `core`, with no Minecraft dependencies) supplies the game state for query functions. AzureLib's implementation, `AzMolangQueryContext`, is re-bound by each animator before it evaluates, and exposes the current entity and partial tick for custom query functions. - New `MolangParser#alias(alias, target)` makes two names share one variable. - Function calls in Molang are now looked up with normalized names, so any registered function can be called with the short `q.`, `v.`, `t.` or `c.` prefix. - Added `AzBoneCache#wasRotationAnimatedThisFrame`, `wasPositionAnimatedThisFrame` and `wasScaleAnimatedThisFrame`. Call them in `setCustomAnimations` to tell whether a controller moved a bone this frame, so code can add to the animated value when there is one and start from the default pose when there isn't. Adding to a bone's current value without this check makes un-animated bones drift a little further every frame. - Added `AzEasingTypeRegistry#registerStateless(String, Double2DoubleFunction)` for easing types whose curve doesn't take an argument. The curve is built once and shared by every keyframe. The built-in argument-free easings now use it. - Added `AzEasingType#resolveTransformer(AzKeyframe)`, which lets an easing type hand over a keyframe's curve when the animation loads. It returns `null` by default, which keeps resolving the curve at playback, so existing custom easing types are unaffected. Built-in easings only bake curves whose argument is a fixed value. - Added `AzAnimationPoint#bakedTransformer()` and a `set` overload that carries it, plus `Constant#isFixed()`, which is `true` for shared constants from `Constant.of` that can't change. - Bones with a texture override now render with the model's render type rebuilt for the override texture (`entityCutout`, `entityTranslucent`, `entityTranslucentEmissive` and `armorCutoutNoCull` are recognized; anything else falls back to `entityCutout`). Subclasses can change this through `AzModelRenderer#retargetRenderType`, and `setBoneRenderTypeOverrideProvider` still takes precedence.

v4.0.4 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. - Re-added armor trim support for 26.3 with `AzArmorTrimLayer`, rebuilt on Minecraft's new paletted trim textures. Trims are colored by the trim material's palette at runtime, and decal patterns render like vanilla's. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior. - `AzArmorTrimLayer` (26.3): - Trim textures are no longer registered in the `armor_trims` atlas (removed by Minecraft in 26.3). Instead, each grayscale trim texture needs a `.png.mcmeta` with `{"palette": {"base_palette": "minecraft:trim_base"}}`, and must be the same size as the armor texture. - Texture ids are relative to `textures/` (e.g. `yourmod:trims/your_armor_trim`) and use `Identifier` instead of `ResourceLocation`. - **Breaking:** custom texture functions now return only the texture, without the material suffix (`_gold`, `_iron`, ...), since the color comes from the palette. - New `AzArmorTrimLayer(textureFn, paletteFn)` constructor to choose the palette per trim, e.g. `TrimMaterials.Palette.GOLD_DARKER.id()` for vanilla-style darker trims. `AzArmorTrimLayer.MATERIAL_PALETTE` is the default (the trim material's own palette). - See the updated Armor Trims docs page for setup and migration.

v4.0.4 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. - Re-added armor trim support for 26.3 with `AzArmorTrimLayer`, rebuilt on Minecraft's new paletted trim textures. Trims are colored by the trim material's palette at runtime, and decal patterns render like vanilla's. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior. - `AzArmorTrimLayer` (26.3): - Trim textures are no longer registered in the `armor_trims` atlas (removed by Minecraft in 26.3). Instead, each grayscale trim texture needs a `.png.mcmeta` with `{"palette": {"base_palette": "minecraft:trim_base"}}`, and must be the same size as the armor texture. - Texture ids are relative to `textures/` (e.g. `yourmod:trims/your_armor_trim`) and use `Identifier` instead of `ResourceLocation`. - **Breaking:** custom texture functions now return only the texture, without the material suffix (`_gold`, `_iron`, ...), since the color comes from the palette. - New `AzArmorTrimLayer(textureFn, paletteFn)` constructor to choose the palette per trim, e.g. `TrimMaterials.Palette.GOLD_DARKER.id()` for vanilla-style darker trims. `AzArmorTrimLayer.MATERIAL_PALETTE` is the default (the trim material's own palette). - See the updated Armor Trims docs page for setup and migration.

v3.1.16 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.1.16 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.1.15 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.1.15 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.2.15 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.2.15 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.2.15 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v3.2.15 ### Additions - Added reverse animation playback. Animations can be reversed per stage (`withShouldReverse(true)` / `AzSequence#playReversed`) or per controller via the existing set reverse AzCommands. - Reversed animations play their keyframes, Molang `query.anim_time` and keyframe events (sounds, particles, custom instructions) backwards. - Transitions into a reversed animation now blend towards its last frame instead of its first. - Reversing a controller mid-animation now turns the animation around from its current pose instead of snapping to the mirrored frame. - Added the `PING_PONG` play behavior (`AzPlayBehaviors.PING_PONG` / `AzSequence#pingPong`), which plays an animation forward then backward indefinitely with seamless turnarounds. - Animation files can now define their own play behavior, so it no longer has to be set through AzCommands: - `"loop"` now accepts `true`, `"hold_on_last_frame"`, `"ping_pong"`, `"repeat_x_times"` and `"freeze_on_frame"`. - `"repeat_times"` sets the play count for `repeat_x_times`. - `"freeze_at"` sets the freeze point in seconds for `freeze_on_frame`. - These can all be set in Blockbench with AzureLib Animator 2.2.0+. - Added `AzPlayBehaviors.AS_AUTHORED` and `AzSequence#authored` to explicitly play an animation with the behavior from its animation file. - Molang expressions are now simplified further when animations load. Parts that only use constants (including `math.pi`) are calculated once instead of every frame, and no-op math like `x * 1` or `x - 0` is removed. - Repeated numbers in animation files (keyframe values, rotations, easing arguments) now share one object per value instead of one per occurrence, reducing memory use for large animation sets. ### Fixes - Fixed `REPEAT_X_TIMES` playing one extra time for counts above 1 (2 played 3 times). The repeat count is now the total number of plays. - Fixed the `loop` field in animation files being parsed but never used. - Fixed the controller reverse property and per-stage reverse settings being ignored. - Fixed per-stage properties other than the play behavior being dropped when an animation was queued, which prevented stage-level reversing. - Fixed Molang `query.anim_time` during transitions using the transition's progress instead of the time of the pose being blended to. - Fixed animation files exported by older AzureLib Animator versions with `"loop": "once"` or `"loop": "hold"` not being recognized. - Fixed `math.pi` evaluating to `0` in Molang expressions. It was registered as a function that didn't exist instead of a constant. - Fixed `AzCommand#create` / `createRoot` ignoring their `transitionLength` parameter. ### Developer Notes - **Behavior change:** stages queued without a play behavior (e.g. `AzAnimationSequenceBuilder#queue(name)`) now use the animation file's `loop` value. Files without a `loop` field still play once. Previously `loop` was ignored, so animations exported with `"loop": true` and queued without a behavior will now loop. - **Behavior change:** `REPEAT_X_TIMES` / `setRepeatAmount` now means total plays. Values of 2 or more play one fewer time than before; 1 or less plays once. - A play behavior or repeat count / freeze point set on the code side (stage or AzCommand) always takes priority over the animation file. - New API: - `AzAnimationController`: `isPlayingReversed()`, `sampleTick()`, `reverseInPlace()`, `setReversing(boolean)`, `flipDirection()`, `effectiveRepeatXTimes()`, `effectiveFreezeTickOffset()`. - `AzAnimationControllerTimer#seek(double)`. - `AzKeyframeCallbackHandler`: `handle(animatable, tick, reversed)`, `resync(tick, reversed)`. - `AzQueuedAnimation#reverseOverride()`, `AzBakedAnimation#defaults()`, new `AzAnimationDefaults` record. - Animation progress (`getAdjustedTick()`) always counts forward regardless of direction; use `AzAnimationController#sampleTick()` for the tick actually being sampled. - The previous `AzQueuedAnimation` and `AzBakedAnimation` constructors are kept for compatibility. - **Behavior change:** animations using `math.pi` were previously getting `0` and will now animate with the correct value. - Constant pool: `Constant.of(double)` returns a shared, immutable constant per value (calling `set()` on one throws). `new Constant(...)` still creates a mutable one. `MolangParser#constantValue(double)` shares constant `MolangValue`s the same way, and `MolangParser#clearExpressionCache()` now also clears both pools. - `MathBuilder#parse(String)` now returns an already simplified tree. Simplification never changes the value an expression returns. - Added `MathBuilder#registerConstant(String, double)` for named values that are folded at parse time, unlike `Variable`s. `PI` and `E` are now registered as constants (and still as variables for compatibility). - `Operation` is now a plain enum with a single `calculate` implementation, which `Operator` uses for evaluation. Added `Operation#fromSign(String)`. `Operation.OPERATORS` is now unmodifiable. - **Behavior change:** `AzCommand#create(controller, animation)` and `create(controller, animation, behavior)` no longer reset the controller's speed, start offset, freeze point, repeat amount and reverse direction. Settings from the controller builder or an earlier command now carry over. - **Behavior change:** `AzCommand#create(controller, animation)` now plays the animation with the loop mode from its animation file (`AzPlayBehaviors.AS_AUTHORED`) instead of always `PLAY_ONCE`. Animations exported with `"loop": true` (or any other loop mode) will now play that way; files without a `loop` field still play once. Pass `AzPlayBehaviors.PLAY_ONCE` explicitly to keep the old behavior.

v4.0.3 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v4.0.3 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.1.14 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.1.14 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.1.15 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.1.15 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.2.14 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.2.14 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.2.14 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v3.2.14 ### Additions - Added `AzWeightedPoolBehavior`, a play behavior that picks the next animation from a weighted pool each time the current one finishes, for idle or walk variety without timers. - The next pick happens when the animation actually ends, based on its real length, so resource packs that retime or replace animations keep working. - `addNoRepeat` stops an animation from playing twice in a row (useful for detail animations like a sniff or head turn), and `avoidImmediateRepeat()` applies this to every entry at once. - `randomSequence()` starts a pool on a weighted-random entry; `sequence()` always starts on the first entry or the one chosen with `startWith(...)`. - If a resource pack removes an animation, the pool skips it; if none of its animations can be found, the current animation keeps looping. ### Fixes - ### Developer Notes - Pools must be built during common init so they're registered on both sides. Only the pool name is sent over the network, and if the client doesn't know it, the animation plays once and stops without an error. Use a namespaced name like `modid:pool_name`. - Pools are meant to be the last stage of a sequence. Stages queued after a pool play after its first animation, and the pool doesn't pick in that case. - Picks happen on each client, so different players may see different variants. - Sending the pool that's already playing does nothing, so the same pool command can be sent every tick. Call `randomSequence()` once when entering a state and keep sending that command; calling it every tick restarts the pool.

v4.0.2 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. - Fixed vanilla armor worn by AzureLib entities rendering far below the entity. Vanilla now resets armor model parts when drawing them, so the bone positioning was being thrown away. - Fixed mob heads and skulls worn by AzureLib entities rendering upside down and beside the entity instead of on its head. - Fixed player heads worn by AzureLib entities always showing the default skin instead of the head's owner. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures. - In 26.3, `SkullBlockRenderer.submitSkull` no longer centers or flips the skull model. Custom layers that render skulls should flip it into model space themselves (`scale(-1, -1, 1)`) and drop the old `translate(-0.5, 0, -0.5)` offset.

v4.0.2 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. - Fixed vanilla armor worn by AzureLib entities rendering far below the entity. Vanilla now resets armor model parts when drawing them, so the bone positioning was being thrown away. - Fixed mob heads and skulls worn by AzureLib entities rendering upside down and beside the entity instead of on its head. - Fixed player heads worn by AzureLib entities always showing the default skin instead of the head's owner. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures. - In 26.3, `SkullBlockRenderer.submitSkull` no longer centers or flips the skull model. Custom layers that render skulls should flip it into model space themselves (`scale(-1, -1, 1)`) and drop the old `translate(-0.5, 0, -0.5)` offset.

v3.1.13 ### Additions - Added `AzSequence`, an API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.1.13 ### Additions - Added `AzSequence`, an API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.1.14 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.1.14 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.2.13 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.2.13 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.2.13 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v3.2.13 ### Additions - Added `AzSequence`, a fluent API for chaining animations into a single reusable sequence. Stages can be added with `play`, `loop`, `hold`, or `then(name, behavior)`, using either a chain style (`AzSequence.create().then(...)`) or a builder style (`AzSequence.builder()...build()`). Adding a stage after a looping or holding stage now throws an error instead of silently creating a stage that can never play. - Added timed events to `AzSequence` via `event(name, tick)`, delivered by the new `AzSequencePlayer`. Events are counted in ticks from the start of the sequence and can be handled server-side, e.g. to deal damage on a specific frame of an attack. - Added `AzCommand.create(controller, AzSequence)`, `AzCommand.createRoot(AzSequence)`, and `playSequence` overloads on the controller and root command builders that accept an `AzSequence`. - Added controller layering, so several controllers can animate the same bone at once instead of the last one fully replacing the others. Controllers are layered in the order they are added, and each can be configured with: - a weight from 0 to 1 (`setWeight`), controlling how strongly its animation is applied; - a blend mode (`setBlendMode`): `AzBlendMode.OVERRIDE` blends toward its animation, while `AzBlendMode.ADDITIVE` adds its movement on top of the layers below, e.g. breathing or recoil over a walk cycle; - a bone mask (`setBoneMask`), limiting it to certain bones and their children with `AzBoneMask.only(...)` or `AzBoneMask.except(...)`, e.g. an upper-body aiming layer. - Added `AzAnimationController.fadeWeight(weight, ticks)` to fade a layer in or out smoothly instead of switching instantly. - Added `setWeight` and `fadeWeight` to `AzControllerCommandBuilder`, so the server can change a controller's weight on clients, e.g. `AzCommand.controllerBuilder().fadeWeight("aim", 1F, 5F).build()`. ### Performance - Molang expressions are now cached when animations load, so identical keyframe expressions share one parsed tree instead of each being parsed separately. In benchmarks, animation loading is up to 31× faster and allocates about 97% less. - Molang no longer allocates any memory per frame. Previously every animated entity created around 830 bytes of garbage each frame from re-binding its queries. - Molang expressions are optimized once when they load: constant parts are pre-calculated, parentheses add no extra work, and single-statement expressions are evaluated directly. Animators also look up their queries once instead of by name every frame. In benchmarks, Molang costs about 34% less per frame with 1000 animated mobs. ### Fixes - Fixed multi-stage animation sequences stopping after the first stage. `PLAY_ONCE` and `REPEAT_X_TIMES` now move on to the next queued animation instead of stopping the controller. Previously, later stages only played if the command was re-sent every tick. - Fixed a one-frame flash of the previous animation's first frame when moving between stages of a sequence. - Fixed re-sending a sequence that had already finished replaying only its last stage. It now restarts from the beginning. - Fixed cancelling a controller mid-sequence starting the next queued stage instead of stopping. - Fixed `AzControllerCommandBuilder.play()` sometimes using the wrong play behavior. Animation property `with*()` methods were modifying the shared `EMPTY`/`DEFAULT` instances, so settings leaked between unrelated commands and controllers. - Fixed transition length not being applied when sent from the server. - Fixed `REPEAT_X_TIMES` sharing a single repeat counter across every controller using it, which caused animations to repeat the wrong number of times when several played at once. - Fixed Molang `==`, `<=` and `>=` never working. Any expression using them failed to parse and evaluated to 0. - Fixed Molang operator precedence. Comparisons and `&&`/`||` bound tighter than arithmetic, so `2 * 3 > 5` was read as `2 * (3 > 5)`; `&&` and `||` had equal precedence; and chains mixing `^` with other operators could calculate in the wrong order. Precedence now follows Molang: `||`, `&&`, `== !=`, `< <= > >=`, `+ -`, `* / %`, `^`. - Fixed Molang `-(...)` after an operator, e.g. `2 * -(q.anim_time)`, failing to parse and evaluating to 0. - Fixed Molang assignments. Assigning a variable in the first statement of an expression (`v.x = 6`) failed, and later statements never read the assigned value back (`v.x = 6; return v.x + 1` returned 1). Variables assigned inside an expression also no longer leak into the global variable list. - Fixed Molang `return` not ending the expression. Statements after a `return` still ran and replaced its result. - Fixed `query.item_is_enchanted` returning 1 for items that are not enchanted. - Fixed `query.item_current_durability` returning NaN for items that cannot take damage. It now returns 0. - Fixed living-entity queries such as `query.health` and `query.limb_swing` reading values from a previously animated entity when used on a non-living entity. They now return 0. - Fixed a Molang expression that failed to parse logging an error every frame for every keyframe using it. The error is now logged once when the animation loads. - Fixed Molang short prefixes other than `q.` not being treated as aliases. `v.`, `t.` and `c.` now refer to the same variables as `variable.`, `temp.` and `context.`, so `v.speed` and `variable.speed` are one variable. - Fixed `math.hermite_blend` only returning whole numbers. It rounded its input up and its result down, so it jumped straight from 0 to 1 instead of following the smooth curve 3t² − 2t³. - Fixed glowmasks not working on animated textures when another mod that replaces animated textures, such as GeckoLib, is installed. The glow layer showed every frame of the texture squashed together, and the glowing parts stayed visible on the base texture. - Fixed animated textures losing their glowmask after a resource reload (F3+T or changing resource packs). - Fixed animated textures leaking memory every time they were loaded or reloaded. - Fixed textures that gain an animation from a resource pack not animating until the game was restarted. ### Developer Notes - `AzAnimationProperties` and `AzAnimationStageProperties` are now immutable. Their `with*()` methods always return a new instance, so make sure you use the returned value; calling `with*()` without assigning the result no longer has any effect. - Custom `AzPlayBehavior`s that end an animation should call `AzPlayBehaviors.advanceOrStop(context)` instead of `context.stateMachine().stop()`, so that the remaining stages of a sequence still play. - `AzSequence` event ticks are not scaled by animation speed, and the controller's transition length is added before each stage on the client. Account for both when lining events up with specific keyframes. - The Molang fixes change what some existing animations evaluate to, mainly those using comparisons, `&&`/`||`, `^`, assignments or `return`. Expressions that only use `+ - * / %` evaluate exactly as before. If an animation was tuned around the old behavior, re-check it. - Parsed Molang trees are now shared between every keyframe with the same expression. Don't modify a `MolangValue` returned by the parser. - To bind a query every frame, prefer a `MolangVariableRef` over `MolangParser.setValue`/`setMemoizedValue` by name. It resolves the variable once and follows `MolangParser.register` if the variable is replaced. - `temp.`/`t.` Molang variables are now always scoped to their expression. - Controllers with the default settings (weight 1, `OVERRIDE`, no bone mask) behave exactly as before layering was added, so existing animators need no changes. - `setCustomAnimations` runs after all controllers have been layered, so values set there still replace the animated pose. Add to a bone's current value to layer code-driven movement on top instead. - Weight fades follow the animator's clock: they run smoothly between game ticks, pause with the game, and are not affected by animation speed. A controller's weight is kept when a new animation or sequence is played on it. - Layering adds a new network action (`controller/set_weight`), so clients and servers need to be on the same AzureLib version. - `MolangParser.register` stores variables under the expanded name, so registering `v.foo` and reading `variable.foo` (or the reverse) now reach the same variable. The registered object's `getName()` is left as you passed it. - New API: `MolangParser.parseCached`, `parseUncached`, `clearExpressionCache` and `expressionCacheSize`; `LazyVariable.setMemoized`; `MolangVariableRef`; `IValue.simplify()` (a default method, so existing implementations are unaffected); and `MolangCompoundValue.compact()`. `MolangParser.parseOneLine(String, MolangCompoundValue)` is deprecated, and the unused `HermiteBlend.random` field has been removed. - New layering API: `AzBlendMode`, `AzBoneMask`, `AzWeightFade` and `AzControllerSetWeightAction`; `setWeight`, `setBlendMode` and `setBoneMask` on `AzAnimationControllerBuilder`; `weight`, `setWeight`, `fadeWeight`, `isFadingWeight`, `blendMode`, `setBlendMode`, `boneMask` and `setBoneMask` on `AzAnimationController`; and `AzBoneCache.currentFrame()`. `AzBoneAnimationUpdateUtil` and `AzBoneAnimationQueueCache.update` gained overloads that take a weight and blend mode; the existing signatures still work and apply at full weight. - When a texture has an AzureLib glowmask, AzureLib now uses its own animated texture for that texture path, replacing one registered by another mod. A GeckoLib renderer sharing that exact texture path will no longer animate it, so give each library's renderers their own textures.

v4.0.1 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v4.0.1 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.1.12 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.1.12 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.1.13 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.1.13 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.2.12 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.2.12 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.2.12 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v3.2.12 ### Fixes - Fixed armor and item renderers sometimes failing to register when multiple mods registered them at the same time during parallel client setup on NeoForge. This caused armor to randomly render with vanilla/missing textures (e.g. purple armor), with different pieces affected between launches. `AzArmorRendererRegistry` and `AzItemRendererRegistry` are now thread-safe. - Fixed `AzIdentityRegistry` having the same issue, which could cause trigger animations to silently stop working for some items. It is now thread-safe. ### Developer Notes - On NeoForge, renderer and identity registration should be wrapped in `event.enqueueWork(...)` inside `FMLClientSetupEvent` / `FMLCommonSetupEvent`. The docs have been updated to reflect this. The registries are now safe either way, but `enqueueWork` also protects your mod on older AzureLib versions.

v4.0.0 - Updated to support 26.3

v4.0.0 - Updated to support 26.3

v4.0.0 - Heavily behind the hood rework for 26.2, with special thanks to collinvht for the massive help in getting this to the finish line. - Configuration screen no longer an option from mods menu, file still works and syncs fine. Just less render code I want to keep up with.

v4.0.0 - Heavily behind the hood rework for 26.2, with special thanks to collinvht for the massive help in getting this to the finish line. - Configuration screen no longer an option from mods menu, file still works and syncs fine. Just less render code I want to keep up with.

v3.1.11 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.1.11 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.1.12 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.1.12 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.2.11 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.2.11 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.2.11 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.2.11 ### Fixes - Fixed an issue where `q.x` queries were not working correctly. - Fixed crash when overriding bedrock easings with other bedrock easings. Now properly works.

v3.1.10 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.1.10 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.1.11 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.1.11 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.2.10 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.2.10 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.2.10 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.2.10 ## Performance — Rendering Pipeline Overhaul This release is a focused performance pass targeting the client-side rendering pipeline. The goal was to bring per-entity CPU and GC cost for complex animated models in line with vanilla mob rendering. All changes are backwards-compatible — no model files, animator classes, or existing renderer configurations require modification. ### Fixes - Fixed registry of easing types (Credit to Collinvh for fix) - Fixed bedrock easing interpolation having the position incorrectly in the place of the first value. (Credit to Collinvh for fix) - Fixed broken matrix translation in `RenderUtils.translateMatrix`. The previous implementation used `Matrix4f.add()` to apply a translation vector, which is mathematically incorrect and produced wrong world-space matrix results for bone tracking. Now uses `Matrix4f.translate()` as intended. - Fixed triple `boneTextureOverrideProvider` call per bone. The provider lambda was invoked three times per bone per frame in `getOrRefreshRenderBuffer`. Now called once, result cached locally. - Replaced per-cube `pushPose`/`popPose` with save/restore in `renderCubesOfBone`. The pose stack entry is now captured once per bone and restored after each cube transform, eliminating N matrix stack copies per multi-cube bone. - Added hidden bone early-out to `renderRecursively`. Hidden bones now skip all matrix work (`pushPose`, translate, rotate, scale) entirely. Children are still iterated unless `isHidingChildren()` is also true, matching Bedrock's bone visibility spec. - Hoisted flat-cube check out of the quad loop in `renderCube`. `fixInvertedFlatCube` is only relevant for 2D plane cubes (one dimension = 0). The check is now computed once per cube before the quad loop and skipped entirely for standard 3D cubes. - Eliminated per-vertex redundant reads in `createVerticesOfQuad`. `getTextureOverride()`, `packedOverlay()`, `packedLight()`, and normal vector components are now all hoisted outside the vertex loop. UV scale factors for the texture override path are pre-computed as floats, replacing two integer divisions per vertex with a single multiply. - Fixed `invertAndMultiplyMatrices` allocation. Previously allocated a `new Matrix4f` on every call (called twice per tracked bone per frame). Now uses a static `INVERT_SCRATCH` buffer; one allocation per call for the returned result only. - Eliminated per-frame `Matrix4f` heap allocations in `renderRecursively`. The two `new Matrix4f(...)` calls in the bone matrix tracking path are replaced with reusable `scratchPoseState` and `scratchLocalMatrix` instance fields. - Fixed triple `getAdjustedTick()` call. Was called once before the bone loop, once inside the loop per bone, and once for the callback. Now called once; `currentAdjustedTick` field reused throughout. - Fixed severe per-frame allocation spam. The previous implementation called `CubicBezierCurve.getPoints(200)` on every bezier keyframe every frame, allocating an `ArrayList` and 201 `Vector2d` objects per call. Additionally `findClosestPoints` allocated two more `Vector2d` instances and a `Vector2d[]` return on every call, and `buildBezierCurve` allocated four `Vector2d` control points per call. For a model with multiple bezier-eased bones this produced 240+ allocations per frame contributing significantly to GC pressure. - Fixed AzArmorRendererPipeline using head for the leftArm scaling. ### Changed - Replaced nine `ArrayDeque<AzAnimationPoint>` queues with a flat object pool. Nine pre-allocated `AzAnimationPoint` instances are reused every frame via `set()`. A `boolean[9]` presence array replaces queue state. This eliminates the dominant source of per-frame heap allocation in the animation pipeline — previously ~180 record allocations per animated bone per frame. - Removed `LinkedList` usage. Previously used for all nine queues before the `ArrayDeque` interim; now eliminated entirely. - Converted from `record` to mutable `final class`. All record accessor names preserved for API compatibility. New `set(...)` method enables in-place reuse by the pool in `AzBoneAnimationQueue`. - Converted from `record` to mutable `final class`. New `set(T, double)` method allows the single scratch instance on `AzAbstractKeyframeExecutor` to be truly reused end-to-end with zero allocation. - Replaced linear keyframe scan with binary search. `getCurrentKeyframeLocation` previously walked all keyframes from the start (O(n)). Now builds a cumulative end-time array and binary searches it (O(log n)). Meaningful for animations with many keyframes per bone. - Add overload method for per bone Texture/Render Type to support the entity as well. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`. A stable `animTimeSupplier` field closes over `currentAdjustedTick`; `setMemoizedValue` receives the same object reference every frame. - Replaced per-frame `DoubleSupplier` lambda allocation for `ANIM_TIME`, matching the fix in `AzKeyframeExecutor`. - Replaced four per-frame `DoubleSupplier` lambda/method-reference allocations in `applyMolangQueries`. `LIFE_TIME`, `ACTOR_COUNT`, `TIME_OF_DAY`, and `MOON_PHASE` now use stable supplier fields that read mutable double fields set before each call. - Updated to use pool-based `pollRotX/Y/Z`, `pollPosX/Y/Z`, `pollSclX/Y/Z` accessors from the new `AzBoneAnimationQueue` pool design. - Replaced point-scan lookup with binary search on curve parameter `t`. Rather than sampling the curve at 200 evenly-spaced points and scanning for the nearest two, the curve is now evaluated via binary search on `t` (20 iterations), exploiting the monotonically increasing x-coordinate of well-formed animation curves. Converges to the same result with zero heap allocation. - Added `translateMatrixInPlace(Matrix4f, Vector3f)`. Mutates the matrix directly, for call sites that already own the matrix and don't need the original preserved. - Removed `getPoints(int)`. No longer needed now that `evaluateAtTime` handles all call sites. - Fixed custom easing type lookup when easing names use mixed or lower camel case. ### Added - Added hidden bone early-out matching `AzModelRenderer`, before `pushPose` and all transform calls. - Added scratch `AzKeyframeLocation` field. The single instance is reused across all `getAnimationPointAtTick` calls via `.set()`, eliminating one record allocation per axis per bone per frame. - Added `prepareFrame()` method. Clears all pool presence flags before the keyframe executor writes new values each frame, preventing stale values from partially-animated prior frames bleeding through. - Added `boneAnimationQueueCache.prepareFrame()` call before `stateMachine.update()` in the per-frame update order. - Added reusable scratch fields. Four `Vector2d` fields replace the per-call control point allocations in `buildBezierCurve`, and two scratch `Vector2d` fields are passed into `CubicBezierCurve.evaluateAtTime` for the binary search iterations. - Added `evaluateAtTime(double, Vector2d, Vector2d)`. Zero-allocation curve evaluation using binary search on `t`, accepting caller-provided scratch vectors. Replaces the allocation-heavy `getPoints(int)` approach. - Configures bone hierarchy depth culling and animation tick-rate reduction, each with independent distance thresholds. - `AzLodConfig.DISABLED` — no LOD applied. - `AzLodConfig.DEFAULT` — automatically applied to all entity renderers unless overridden: bone LOD at 20 blocks (depth ≤ 3), animation LOD at 28 blocks (every 2 ticks). - Per-entity runtime manager. Walks the bone tree and calls `setHidden(true)` on bones exceeding the depth budget. Tracks a `lodHidden` flag so LOD-hidden bones can be restored when the entity returns to close range without affecting model-authored hidden bones. - Returns a `shouldAnimate` boolean to gate the full animation pipeline update, implementing tick-rate reduction for distant entities. - Added `withLodConfig(AzLodConfig)` builder method. Defaults to `AzLodConfig.DEFAULT` when not specified. - Wires `AzLodManager` into the render loop. LOD manager is instantiated per entity UUID and updated each frame before the pipeline runs. When `shouldAnimate` is false the model renders at its last computed pose, skipping all animation controller work. - Added `lodHidden` field with `getLodHidden()` / `setLodHidden(boolean)` accessors. Distinguishes LOD-driven visibility from model-authored `dontRender` flags. Propagated through `deepCopy()`.

v3.1.10 ### Fixes - Prevent MolangVariableHolder NPE for constant fallbacks

v3.1.10 ### Fixes - Prevent MolangVariableHolder NPE for constant fallbacks

v3.2.9 ### Fixes - Prevent MolangVariableHolder NPE for constant fallbacks

v3.2.9 ### Fixes - Prevent MolangVariableHolder NPE for constant fallbacks

v3.2.9 ### Fixes - Prevent MolangVariableHolder NPE for constant fallbacks

v3.2.9 ### Fixes - Prevent MolangVariableHolder NPE for constant fallbacks

v3.1.8 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.1.8 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.1.9 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.1.9 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.2.8 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.2.8 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.2.8 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.2.8 ### Fixes - Fixes endless loading if geo has broken parent bone - Fixes crash if animatable is null on animation queuing. - Fixes AzAutoGlowingLayer not restoring rendertype/vertext data. - Fixes crash on a missing geo file and animating. ### Changes - Improves logging of animation including features.

v3.1.7 ### Fixes - Fixed the texture issue regarding animated textures.

v3.1.7 ### Fixes - Fixed the texture issue regarding animated textures.

v3.1.8 ### Fixes - Fixed empty nbt on crafted items.

v3.1.8 ### Fixes - Fixed empty nbt on crafted items.

v3.2.7 ### Fixes - Fixed empty nbt on crafted items.

v3.2.7 ### Fixes - Fixed empty nbt on crafted items.

v3.2.7 ### Fixes - Fixed empty nbt on crafted items.

v3.2.7 ### Fixes - Fixed empty nbt on crafted items.

v3.1.6 ### Fixes - Fixed mixin crash. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.1.6 ### Fixes - Fixed mixin crash. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.1.7 ### Fixes - Fixed mixin crash. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.1.7 ### Fixes - Fixed mixin crash. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.2.6 ### Fixes - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID tag when crafted if it has an identity registered. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.2.6 ### Fixes - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID tag when crafted if it has an identity registered. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.2.6 ### Fixes - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID tag when crafted if it has an identity registered. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.2.6 ### Fixes - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID tag when crafted if it has an identity registered. ### Changes - Added reRenderWithBakedModel for AzRenderLayer so modders can change the model on layers more easily.

v3.1.5 ### Fixes - Fixed some edge cases with AzCachedBoneUpdateUtil - Fixed a bug that caused double rendering with armor trims. - Fixed an issue where Azure armor used in AzArmorRender would not properly move with the entity. - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID component when crafted if it has an identity registered.

v3.1.5 ### Fixes - Fixed some edge cases with AzCachedBoneUpdateUtil - Fixed a bug that caused double rendering with armor trims. - Fixed an issue where Azure armor used in AzArmorRender would not properly move with the entity. - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID component when crafted if it has an identity registered.

v3.1.6 ### Fixes - Fixed a bug that caused double rendering with armor trims. - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID tag when crafted if it has an identity registered.

v3.1.6 ### Fixes - Fixed a bug that caused double rendering with armor trims. - Added ItemMixin_EnsureCraftHasID to ensure items have an az_id UUID tag when crafted if it has an identity registered.

v3.1.5 ### Fixes - Fixed the texture issue regarding animated textures. - Fixed some edge cases with AzCachedBoneUpdateUtil

v3.1.5 ### Fixes - Fixed the texture issue regarding animated textures. - Fixed some edge cases with AzCachedBoneUpdateUtil

v3.2.5 ### Fixes - Fixed the texture issue regarding animated textures. - Fixed some edge cases with AzCachedBoneUpdateUtil

v3.2.5 ### Fixes - Fixed the texture issue regarding animated textures. - Fixed some edge cases with AzCachedBoneUpdateUtil

v3.2.5 ### Fixes - Fixed the texture issue regarding animated textures. - Fixed some edge cases with AzCachedBoneUpdateUtil

v3.2.5 ### Fixes - Fixed the texture issue regarding animated textures. - Fixed some edge cases with AzCachedBoneUpdateUtil

v3.1.4 ### Fixes - Fixed mixin conflict with Gankolib animated textures.

v3.1.4 ### Fixes - Fixed mixin conflict with Gankolib animated textures.

v3.1.4 ### Fixes - Fixed crash due to invisible AzEntities. - Fixed mixin conflict with Gankolib animated textures.