Glowing Entity Textures and Emissive Materials

In Minecraft Bedrock, standard entity rendering applies ambient and block lighting to every pixel of your texture based on where the entity is standing. To make sections of a texture glow, you do not use a separate second texture map like you might for blocks or in other engines. Instead, the default emissive entity shaders read the alpha channel (opacity) of your single PNG texture to decide which pixels receive world lighting and which pixels bypass it.

Because the alpha channel is repurposed to control emissiveness, there is a strict trade-off you must plan for when painting your texture: an emissive material usually cannot have smooth partial transparency (like stained glass) and glowing pixels on the same geometry part using a single material. Depending on the base material you inherit from, completely transparent pixels (alpha 0) can still be culled so you can have cutouts like ragged wings, while partially transparent pixels (alpha 1 to 254) are rendered as opaque and glowing.

To enable emissive rendering, your resource pack needs a custom material defined in `RP/materials/entity.material` that inherits from one of the built-in emissive states, or your client entity file must directly reference an existing vanilla emissive material such as `spider` or `enderman`. Defining your own material inheritance is safer because it isolates your entity from future changes to vanilla mobs.

There are two main base materials to inherit from: `entity_emissive` and `entity_emissive_alpha`. Both read the texture's alpha channel to control brightness, but they treat completely transparent pixels differently. If your model is a solid box where every pixel of the UV map is visible, use `entity_emissive`. If your model has flat planes that rely on transparent pixels to cut out shapes—such as hair fringes, horns, or tattered cloth—use `entity_emissive_alpha`.

{
  "materials": {
    "version": "1.0.0",
    "custom_glowing_solid:entity_emissive": {},
    "custom_glowing_cutout:entity_emissive_alpha": {}
  }
}

Most standard image editors combine the Red, Green, Blue, and Alpha channels so that lowering the alpha value makes the pixels look faint on your canvas. When painting for `entity_emissive_alpha`, you want the colour channels to remain at full vibrancy while the alpha value is slightly reduced.

For pixels that should respond normally to daylight and cave darkness, keep their alpha at 255 (100% opacity). For pixels that should glow, set their alpha anywhere between 1 and 254. The lower the alpha value is (closer to 1), the stronger the unlit emissive effect becomes. If you are using `entity_emissive_alpha`, make sure you do not drop the alpha of glowing pixels all the way to 0, or the game will discard those pixels completely and leave a hole in your mob.

A common pitfall with image editors like Paint.NET, Photoshop, or Aseprite is that saving a PNG with an alpha of 0 will sometimes overwrite the RGB colour data with black or white. Always keep your glowing regions at an opacity around 10% to 90% (alpha 25 to 230) so the colour data is preserved and the pixel stays visible.

Once your texture is saved in `RP/textures/entity/` and your material is defined, you must link them together inside the entity's client definition file (`RP/entity/`). You map a short name to your custom material in the `materials` object, and do the same for your texture and geometry.

In the example below, the material short name `default` is assigned to our `custom_glowing_cutout` material. The standard `controller.render.default` render controller automatically looks for a material named `default` and a texture named `default`, meaning you do not need to write a custom render controller just for basic glowing eyes.

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "wiki:glow_beetle",
      "materials": {
        "default": "custom_glowing_cutout"
      },
      "textures": {
        "default": "textures/entity/glow_beetle"
      },
      "geometry": {
        "default": "geometry.glow_beetle"
      },
      "render_controllers": [
        "controller.render.default"
      ],
      "spawn_egg": {
        "base_color": "#1a1a2e",
        "overlay_color": "#00ffcc"
      }
    }
  }
}

Sometimes you need an entity to have translucent parts (like ghost limbs using `entity_alphablend`) alongside glowing parts (like eyes using `entity_emissive_alpha`). Because a single material cannot do both at the same time, you can assign different materials to specific bones of your geometry inside a custom render controller.

In the `materials` array of a render controller, each object maps a bone name pattern to a material short name defined in the client entity file. The game evaluates this list from top to bottom, so you place the wildcard `"*"` first to set the base material for the whole body, and then override specific bones like `"head"` or `"eyes"` below it.

{
  "format_version": "1.8.0",
  "render_controllers": {
    "controller.render.glow_beetle": {
      "geometry": "Geometry.default",
      "materials": [
        { "*": "Material.body_translucent" },
        { "eyes_bone": "Material.eyes_glowing" }
      ],
      "textures": [
        "Texture.default"
      ]
    }
  }
}

Applies to all modern Bedrock versions (format_version 1.8.0 and 1.10.0 for client entities and render controllers). No experimental toggles are required. Note that RenderDragon handles the underlying shader logic automatically as long as you inherit from the vanilla `entity_emissive` or `entity_emissive_alpha` material definitions.

Read out of the game itself, so the ids match the version you are building for.