Custom Model Render (Power Type)

Changes how a player or any mob looks. Texture mode re-skins the entity's own model with a texture, and geometry mode draws a separate 3D model made in Blockbench that follows the entity's pose. Geometry mode is a feature renderer defined in JSON, so it needs no Java and no extra mods.

Type ID: apoli:custom_model_render

Fields for both modes

Texture-mode fields (mode: texture)

Geometry-mode fields (mode: geometry)

Live textures

Every texture field here takes a keyword instead of a texture ID, resolved every frame against the entity being drawn:

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:wings",
  "texture_location": "player"
}

That draws the wings model UV-mapped onto the wearer's own skin, so it takes each player's colours without a texture per player.

Geometry on the player

When resources load or reload, the log prints Loaded N custom model(s) for custom_model_render. If your model isn't drawing, check N and confirm the file sits at one of the two paths above with the .geo.json extension.

The model is placed exactly where Blockbench shows it, relative to the player's feet. A bone at Bedrock pivot [0, 0, 0] sits on the ground, and one at [0, 24, 0] sits at the head pivot. Per-cube rotations, bone rotations, bone parenting, inflate and mirror all carry over unchanged, and Box UV is packed the way Blockbench's Bedrock preview packs it. That includes cubes with fractional sizes, where Blockbench rounds each dimension down before laying the six faces out.

Bones named head, body, right_arm, left_arm, right_leg, left_leg and hat pick up the matching vanilla body part's animation, so the model bends with the arms and turns with the head. Any other bone (a cape, a backpack, a tail) rides along with its parent bone.

Bones placed off the pivots on purpose still work, and suit anything that isn't a limb. An aura ring pivoted at the feet, or a floating orb pivoted at the head, orbits the player instead of tracking a joint.

A bone follows the body part as it is posed, so a resource pack that replaces the player model through Entity Model Features (Fresh Animations and the like) carries the model with it.

Names are matched loosely, so you rarely have to rename anything Blockbench gave you. Case, spaces, _ and - are ignored (Head, RightArm and right arm all work), and these spellings bind to the same body part:

Every bone whose name matches a body part binds to it, not only the first one. A rig with right_arm and right_sleeve, or head and hat_layer, or body and jacket, animates all of them together, and a second layer bone stays on its limb through poses that move a part as well as rotating it: sneaking, blocking with a shield, winding up a trident.

Nesting is fine. A body part bone animates from the player whether it sits at the top level, inside a wrapper group like bb_main, or under your Body bone. It always swings the way the player's own limb swings, and never twice over.

Animations

Blockbench exports animations as a .animation.json next to your model. Drop it at assets/<namespace>/animations/<path>.animation.json and name it in animations:

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:wings",
  "texture_location": "example:textures/entity/wings.png",
  "render_type": "cutout_no_cull",
  "animations": {
    "animation": "example:wings",
    "name": "animation.wings.idle"
  }
}

animations also takes an array and works like hud_render does: the entries are read top to bottom and the first one whose condition passes is the one that plays. That drives a model from the holder's state without any Java:

"animations": [
  {
    "animation": "example:wings",
    "name": "animation.wings.flap",
    "condition": {
      "type": "apoli:fall_flying"
    }
  },
  {
    "animation": "example:wings",
    "name": "animation.wings.idle"
  }
]

Playback time restarts whenever the selected entry changes, so an animation that doesn't loop replays each time its condition turns back on. speed scales the playback rate and loop overrides the file's own loop flag. See Model Animation for the full field list.

The animation is applied on top of the pose the player's body already gives the model, so a bone named right_arm gets the player's arm swing and your keyframes added together. Bones that aren't body parts get the keyframes alone. Position keyframes are in Bedrock units and rotation keyframes in degrees, exactly as Blockbench writes them.

When resources load or reload, the log prints Loaded N custom model animation(s) from M file(s). Check it if nothing moves.

Rigs that animate themselves

Some models aren't meant to move like a player at all: a creature with its own walk cycle, a floating spirit, a mech. Set bind_body_parts to false and the model is drawn exactly as its animations pose it:

• Bones named head, right_arm and the rest keep your hierarchy. They aren't lifted out of their groups, and they don't pick up the player's limb swing, head turn or sneak. Only your keyframes move them.
• The model still turns with the holder's body and is still placed relative to their feet.
• body_parts still hides and shows bones by name.
• With show_first_person, the right_arm and left_arm bones (and everything under them) are drawn where the vanilla first person arm is, with the rotation your animation gives them, so the held item and the hand line up.

Drive the model from the holder's state with conditional animations entries, and hide the player underneath with apoli:modify_model_parts:

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:golem",
  "texture_location": "example:textures/entity/golem.png",
  "bind_body_parts": false,
  "show_first_person": true,
  "hide_cape": true,
  "animations": [
    {
      "animation": "example:golem",
      "name": "animation.golem.walk",
      "condition": {
        "type": "apoli:moving"
      }
    },
    {
      "animation": "example:golem",
      "name": "animation.golem.idle"
    }
  ]
}

Geometry mode on minions

Give the power to an apoli:summon_minion minion through that action's powers list and the minion is drawn as your Blockbench model instead of the default orb. That gives a summon any shape you like from a data pack alone.

The minion skeleton is main (the root bone, Bedrock pivot [0, 4, 0]) with flat2 and flat3 under it. A bone named main turns to face wherever the minion is looking, which is the minion's only vanilla animation. flat2 and flat3 hold fixed poses, so a bone named after them inherits nothing. Every other bone keeps the pose you gave it in Blockbench and rides along with the root.

The minion's texture field still applies to the minion's own model, so it only matters when render_as_overlay is true. Your geometry always uses texture_location. scale on the summon still applies, and the custom model is scaled with the minion.

{
  "type": "apoli:summon_minion",
  "follow_owner": true,
  "follow_offset": [
    0,
    1,
    -1
  ],
  "max_life_ticks": 0,
  "powers": [
    "example:minion_wisp_model"
  ]
}

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:wisp",
  "texture_location": "example:textures/entity/wisp.png",
  "render_type": "cutout_no_cull"
}

Energy swirl

render_type: energy_swirl draws the texture the way a charged creeper's aura and a wither's armour are drawn: additively, so it glows over the model, with the texture sliding across it. The sideways drift is fixed. scroll_speed adds a steady scroll along the model on top, and 0.0 holds the texture completely still. Pair it with a scale above 1.0 to lift the swirl off the body into a shell.

{
  "type": "apoli:custom_model_render",
  "texture_location": "minecraft:textures/entity/creeper/creeper_armor.png",
  "render_as_overlay": true,
  "render_type": "energy_swirl",
  "scroll_speed": 0.01,
  "scale": 1.1,
  "red": 0.5,
  "green": 0.5,
  "blue": 0.5
}

This puts a charged creeper aura on whoever holds the power, whether a player, a zombie or anything else alive.

The type ID apoli:energy_swirl loads as this power with the swirl already set up. It reads texture_location, size (as scale) and speed (as scroll_speed), and fills in whatever is left out with render_as_overlay: true, render_type: energy_swirl, the wither's armour texture as texture_location, scroll_speed: 0.01 and a 0.5 grey tint:

{
  "type": "apoli:energy_swirl",
  "texture_location": "example:textures/entity/rewind.png",
  "size": 1.05,
  "speed": 0.02
}

Behaviour and limits

• Several active custom_model_render powers stack, and each is drawn. On a minion, one geometry power that isn't an overlay is enough to hide the base model, and the rest still draw.
• Conditions on the power switch the whole render on and off as they change. Combine them with hidden_slots to hide it based on equipment.
• Geometry mode draws in first person with show_first_person: true, but only the arm bones, because first person only draws an arm. A bound arm bone is posed onto the vanilla arm, and an unbound one is drawn at it with its animated rotation. Geometry does draw in full wherever the game renders a whole player body, including the inventory preview and other entity preview screens, whatever camera mode you are in, and when your body is visible in first person (while sleeping, for instance).
• The first person arm is drawn from the same bones as the third person model, so the vanilla arm underneath is still there. Hide it with apoli:modify_model_parts if your model should replace it instead of sitting over it.
• If model_location fails to load, the minion falls back to its normal model instead of turning invisible.
• The Bedrock parser supports box UV and per-face UV (including both in one model, cube by cube), per-cube and per-bone pivot and rotation, inflate, mirror and bone parenting. Only minecraft:geometry[0] is read. uv_rotation (Bedrock format 1.21.0 and later) isn't supported, so a model using it logs a warning and draws that face unrotated.
• A cube with a zero-size axis is a flat plane in Bedrock too, and both of its faces land on the same plane. Blockbench shows this as z-fighting and so does the game. Give the cube a small inflate or a thickness above zero if it flickers.

Examples

Replace the skin in third person (the replace mode of entity_texture_overlay):

{
  "type": "apoli:custom_model_render",
  "mode": "texture",
  "wide_texture_location": "example:textures/entity/husk_wide.png",
  "slim_texture_location": "example:textures/entity/husk_slim.png"
}

Glowing eyes on the head only, over the normal skin:

{
  "type": "apoli:custom_model_render",
  "mode": "texture",
  "render_as_overlay": true,
  "render_type": "eyes",
  "body_parts": "head",
  "wide_texture_location": "example:textures/entity/glowing_eyes.png"
}

A custom cape model that follows the body, hidden when a chestplate is worn:

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:cape",
  "texture_location": "example:textures/entity/cape.png",
  "render_type": "cutout_no_cull",
  "hidden_slots": [
    "chest"
  ]
}

Clawed gauntlets you can also see on your own hands:

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:gauntlets",
  "texture_location": "example:textures/entity/gauntlets.png",
  "render_type": "cutout_no_cull",
  "show_first_person": true
}

The model's right_arm and left_arm bones sit on the vanilla arm pivots, so they follow the arm in third person and are drawn onto the first person hand as well.

On mobs

Grant the power to a mob with apoli:grant_power, the /apoli:power grant command or a global power set, and it renders on that mob. That is how you make mob variants such as a red zombie, a crystal spider or a ghast with a crown.

Texture mode paints onto the mob's own model, through that model's own UV layout. A texture made for it is the mob's vanilla texture repainted: open minecraft:textures/entity/zombie/zombie.png (or the spider's, or the ghast's) from the vanilla resources, paint over it, and point texture_location at your copy. It fits whatever shape the model has, at any resolution, as long as it keeps the layout, so a 128×128 repaint of a 64×64 texture works.

• render_as_overlay: false swaps the mob's texture outright. The mob's own extra layers that reuse its texture, such as a slime's translucent outer shell, take the new texture too.
• render_as_overlay: true draws your texture over the mob's, with render_type, the tint and scale, for glowing markings, an energy shell or a coat of frost.

{
  "type": "apoli:custom_model_render",
  "texture_location": "example:textures/entity/zombie/infernal_zombie.png"
}

Geometry mode draws your Blockbench model on the mob. Bones named after the mob's own model parts follow those parts, the same way head and right_arm follow a player:

The names are the ones Minecraft's own model code gives the parts, with case, spaces, _ and - ignored. Every bone follows its part relative to where that part rests, so put each bone's pivot where the vanilla part's pivot is. Nest the bones the way the mob's parts are nested (a vex's right_arm under its body), so a parent's movement reaches its children once and not twice. Bones that name no part ride along with their parent.

With render_as_overlay: false (the default), your model replaces the mob's and the vanilla model isn't drawn. The mob's other layers still are (held items, armour, a spider's glowing eyes), so hide the ones you don't want with apoli:prevent_feature_render. With render_as_overlay: true your model is drawn on top of the mob, which is how you give it a hat, horns or wings.

{
  "type": "apoli:custom_model_render",
  "mode": "geometry",
  "model_location": "example:crystal_spider",
  "texture_location": "example:textures/entity/crystal_spider.png",
  "render_type": "cutout_no_cull"
}

On something other than a player or a mob

The power renders on whatever entity holds it, so granting it to a summon, a clone or a projectile puts the model on that entity instead of on you:

• A minion or a clone that holds the power renders with the geometry, with its humanoid bones driven by the entity's own pose.
• A projectile fired by apoli:fire_projectile with a texture_location renders the geometry instead of its flat texture, pointed along its flight path. Grant the power from that power's projectile_action. With Flywheel installed, the projectile is drawn with instancing (see Performance Mods).

Minions and projectiles draw the model the way bind_body_parts: false does, so bones named after player body parts stay where you nested them. On a minion, bind_body_parts: false also stops the main bone from turning with the minion's gaze. offset applies on both, which is the easy way to centre a model that was built off the origin.

hidden_slots only applies to entities that wear equipment, and is ignored on a projectile.

While disguised

An apoli:disguise_as disguise swaps out the whole player renderer, so the power has to be drawn onto the disguise instead. It is, whenever the disguise's model is humanoid: zombie, husk, drowned, skeleton, stray, wither skeleton, piglin and the rest of the two-arms-two-legs family. Texture overlays paint onto the disguise's limbs, and geometry bound to head, body, right_arm, left_arm, right_leg or left_leg tracks the disguise's live pose.

{
  "type": "apoli:multiple",
  "skeleton_body": {
    "type": "apoli:action_on_callback",
    "entity_action_added": {
      "type": "apoli:disguise_as",
      "entity_type": "minecraft:skeleton"
    },
    "entity_action_removed": {
      "type": "apoli:remove_disguise"
    }
  },
  "armor": {
    "type": "apoli:custom_model_render",
    "mode": "texture",
    "render_as_overlay": true,
    "wide_texture_location": "example:textures/models/armor/plate_wide.png",
    "slim_texture_location": "example:textures/models/armor/plate_slim.png"
  }
}

The armour is painted over the skeleton. Which of the two textures is used still follows the player's own skin model and not the disguise's, so a slim-armed player gets the slim sheet.