Prism Shaders LogoPrismShaders

Shader API

The Bloxd shader API, without the guesswork.

The complete apiVersion 5 reference, the official Bloxd source, all 8 example packs and the v1 to v4 history. Hooks, structs, flags, macros, lighting, shadows and 906 block textures, with no scattered notes.

Community reference researched by GlitchHunterCoder. The official Bloxd files are kept separate in the appendix.

LanguageWGSL
CurrentapiVersion 5
Versions1 to 5
Hooks9 callbacks
Manifestpack.json

Pack structure

A Bloxd pack is a folder with a pack.json manifest and one or more WGSL files. Bloxd prepends the API definitions at compile time, so a pack only writes the hooks it wants to change.

Folder
MyShader/
├── pack.json
├── terrain.wgsl
├── liquid.wgsl
└── model.wgsl
pack.json
{
  "apiVersion": 5,
  "name": "[Prism Shaders] Prism XT [v1.0.1]",
  "author": "BloxdSeno"
}

The manifest has three fields. apiVersion must be 5, name is free text, and author is optional. This site reads that manifest on upload, so author and version fill themselves in.

Engine inputs

Frame data lives in BloxdPackInputs. Read it through the helper functions, not the uniform directly.

FieldTypeNotes
secondsf32Seconds since page load. Use modulo for a repeating timer.
litu32Non zero when block and sky lighting are on.
renderOffsetvec3iRender position plus this offset is world position.
sunDirectionvec3fUnit vector towards the sun, zero when there is no sun.
eyePositionvec3fCamera render position.

BloxdOpaqueBehind comes from scene depth reads: hit is false where the sky is behind the fragment, position is the render position and distance is from the camera.

Hooks

Bloxd calls these functions. Return the struct, do not mutate the input in place. Every hook has a default in the API, so a pack can override one and leave the rest alone.

HookSignatureWhat it does
bloxdTerrainVertex(v: BloxdVertexIn) -> BloxdVertexMove terrain vertices. Wrap in #ifndef BLOXD_STRICT so strict games keep the pack.
bloxdTerrainSurface(s: BloxdSurfaceIn) -> BloxdSurfaceRecolour terrain, add emission, edit enchant and overlay.
bloxdTerrainLight(s: BloxdSurface, l: BloxdLightIn) -> BloxdLightFinal terrain light. Fog is applied after the surface hook.
bloxdLiquidVertex(v: BloxdVertexIn) -> BloxdVertexWave geometry for water and other liquids.
bloxdLiquidSurface(s: BloxdSurfaceIn) -> BloxdSurfaceWater colour, depth tint, foam and caustics.
bloxdLiquidLight(s: BloxdSurface, l: BloxdLightIn) -> BloxdLightFinal liquid light, including any emission you added.
bloxdModelVertex(v: BloxdVertexIn) -> BloxdVertexSlabs, stairs, plants, items, players and mobs.
bloxdModelSurface(s: BloxdSurfaceIn) -> BloxdSurfaceModel colour, texture reads and emission.
bloxdModelLight(s: BloxdSurface, l: BloxdLightIn) -> BloxdLightFinal model light. Keep it cheap, players are on screen often.

Terrain covers every block except water and block models. Models cover slabs, stairs, plants, items, players and mobs.

Surface data

The surface hook receives BloxdSurfaceIn: the face colour, position, flags and texture coordinates after the vertex hook. Write colour to BloxdSurface.colour and glow to BloxdSurface.emission, which lands after lighting and before fog.

FieldTypeNotes
colourvec3fTexture, tint and ambient occlusion already multiplied together.
alphaf32Opacity. Only writable in the output when BLOXD_ALPHA is defined.
enchantTieru32Enchanted items and armour only. 1 to 5, zero otherwise.
enchantColourvec4fEnchant RGB plus animated alpha. Zero for normal blocks.
enchantSpeedf32How fast the enchant pattern moves. Higher tiers move faster.
overlayColourvec4fPlayers and mobs only, such as the red hurt flash.
positionvec3fRender position. Pair with bloxdWorldPosition for stable world space.
normalvec3fUnit vector pointing away from the face.
localPositionvec3fModel local coordinates. Zero for terrain and liquids.
flagsBloxdFlagsBooleans describing the block, item or lifeform.
textureIdu32Which texture this face uses. Zero when the face has none.
textureRotationu32Quarter turns clockwise, applied by bloxdTexel.
uvvec2fTexture coordinates, 0 to 1. fract(uv) is the drawn span.
mipLevelf32Mipmap level. 0 is full size, 1 is half, and so on.

Light data

BloxdLightIn is what the light hooks receive. bloxdLitColour applies overlay, shading, enchant and world light in the same order as the engine.

FieldTypeNotes
litColourvec3fLit and enchanted colour before emission and fog.
directionalf32Summed Lambert from directional lights. Zero when off.
diffusevec3fMaterial response to directional light.
emissivevec3fMaterial glow, added to directional light.
ambientvec3fAmbient colour, added to directional light.
blockLightvec3fRGB block light from 0 to 1. Zero when lighting is off.
skyLightf32Sky light from 0 to 1. One when lighting is off.
ambientLightColourvec3fMinimum RGB light. One when lighting is off.
skyLightColourvec3fRGB colour of sky light.
heldLightvec3fHeld light contribution. Zero without a light source.
fogColourvec3fThe game fog colour. Zero when the game has no fog.
fogAlphaf32Zero means no fog, one means only fog colour.
positionvec3fRender position, same as the surface input.
normalvec3fFace normal, same as the surface input.
localPositionvec3fModel local position. Zero for terrain and liquids.
flagsBloxdFlagsBlock, item or lifeform flags.
textureIdu32Texture used by this face.
textureRotationu32Quarter turns clockwise.
uvvec2fTexture coordinates.
mipLevelf32Mipmap level.

Shadows and light shafts

The engine tells you how much sun or moonlight reaches a fragment, and how much reaches the air between the camera and that fragment. Both read cleanly in surface and light hooks, and they work with the sun, the moon, or the default sky when a game has none.

FunctionReturnsNotes
bloxdShadow()f32Sun or moonlight reaching this fragment. 0 in shadow, 1 lit. Fades as the sun or moon sets and as the face turns away, and stays 1 on emissive faces.
bloxdAirShadow(t)f32Shadow at a point between the camera (t = 0) and this fragment (t = 1). Blocks only, blurred to whole blocks, which is what makes it smooth enough for shafts.
bloxdShadowDirection()vec3fThe direction the shadow-casting light travels. Sun by day, moon by night, the default sky sun when a game has none.

Multiply bloxdShadow() into light.skyLight rather than into the finished colour, so torches keep lighting a shadowed cave. With lighting off everything counts as sunlight and skyLight is 1, so scale the whole lit colour instead.

terrain.wgsl
const SHADOW = 0.45;                    // Shadow strength. 0 = none, 1 = full.
const SHAFTS = 0.35;                    // Light shaft brightness. 0 = none.
const SHAFT_RANGE = 64.0;               // Blocks of sunlit air to glow fully.
const SUN_AIR = vec3f(1.0, 0.9, 0.7);   // Sunlit air by day.
const MOON_AIR = vec3f(0.2, 0.25, 0.4); // Moonlit air by night.

fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
  // Shadows only dim sky light, so torches still light a shadowed cave.
  var shaded = light;
  shaded.skyLight *= 1.0 - SHADOW * (1.0 - bloxdShadow());

  let lit = bloxdLitColour(surface, shaded);

  // Sunlit air glows by day and moonlit air by night, unless there is no sun.
  let sun = bloxdSunDirection();
  let day = smoothstep(-0.1, 0.1, sun.y);
  let reach = min(distance(light.position, bloxdEyePosition()) / SHAFT_RANGE, 1.0);
  let shaft = bloxdAirShadow(0.5) * reach * length(sun);
  let glow = mix(MOON_AIR, SUN_AIR, day) * SHAFTS * shaft;

  // Fog last, so distant terrain always becomes light.fogColour.
  return BloxdLight(bloxdApplyFog(lit + surface.emission + glow, light));
}

Shadows need geometry to cast them, and bloxdAirShadow only accounts for blocks, not models or players. It is built for shafts through open air, not for shadow maps.

Helpers

The engine exposes read only helpers for time, camera, sun, world position and lighting. Calling bloxdLitColour gets you the engine result before emission and fog, which is the usual starting point for a grade.

FunctionReturnsNotes
bloxdSeconds() -> f32Seconds since page load. Use modulo for a repeating timer.
bloxdEyePosition() -> vec3fCamera render position.
bloxdRenderOffset() -> vec3iRender position plus this offset is world position.
bloxdSunDirection() -> vec3fUnit vector towards the sun. Zero when there is none.
bloxdShadowDirection() -> vec3fDirection the shadow light travels: the sun by day, the moon by night. Its y never goes above 0.
bloxdLit() -> boolWhether block and sky lighting is on for this frame.
bloxdShadow() -> f32Sun or moonlight reaching this fragment: 0 in shadow, 1 lit. Surface and light hooks only.
bloxdAirShadow(t: f32) -> f32Shadow in the air between the camera (t = 0) and the fragment (t = 1), for light shafts. Blocks only.
bloxdWorldPosition(p: vec3f) -> vec3fConverts a render position to world space. May lose precision far out.
bloxdFragmentBlockPosition(position: vec3f, normal: vec3f) -> vec3iThe block a fragment belongs to, worked out from its position and normal.
bloxdTexel(textureId: u32, uv: vec2f, mipLevel: f32) -> vec4fRaw RGBA of a texture before tint and ambient occlusion. Surface and light hooks only.
bloxdTextureSize(mipLevel: f32) -> vec2uTexel width and height at a mip level. 1 by 1 for faces with no texture.
bloxdOpaqueBehind() -> BloxdOpaqueBehindNearest opaque surface behind this fragment. Liquids only, behind BLOXD_SCENE_DEPTH.
bloxdShading(l: BloxdLightIn) -> vec3fMaterial and angle response: diffuse light plus emissive and ambient.
bloxdWorldLight(l: BloxdLightIn) -> vec3fBrightest of block, sky and held light, never under ambient.
bloxdLitColour(s: BloxdSurface, l: BloxdLightIn) -> vec3fColour lit the way the engine lights it, before emission and fog.
bloxdApplyFog(c: vec3f, l: BloxdLightIn) -> vec3fApplies this fragment fog the way the engine does.
bloxdDefaultVertex(v: BloxdVertexIn) -> BloxdVertexThe engine pass through. Always start here.
bloxdDefaultSurface(s: BloxdSurfaceIn) -> BloxdSurfaceThe default surface output, ready to edit.
bloxdDefaultLight(s: BloxdSurface, l: BloxdLightIn) -> BloxdLightLit colour plus emission, then fog.
bloxdPi 3.1415926535898bloxdTau 6.2831853071796bloxdChunkSize 32

Block flags

Branch on flags, not block names. A block can carry several, so sandstone is both sand and rock, and a grass block is dirt and vegetation.

opaqueFull cubes with no gaps. Leaves and ice count too.
emissiveBlocks that emit light, such as lava, lamps and glowing ore.
vegetationLeaves, grass blocks and leafy plants.
dirtSoil and grass blocks. Rocky Dirt is rock as well.
sandSand, Red Sand and every sandstone.
rockStone variants, gravel, ores, magma and obsidian.
slabHalf blocks. Never part of terrain.
stairsStairs and corner stairs.
flatPlanes such as tall grass, flowers, crops and cobwebs.
placedBlocks placed as part of the world.
heldItems in a hand, first or third person.
droppedDropped items on the ground, a belt or in a pipe.
thrownItems in flight, such as arrows and snowballs.
lifeformPlayers, mobs and NPCs, including armour and cosmetics.

Macros

These are defined by the game when it compiles your pack. Use #ifdef and #ifndef the same way as in C.

BLOXD_STRICT

Strict games keep terrain where it is. Hooks wrapped in #ifndef BLOXD_STRICT switch off there instead of failing.

BLOXD_ALPHA

Defined when the shader accepts alpha. The surface output gains an alpha field.

BLOXD_SCENE_DEPTH

Gates bloxdOpaqueBehind and scene depth reads in surface and light hooks.

A working example

This terrain hook keeps the engine surface, tints vegetation and makes emissive blocks pulse. It is valid apiVersion 5 and safe inside strict games because it only touches surface output.

terrain.wgsl
fn bloxdTerrainSurface(s: BloxdSurfaceIn) -> BloxdSurface {
  var out = bloxdDefaultSurface(s);

  let world = bloxdWorldPosition(s.position);
  let pulse = 0.5 + 0.5 * sin(world.x * 0.6 + bloxdSeconds() * 1.4);

  if (s.flags.vegetation) {
    out.colour = mix(out.colour, out.colour * vec3f(0.86, 1.12, 0.9), 0.7);
  }

  if (s.flags.emissive) {
    out.emission = s.colour * pulse;
  }

  return out;
}

Lighting gets its own hook. This one warms the lit colour slightly, keeps the emission the surface hook wrote, and fogs it the way the engine would.

terrain.wgsl
fn bloxdTerrainLight(s: BloxdSurface, l: BloxdLightIn) -> BloxdLight {
  let lit = bloxdLitColour(s, l);
  let warm = lit * vec3f(1.06, 1.0, 0.94);
  return BloxdLight(bloxdApplyFog(warm + s.emission, l));
}

Start from the default

Call bloxdDefaultSurface and edit the result. Rebuilding the struct by hand loses the enchant and overlay values the engine passed in.

Keep hooks cheap

Surface runs on every visible fragment. Trigonometry and noise are fine, texture reads and loops need care.

Use flags, not block ids

Flags survive block additions. Branch on flags.vegetation or flags.emissive instead of hard coding block names.

Respect strict games

Vertex hooks can move geometry. Wrapping them in #ifndef BLOXD_STRICT keeps your pack working in games that lock terrain.

Dim sky light, not colour

Multiply bloxdShadow into light.skyLight so torches still light a shadowed cave. With lighting off, skyLight is 1, so scale the whole lit colour instead.

Full source

The complete prepended definitions for v5 and v1. Use these when you need the exact declaration instead of a summary.

apiVersion 5 source
v5
// The Bloxd shader pack API, apiVersion 5. Read-only, prepended to all packs.

// Engine-defined only. Can be checked with #ifdef/#ifndef BLOXD_* ... #endif.
#define BLOXD_STRICT      // Defined in strict games, which enforce visibility.
#define BLOXD_ALPHA       // Defined for liquids and non-strict games.
#define BLOXD_SCENE_DEPTH // Defined for liquids, enabling bloxdOpaqueBehind().

const bloxdPi: f32 = 3.1415926535898;
const bloxdTau: f32 = 6.2831853071796;

// Blocks along each side of a chunk.
const bloxdChunkSize: i32 = 32;

// These functions return the same value for the entire frame.

// The camera's render position.
fn bloxdEyePosition() -> vec3f { ... }

// Integer distance, in blocks: render position + this offset = world position.
// Changes as the player travels, so render positions stay close to 0,0,0.
// See bloxdWorldPosition for one way to use it.
fn bloxdRenderOffset() -> vec3i { ... }

// The unit vector towards the sun, in world orientation; 0 when there's no sun.
// It's below the horizon (y < 0) at night. The moon is always opposite it.
fn bloxdSunDirection() -> vec3f { ... }

// The unit vector the light that casts bloxdShadow's shadows travels along,
// in world orientation: from the sun by day, the moon by night, and the
// default sky's sun when there's no sun. Its y is never above 0 (0 when the
// sun is on the horizon).
fn bloxdShadowDirection() -> vec3f { ... }

// Seconds since the page loaded. As an f32, it has sub-millisecond precision
// for the first 4.5 hours. Get a recurring timer using bloxdSeconds() % period.
fn bloxdSeconds() -> f32 { ... }

// Whether block and sky lighting is on. When it's off, BloxdLightIn's
// blockLight and heldLight are 0, and its skyLight and light colours are 1.
fn bloxdLit() -> bool { ... }

// What kind of block, item or lifeform a face is. Any number of flags may be
// set, possibly even none. For example, sandstone is sand and rock.
struct BloxdFlags {
    opaque: bool,     // Opaque blocks, i.e. full cubes with no gaps or holes.
    emissive: bool,   // Blocks that emit light, e.g. lava and glowing ores.
    vegetation: bool, // Leaves, grass blocks and leafy plants, e.g. tall grass.
    dirt: bool,       // Soil, grass blocks included. Rocky Dirt is rock too.
    sand: bool,       // Sand, Red Sand and every sandstone, which is rock too.
    rock: bool,       // Stone variants, and more, e.g. gravel, ores and magma.

    // Drawn as block models, so never part of terrain or flagged as opaque.
    slab: bool,       // Half blocks.
    stairs: bool,     // Stairs and corner stairs.
    flat: bool,       // Planes, e.g. tall grass, flowers, crops and cobwebs.

    placed: bool,     // Blocks placed as part of chunks. Not items or vehicles.
    held: bool,       // Items in a hand, in first or third person.
    dropped: bool,    // Dropped items, on the ground, on a belt or in a pipe.
    thrown: bool,     // Items in flight, e.g. snowballs, arrows and rockets.

    lifeform: bool,   // Players, mobs and NPCs. Includes armour and cosmetics.
}

// Convert a render position to a world position, with possible f32 inaccuracy.
fn bloxdWorldPosition(position: vec3f) -> vec3f {
    return position + vec3f(bloxdRenderOffset());
}

// Using a fragment's position and normal, identify the block's world position.
// Terrain looks half a block behind the face, and models 1/64 behind. Where
// that point is inside a placed block model's own block, it gives that block.
fn bloxdFragmentBlockPosition(position: vec3f, normal: vec3f) -> vec3i { ... }

struct BloxdVertexIn {
    position: vec3f,      // Render position.
    normal: vec3f,        // Unit vector pointing away from the face.
    localPosition: vec3f, // A model's local coordinates. 0 for terrain/liquid.
    flags: BloxdFlags,    // What kind of block, item or lifeform.
}

struct BloxdVertex {
    position: vec3f,      // The render position output. Normals don't change.
}

struct BloxdSurfaceIn {
    colour: vec3f,        // RGB colour = texture * tint * ambient occlusion.
    alpha: f32,           // Opacity.

    // Enchanted items and armour only, all 0 for anything else.
    enchantTier: u32,     // 1-5 for Tier 1-5.
    enchantColour: vec4f, // RGB enchant colour, and its animated alpha.
    enchantSpeed: f32,    // How fast the pattern moves, faster at higher tiers.

    // Players and mobs only, 0 for anything else: RGB overlay colour, e.g. the
    // red flash when hurt, and its alpha. bloxdLitColour mixes it into colour.
    overlayColour: vec4f,

    // These mean the same as in BloxdVertexIn, after the vertex hook.
    position: vec3f,      // Render position.
    normal: vec3f,        // Unit vector pointing away from the face.
    localPosition: vec3f, // A model's local coordinates. 0 for terrain/liquid.
    flags: BloxdFlags,    // What kind of block, item or lifeform.

    // These are all 0 if the face has no texture. Most models use textureId 0.
    textureId: u32,       // This face's texture. Compare with bloxdTextureId*.
    textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
    uv: vec2f,            // The texture spans 0-1. fract(uv) is drawn.
    mipLevel: f32,        // Texture mipmap level. 0 = full size, 1 = half, etc.
}

// Each textureId has a name: bloxdTextureId followed by its texture pack file
// name, e.g. bloxdTextureIdGrassTop for grass_top.png. For animated textures,
// skip the frame number, e.g. bloxdTextureIdLava for lava0.png to lava7.png.
// After bloxdTextureId, case and underscores don't matter.
// See BLOCK_TEXTURES.md for a list of textureId names.

// Raw RGBA colour of textureId at the given uv coordinates and round(mipLevel).
// For animated textures, it takes the current animation frame into account.
// Before tint and ambient occlusion. White if the face has no texture (water).
// Faces with a texture of their own rather than an atlas one (players, mobs,
// plants and other models) read it with textureId 0; other IDs read white.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdTexel(textureId: u32, uv: vec2f, mipLevel: f32) -> vec4f { ... }

// Texel width and height of the textures bloxdTexel reads for round(mipLevel):
// atlas textures, which all share the same size, or a face's own texture, e.g.
// one player's skin. 1 by 1 for faces without any texture (water).
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdTextureSize(mipLevel: f32) -> vec2u { ... }

struct BloxdSurface {
    colour: vec3f,        // RGB colour output.
#ifdef BLOXD_ALPHA
    alpha: f32,           // Opacity output.
#endif
    emission: vec3f,      // Emissive RGB, added after lighting, before fog.
    enchantColour: vec4f, // Enchant output, mixed in by bloxdLitColour.
    overlayColour: vec4f, // Overlay output, mixed in by bloxdLitColour.
}

// blockLight, skyLight and heldLight are 0-1, from the 0-15 light levels on an
// ease-out curve, e.g. 6->0.45, 12->0.92. They all exclude ambientLightColour.
// bloxdLitColour lights a surface from these as the engine does.
struct BloxdLightIn {
    litColour: vec3f,  // Lit and enchanted RGB colour, before emission and fog.
    directional: f32,  // Summed Lambert from directional lights; 0 if none.
    diffuse: vec3f,    // The material's RGB response to directional light.
    emissive: vec3f,   // The material's RGB glow, added to directional light.
    ambient: vec3f,    // RGB ambient colour, added to directional light.
    blockLight: vec3f, // RGB block light; 0 when !bloxdLit().
    skyLight: f32,     // Sky light; 1 when !bloxdLit().
    ambientLightColour: vec3f, // Minimum RGB light; 1 when !bloxdLit().
    skyLightColour: vec3f, // RGB colour of skyLight; 1 when !bloxdLit().
    heldLight: vec3f,  // RGB held light; 0 when !bloxdLit() or no light held.
    fogColour: vec3f,  // The game's RGB fog colour; 0 when the game has no fog.
    fogAlpha: f32,     // 0 = no fog, 1 = only fogColour.

    // These are the same as in BloxdSurfaceIn.
    position: vec3f,      // Render position.
    normal: vec3f,        // Unit vector pointing away from the face.
    localPosition: vec3f, // A model's local coordinates. 0 for terrain/liquid.
    flags: BloxdFlags,    // What kind of block, item or lifeform.
    textureId: u32,       // This face's texture. Compare with bloxdTextureId*.
    textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
    uv: vec2f,            // The texture spans 0-1. fract(uv) is drawn.
    mipLevel: f32,        // Texture mipmap level. 0 = full size, 1 = half, etc.
}

struct BloxdLight {
    colour: vec3f, // Final RGB colour, emission and fog included.
}

// Sunlight or moonlight reaching this fragment: 0 in shadow, 1 lit. Blocks,
// players, mobs and items cast shadows. Fades to 0 as the sun or moon sets, or
// as the face turns away from it. 1 on flags.emissive faces. The light travels
// along bloxdShadowDirection(), so shadows show under a sky with no sun too.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdShadow() -> f32 { ... }

// Like bloxdShadow, but at a point between the camera (t = 0) and this
// fragment (t = 1), e.g. for light shafts. Only blocks cast these shadows,
// blurred to whole blocks. t is clamped to 0-1.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdAirShadow(t: f32) -> f32 { ... }

#ifdef BLOXD_SCENE_DEPTH
// The nearest opaque surface behind this fragment.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdOpaqueBehind() -> BloxdOpaqueBehind { ... }
#endif

struct BloxdOpaqueBehind {
    hit: bool,       // False where nothing opaque is behind (sky).
    position: vec3f, // The render position; 0 when !hit.
    distance: f32,   // From the camera; 0 when !hit.
}

fn bloxdDefaultVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    return BloxdVertex(vertex.position);
}

fn bloxdDefaultSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return BloxdSurface(
        surface.colour,
#ifdef BLOXD_ALPHA
        surface.alpha,
#endif
        vec3f(0.0),
        surface.enchantColour,
        surface.overlayColour,
    );
}

// Apply this fragment's fog to colour, as the engine does.
fn bloxdApplyFog(colour: vec3f, light: BloxdLightIn) -> vec3f {
    return mix(colour, light.fogColour, light.fogAlpha);
}

// How the face's material and angle light it: directional light on its
// diffuse colour, plus its emissive and ambient terms, clamped to 0-1.
fn bloxdShading(light: BloxdLightIn) -> vec3f {
    let diffuse = light.directional * light.diffuse;
    return saturate(diffuse + light.emissive + light.ambient);
}

// The world's light at this fragment: the brightest of block, sky and held
// light, none below ambientLightColour.
fn bloxdWorldLight(light: BloxdLightIn) -> vec3f {
    let ambientLight = light.ambientLightColour;
    let blockLight = ambientLight + light.blockLight * (1.0 - ambientLight);
    let skyLight = mix(ambientLight, light.skyLightColour, light.skyLight);
    let heldLight = ambientLight + light.heldLight * (1.0 - ambientLight);
    return max(max(blockLight, skyLight), heldLight);
}

// The surface's colour lit as the engine does, before emission and fog:
// mixed with overlayColour, then bloxdShading, then mixed with
// enchantColour, then bloxdWorldLight.
fn bloxdLitColour(surface: BloxdSurface, light: BloxdLightIn) -> vec3f {
    let overlay = surface.overlayColour;
    let overlaid = mix(surface.colour, overlay.rgb, overlay.a);
    let shaded = bloxdShading(light) * overlaid;
    let enchant = surface.enchantColour;
    let enchanted = mix(shaded, enchant.rgb, enchant.a);
    return max(enchanted * bloxdWorldLight(light), vec3f(0.0));
}

fn bloxdDefaultLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    let lit = bloxdLitColour(surface, light);
    return BloxdLight(bloxdApplyFog(lit + surface.emission, light));
}

// If you want to override the default hooks, define some in your pack.
// Each program only runs its own hooks: liquids use bloxdLiquid*; models,
// such as block models, items, players and mobs, use bloxdModel*; terrain
// uses bloxdTerrain*.
// To run the same code in more than one, call one function from each.

// fn bloxdTerrainVertex(vertex: BloxdVertexIn) -> BloxdVertex
// fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface
// fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight
// fn bloxdLiquidVertex(vertex: BloxdVertexIn) -> BloxdVertex
// fn bloxdLiquidSurface(surface: BloxdSurfaceIn) -> BloxdSurface
// fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight
// fn bloxdModelVertex(vertex: BloxdVertexIn) -> BloxdVertex
// fn bloxdModelSurface(surface: BloxdSurfaceIn) -> BloxdSurface
// fn bloxdModelLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight
apiVersion 1 source
v1
struct bloxd_VertexIn {
  position: vec3f,
  normal: vec3f,
  originOffset: vec3i,
  time: f32,
}

#ifndef BLOXD_STRICT
struct bloxd_Vertex {
  position: vec3f,
}
#endif

struct bloxd_SurfaceIn {
  colour: vec3f,
  alpha: f32,
  normal: vec3f,
  position: vec3f,
  originOffset: vec3i,
  eyePosition: vec3f,
  time: f32,
  sunDirection: vec3f,
}

struct bloxd_Surface {
  colour: vec3f,
#ifdef BLOXD_ALPHA
  alpha: f32,
#endif
  emission: vec3f,
}

struct bloxd_LightIn {
  engineColour: vec3f,
  directional: f32,
  ambient: vec3f,
#ifdef BLOXD_LIGHTING
  blockLight: vec3f,
  skyLight: f32,
  ambientLightColour: vec3f,
  skyLightColour: vec3f,
  heldLight: vec3f,
#endif
  fogColour: vec3f,
  fogFactor: f32,
  position: vec3f,
  normal: vec3f,
  originOffset: vec3i,
  eyePosition: vec3f,
  time: f32,
  sunDirection: vec3f,
}

struct bloxd_Light {
  colour: vec3f,
}

#ifndef BLOXD_STRICT
fn bloxd_defaultVertex(v: bloxd_VertexIn) -> bloxd_Vertex {
  return bloxd_Vertex(v.position);
}
#endif

fn bloxd_defaultSurface(s: bloxd_SurfaceIn) -> bloxd_Surface {
#ifdef BLOXD_ALPHA
  return bloxd_Surface(s.colour, s.alpha, vec3f(0.0));
#else
  return bloxd_Surface(s.colour, vec3f(0.0));
#endif
}

fn bloxd_defaultLight(s: bloxd_Surface, l: bloxd_LightIn) -> bloxd_Light {
  return bloxd_Light(l.engineColour + s.emission * l.fogFactor);
}

fn bloxd_terrain_vertex(v: bloxd_VertexIn) -> bloxd_Vertex {}
fn bloxd_terrain_surface(v: bloxd_SurfaceIn) -> bloxd_Surface {}
fn bloxd_terrain_light(s: bloxd_Surface, l: bloxd_LightIn) -> bloxd_Light {}

fn bloxd_liquid_vertex(v: bloxd_VertexIn) -> bloxd_Vertex {}
fn bloxd_liquid_surface(v: bloxd_SurfaceIn) -> bloxd_Surface {}
fn bloxd_liquid_light(s: bloxd_Surface, l: bloxd_LightIn) -> bloxd_Light {}

Version history

Bloxd has shipped five shader API versions. A pack declares one in pack.json and the engine prepends that version's definitions. The current target is v5.

v1

The first API

Four structs, two hook groups and no model pass. Surface input carried time, origin offset, eye position and sun direction directly.

v2

Pack inputs

Moved frame data into BloxdPackInputs, added block ids, bloxdTime, bloxdOriginOffset, bloxdFaceBlock and scene depth.

v3

Block flags

Replaced block ids with bit flags, added bloxdBlockFlag constants, bloxdPi and bloxdTau.

v4

Texture reads

Added textureId, textureRotation, uv and mipLevel to surface and light input. Added bloxdFragmentBlockPosition.

v5

Materials and models

Current API. BloxdFlags struct, local positions, model hooks, enchant and overlay channels, lit state, the full lighting helpers and sun or moon shadows with light shafts.

Current
VersionSurface inputFieldsHooksWhat changed
v1bloxd_SurfaceIncolour, alpha, normal, position, originOffset, eyePosition, time, sunDirectionterrain and liquid, vertex, surface, lightNo model hooks. Light input exposed engineColour, directional, ambient, fogColour and fogFactor.
v2BloxdSurfaceIncolour, alpha, normal, position, blockIdterrain and liquidPack inputs and helper functions arrive. fogVisibility replaces fogFactor. Scene depth helper is added.
v3BloxdSurfaceIncolour, alpha, normal, position, blockFlagsterrain and liquidBlock flags become a u32 bit mask. bloxdFaceBlock is available. Constants bloxdPi and bloxdTau are added.
v4BloxdSurfaceIncolour, alpha, normal, position, blockFlags, textureId, textureRotation, uv, mipLevelterrain and liquidTexture coordinates and mip level added. bloxdFragmentBlockPosition replaces bloxdFaceBlock.
v5BloxdSurfaceIncolour, alpha, enchantTier, enchantColour, enchantSpeed, overlayColour, position, normal, localPosition, flags, textureId, textureRotation, uv, mipLevelterrain, liquid and modelMaterial flags become a struct, models get their own hooks, lighting gets bloxdShading, bloxdWorldLight and bloxdLitColour, and shadows arrive with bloxdShadow, bloxdAirShadow and bloxdShadowDirection.

Older packs still load when their manifest version matches. New packs should target apiVersion 5.

Official Bloxd API files

apiVersion 5

Everything in this section comes from the API folder: the complete bloxd-api.wgsl, the WGSL built-in reference, all 8 official example packs and the full block texture table. Nothing is summarised or cut down.

5apiVersion
8official packs
9WGSL files
906block textures
Straight from the source.

These are the official Bloxd apiVersion 5 declarations and sample packs. The community notes above explain the same API; this section keeps the original comments, macros, declarations and examples intact.

Official API source

bloxd-api.wgsl is the read-only apiVersion 5 source that Bloxd prepends to every pack. It contains the strict, alpha and scene-depth macros, every struct, the helpers and the default hook implementations.

bloxd-api.wgsl268 lines, the full apiVersion 5 source
// The Bloxd shader pack API, apiVersion 5. Read-only, prepended to all packs.

// Engine-defined only. Can be checked with #ifdef/#ifndef BLOXD_* ... #endif.
#define BLOXD_STRICT      // Defined in strict games, which enforce visibility.
#define BLOXD_ALPHA       // Defined for liquids and non-strict games.
#define BLOXD_SCENE_DEPTH // Defined for liquids, enabling bloxdOpaqueBehind().

const bloxdPi: f32 = 3.1415926535898;
const bloxdTau: f32 = 6.2831853071796;

// Blocks along each side of a chunk.
const bloxdChunkSize: i32 = 32;

// These functions return the same value for the entire frame.

// The camera's render position.
fn bloxdEyePosition() -> vec3f { ... }

// Integer distance, in blocks: render position + this offset = world position.
// Changes as the player travels, so render positions stay close to 0,0,0.
// See bloxdWorldPosition for one way to use it.
fn bloxdRenderOffset() -> vec3i { ... }

// The unit vector towards the sun, in world orientation; 0 when there's no sun.
// It's below the horizon (y < 0) at night. The moon is always opposite it.
fn bloxdSunDirection() -> vec3f { ... }

// The unit vector the light that casts bloxdShadow's shadows travels along,
// in world orientation: from the sun by day, the moon by night, and the
// default sky's sun when there's no sun. Its y is never above 0 (0 when the
// sun is on the horizon).
fn bloxdShadowDirection() -> vec3f { ... }

// Seconds since the page loaded. As an f32, it has sub-millisecond precision
// for the first 4.5 hours. Get a recurring timer using bloxdSeconds() % period.
fn bloxdSeconds() -> f32 { ... }

// Whether block and sky lighting is on. When it's off, BloxdLightIn's
// blockLight and heldLight are 0, and its skyLight and light colours are 1.
fn bloxdLit() -> bool { ... }

// What kind of block, item or lifeform a face is. Any number of flags may be
// set, possibly even none. For example, sandstone is sand and rock.
struct BloxdFlags {
    opaque: bool,     // Opaque blocks, i.e. full cubes with no gaps or holes.
    emissive: bool,   // Blocks that emit light, e.g. lava and glowing ores.
    vegetation: bool, // Leaves, grass blocks and leafy plants, e.g. tall grass.
    dirt: bool,       // Soil, grass blocks included. Rocky Dirt is rock too.
    sand: bool,       // Sand, Red Sand and every sandstone, which is rock too.
    rock: bool,       // Stone variants, and more, e.g. gravel, ores and magma.

    // Drawn as block models, so never part of terrain or flagged as opaque.
    slab: bool,       // Half blocks.
    stairs: bool,     // Stairs and corner stairs.
    flat: bool,       // Planes, e.g. tall grass, flowers, crops and cobwebs.

    placed: bool,     // Blocks placed as part of chunks. Not items or vehicles.
    held: bool,       // Items in a hand, in first or third person.
    dropped: bool,    // Dropped items, on the ground, on a belt or in a pipe.
    thrown: bool,     // Items in flight, e.g. snowballs, arrows and rockets.

    lifeform: bool,   // Players, mobs and NPCs. Includes armour and cosmetics.
}

// Convert a render position to a world position, with possible f32 inaccuracy.
fn bloxdWorldPosition(position: vec3f) -> vec3f {
    return position + vec3f(bloxdRenderOffset());
}

// Using a fragment's position and normal, identify the block's world position.
// Terrain looks half a block behind the face, and models 1/64 behind. Where
// that point is inside a placed block model's own block, it gives that block.
fn bloxdFragmentBlockPosition(position: vec3f, normal: vec3f) -> vec3i { ... }

struct BloxdVertexIn {
    position: vec3f,      // Render position.
    normal: vec3f,        // Unit vector pointing away from the face.
    localPosition: vec3f, // A model's local coordinates. 0 for terrain/liquid.
    flags: BloxdFlags,    // What kind of block, item or lifeform.
}

struct BloxdVertex {
    position: vec3f,      // The render position output. Normals don't change.
}

struct BloxdSurfaceIn {
    colour: vec3f,        // RGB colour = texture * tint * ambient occlusion.
    alpha: f32,           // Opacity.

    // Enchanted items and armour only, all 0 for anything else.
    enchantTier: u32,     // 1-5 for Tier 1-5.
    enchantColour: vec4f, // RGB enchant colour, and its animated alpha.
    enchantSpeed: f32,    // How fast the pattern moves, faster at higher tiers.

    // Players and mobs only, 0 for anything else: RGB overlay colour, e.g. the
    // red flash when hurt, and its alpha. bloxdLitColour mixes it into colour.
    overlayColour: vec4f,

    // These mean the same as in BloxdVertexIn, after the vertex hook.
    position: vec3f,      // Render position.
    normal: vec3f,        // Unit vector pointing away from the face.
    localPosition: vec3f, // A model's local coordinates. 0 for terrain/liquid.
    flags: BloxdFlags,    // What kind of block, item or lifeform.

    // These are all 0 if the face has no texture. Most models use textureId 0.
    textureId: u32,       // This face's texture. Compare with bloxdTextureId*.
    textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
    uv: vec2f,            // The texture spans 0-1. fract(uv) is drawn.
    mipLevel: f32,        // Texture mipmap level. 0 = full size, 1 = half, etc.
}

// Each textureId has a name: bloxdTextureId followed by its texture pack file
// name, e.g. bloxdTextureIdGrassTop for grass_top.png. For animated textures,
// skip the frame number, e.g. bloxdTextureIdLava for lava0.png to lava7.png.
// After bloxdTextureId, case and underscores don't matter.
// See BLOCK_TEXTURES.md for a list of textureId names.

// Raw RGBA colour of textureId at the given uv coordinates and round(mipLevel).
// For animated textures, it takes the current animation frame into account.
// Before tint and ambient occlusion. White if the face has no texture (water).
// Faces with a texture of their own rather than an atlas one (players, mobs,
// plants and other models) read it with textureId 0; other IDs read white.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdTexel(textureId: u32, uv: vec2f, mipLevel: f32) -> vec4f { ... }

// Texel width and height of the textures bloxdTexel reads for round(mipLevel):
// atlas textures, which all share the same size, or a face's own texture, e.g.
// one player's skin. 1 by 1 for faces without any texture (water).
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdTextureSize(mipLevel: f32) -> vec2u { ... }

struct BloxdSurface {
    colour: vec3f,        // RGB colour output.
#ifdef BLOXD_ALPHA
    alpha: f32,           // Opacity output.
#endif
    emission: vec3f,      // Emissive RGB, added after lighting, before fog.
    enchantColour: vec4f, // Enchant output, mixed in by bloxdLitColour.
    overlayColour: vec4f, // Overlay output, mixed in by bloxdLitColour.
}

// blockLight, skyLight and heldLight are 0-1, from the 0-15 light levels on an
// ease-out curve, e.g. 6->0.45, 12->0.92. They all exclude ambientLightColour.
// bloxdLitColour lights a surface from these as the engine does.
struct BloxdLightIn {
    litColour: vec3f,  // Lit and enchanted RGB colour, before emission and fog.
    directional: f32,  // Summed Lambert from directional lights; 0 if none.
    diffuse: vec3f,    // The material's RGB response to directional light.
    emissive: vec3f,   // The material's RGB glow, added to directional light.
    ambient: vec3f,    // RGB ambient colour, added to directional light.
    blockLight: vec3f, // RGB block light; 0 when !bloxdLit().
    skyLight: f32,     // Sky light; 1 when !bloxdLit().
    ambientLightColour: vec3f, // Minimum RGB light; 1 when !bloxdLit().
    skyLightColour: vec3f, // RGB colour of skyLight; 1 when !bloxdLit().
    heldLight: vec3f,  // RGB held light; 0 when !bloxdLit() or no light held.
    fogColour: vec3f,  // The game's RGB fog colour; 0 when the game has no fog.
    fogAlpha: f32,     // 0 = no fog, 1 = only fogColour.

    // These are the same as in BloxdSurfaceIn.
    position: vec3f,      // Render position.
    normal: vec3f,        // Unit vector pointing away from the face.
    localPosition: vec3f, // A model's local coordinates. 0 for terrain/liquid.
    flags: BloxdFlags,    // What kind of block, item or lifeform.
    textureId: u32,       // This face's texture. Compare with bloxdTextureId*.
    textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
    uv: vec2f,            // The texture spans 0-1. fract(uv) is drawn.
    mipLevel: f32,        // Texture mipmap level. 0 = full size, 1 = half, etc.
}

struct BloxdLight {
    colour: vec3f, // Final RGB colour, emission and fog included.
}

// Sunlight or moonlight reaching this fragment: 0 in shadow, 1 lit. Blocks,
// players, mobs and items cast shadows. Fades to 0 as the sun or moon sets, or
// as the face turns away from it. 1 on flags.emissive faces. The light travels
// along bloxdShadowDirection(), so shadows show under a sky with no sun too.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdShadow() -> f32 { ... }

// Like bloxdShadow, but at a point between the camera (t = 0) and this
// fragment (t = 1), e.g. for light shafts. Only blocks cast these shadows,
// blurred to whole blocks. t is clamped to 0-1.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdAirShadow(t: f32) -> f32 { ... }

#ifdef BLOXD_SCENE_DEPTH
// The nearest opaque surface behind this fragment.
// Only valid in surface and light hooks, and in functions those hooks call.
fn bloxdOpaqueBehind() -> BloxdOpaqueBehind { ... }
#endif

struct BloxdOpaqueBehind {
    hit: bool,       // False where nothing opaque is behind (sky).
    position: vec3f, // The render position; 0 when !hit.
    distance: f32,   // From the camera; 0 when !hit.
}

fn bloxdDefaultVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    return BloxdVertex(vertex.position);
}

fn bloxdDefaultSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return BloxdSurface(
        surface.colour,
#ifdef BLOXD_ALPHA
        surface.alpha,
#endif
        vec3f(0.0),
        surface.enchantColour,
        surface.overlayColour,
    );
}

// Apply this fragment's fog to colour, as the engine does.
fn bloxdApplyFog(colour: vec3f, light: BloxdLightIn) -> vec3f {
    return mix(colour, light.fogColour, light.fogAlpha);
}

// How the face's material and angle light it: directional light on its
// diffuse colour, plus its emissive and ambient terms, clamped to 0-1.
fn bloxdShading(light: BloxdLightIn) -> vec3f {
    let diffuse = light.directional * light.diffuse;
    return saturate(diffuse + light.emissive + light.ambient);
}

// The world's light at this fragment: the brightest of block, sky and held
// light, none below ambientLightColour.
fn bloxdWorldLight(light: BloxdLightIn) -> vec3f {
    let ambientLight = light.ambientLightColour;
    let blockLight = ambientLight + light.blockLight * (1.0 - ambientLight);
    let skyLight = mix(ambientLight, light.skyLightColour, light.skyLight);
    let heldLight = ambientLight + light.heldLight * (1.0 - ambientLight);
    return max(max(blockLight, skyLight), heldLight);
}

// The surface's colour lit as the engine does, before emission and fog:
// mixed with overlayColour, then bloxdShading, then mixed with
// enchantColour, then bloxdWorldLight.
fn bloxdLitColour(surface: BloxdSurface, light: BloxdLightIn) -> vec3f {
    let overlay = surface.overlayColour;
    let overlaid = mix(surface.colour, overlay.rgb, overlay.a);
    let shaded = bloxdShading(light) * overlaid;
    let enchant = surface.enchantColour;
    let enchanted = mix(shaded, enchant.rgb, enchant.a);
    return max(enchanted * bloxdWorldLight(light), vec3f(0.0));
}

fn bloxdDefaultLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    let lit = bloxdLitColour(surface, light);
    return BloxdLight(bloxdApplyFog(lit + surface.emission, light));
}

// If you want to override the default hooks, define some in your pack.
// Each program only runs its own hooks: liquids use bloxdLiquid*; models,
// such as block models, items, players and mobs, use bloxdModel*; terrain
// uses bloxdTerrain*.
// To run the same code in more than one, call one function from each.

// fn bloxdTerrainVertex(vertex: BloxdVertexIn) -> BloxdVertex
// fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface
// fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight
// fn bloxdLiquidVertex(vertex: BloxdVertexIn) -> BloxdVertex
// fn bloxdLiquidSurface(surface: BloxdSurfaceIn) -> BloxdSurface
// fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight
// fn bloxdModelVertex(vertex: BloxdVertexIn) -> BloxdVertex
// fn bloxdModelSurface(surface: BloxdSurfaceIn) -> BloxdSurface
// fn bloxdModelLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight

wgsl-api.wgsl is the WGSL reference packs build on: types, scalar and vector maths, matrices, bit operations, packing functions, derivatives and the parts of WGSL that packs cannot use.

wgsl-api.wgsl505 lines, the full WGSL reference
// WGSL's functions and types, as packs can use them. For reference only. Every
// detail is in the WGSL spec (https://www.w3.org/TR/WGSL/#builtin-functions).

// Not WGSL: these names say which types or sizes functions take and return.
// Each is the same throughout a call: max(v, vec3f(0.0)), not max(v, 0.0).
// ANY:     any scalar or vector, bool included.
// NUMERIC: any non-bool scalar or vector.
// FLOAT:   floating point NUMERIC types: f32, vec2f, vec3f or vec4f.
// INT:     integer NUMERIC types: i32 or u32, or a vector of these.
// N/C/R:   any vector or matrix size: 2, 3 or 4.

// Types:
// Scalars: bool, i32, u32, f32.
// Vectors: vecN<scalar>, or vecNf, vecNi and vecNu for f32, i32, u32.
// Matrices: matCxR<f32>, C columns of R rows, or matCxRf for f32.
// Arrays: array<type, length>, where length is a constant.
// Pointers: ptr<function, type> and ptr<private, type>.
// Constructors convert: f32(i), vec3f(0.5), vec4f(colour, 1.0), vec3i(normal).

// With vectors, a function returning NUMERIC, FLOAT or INT works per component.
// Outside its domain, such as sqrt(x) with x < 0, a function's result is
// indeterminate, and can differ between GPUs. If constant arguments yield an
// indeterminate result, as in sqrt(-1.0), the pack won't compile.

// Absolute value, i.e. the value with positive sign and equal magnitude.
// The most negative i32, -2147483648, is returned unchanged.
fn abs(e: NUMERIC) -> NUMERIC { ... }

// Keep e between low and high. Expects low to be no greater than high.
fn clamp(e: NUMERIC, low: NUMERIC, high: NUMERIC) -> NUMERIC {
    return min(max(e, low), high);
}

// The larger of e1 and e2.
fn max(e1: NUMERIC, e2: NUMERIC) -> NUMERIC {
    return select(e1, e2, e1 < e2);
}

// The smaller of e1 and e2.
fn min(e1: NUMERIC, e2: NUMERIC) -> NUMERIC {
    return select(e1, e2, e2 < e1);
}

// -1 for negative e. 1 for positive e. 0 otherwise. Rejects unsigned e (u32).
fn sign(e: NUMERIC) -> NUMERIC {
    return NUMERIC(e > NUMERIC(0)) - NUMERIC(e < NUMERIC(0));
}

// Inverse cosine (cos() -> e), in radians from 0 to bloxdPi.
// Expects abs(e) <= 1.
fn acos(e: FLOAT) -> FLOAT {
    return atan2(sqrt(1.0 - e * e), e);
}

// Inverse hyperbolic cosine (cosh() -> e), at least 0. Expects e >= 1.
fn acosh(e: FLOAT) -> FLOAT {
    return log(e + sqrt(e * e - 1.0));
}

// Inverse sine (sin() -> e), in radians from -bloxdPi/2 to bloxdPi/2.
// Expects abs(e) <= 1.
fn asin(e: FLOAT) -> FLOAT {
    return atan2(e, sqrt(1.0 - e * e));
}

// Inverse hyperbolic sine (sinh() -> e).
fn asinh(e: FLOAT) -> FLOAT {
    return log(e + sqrt(e * e + 1.0));
}

// Inverse tangent (tan() -> e), in radians from -bloxdPi/2 to bloxdPi/2.
fn atan(e: FLOAT) -> FLOAT { ... }

// Inverse tangent (tan() -> y/x), in radians from -bloxdPi to bloxdPi.
// The signs of y and x determine the correct quadrant.
fn atan2(y: FLOAT, x: FLOAT) -> FLOAT { ... }

// Inverse hyperbolic tangent (tanh() -> e). Expects abs(e) < 1.
fn atanh(e: FLOAT) -> FLOAT {
    return log((1.0 + e) / (1.0 - e)) * 0.5;
}

// Round e up to a whole number: ceil(-1.5) gives -1.0.
fn ceil(e: FLOAT) -> FLOAT { ... }

// Cosine of e, an angle in radians.
fn cos(e: FLOAT) -> FLOAT { ... }

// Hyperbolic cosine of e.
fn cosh(e: FLOAT) -> FLOAT {
    return (exp(e) + exp(-e)) * 0.5;
}

// Radians to degrees.
fn degrees(e: FLOAT) -> FLOAT {
    return e * 57.295779513082322865;
}

// 2.71828 to the power of e (log() -> e).
fn exp(e: FLOAT) -> FLOAT { ... }

// 2 to the power of e (log2() -> e).
fn exp2(e: FLOAT) -> FLOAT { ... }

// Round e down to a whole number: floor(-1.5) gives -2.0.
fn floor(e: FLOAT) -> FLOAT { ... }

// Multiply e1 by e2, then add e3. Offers better numeric precision on some GPUs.
fn fma(e1: FLOAT, e2: FLOAT, e3: FLOAT) -> FLOAT {
    return e1 * e2 + e3;
}

// How far e is above floor(e), from 0 to 1: fract(-1.25) gives 0.75.
fn fract(e: FLOAT) -> FLOAT {
    return e - floor(e);
}

// 1 divided by sqrt(e). Expects e > 0.
fn inverseSqrt(e: FLOAT) -> FLOAT {
    return 1.0 / sqrt(e);
}

// Reverse frexp: e1 times the e2-th power of 2, e.g. ldexp(0.75, 1) gives 1.5.
fn ldexp(e1: f32, e2: i32) -> f32 {
    return e1 * exp2(f32(e2));
}

fn ldexp(e1: vecNf, e2: vecNi) -> vecNf {
    return e1 * exp2(vecNf(e2));
}

// Natural logarithm (exp() -> e). Expects e > 0.
fn log(e: FLOAT) -> FLOAT { ... }

// Base 2 logarithm (exp2() -> e). Expects e > 0.
fn log2(e: FLOAT) -> FLOAT { ... }

// Linear interpolation (lerp) between e1 and e2 using interpolation factor e3,
// which can be an f32 even when FLOAT is a vector.
fn mix(e1: FLOAT, e2: FLOAT, e3: FLOAT) -> FLOAT {
    return e1 * (1.0 - e3) + e2 * e3;
}

// Raise e1 to the power of e2. Expects e1 >= 0.
fn pow(e1: FLOAT, e2: FLOAT) -> FLOAT {
    return exp2(e2 * log2(e1));
}

// Round e to f16 precision, keeping it an f32. Expects abs(e) <= 65504.
fn quantizeToF16(e: FLOAT) -> FLOAT { ... }

// Degrees to radians.
fn radians(e: FLOAT) -> FLOAT {
    return e * 0.017453292519943295474;
}

// Round e to the nearest whole number. Halves go to even: 2.5 gives 2.0.
fn round(e: FLOAT) -> FLOAT { ... }

// Keep e between 0 and 1.
fn saturate(e: FLOAT) -> FLOAT {
    return clamp(e, FLOAT(0.0), FLOAT(1.0));
}

// Sine of e, an angle in radians.
fn sin(e: FLOAT) -> FLOAT { ... }

// Hyperbolic sine of e.
fn sinh(e: FLOAT) -> FLOAT {
    return (exp(e) - exp(-e)) * 0.5;
}

// A smooth step(): 0 at edge0, 1 at edge1, flat beyond and curved between.
fn smoothstep(edge0: FLOAT, edge1: FLOAT, x: FLOAT) -> FLOAT {
    let t = saturate((x - edge0) / (edge1 - edge0));
    return t * t * (3.0 - 2.0 * t);
}

// Square root. Expects e >= 0.
fn sqrt(e: FLOAT) -> FLOAT { ... }

// 1 when x >= edge, else 0.
fn step(edge: FLOAT, x: FLOAT) -> FLOAT {
    return select(FLOAT(0.0), FLOAT(1.0), edge <= x);
}

// Tangent of e, an angle in radians.
fn tan(e: FLOAT) -> FLOAT {
    return sin(e) / cos(e);
}

// Hyperbolic tangent of e.
fn tanh(e: FLOAT) -> FLOAT {
    return sinh(e) / cosh(e);
}

// Round e towards 0: trunc(-1.5) gives -1.0.
fn trunc(e: FLOAT) -> FLOAT { ... }

// There's no mod(): x % y truncates, keeping x's sign.
// For GLSL's mod(x, y), use x - y * floor(x / y).

// For each float, separate the fractional part from the whole-number part.
// Shaders can't name the return types, so use let result = modf(e).
// Then result.whole is trunc(e), and result.fract is e - result.whole.
fn modf(e: FLOAT) -> struct { fract: FLOAT, whole: FLOAT } { ... }

// For each float, separate the fraction (mantissa) from the integer exponent.
// .fract * exp2(.exp) = e, with abs(.fract) at least 0.5, but less than 1.0, so
// frexp(1.5) gives .fract 0.75 and .exp 1. For 0.0, .fract is 0.0, .exp is 0.
// Shaders can't name the return types, so use let result = frexp(e).
// Then result.fract is the mantissa and result.exp is the integer exponent.
fn frexp(e: f32) -> struct { fract: f32, exp: i32 } { ... }
fn frexp(e: vecNf) -> struct { fract: vecNf, exp: vecNi } { ... }

// Cross product: a vector at right angles to both e1 and e2, or 0 when they're
// parallel.
fn cross(e1: vec3f, e2: vec3f) -> vec3f {
    return vec3f(
        e1.y * e2.z - e1.z * e2.y,
        e1.z * e2.x - e1.x * e2.z,
        e1.x * e2.y - e1.y * e2.x,
    );
}

// The distance between points e1 and e2.
fn distance(e1: FLOAT, e2: FLOAT) -> f32 {
    return length(e1 - e2);
}

// Dot product: the sum of e1[i] * e2[i]. With unit vectors, it's the cosine
// of the angle between them.
fn dot(e1: vecN<NUMERIC>, e2: vecN<NUMERIC>) -> NUMERIC {
    var sum = NUMERIC(0);
    for (var i = 0; i < N; i++) {
        sum += e1[i] * e2[i];
    }
    return sum;
}

// e1 if dot(e2, e3) < 0, else -e1. faceForward(n, d, n) turns a normal n to
// face against a direction d.
fn faceForward(e1: vecNf, e2: vecNf, e3: vecNf) -> vecNf {
    return select(-e1, e1, dot(e2, e3) < 0.0);
}

// The length of e, its distance from 0.
fn length(e: vecNf) -> f32 {
    return sqrt(dot(e, e));
}

fn length(e: f32) -> f32 {
    return abs(e);
}

// Scale e to length 1, keeping its direction. Expects length(e) > 0.
fn normalize(e: vecNf) -> vecNf {
    return e / length(e);
}

// Direction e1 reflected off a surface with normal e2. Expects e2 to have
// length 1.
fn reflect(e1: vecNf, e2: vecNf) -> vecNf {
    return e1 - 2.0 * dot(e2, e1) * e2;
}

// Direction e1 bent through a surface with normal e2, where e3 is the ratio
// of refractive indices, e.g. 1.0/1.33 from air into water. 0 where it
// reflects instead. Expects e1 and e2 to have length 1.
fn refract(e1: vecNf, e2: vecNf, e3: f32) -> vecNf {
    let k = 1.0 - e3 * e3 * (1.0 - dot(e2, e1) * dot(e2, e1));
    if (k < 0.0) {
        return vecNf(0.0);
    }
    return e3 * e1 - (e3 * dot(e2, e1) + sqrt(k)) * e2;
}

// How much e scales area or volume, negative if it flips. There's no inverse().
fn determinant(e: matNxN<f32>) -> f32 { ... }

// e with its rows and columns swapped.
fn transpose(e: matCxR<f32>) -> matRxC<f32> {
    var t: matRxC<f32>;
    for (var col = 0; col < C; col++) {
        for (var row = 0; row < R; row++) {
            t[row][col] = e[col][row];
        }
    }
    return t;
}

// Bit 0 is the lowest.

// The number of 0 bits above the highest 1 bit: 32 when e is 0.
fn countLeadingZeros(e: INT) -> INT { ... }

// The number of 1 bits.
fn countOneBits(e: INT) -> INT { ... }

// The number of 0 bits below the lowest 1 bit: 32 when e is 0.
fn countTrailingZeros(e: INT) -> INT { ... }

// e's bits in reverse order: bit 0 swaps with bit 31, bit 1 with 30, etc.
fn reverseBits(e: INT) -> INT { ... }

// The count bits of e starting at bit offset, moved down to bit 0. For i32,
// the highest of them also fills every bit above. Expects offset + count <= 32.
fn extractBits(e: INT, offset: u32, count: u32) -> INT { ... }

// e with count bits starting at bit offset replaced by the lowest count bits
// of newbits. Expects offset + count <= 32.
fn insertBits(e: INT, newbits: INT, offset: u32, count: u32) -> INT { ... }

// The index of the highest 1 bit, or for a negative i32 the highest 0 bit.
// All bits set (-1 as i32) when there's no such bit.
fn firstLeadingBit(e: INT) -> INT { ... }

// The index of the lowest 1 bit. All bits set (-1 as i32) when e is 0.
fn firstTrailingBit(e: INT) -> INT { ... }

// Whether every component of e is true.
fn all(e: vecN<bool>) -> bool {
    for (var i = 0; i < N; i++) {
        if (!e[i]) {
            return false;
        }
    }
    return true;
}

// Whether any component of e is true.
fn any(e: vecN<bool>) -> bool {
    for (var i = 0; i < N; i++) {
        if (e[i]) {
            return true;
        }
    }
    return false;
}

// Choose between f and t based on cond. The argument order may surprise you.
// WGSL has no ternary operator (cond ? t : f). All arguments are evaluated.
// When ANY is a vector, cond can be a vecN<bool>.
fn select(f: ANY, t: ANY, cond: bool) -> ANY {
    if (cond) {
        return t;
    }
    return f;
}

// Read the bits of e as type TO, e.g. bitcast<u32>(x) for hashing.
// TO and FROM are NUMERIC types of the same size.
fn bitcast<TO>(e: FROM) -> TO { ... }

// Floats packed into a u32's bits, and unpacked. The spec rounds halves up;
// some GPUs round them to even.

// Pack four floats, clamped to -1 to 1, into a u32: e.x in bits 0-7, etc.
fn pack4x8snorm(e: vec4f) -> u32 {
    let v = vec4i(floor(0.5 + 127.0 * clamp(e, vec4f(-1.0), vec4f(1.0))));
    let bytes = bitcast<vec4u>(v) & vec4u(0xff);
    return bytes.x | (bytes.y << 8) | (bytes.z << 16) | (bytes.w << 24);
}

// Pack four floats, clamped to 0 to 1, into a u32: e.x in bits 0-7, etc.
fn pack4x8unorm(e: vec4f) -> u32 {
    let bytes = vec4u(floor(0.5 + 255.0 * saturate(e)));
    return bytes.x | (bytes.y << 8) | (bytes.z << 16) | (bytes.w << 24);
}

// Pack two floats, clamped to -1 to 1, into a u32: e.x in bits 0-15, e.y above.
fn pack2x16snorm(e: vec2f) -> u32 {
    let v = vec2i(floor(0.5 + 32767.0 * clamp(e, vec2f(-1.0), vec2f(1.0))));
    let halves = bitcast<vec2u>(v) & vec2u(0xffff);
    return halves.x | (halves.y << 16);
}

// Pack two floats, clamped to 0 to 1, into a u32: e.x in bits 0-15, e.y above.
fn pack2x16unorm(e: vec2f) -> u32 {
    let halves = vec2u(floor(0.5 + 65535.0 * saturate(e)));
    return halves.x | (halves.y << 16);
}

// Pack two floats into a u32 as f16s: e.x in bits 0-15, e.y above.
// Expects abs(e) <= 65504.
fn pack2x16float(e: vec2f) -> u32 { ... }

// Reverse pack4x8snorm: four floats from -1 to 1.
fn unpack4x8snorm(e: u32) -> vec4f {
    let v = bitcast<vec4i>(vec4u(e) << vec4u(24, 16, 8, 0)) >> vec4u(24);
    return max(vec4f(v) / 127.0, vec4f(-1.0));
}

// Reverse pack4x8unorm: four floats from 0 to 1.
fn unpack4x8unorm(e: u32) -> vec4f {
    let v = (vec4u(e) >> vec4u(0, 8, 16, 24)) & vec4u(0xff);
    return vec4f(v) / 255.0;
}

// Reverse pack2x16snorm: two floats from -1 to 1.
fn unpack2x16snorm(e: u32) -> vec2f {
    let v = bitcast<vec2i>(vec2u(e) << vec2u(16, 0)) >> vec2u(16);
    return max(vec2f(v) / 32767.0, vec2f(-1.0));
}

// Reverse pack2x16unorm: two floats from 0 to 1.
fn unpack2x16unorm(e: u32) -> vec2f {
    let v = (vec2u(e) >> vec2u(0, 16)) & vec2u(0xffff);
    return vec2f(v) / 65535.0;
}

// Reverse pack2x16float.
fn unpack2x16float(e: u32) -> vec2f { ... }

// Four 8-bit integers in a u32. These come from a WGSL language extension that
// Chrome and Edge have had since version 123, and Firefox and Safari since
// their first WebGPU release; a pack calling one won't compile in an older
// browser.

// Pack the lowest 8 bits of each of e's i32s into a u32: e.x in bits 0-7, etc.
fn pack4xI8(e: vec4i) -> u32 {
    let bytes = bitcast<vec4u>(e) & vec4u(0xff);
    return bytes.x | (bytes.y << 8) | (bytes.z << 16) | (bytes.w << 24);
}

// Like pack4xI8, for u32s.
fn pack4xU8(e: vec4u) -> u32 {
    let bytes = e & vec4u(0xff);
    return bytes.x | (bytes.y << 8) | (bytes.z << 16) | (bytes.w << 24);
}

// pack4xI8, with e clamped to -128 to 127 first.
fn pack4xI8Clamp(e: vec4i) -> u32 {
    return pack4xI8(clamp(e, vec4i(-128), vec4i(127)));
}

// pack4xU8, with e clamped to 0 to 255 first.
fn pack4xU8Clamp(e: vec4u) -> u32 {
    return pack4xU8(clamp(e, vec4u(0), vec4u(255)));
}

// Reverse pack4xI8: four i32s from -128 to 127.
fn unpack4xI8(e: u32) -> vec4i {
    return bitcast<vec4i>(vec4u(e) << vec4u(24, 16, 8, 0)) >> vec4u(24);
}

// Reverse pack4xU8: four u32s from 0 to 255.
fn unpack4xU8(e: u32) -> vec4u {
    return (vec4u(e) >> vec4u(0, 8, 16, 24)) & vec4u(0xff);
}

// dot() of the 4 i32s in e1 and e2, as unpack4xI8 reads them.
fn dot4I8Packed(e1: u32, e2: u32) -> i32 {
    return dot(unpack4xI8(e1), unpack4xI8(e2));
}

// dot() of the 4 u32s in e1 and e2, as unpack4xU8 reads them.
fn dot4U8Packed(e1: u32, e2: u32) -> u32 {
    return dot(unpack4xU8(e1), unpack4xU8(e2));
}

// Derivatives: how much e changes from one pixel to the next. Only in code a
// surface or light hook reaches, and not where a per-fragment value, such as
// a hook input, decides whether the call runs:
// - inside an if, loop or switch that tests one
// - after an early return under such a test
// - right of a && or || that starts with one
// Coarse versions can share one value across each 2x2 block of pixels; Fine
// versions can't. The plain names might be either, chosen by the GPU.

// The change in e from this pixel to the one on its right.
fn dpdx(e: FLOAT) -> FLOAT { ... }
fn dpdxCoarse(e: FLOAT) -> FLOAT { ... }
fn dpdxFine(e: FLOAT) -> FLOAT { ... }

// The change in e from this pixel to the one above it, same behaviour as GLSL.
// Normally in WGSL, dpdy looks at the one below, so the compiler negates it.
fn dpdy(e: FLOAT) -> FLOAT { ... }
fn dpdyCoarse(e: FLOAT) -> FLOAT { ... }
fn dpdyFine(e: FLOAT) -> FLOAT { ... }

// The total magnitude of changes in e to the right and above.
fn fwidth(e: FLOAT) -> FLOAT {
    return abs(dpdx(e)) + abs(dpdy(e));
}

// fwidth, from the Coarse derivatives.
fn fwidthCoarse(e: FLOAT) -> FLOAT {
    return abs(dpdxCoarse(e)) + abs(dpdyCoarse(e));
}

// fwidth, from the Fine derivatives.
fn fwidthFine(e: FLOAT) -> FLOAT {
    return abs(dpdxFine(e)) + abs(dpdyFine(e));
}

// Not available in packs, and what to use instead:
// - f16: use f32. quantizeToF16 rounds to f16 precision, and pack2x16float
//   stores two f16s in a u32.
// - Textures, samplers and texture*: surface and light hooks can read atlas
//   textures with bloxdTexel and bloxdTextureSize, explained in bloxd-api.wgsl.
// - Buffers, buffer* and arrayLength: put data in a const array<type, length>.
// - Atomics, atomic*, storageBarrier, textureBarrier, workgroupBarrier and
//   workgroupUniformLoad: use a var. Each vertex and pixel gets its own.
// - subgroup* and quad*: dpdx and dpdy give changes from one pixel to the next.

Official example packs

These 8 zips are complete packs authored by Bloxd. Each has a pack.json and the WGSL that goes with it. Open one to read the full source exactly as shipped.

Default hooksEvery hook at its engine default. The cleanest starting point for a new pack.

Manifest and source exactly as shipped in default.zip.

pack.json
{ "apiVersion": 5, "name": "Default", "author": "Bloxd" }
pack.wgsl 50 lines
// Every hook here returns its engine default. Modify the return values to start
// building a shader pack. If you delete a hook, the default is used instead.

// All blocks but water and block models use terrain hooks.
#ifndef BLOXD_STRICT
// Strict games keep terrain where it is. Without the #ifndef, this hook would
// turn the whole shader pack off there.
fn bloxdTerrainVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    return bloxdDefaultVertex(vertex);
}
#endif

fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return bloxdDefaultSurface(surface);
}

fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return bloxdDefaultLight(surface, light);
}

// Water uses liquid hooks. To share code with another hook, define a function
// and call it from both places.
#ifndef BLOXD_STRICT
fn bloxdLiquidVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    return bloxdDefaultVertex(vertex);
}
#endif

fn bloxdLiquidSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return bloxdDefaultSurface(surface);
}

fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return bloxdDefaultLight(surface, light);
}

// Models: block models such as slabs and plants, items, players and mobs.
#ifndef BLOXD_STRICT
fn bloxdModelVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    return bloxdDefaultVertex(vertex);
}
#endif

fn bloxdModelSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return bloxdDefaultSurface(surface);
}

fn bloxdModelLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return bloxdDefaultLight(surface, light);
}
VividContrast, saturation and split toning applied after lighting.

Manifest and source exactly as shipped in vivid.zip.

pack.json
{ "apiVersion": 5, "name": "Vivid", "author": "Bloxd" }
pack.wgsl 45 lines
// Higher colour saturation, cooler shadows and warmer highlights.

const CONTRAST = 0.4;                     // 0 = normal contrast. 1 = extreme.
const SATURATION = 1.3;                   // Colour saturation multiplier.
const SHADOW = vec3f(0.0, 0.03, 0.12);    // RGB colour black becomes.
const HIGHLIGHT = vec3f(1.08, 1.0, 0.86); // RGB colour white becomes.

// Standard formula for relative luminance (apparent brightness).
fn luminance(colour: vec3f) -> f32 {
    return dot(colour, vec3f(0.2126, 0.7152, 0.0722));
}

fn vivid(colour: vec3f) -> vec3f {
    // Brighten and darken using smoothstep's S-curve shape to boost contrast.
    let curve = smoothstep(vec3f(0.0), vec3f(1.0), colour);
    let mixed = mix(colour, curve, CONTRAST);
    let toned = mix(SHADOW, HIGHLIGHT, mixed);

    // Make the colour less grey, and use saturate to clamp to 0-1.
    return saturate(mix(vec3f(luminance(toned)), toned, SATURATION));
}

// We want to modify the colours after lighting has been applied, which is what
// light hooks are for. Surface hooks would tint dark textures, not dark places.
fn vividLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    var out = bloxdDefaultLight(surface, light);
    let colour = vivid(light.litColour + surface.emission);

    // Fog is applied last so distant terrain always becomes light.fogColour.
    out.colour = bloxdApplyFog(colour, light);
    return out;
}

// Each program only runs its own hooks, so each light hook calls vividLight.
fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return vividLight(surface, light);
}

fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return vividLight(surface, light);
}

fn bloxdModelLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return vividLight(surface, light);
}
WaterRipples, sky reflection, sun glints and depth tint for liquids.

Manifest and source exactly as shipped in water.zip.

pack.json
{ "apiVersion": 5, "name": "Water", "author": "Bloxd" }
pack.wgsl 178 lines
// Water ripples, reflects the sky, glints in the sun and darkens with depth.

// Replace the default colour with our own depth-based colour and alpha.
const DEFAULT_TINT = vec3f(0.5, 0.5, 0.8);  // Default RGB tint of water.
const SHALLOW_TINT = vec3f(0.3, 0.6, 0.66); // New RGB tint for shallow water.
const DEEP_TINT = vec3f(0.1, 0.22, 0.45);   // New RGB tint for deep water.
const DEEP_BLOCKS = 6.0;                    // Depth for max opacity DEEP_TINT.
const SHALLOW_ALPHA = 0.55;                 // Shallow water opacity multiplier.

// Reflect sky light. This considers both the sky light strength and the colour.
const SKY_COLOUR = vec3f(0.7, 0.8, 0.94);   // RGB colour of the reflected sky.
const HEAD_ON_REFLECTION = 0.01;            // Reflect only 1% of sky head-on.
const GRAZING_REFLECTION = 0.45;            // Reflect 45% of sky when grazing.
const INDOOR_SKY_LIGHT = 0.45;              // No reflection or glint below.
const OUTDOOR_SKY_LIGHT = 0.98;             // Full reflection and glint above.

// Add light and opacity where the water catches the sun's reflection.
const GLINT_BRIGHTNESS = 0.18;              // Brightness of the glint's centre.
const GLINT_SHARPNESS = 240.0;              // Sharpness and tightness of glint.
const GLINT_COLOUR = vec3f(1.0, 0.97, 0.9); // RGB colour of the glint.
const GLINT_ALPHA = 0.5;                    // Alpha added by a brightness of 1.
const GLINT_FADE_SUN_Y = 0.25;              // As sun falls below, glints fade.

// Apply ripples when lit by the sky, fading at small sizes to reduce flicker.
const CELLS_PER_BLOCK = 8;                  // Ripple cells along block edges.
const SIDE_RIPPLE = 0.25;                   // How bumpy side faces look.
const FLAT_CELL_PIXELS = 0.05;              // Fully fade cells this small.
const FULL_CELL_PIXELS = 0.2;               // Fully show cells this large.

// Ripples use two grid layers which don't line up, so they look natural.
const LARGE_SIZE = 2.0;                     // Large grid size in blocks.
const LARGE_ANGLE = 20.0;                   // Large grid's degrees of yaw.
const LARGE_AMPLITUDE = 0.125;              // How bumpy large ripples look.
const SMALL_SIZE = 0.83;                    // Small grid size in blocks.
const SMALL_ANGLE = 35.0;                   // Small grid's degrees of yaw.
const SMALL_AMPLITUDE = 0.05;               // How bumpy small ripples look.
const SLOW_CYCLE_SECONDS = 20.0;            // Slowest corner ripple period.
const FAST_CYCLE_SECONDS = 7.0;             // Fastest corner ripple period.

// Map vec2i to two values between 0 and 1 inclusive. Same point = same output.
// PCG2D, from Jarzynski and Olano's "Hash Functions for GPU Rendering".
fn hashVec2i(point: vec2i) -> vec2f {
    var hash = vec2u(point) * 1664525 + 1013904223;
    hash.x += hash.y * 1664525;
    hash.y += hash.x * 1664525;
    hash ^= hash >> vec2u(16);
    hash.x += hash.y * 1664525;
    hash.y += hash.x * 1664525;
    hash ^= hash >> vec2u(16);
    return vec2f(hash) / f32(0xffffffff);
}

// Grid corner ripple value, between -1 and 1. Each corner uses its own timing.
fn corner(point: vec2i) -> f32 {
    let hash = hashVec2i(point);
    let cycleSeconds = mix(SLOW_CYCLE_SECONDS, FAST_CYCLE_SECONDS, hash.x);
    let cyclePosition = fract(bloxdSeconds() / cycleSeconds + hash.y);
    return sin(bloxdTau * cyclePosition);
}

// Slope of a smooth blend between grid corners around `point`, along grid axes.
fn gridSlope(point: vec2f) -> vec2f {
    let p00 = vec2i(floor(point));
    let h00 = corner(p00);
    let h10 = corner(p00 + vec2i(1, 0));
    let h01 = corner(p00 + vec2i(0, 1));
    let h11 = corner(p00 + vec2i(1, 1));

    // Like smoothstep's S-curve, but quintic, so the ripples have no creases.
    let t = fract(point);
    let blend = t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
    let blendSlope = 30.0 * t * t * (t * (t - 2.0) + 1.0);

    // Slope of h00 + a.x * x + a.y * y + b * x * y, at the blended x and y.
    let a = vec2f(h10, h01) - h00;
    let b = h00 - h10 - h01 + h11;
    return blendSlope * (a + b * blend.yx);
}

// Ripple layer slope along world x and z axes.
fn rippleLayer(world: vec2f, size: f32, yaw: f32) -> vec2f {
    let angle = radians(yaw);
    let rotation = mat2x2f(cos(angle), sin(angle), -sin(angle), cos(angle));
    let slope = gridSlope(rotation * world / size);

    // Convert from grid axes back into world x and z, scaled to be per-block.
    return slope * rotation / size;
}

// The ripples' slope along world x and z, at a world x and z position.
fn ripples(world: vec2f) -> vec2f {
    let large = rippleLayer(world, LARGE_SIZE, LARGE_ANGLE);
    let small = rippleLayer(world, SMALL_SIZE, SMALL_ANGLE);
    return LARGE_AMPLITUDE * large + SMALL_AMPLITUDE * small;
}

// Surface information used by the light hook, which runs in the same fragment.
// Reflection and glint effects need sky light, which only the light hook knows.
struct WaterShade {
    reflection: f32,
    glint: f32,
}
var<private> shade: WaterShade;

fn waterShade(surface: BloxdSurfaceIn) -> WaterShade {
    // Move half a cell into the block to prevent flickering on side faces.
    let cell = floor(surface.position * CELLS_PER_BLOCK - surface.normal * 0.5);

    // Integer world cells, so ripples don't jump during render offset changes.
    let worldCell = vec3i(cell).xz + bloxdRenderOffset().xz * CELLS_PER_BLOCK;
    let slope = ripples((vec2f(worldCell) + 0.5) / CELLS_PER_BLOCK);

    // Pixels across a cell on screen.
    let cellPixels = 1.0 / (length(fwidth(surface.position)) * CELLS_PER_BLOCK);
    let rippling = smoothstep(FLAT_CELL_PIXELS, FULL_CELL_PIXELS, cellPixels);

    // The ripples only tilt the normal: the surface itself stays flat.
    let strength = mix(SIDE_RIPPLE, 1.0, saturate(surface.normal.y)) * rippling;
    let tilt = vec3f(slope.x, 0.0, slope.y) * strength;
    let normal = normalize(surface.normal - tilt);

    // From the cell's centre, so the reflection and glints are pixelated too.
    let toEye = normalize(bloxdEyePosition() - (cell + 0.5) / CELLS_PER_BLOCK);

    // Schlick's fresnel: 0 head-on, rising to 1 at grazing angles.
    // The light hook maps 0 to HEAD_ON_REFLECTION and 1 to GRAZING_REFLECTION.
    let grazing = 1.0 - saturate(dot(toEye, normal));
    let reflection = pow(grazing, 5.0);

    // Glints are brightest where the rippled surface normal points halfway
    // between the camera and the sun. They fade out as the sun sets.
    let sun = bloxdSunDirection();
    let halfway = toEye + sun;

    // Not normalize(halfway), which is NaN for a sun exactly behind the water.
    let facing = saturate(dot(normal, halfway) / max(length(halfway), 0.0001));
    let sunUp = saturate(sun.y / GLINT_FADE_SUN_Y);
    let glint = GLINT_BRIGHTNESS * pow(facing, GLINT_SHARPNESS) * sunUp;
    return WaterShade(reflection, glint);
}

fn bloxdLiquidSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    var out = bloxdDefaultSurface(surface);
    shade = waterShade(surface);

    // 0 at the shore to 1 at DEEP_BLOCKS deep, per pixel rather than per cell,
    // so the colour blends smoothly. Open sky behind the water counts as deep.
    let behind = bloxdOpaqueBehind();
    let blocksDeep = surface.position.y - behind.position.y;
    let depth = select(1.0, saturate(blocksDeep / DEEP_BLOCKS), behind.hit);

    // Tint by depth instead of using the default water tint.
    let tint = mix(SHALLOW_TINT, DEEP_TINT, depth);
    out.colour = surface.colour / DEFAULT_TINT * tint;

    // Shallow water is more see-through than deep water, but glints still show.
    let alpha = surface.alpha * mix(SHALLOW_ALPHA, 1.0, depth);
    out.alpha = saturate(alpha + shade.glint * GLINT_ALPHA);
    return out;
}

fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    var out = bloxdDefaultLight(surface, light);

    // Apply reflection.
    let reflectionColour = light.skyLightColour * SKY_COLOUR;
    let sky = smoothstep(INDOOR_SKY_LIGHT, OUTDOOR_SKY_LIGHT, light.skyLight);
    var colour = mix(
        light.litColour,
        reflectionColour,
        mix(HEAD_ON_REFLECTION, GRAZING_REFLECTION, shade.reflection) * sky,
    );

    // Then add glint, then emission and fog, same as the default light hook.
    colour += light.skyLightColour * GLINT_COLOUR * shade.glint * sky;
    out.colour = bloxdApplyFog(colour + surface.emission, light);
    return out;
}
SwayWind displacement for leaves and plants, anchored at the block base.

Manifest and source exactly as shipped in sway.zip.

pack.json
{ "apiVersion": 5, "name": "Sway", "author": "Bloxd" }
pack.wgsl 44 lines
// Leaves and plants sway in the wind. Off in strict games.

const AMPLITUDE = 0.1;                   // Maximum displacement, per axis.
const SWAY_SECONDS = vec2f(3.5, 4.5);    // Cycle durations for x and z axes.
const PHASE_PER_BLOCK = vec2f(0.7, 0.5); // Phase (radians) per block along x/z.

// Leaves and plants are vegetation, like grass blocks, but those are dirt too.
fn sways(flags: BloxdFlags) -> bool {
    return flags.vegetation && !flags.dirt;
}

// The wind's displacement at a render position.
fn wind(position: vec3f) -> vec3f {
    // World position, so the pattern doesn't jump during render offset changes.
    let world = bloxdWorldPosition(position);

    // Longer sway cycle duration = longer sway wavelength.
    let phase = dot(world.xz, PHASE_PER_BLOCK) * SWAY_SECONDS.x / SWAY_SECONDS;
    let angle = phase + bloxdTau * bloxdSeconds() / SWAY_SECONDS;
    let sway = sin(angle % bloxdTau) * AMPLITUDE;
    return vec3f(sway.x, 0.0, sway.y);
}

// Strict games prevent vertex movement, so they turn this shader pack off. We
// don't wrap these hooks in #ifndef BLOXD_STRICT, as they're the only ones.
fn bloxdTerrainVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    var out = bloxdDefaultVertex(vertex);
    if (sways(vertex.flags)) {
        out.position += wind(vertex.position);
    }
    return out;
}

// Plants are block models. The top sways, anchored to the fixed bottom.
fn bloxdModelVertex(vertex: BloxdVertexIn) -> BloxdVertex {
    var out = bloxdDefaultVertex(vertex);
    // We only animate placed models, as held or dropped plants shouldn't sway.
    if (sways(vertex.flags) && vertex.flags.placed) {
        // Map vertex local y to a height relative to the block's fixed bottom.
        let height = vertex.localPosition.y + 0.5;
        out.position += wind(vertex.position) * clamp(height, 0.0, 1.0);
    }
    return out;
}
DissolveBlocks glow then vanish on a per-block cycle, with a strict-game fallback.

Manifest and source exactly as shipped in dissolve.zip.

pack.json
{ "apiVersion": 5, "name": "Dissolve", "author": "Bloxd" }
pack.wgsl 44 lines
// Blocks glow, then vanish, one by one. In strict games they only glow.

const CYCLE_SECONDS = 20.0;                // Repeating cycle duration.
const GLOW_SECONDS = 1.5;                  // Duration of glow effect.
const GLOW_COLOUR = vec3f(1.0, 0.45, 0.1); // RGB colour of the warm glow.

// Map vec3i to a value between 0 and 1 inclusive. Same point = same output.
fn hashVec3i(point: vec3i) -> f32 {
    let scaled = vec3u(point) * vec3u(73856093, 19349663, 83492791);
    var hash = scaled.x ^ scaled.y ^ scaled.z;
    hash = (hash ^ (hash >> 13)) * 1274126177;
    return f32(hash) / f32(0xffffffff);
}

fn dissolve(surface: BloxdSurfaceIn) -> BloxdSurface {
    var out = bloxdDefaultSurface(surface);
    let block = bloxdFragmentBlockPosition(surface.position, surface.normal);
    let start = hashVec3i(block) * (CYCLE_SECONDS - GLOW_SECONDS);
    let elapsed = bloxdSeconds() % CYCLE_SECONDS - start;
    if (elapsed > GLOW_SECONDS) {
#ifndef BLOXD_STRICT
        // Strict games prevent `discard`, as it could show what's behind walls.
        // Without the #ifndef, it would turn the whole shader pack off there.
        discard;
#endif
    } else if (elapsed > 0.0) {
        // bloxdDefaultLight adds emission after lighting.
        out.emission = GLOW_COLOUR;
    }
    return out;
}

fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return dissolve(surface);
}

// Models vanish according to the block they're in.
fn bloxdModelSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    // Items use model hooks too, so held items would flicker as holders move.
    if (surface.flags.held) {
        return bloxdDefaultSurface(surface);
    }
    return dissolve(surface);
}
InvertAnimated 4D noise flips colours across terrain, liquids and models.

Manifest and source exactly as shipped in invert.zip.

pack.json
{ "apiVersion": 5, "name": "Invert", "author": "Bloxd" }
pack.wgsl 36 lines
// Invert colours for half the pixels, using shapes that are always shifting.

const NOISE_BLOCKS = 2.0;  // Noise scale in blocks: larger = bigger shapes.
const NOISE_SECONDS = 4.0; // Noise scale in time: larger = slower changes.

// Inverts the lit colour, emission included, where the noise is above 0.
fn invert(surface: BloxdSurface, light: BloxdLightIn, position: vec3f) -> BloxdLight {
    var out = bloxdDefaultLight(surface, light);
    var colour = light.litColour + surface.emission;

    // Use noise.wgsl's gradient noise to decide whether to invert the colour.
    let point = vec4f(position / NOISE_BLOCKS, bloxdSeconds() / NOISE_SECONDS);
    if (noise4d(point) > 0.0) {
        colour = 1.0 - saturate(colour);
    }

    // Fog comes last, so inverted pixels fade into it like everything else.
    out.colour = bloxdApplyFog(colour, light);
    return out;
}

// World positions, so shapes don't jump during render offset changes.
fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return invert(surface, light, bloxdWorldPosition(light.position));
}

fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return invert(surface, light, bloxdWorldPosition(light.position));
}

// Held items move with the camera, so their noise shapes move with them.
fn bloxdModelLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    let worldPosition = bloxdWorldPosition(light.position);
    let position = select(worldPosition, light.localPosition, light.flags.held);
    return invert(surface, light, position);
}
noise.wgsl 79 lines
// 4D simplex noise, from Yuwen Wu's optimised HLSL in bitangent_noise
// (https://github.com/atyuwen/bitangent_noise), which builds on Ashima Arts'
// and Stefan Gustavson's webgl-noise (https://github.com/stegu/webgl-noise).
//
// Copyright (c) 2021 Yuwen Wu
// Copyright (C) 2011 by Ashima Arts (Simplex noise)
// Copyright (C) 2011-2016 by Stefan Gustavson (Classic noise and others)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

const F4 = 0.309016994374947451; // (sqrt(5) - 1) / 4: skews onto the grid.
const G4 = 0.138196601125011;    // (5 - sqrt(5)) / 20: skews back.

// Hashes a grid point. Only the top 16 bits are well mixed.
// From Jarzynski and Olano's "Hash Functions for GPU Rendering".
fn pcg4d16(point: vec4i) -> u32 {
    var v = vec4u(point) * 1664525u + 1013904223u;
    v.x += v.y * v.w;
    v.y += v.z * v.x;
    v.z += v.x * v.y;
    v.w += v.y * v.z;
    v.x += v.y * v.w;
    return v.x;
}

// One of 16 gradients, each axis -1 or 1, from four of the hash's top bits.
fn gradient4d(hash: u32) -> vec4f {
    const BITS = vec4u(0x80000, 0x40000, 0x20000, 0x10000);
    return vec4f(vec4u(hash) & BITS) * (2.0 / vec4f(BITS)) - 1.0;
}

// Smooth noise, about -1 to 1, and above 0 at half of all points.
fn noise4d(p: vec4f) -> f32 {
    let i = floor(p + dot(p, vec4f(F4)));
    let x0 = p - i + dot(i, vec4f(G4));

    let isX = step(x0.yzw, x0.xxx);
    let isYZ = step(x0.zww, x0.yyz);
    let rank = vec4f(isX.x + isX.y + isX.z, 1.0 - isX)
        + vec4f(0.0, isYZ.x + isYZ.y, 1.0 - isYZ.xy)
        + vec4f(0.0, 0.0, isYZ.z, 1.0 - isYZ.z);
    let i1 = saturate(rank - 2.0);
    let i2 = saturate(rank - 1.0);
    let i3 = saturate(rank);

    let x1 = x0 - i1 + G4;
    let x2 = x0 - i2 + 2.0 * G4;
    let x3 = x0 - i3 + 3.0 * G4;
    let x4 = x0 + (4.0 * G4 - 1.0);

    let corner = vec4i(i);
    let g0 = gradient4d(pcg4d16(corner));
    let g1 = gradient4d(pcg4d16(corner + vec4i(i1)));
    let g2 = gradient4d(pcg4d16(corner + vec4i(i2)));
    let g3 = gradient4d(pcg4d16(corner + vec4i(i3)));
    let g4 = gradient4d(pcg4d16(corner + 1));

    let m0 = saturate(0.6 - vec3f(dot(x0, x0), dot(x1, x1), dot(x2, x2)));
    let m1 = saturate(0.6 - vec2f(dot(x3, x3), dot(x4, x4)));
    let near = dot(m0 * m0 * m0, vec3f(dot(g0, x0), dot(g1, x1), dot(g2, x2)));
    let far = dot(m1 * m1 * m1, vec2f(dot(g3, x3), dot(g4, x4)));
    return 9.0 * (near + far);
}
CrackProcedural cracks along texture edges, fading with distance and mip level.

Manifest and source exactly as shipped in crack.zip.

pack.json
{ "apiVersion": 5, "name": "Crack", "author": "Bloxd" }
pack.wgsl 103 lines
// Blocks randomly crack along edges in textures, mostly near the camera.

const MIN_DARKEN = 0.2;     // The least a block's cracks darken; 0 is none.
const MAX_DARKEN = 0.8;     // The most a block's cracks darken; 1 is black.
const MIN_THRESHOLD = 0.01; // The minimum luminance delta for cracks to start.
const MAX_THRESHOLD = 0.5;  // The maximum luminance delta for cracks to start.
const MIN_DISTANCE = 3.0;   // The nearest distance at which cracks can start.
const MAX_DISTANCE = 96.0;  // The farthest distance at which cracks can start.
const FADE_BLOCKS = 2.0;    // Cracks fade in over this distance in blocks.
const FADE_LEVELS = 1.0;    // Cracks fade out over this many mip levels.

// Map vec2i to two values between 0 and 1 inclusive. Same point = same output.
// PCG2D, from Jarzynski and Olano's "Hash Functions for GPU Rendering".
fn hashVec2i(point: vec2i) -> vec2f {
    var hash = vec2u(point) * 1664525 + 1013904223;
    hash.x += hash.y * 1664525;
    hash.y += hash.x * 1664525;
    hash ^= hash >> vec2u(16);
    hash.x += hash.y * 1664525;
    hash.y += hash.x * 1664525;
    hash ^= hash >> vec2u(16);
    return vec2f(hash) / f32(0xffffffff);
}

// Map t, 0-1, to low-high, spread evenly across each doubling, so we bias
// towards smaller values. Both low and high must be above 0.
fn logMix(low: f32, high: f32, t: f32) -> f32 {
    return exp2(mix(log2(low), log2(high), t));
}

// Standard formula for relative luminance (apparent brightness).
fn luminance(colour: vec3f) -> f32 {
    return dot(colour, vec3f(0.2126, 0.7152, 0.0722));
}

// Obtain the texture luminance for the given uv coordinates and offset.
// We treat transparency as darkness by multiplying by the alpha channel.
fn texelLuminance(textureId: u32, uv: vec2f, offset: vec2f) -> f32 {
    let colour = bloxdTexel(textureId, uv + offset, 0.0);
    return luminance(colour.rgb) * colour.a;
}

// How much brighter the brightest neighbour is than this texel, 0-1. Reading
// past the texture's edge wraps to its opposite edge, as the texture repeats.
fn neighbourhoodDelta(textureId: u32, uv: vec2f) -> f32 {
    // Calculate the size of an individual texel to use as the offset size.
    let texel = 1.0 / vec2f(bloxdTextureSize(0.0));
    let dx = vec2f(texel.x, 0.0);
    let dy = vec2f(0.0, texel.y);

    let centre = texelLuminance(textureId, uv, vec2f(0.0));
    var brightest = centre;
    brightest = max(brightest, texelLuminance(textureId, uv, dx));
    brightest = max(brightest, texelLuminance(textureId, uv, -dx));
    brightest = max(brightest, texelLuminance(textureId, uv, dy));
    brightest = max(brightest, texelLuminance(textureId, uv, -dy));
    return brightest - centre;
}

fn crack(surface: BloxdSurfaceIn) -> BloxdSurface {
    var out = bloxdDefaultSurface(surface);

    // Each Y level is offset differently to ensure the hashes are misaligned.
    let block = bloxdFragmentBlockPosition(surface.position, surface.normal);
    let hash = hashVec2i(block.xz + block.y * vec2i(1619, 31337));

    // Each block cracks once the camera is within its own distance.
    let crackDistance = logMix(MIN_DISTANCE, MAX_DISTANCE, hash.y);
    let crackStart = crackDistance - FADE_BLOCKS;
    let eyeDistance = distance(bloxdEyePosition(), surface.position);
    let near = 1.0 - smoothstep(crackStart, crackDistance, eyeDistance);

    // Far away, many texels share a pixel, and cracks would shimmer as the
    // camera moves, so they fade out as the mip level rises. They read the
    // full-size texture throughout, so they don't jump where mip levels change.
    let fade = near * (1.0 - saturate(surface.mipLevel / FADE_LEVELS));
    if (fade > 0.0) {
        // Each block cracks by its own amount: a lower threshold cracks more.
        let threshold = logMix(MIN_THRESHOLD, MAX_THRESHOLD, hash.x);
        let delta = neighbourhoodDelta(surface.textureId, surface.uv);
        let edge = smoothstep(threshold, 2.0 * threshold, delta);

        // From hash.y, like distance, so cracks that spawn far away are darker.
        let darken = mix(MIN_DARKEN, MAX_DARKEN, hash.y);

        // Scale the colour rather than replace it, keeping tint and shading.
        out.colour *= 1.0 - darken * fade * edge;
    }
    return out;
}

// Block models (e.g. slabs) use model hooks, not terrain hooks.
fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    return crack(surface);
}

// Items, vehicles, players and mobs use model hooks too, without flags.placed.
fn bloxdModelSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
    if (!surface.flags.placed) {
        return bloxdDefaultSurface(surface);
    }
    return crack(surface);
}
ShadowSun and moon shadows, and light shafts where sunlight crosses the air.

Manifest and source exactly as shipped in shadow.zip.

pack.json
{ "apiVersion": 5, "name": "Shadow", "author": "Bloxd" }
pack.wgsl 70 lines
// Sun and moon shadows, and light shafts where sunlight crosses the air.

const SHADOW = 0.45;                    // Shadow strength. 0 = none, 1 = full.
const SHAFTS = 0.35;                    // Light shaft brightness. 0 = none.
const SHAFT_RANGE = 64.0;               // Blocks of sunlit air to glow fully.
const SAMPLES = 12;                     // Higher is smoother but slower.
const SUN_AIR = vec3f(1.0, 0.9, 0.7);   // RGB colour of sunlit air by day.
const MOON_AIR = vec3f(0.2, 0.25, 0.4); // RGB colour of moonlit air by night.

// The engine's lit colour, dimmed in shadow.
fn shadedColour(surface: BloxdSurface, light: BloxdLightIn) -> vec3f {
    let shade = 1.0 - SHADOW * (1.0 - bloxdShadow());

    // With lighting off, all light counts as sunlight, so shadows dim it all.
    if (!bloxdLit()) {
        return bloxdLitColour(surface, light) * shade;
    }

    // Shadows only dim sky light, so torches still light places in shadow.
    var shaded = light;
    shaded.skyLight *= shade;
    return bloxdLitColour(surface, shaded);
}

// Map vec3f to a value between 0 and 1. Same point = same output. Avoids sin,
// which loses accuracy far from 0 on some GPUs.
fn hash(position: vec3f) -> f32 {
    var p = fract(position * 0.1031);
    p += dot(p, p.zyx + 31.32);
    return fract((p.x + p.y) * p.z);
}

// How much sunlit air lies between the camera and this fragment, 0-1.
fn sunlitAir(light: BloxdLightIn) -> f32 {
    // A different start per fragment turns banding into fine noise.
    let start = hash(light.position);
    var lit = 0.0;
    for (var i = 0; i < SAMPLES; i++) {
        lit += bloxdAirShadow((f32(i) + start) / f32(SAMPLES));
    }
    let air = min(distance(light.position, bloxdEyePosition()) / SHAFT_RANGE, 1.0);
    return lit / f32(SAMPLES) * air;
}

fn shadowLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    var out = bloxdDefaultLight(surface, light);
    let lit = shadedColour(surface, light);

    // Sunlit air glows by day and moonlit air by night, unless there's no sun.
    let sun = bloxdSunDirection();
    let day = smoothstep(-0.1, 0.1, sun.y);
    let glow = mix(MOON_AIR, SUN_AIR, day) * SHAFTS * sunlitAir(light) * length(sun);

    // Fog is applied last so distant terrain always becomes light.fogColour.
    out.colour = bloxdApplyFog(lit + surface.emission + glow, light);
    return out;
}

// Each program only runs its own hooks, so each light hook calls shadowLight.
fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return shadowLight(surface, light);
}

fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return shadowLight(surface, light);
}

fn bloxdModelLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
    return shadowLight(surface, light);
}

Block textures

The 906 block textures a shader pack can name, the texture pack files and the blocks that use them. After bloxdTextureId, case and underscores do not matter. Animated textures are named without their frame number.

906 textures
Texture nameFileBlocks
bloxdTextureIdAlloyKilnBackalloy_kiln_back.pngAlloy Kiln
bloxdTextureIdAlloyKilnFrontalloy_kiln_front.pngAlloy Kiln
bloxdTextureIdAlloyKilnSidealloy_kiln_side.pngAlloy Kiln
bloxdTextureIdAlloyKilnSideRunningalloy_kiln_side_running0.png (0-3)Alloy Kiln
bloxdTextureIdAlloyKilnTopalloy_kiln_top.pngAlloy Kiln
bloxdTextureIdAndesiteBrickandesite_brick.pngAndesite Bricks, Andesite Bricks Slab, Andesite Bricks Stairs
bloxdTextureIdAppleBlockBottomapple_block_bottom.pngApple Block
bloxdTextureIdAppleBlockSideapple_block_side.pngApple Block
bloxdTextureIdAppleBlockTopapple_block_top.pngApple Block
bloxdTextureIdArmourLuckyBlockarmour_lucky_block.pngArmour Lucky Block
bloxdTextureIdArmourLuckyBlockRarearmour_lucky_block_rare.pngRare Armour Lucky Block
bloxdTextureIdArmourLuckyBlockSuperarmour_lucky_block_super.pngSuper Armour Lucky Block
bloxdTextureIdArtisanTableSideartisan_table_side.pngArtisan Bench
bloxdTextureIdArtisanTableTopartisan_table_top.pngArtisan Bench
bloxdTextureIdAshash.pngAsh
bloxdTextureIdAutoBenchBackauto_bench_back.pngAssembler
bloxdTextureIdAutoBenchFrontauto_bench_front.pngAssembler
bloxdTextureIdAutoBenchSideauto_bench_side.pngAssembler
bloxdTextureIdAutoBenchSideRunningauto_bench_side_running0.png (0-3)Assembler
bloxdTextureIdAutoBenchTopauto_bench_top.pngAssembler
bloxdTextureIdAutocrafterBottomautocrafter_bottom.pngAuto Crafter
bloxdTextureIdAutocrafterLuniteBottomautocrafter_lunite_bottom.pngLunite Auto Crafter
bloxdTextureIdAutocrafterLuniteSideautocrafter_lunite_side.pngLunite Auto Crafter
bloxdTextureIdAutocrafterSideautocrafter_side.pngAuto Crafter
bloxdTextureIdBananaBlockSidebanana_block_side.pngBanana Block
bloxdTextureIdBananaBlockTopbanana_block_top.pngBanana Block
bloxdTextureIdBeaconbeacon.pngBeacon
bloxdTextureIdBedrockbedrock.pngBedrock
bloxdTextureIdBeetrootBlockBottombeetroot_block_bottom.pngBeetroot Block
bloxdTextureIdBeetrootBlockSidebeetroot_block_side.pngBeetroot Block
bloxdTextureIdBeetrootBlockTopbeetroot_block_top.pngBeetroot Block
bloxdTextureIdBeltDropSidebelt_drop_side.pngBelt Drop
bloxdTextureIdBeltDropTopbelt_drop_top.pngBelt Drop
bloxdTextureIdBeltLiftSidebelt_lift_side.pngBelt Lift
bloxdTextureIdBeltLiftTopbelt_lift_top.pngBelt Lift
bloxdTextureIdBeltLoaderSlabFrontbelt_loader_slab_front.pngBelt Loader
bloxdTextureIdBeltLoaderTopbelt_loader_top.pngBelt Loader
bloxdTextureIdBeltTunnelBackbelt_tunnel_back.pngBelt Tunnel
bloxdTextureIdBeltTunnelExitTopbelt_tunnel_exit_top.pngBelt Tunnel
bloxdTextureIdBeltTunnelMouthbelt_tunnel_mouth.pngBelt Tunnel
bloxdTextureIdBeltTunnelSidebelt_tunnel_side.pngBelt Tunnel
bloxdTextureIdBeltTunnelTopbelt_tunnel_top.pngBelt Tunnel
bloxdTextureIdBlackConcreteblack_concrete.pngBlack Concrete, Black Concrete Slab, Black Concrete Stairs
bloxdTextureIdBlackGlazedTerracottablack_glazed_terracotta.pngBlack Ceramic
bloxdTextureIdBlackPlanksblack_planks.pngBlack Planks
bloxdTextureIdBlackPortalblack_portal0.png (0-3)Black Portal
bloxdTextureIdBlackSpawnBlockSideblack_spawn_block_side.pngSpawn Block (Black)
bloxdTextureIdBlackSpawnBlockTopblack_spawn_block_top.pngSpawn Block (Black)
bloxdTextureIdBlockDestroyerTntSideblock_destroyer_tnt_side.pngBlock Destroyer TNT
bloxdTextureIdBlockDestroyerTntTopblock_destroyer_tnt_top.pngBlock Destroyer TNT
bloxdTextureIdBlueConcreteblue_concrete.pngBlue Concrete, Blue Concrete Slab, Blue Concrete Stairs
bloxdTextureIdBlueGenSpawnCoalblue_gen_spawn_coal.pngGenerator Spawn Block (Blue)
bloxdTextureIdBlueGenSpawnIronblue_gen_spawn_iron.pngGenerator Spawn Block (Blue)
bloxdTextureIdBlueGenSpawnTopblue_gen_spawn_top.pngGenerator Spawn Block (Blue)
bloxdTextureIdBlueGlazedTerracottablue_glazed_terracotta.pngBlue Ceramic
bloxdTextureIdBlueLuckyBlockblue_lucky_block.pngArmour Lucky Block
bloxdTextureIdBlueLuckyBlockRareblue_lucky_block_rare.pngRare Armour Lucky Block
bloxdTextureIdBlueLuckyBlockSuperblue_lucky_block_super.pngSuper Armour Lucky Block
bloxdTextureIdBluePlanksblue_planks.pngBlue Planks
bloxdTextureIdBluePortalblue_portal0.png (0-3)Blue Portal
bloxdTextureIdBlueSpawnBlockSideblue_spawn_block_side.pngSpawn Block (Blue)
bloxdTextureIdBlueSpawnBlockTopblue_spawn_block_top.pngGoal Block (Blue), Spawn Block (Blue)
bloxdTextureIdBoneBlockSidebone_block_side.pngBone Block
bloxdTextureIdBoneBlockTopbone_block_top.pngBone Block
bloxdTextureIdBookshelfbookshelf.pngBookshelf
bloxdTextureIdBookshelf1bookshelf_1.pngBookshelf
bloxdTextureIdBookshelf2bookshelf_2.pngBookshelf
bloxdTextureIdBookshelf3bookshelf_3.pngBookshelf
bloxdTextureIdBookshelf4bookshelf_4.pngBookshelf
bloxdTextureIdBookshelf5bookshelf_5.pngBookshelf
bloxdTextureIdBookshelfEmptybookshelf_empty.pngEmpty Bookshelf
bloxdTextureIdBouncyBombBlockbouncy_bomb_block.pngBouncy Bomb Block
bloxdTextureIdBowlingAlleyFloorbowling_alley_floor.pngBowling Alley Floor
bloxdTextureIdBreadBlockBackbread_block_back.pngBread Block
bloxdTextureIdBreadBlockFrontbread_block_front.pngBread Block
bloxdTextureIdBreadBlockSidebread_block_side.pngBread Block
bloxdTextureIdBreadBlockTopbread_block_top.pngBread Block
bloxdTextureIdBrickbrick.pngBricks, Bricks Slab, Bricks Stairs
bloxdTextureIdBrownConcretebrown_concrete.pngBrown Concrete, Brown Concrete Slab, Brown Concrete Stairs
bloxdTextureIdBrownGlazedTerracottabrown_glazed_terracotta.pngBrown Ceramic
bloxdTextureIdBrownMushroomBlockbrown_mushroom_block.pngBrown Mushroom Block
bloxdTextureIdBrownPlanksbrown_planks.pngBrown Planks
bloxdTextureIdBrownPortalbrown_portal0.png (0-3)Brown Portal
bloxdTextureIdBrownSpawnBlockSidebrown_spawn_block_side.pngSpawn Block (Brown)
bloxdTextureIdBrownSpawnBlockTopbrown_spawn_block_top.pngSpawn Block (Brown)
bloxdTextureIdBuildingLuckyBlockbuilding_lucky_block.pngBuilding Lucky Block
bloxdTextureIdBuildingLuckyBlockRarebuilding_lucky_block_rare.pngRare Building Lucky Block
bloxdTextureIdBuildingLuckyBlockSuperbuilding_lucky_block_super.pngSuper Building Lucky Block
bloxdTextureIdBurnerDrillBackburner_drill_back.pngBurner Drill
bloxdTextureIdBurnerDrillBottomburner_drill_bottom.pngBurner Drill
bloxdTextureIdBurnerDrillFrontburner_drill_front.pngBurner Drill
bloxdTextureIdBurnerDrillSideburner_drill_side.pngBurner Drill
bloxdTextureIdBurnerDrillSideRunningburner_drill_side_running0.png (0-3)Burner Drill
bloxdTextureIdBurnerDrillTopburner_drill_top.pngBurner Drill
bloxdTextureIdCactusDrycactus_dry.pngDry Fat Cactus
bloxdTextureIdCactusTopcactus_top.pngFat Cactus
bloxdTextureIdCarrotBlockBottomcarrot_block_bottom.pngCarrot Block
bloxdTextureIdCarrotBlockSidecarrot_block_side.pngCarrot Block
bloxdTextureIdCarrotBlockTopcarrot_block_top.pngCarrot Block
bloxdTextureIdCarvedMessyStonecarved_messy_stone.pngCarved Messy Stone
bloxdTextureIdCarvedPumpkincarved_pumpkin.pngCarved Pumpkin
bloxdTextureIdChalkchalk.pngChalk
bloxdTextureIdChalkBlackchalk_black.pngBlack Chalk, Black Chalk Slab, Black Chalk Stairs
bloxdTextureIdChalkBluechalk_blue.pngBlue Chalk, Blue Chalk Slab, Blue Chalk Stairs
bloxdTextureIdChalkBricksBlackchalk_bricks_black.pngBlack Chalk Bricks, Black Chalk Bricks Slab, Black Chalk Bricks Stairs
bloxdTextureIdChalkBricksBluechalk_bricks_blue.pngBlue Chalk Bricks, Blue Chalk Bricks Slab, Blue Chalk Bricks Stairs
bloxdTextureIdChalkBricksBrownchalk_bricks_brown.pngBrown Chalk Bricks, Brown Chalk Bricks Slab, Brown Chalk Bricks Stairs
bloxdTextureIdChalkBricksCyanchalk_bricks_cyan.pngCyan Chalk Bricks, Cyan Chalk Bricks Slab, Cyan Chalk Bricks Stairs
bloxdTextureIdChalkBricksGraychalk_bricks_gray.pngGray Chalk Bricks, Gray Chalk Bricks Slab, Gray Chalk Bricks Stairs
bloxdTextureIdChalkBricksGreenchalk_bricks_green.pngGreen Chalk Bricks, Green Chalk Bricks Slab, Green Chalk Bricks Stairs
bloxdTextureIdChalkBricksLightBluechalk_bricks_light_blue.pngLight Blue Chalk Bricks, Light Blue Chalk Bricks Slab, Light Blue Chalk Bricks Stairs
bloxdTextureIdChalkBricksLightGraychalk_bricks_light_gray.pngLight Gray Chalk Bricks, Light Gray Chalk Bricks Slab, Light Gray Chalk Bricks Stairs
bloxdTextureIdChalkBricksLimechalk_bricks_lime.pngLime Chalk Bricks, Lime Chalk Bricks Slab, Lime Chalk Bricks Stairs
bloxdTextureIdChalkBricksMagentachalk_bricks_magenta.pngMagenta Chalk Bricks, Magenta Chalk Bricks Slab, Magenta Chalk Bricks Stairs
bloxdTextureIdChalkBricksOrangechalk_bricks_orange.pngOrange Chalk Bricks, Orange Chalk Bricks Slab, Orange Chalk Bricks Stairs
bloxdTextureIdChalkBricksPinkchalk_bricks_pink.pngPink Chalk Bricks, Pink Chalk Bricks Slab, Pink Chalk Bricks Stairs
bloxdTextureIdChalkBricksPurplechalk_bricks_purple.pngPurple Chalk Bricks, Purple Chalk Bricks Slab, Purple Chalk Bricks Stairs
bloxdTextureIdChalkBricksRedchalk_bricks_red.pngRed Chalk Bricks, Red Chalk Bricks Slab, Red Chalk Bricks Stairs
bloxdTextureIdChalkBricksSlabSideBlackchalk_bricks_slab_side_black.pngBlack Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideBluechalk_bricks_slab_side_blue.pngBlue Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideBrownchalk_bricks_slab_side_brown.pngBrown Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideCyanchalk_bricks_slab_side_cyan.pngCyan Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideGraychalk_bricks_slab_side_gray.pngGray Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideGreenchalk_bricks_slab_side_green.pngGreen Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideLightBluechalk_bricks_slab_side_light_blue.pngLight Blue Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideLightGraychalk_bricks_slab_side_light_gray.pngLight Gray Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideLimechalk_bricks_slab_side_lime.pngLime Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideMagentachalk_bricks_slab_side_magenta.pngMagenta Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideOrangechalk_bricks_slab_side_orange.pngOrange Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSidePinkchalk_bricks_slab_side_pink.pngPink Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSidePurplechalk_bricks_slab_side_purple.pngPurple Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideRedchalk_bricks_slab_side_red.pngRed Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideWhitechalk_bricks_slab_side_white.pngWhite Chalk Bricks Slab
bloxdTextureIdChalkBricksSlabSideYellowchalk_bricks_slab_side_yellow.pngYellow Chalk Bricks Slab
bloxdTextureIdChalkBricksWhitechalk_bricks_white.pngWhite Chalk Bricks, White Chalk Bricks Slab, White Chalk Bricks Stairs
bloxdTextureIdChalkBricksYellowchalk_bricks_yellow.pngYellow Chalk Bricks, Yellow Chalk Bricks Slab, Yellow Chalk Bricks Stairs
bloxdTextureIdChalkBrownchalk_brown.pngBrown Chalk, Brown Chalk Slab, Brown Chalk Stairs
bloxdTextureIdChalkCyanchalk_cyan.pngCyan Chalk, Cyan Chalk Slab, Cyan Chalk Stairs
bloxdTextureIdChalkGraychalk_gray.pngGray Chalk, Gray Chalk Slab, Gray Chalk Stairs
bloxdTextureIdChalkGreenchalk_green.pngGreen Chalk, Green Chalk Slab, Green Chalk Stairs
bloxdTextureIdChalkLightBluechalk_light_blue.pngLight Blue Chalk, Light Blue Chalk Slab, Light Blue Chalk Stairs
bloxdTextureIdChalkLightGraychalk_light_gray.pngLight Gray Chalk, Light Gray Chalk Slab, Light Gray Chalk Stairs
bloxdTextureIdChalkLimechalk_lime.pngLime Chalk, Lime Chalk Slab, Lime Chalk Stairs
bloxdTextureIdChalkMagentachalk_magenta.pngMagenta Chalk, Magenta Chalk Slab, Magenta Chalk Stairs
bloxdTextureIdChalkOrangechalk_orange.pngOrange Chalk, Orange Chalk Slab, Orange Chalk Stairs
bloxdTextureIdChalkPinkchalk_pink.pngPink Chalk, Pink Chalk Slab, Pink Chalk Stairs
bloxdTextureIdChalkPurplechalk_purple.pngPurple Chalk, Purple Chalk Slab, Purple Chalk Stairs
bloxdTextureIdChalkRedchalk_red.pngRed Chalk, Red Chalk Slab, Red Chalk Stairs
bloxdTextureIdChalkWhitechalk_white.pngWhite Chalk, White Chalk Slab, White Chalk Stairs
bloxdTextureIdChalkYellowchalk_yellow.pngYellow Chalk, Yellow Chalk Slab, Yellow Chalk Stairs
bloxdTextureIdChargeVaultSidecharge_vault_side.pngCharge Vault
bloxdTextureIdChargeVaultTopcharge_vault_top.pngCharge Vault
bloxdTextureIdChargingPadSidecharging_pad_side.pngCharging Pad
bloxdTextureIdChargingPadTopcharging_pad_top.pngCharging Pad
bloxdTextureIdCheckpointBlockcheckpoint_block.pngCheckpoint Block
bloxdTextureIdCherryBlockBottomcherry_block_bottom.pngCherry Block
bloxdTextureIdCherryBlockSidecherry_block_side.pngCherry Block
bloxdTextureIdCherryBlockTopcherry_block_top.pngCherry Block
bloxdTextureIdChestBackchest_back.pngChest, Loot Chest
bloxdTextureIdChestDoubleBackHichest_double_back_hi.pngChest
bloxdTextureIdChestDoubleBackLochest_double_back_lo.pngChest
bloxdTextureIdChestDoubleFrontHichest_double_front_hi.pngChest
bloxdTextureIdChestDoubleFrontLochest_double_front_lo.pngChest
bloxdTextureIdChestDoubleTop1Hichest_double_top_1_hi.pngChest
bloxdTextureIdChestDoubleTop1Lochest_double_top_1_lo.pngChest
bloxdTextureIdChestDoubleTop2Hichest_double_top_2_hi.pngChest
bloxdTextureIdChestDoubleTop2Lochest_double_top_2_lo.pngChest
bloxdTextureIdChestFrontchest_front.pngChest, Loot Chest
bloxdTextureIdChestSidechest_side.pngChest, Loot Chest
bloxdTextureIdChestTopchest_top.pngChest, Loot Chest
bloxdTextureIdChiliPepperBlockBottomchili_pepper_block_bottom.pngChili Pepper Block
bloxdTextureIdChiliPepperBlockSidechili_pepper_block_side.pngChili Pepper Block
bloxdTextureIdChiliPepperBlockTopchili_pepper_block_top.pngChili Pepper Block
bloxdTextureIdChiseledRedSandstonechiseled_red_sandstone.pngEngraved Red Sandstone, Engraved Red Sandstone Slab, Engraved Red Sandstone Stairs
bloxdTextureIdChiseledSandstonechiseled_sandstone.pngEngraved Sandstone, Engraved Sandstone Slab, Engraved Sandstone Stairs
bloxdTextureIdClayclay.pngClay
bloxdTextureIdCoalBlockcoal_block.pngBlock of Coal
bloxdTextureIdCoalDepositcoal_deposit.pngCoal Deposit
bloxdTextureIdCoalOrecoal_ore.pngCoal Ore
bloxdTextureIdCoarseDirtcoarse_dirt.pngMessy Dirt
bloxdTextureIdCoconutBlockBottomcoconut_block_bottom.pngCoconut Block
bloxdTextureIdCoconutBlockSidecoconut_block_side.pngCoconut Block
bloxdTextureIdCoconutBlockTopcoconut_block_top.pngCoconut Block
bloxdTextureIdCodeBlockcode_block.pngCode Block
bloxdTextureIdCometHeartcomet_heart.pngComet Heart
bloxdTextureIdCometOrecomet_ore.pngComet Ore
bloxdTextureIdCompressedMessyStonecompressed_messy_stone.pngCompressed Messy Stone
bloxdTextureIdConveyorBeltBottomconveyor_belt_bottom.pngBelt Drop, Belt Lift, Belt Loader, Belt Tunnel, Conveyor Belt, Fast Belt, Sorting Gate, Splitter
bloxdTextureIdConveyorBeltSlabSideconveyor_belt_slab_side.pngBelt Loader, Conveyor Belt
bloxdTextureIdConveyorBeltTopconveyor_belt_top.pngConveyor Belt
bloxdTextureIdConveyorBeltTurnLeftconveyor_belt_turn_left.pngConveyor Belt
bloxdTextureIdConveyorBeltTurnRightconveyor_belt_turn_right.pngConveyor Belt
bloxdTextureIdCopperDepositcopper_deposit.pngCopper Deposit
bloxdTextureIdCopperOrecopper_ore.pngCopper Ore
bloxdTextureIdCornBlockBottomcorn_block_bottom.pngCorn Block
bloxdTextureIdCornBlockSidecorn_block_side.pngCorn Block
bloxdTextureIdCornBlockTopcorn_block_top.pngCorn Block
bloxdTextureIdCraftingTableSidecrafting_table_side.pngWorkbench
bloxdTextureIdCraftingTableTopcrafting_table_top.pngAuto Crafter, Lunite Auto Crafter, Workbench
bloxdTextureIdCratecrate.pngCrate, Hollow Crate
bloxdTextureIdCropHarvesterBackcrop_harvester_back.pngCrop Harvester
bloxdTextureIdCropHarvesterBackRunningcrop_harvester_back_running0.png (0-3)Crop Harvester
bloxdTextureIdCropHarvesterFrontcrop_harvester_front.pngCrop Harvester
bloxdTextureIdCropHarvesterSidecrop_harvester_side.pngCrop Harvester
bloxdTextureIdCropHarvesterSideRunningcrop_harvester_side_running0.png (0-3)Crop Harvester
bloxdTextureIdCropHarvesterTopcrop_harvester_top.pngCrop Harvester
bloxdTextureIdCrusherBackcrusher_back.pngCrusher
bloxdTextureIdCrusherFrontcrusher_front.pngCrusher
bloxdTextureIdCrusherSidecrusher_side.pngCrusher
bloxdTextureIdCrusherSideRunningcrusher_side_running0.png (0-3)Crusher
bloxdTextureIdCrusherTopcrusher_top.pngCrusher
bloxdTextureIdCrystalBlockcrystal_block.pngCrystal Block
bloxdTextureIdCrystalVatBackcrystal_vat_back.pngCrystal Vat
bloxdTextureIdCrystalVatFrontcrystal_vat_front.pngCrystal Vat
bloxdTextureIdCrystalVatSidecrystal_vat_side.pngCrystal Vat
bloxdTextureIdCrystalVatSideRunningcrystal_vat_side_running0.png (0-3)Crystal Vat
bloxdTextureIdCrystalVatTopcrystal_vat_top.pngCrystal Vat
bloxdTextureIdCustomLobbyBlockSidecustom_lobby_block_side.pngCustom Lobby Block
bloxdTextureIdCustomLobbyBlockTopcustom_lobby_block_top.pngCustom Lobby Block
bloxdTextureIdCutRedSandstonecut_red_sandstone.pngMarked Red Sandstone, Marked Red Sandstone Slab, Marked Red Sandstone Stairs
bloxdTextureIdCutSandstonecut_sandstone.pngMarked Sandstone, Marked Sandstone Slab, Marked Sandstone Stairs
bloxdTextureIdCyanConcretecyan_concrete.pngCyan Concrete, Cyan Concrete Slab, Cyan Concrete Stairs
bloxdTextureIdCyanGenSpawnCoalcyan_gen_spawn_coal.pngGenerator Spawn Block (Cyan)
bloxdTextureIdCyanGenSpawnIroncyan_gen_spawn_iron.pngGenerator Spawn Block (Cyan)
bloxdTextureIdCyanGenSpawnTopcyan_gen_spawn_top.pngGenerator Spawn Block (Cyan)
bloxdTextureIdCyanGlazedTerracottacyan_glazed_terracotta.pngCyan Ceramic
bloxdTextureIdCyanPlankscyan_planks.pngCyan Planks
bloxdTextureIdCyanPortalcyan_portal0.png (0-3)Cyan Portal
bloxdTextureIdCyanSpawnBlockSidecyan_spawn_block_side.pngSpawn Block (Cyan)
bloxdTextureIdCyanSpawnBlockTopcyan_spawn_block_top.pngSpawn Block (Cyan)
bloxdTextureIdDarkGreenBricksdark_green_bricks.pngDark Green Bricks
bloxdTextureIdDarkstonedarkstone.pngDarkstone
bloxdTextureIdDarkstoneBricksdarkstone_bricks.pngDarkstone Bricks
bloxdTextureIdDarkstoneBricksCrackeddarkstone_bricks_cracked.pngCracked Darkstone Bricks
bloxdTextureIdDarkstoneBricksLavadarkstone_bricks_lava.pngMolten Darkstone Bricks
bloxdTextureIdDarkstoneEngraveddarkstone_engraved.pngEngraved Darkstone
bloxdTextureIdDarkstoneSmoothdarkstone_smooth.pngSmooth Darkstone
bloxdTextureIdDeepDrillBackdeep_drill_back.pngDeep Drill
bloxdTextureIdDeepDrillBottomdeep_drill_bottom.pngDeep Drill
bloxdTextureIdDeepDrillFrontdeep_drill_front.pngDeep Drill
bloxdTextureIdDeepDrillSidedeep_drill_side.pngDeep Drill
bloxdTextureIdDeepDrillSideRunningdeep_drill_side_running0.png (0-3)Deep Drill
bloxdTextureIdDeepDrillTopdeep_drill_top.pngDeep Drill
bloxdTextureIdDiamondBlockdiamond_block.pngBlock of Diamond
bloxdTextureIdDiamondGenSpawnSidediamond_gen_spawn_side.pngGenerator Spawn Block (Diamond)
bloxdTextureIdDiamondGenSpawnTopdiamond_gen_spawn_top.pngGenerator Spawn Block (Diamond)
bloxdTextureIdDiamondOrediamond_ore.pngDiamond Ore
bloxdTextureIdDioriteBrickdiorite_brick.pngDiorite Bricks, Diorite Bricks Slab, Diorite Bricks Stairs
bloxdTextureIdDirtdirt.pngDirt, Dirt Slab, Dry Grass Block, Grass Block, Jungle Grass Block, Pine Grass Block
bloxdTextureIdDropLocationBlockSidedrop_location_block_side.pngDrop Location Block
bloxdTextureIdDropLocationBlockTopdrop_location_block_top.pngDrop Location Block
bloxdTextureIdDropPaddrop_pad.pngDrop Pad
bloxdTextureIdDryGrassBlockdry_grass_block.pngDry Grass Block, Dry Grass Slab, Overgrown Dry Grass Block
bloxdTextureIdDryGrassBlockSidedry_grass_block_side.pngDry Grass Block
bloxdTextureIdElectricDrillBackelectric_drill_back.pngElectric Drill
bloxdTextureIdElectricDrillBottomelectric_drill_bottom.pngElectric Drill
bloxdTextureIdElectricDrillFrontelectric_drill_front.pngElectric Drill
bloxdTextureIdElectricDrillSideelectric_drill_side.pngElectric Drill
bloxdTextureIdElectricDrillSideRunningelectric_drill_side_running0.png (0-3)Electric Drill
bloxdTextureIdElectricDrillTopelectric_drill_top.pngElectric Drill
bloxdTextureIdEmeraldBlockemerald_block.pngBlock of Emerald
bloxdTextureIdEmeraldOreemerald_ore.pngEmerald Ore
bloxdTextureIdEndStoneend_stone.pngYellowstone
bloxdTextureIdEngravedAndesiteengraved_andesite.pngEngraved Andesite, Engraved Andesite Slab, Engraved Andesite Stairs
bloxdTextureIdEngravedDioriteengraved_diorite.pngEngraved Diorite, Engraved Diorite Slab, Engraved Diorite Stairs
bloxdTextureIdEngravedGraniteengraved_granite.pngEngraved Granite, Engraved Granite Slab, Engraved Granite Stairs
bloxdTextureIdEvilLuckyBlockevil_lucky_block.pngEvil Lucky Block
bloxdTextureIdEvilLuckyBlockFaceevil_lucky_block_face.pngEvil Lucky Block
bloxdTextureIdExplosivePaintBlackSideexplosive_paint_black_side.pngBlack Paintball Explosive
bloxdTextureIdExplosivePaintBlackTopexplosive_paint_black_top.pngBlack Paintball Explosive
bloxdTextureIdExplosivePaintBlueSideexplosive_paint_blue_side.pngBlue Paintball Explosive
bloxdTextureIdExplosivePaintBlueTopexplosive_paint_blue_top.pngBlue Paintball Explosive, Goal Block (Blue)
bloxdTextureIdExplosivePaintBrownSideexplosive_paint_brown_side.pngBrown Paintball Explosive
bloxdTextureIdExplosivePaintBrownTopexplosive_paint_brown_top.pngBrown Paintball Explosive
bloxdTextureIdExplosivePaintCyanSideexplosive_paint_cyan_side.pngCyan Paintball Explosive
bloxdTextureIdExplosivePaintCyanTopexplosive_paint_cyan_top.pngCyan Paintball Explosive
bloxdTextureIdExplosivePaintGraySideexplosive_paint_gray_side.pngGray Paintball Explosive
bloxdTextureIdExplosivePaintGrayTopexplosive_paint_gray_top.pngGray Paintball Explosive
bloxdTextureIdExplosivePaintGreenSideexplosive_paint_green_side.pngGreen Paintball Explosive
bloxdTextureIdExplosivePaintGreenTopexplosive_paint_green_top.pngGreen Paintball Explosive
bloxdTextureIdExplosivePaintLightBlueSideexplosive_paint_light_blue_side.pngLight Blue Paintball Explosive
bloxdTextureIdExplosivePaintLightBlueTopexplosive_paint_light_blue_top.pngLight Blue Paintball Explosive
bloxdTextureIdExplosivePaintLightGraySideexplosive_paint_light_gray_side.pngLight Gray Paintball Explosive
bloxdTextureIdExplosivePaintLightGrayTopexplosive_paint_light_gray_top.pngLight Gray Paintball Explosive
bloxdTextureIdExplosivePaintLimeSideexplosive_paint_lime_side.pngLime Paintball Explosive
bloxdTextureIdExplosivePaintLimeTopexplosive_paint_lime_top.pngLime Paintball Explosive
bloxdTextureIdExplosivePaintMagentaSideexplosive_paint_magenta_side.pngMagenta Paintball Explosive
bloxdTextureIdExplosivePaintMagentaTopexplosive_paint_magenta_top.pngMagenta Paintball Explosive
bloxdTextureIdExplosivePaintOrangeSideexplosive_paint_orange_side.pngOrange Paintball Explosive
bloxdTextureIdExplosivePaintOrangeTopexplosive_paint_orange_top.pngOrange Paintball Explosive
bloxdTextureIdExplosivePaintPinkSideexplosive_paint_pink_side.pngPink Paintball Explosive
bloxdTextureIdExplosivePaintPinkTopexplosive_paint_pink_top.pngPink Paintball Explosive
bloxdTextureIdExplosivePaintPurpleSideexplosive_paint_purple_side.pngPurple Paintball Explosive
bloxdTextureIdExplosivePaintPurpleTopexplosive_paint_purple_top.pngPurple Paintball Explosive
bloxdTextureIdExplosivePaintQuickBlackexplosive_paint_quick_black.pngBlack Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickBlueexplosive_paint_quick_blue.pngBlue Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickBrownexplosive_paint_quick_brown.pngBrown Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickCyanexplosive_paint_quick_cyan.pngCyan Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickGrayexplosive_paint_quick_gray.pngGray Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickGreenexplosive_paint_quick_green.pngGreen Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickLightBlueexplosive_paint_quick_light_blue.pngLight Blue Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickLightGrayexplosive_paint_quick_light_gray.pngLight Gray Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickLimeexplosive_paint_quick_lime.pngLime Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickMagentaexplosive_paint_quick_magenta.pngMagenta Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickOrangeexplosive_paint_quick_orange.pngOrange Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickPinkexplosive_paint_quick_pink.pngPink Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickPurpleexplosive_paint_quick_purple.pngPurple Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickRedexplosive_paint_quick_red.pngRed Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickWhiteexplosive_paint_quick_white.pngWhite Quick Paintball Explosive
bloxdTextureIdExplosivePaintQuickYellowexplosive_paint_quick_yellow.pngYellow Quick Paintball Explosive
bloxdTextureIdExplosivePaintRedSideexplosive_paint_red_side.pngRed Paintball Explosive
bloxdTextureIdExplosivePaintRedTopexplosive_paint_red_top.pngGoal Block (Red), Red Paintball Explosive
bloxdTextureIdExplosivePaintSeekingBlackexplosive_paint_seeking_black.pngBlack Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingBlueexplosive_paint_seeking_blue.pngBlue Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingBrownexplosive_paint_seeking_brown.pngBrown Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingCyanexplosive_paint_seeking_cyan.pngCyan Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingGrayexplosive_paint_seeking_gray.pngGray Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingGreenexplosive_paint_seeking_green.pngGreen Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingLightBlueexplosive_paint_seeking_light_blue.pngLight Blue Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingLightGrayexplosive_paint_seeking_light_gray.pngLight Gray Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingLimeexplosive_paint_seeking_lime.pngLime Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingMagentaexplosive_paint_seeking_magenta.pngMagenta Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingOrangeexplosive_paint_seeking_orange.pngOrange Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingPinkexplosive_paint_seeking_pink.pngPink Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingPurpleexplosive_paint_seeking_purple.pngPurple Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingRedexplosive_paint_seeking_red.pngRed Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingWhiteexplosive_paint_seeking_white.pngWhite Seeking Paintball Explosive
bloxdTextureIdExplosivePaintSeekingYellowexplosive_paint_seeking_yellow.pngYellow Seeking Paintball Explosive
bloxdTextureIdExplosivePaintStickyBlackexplosive_paint_sticky_black.pngBlack Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyBlueexplosive_paint_sticky_blue.pngBlue Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyBrownexplosive_paint_sticky_brown.pngBrown Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyCyanexplosive_paint_sticky_cyan.pngCyan Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyGrayexplosive_paint_sticky_gray.pngGray Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyGreenexplosive_paint_sticky_green.pngGreen Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyLightBlueexplosive_paint_sticky_light_blue.pngLight Blue Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyLightGrayexplosive_paint_sticky_light_gray.pngLight Gray Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyLimeexplosive_paint_sticky_lime.pngLime Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyMagentaexplosive_paint_sticky_magenta.pngMagenta Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyOrangeexplosive_paint_sticky_orange.pngOrange Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyPinkexplosive_paint_sticky_pink.pngPink Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyPurpleexplosive_paint_sticky_purple.pngPurple Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyRedexplosive_paint_sticky_red.pngRed Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyWhiteexplosive_paint_sticky_white.pngWhite Sticky Paintball Explosive
bloxdTextureIdExplosivePaintStickyYellowexplosive_paint_sticky_yellow.pngYellow Sticky Paintball Explosive
bloxdTextureIdExplosivePaintWhiteSideexplosive_paint_white_side.pngWhite Paintball Explosive
bloxdTextureIdExplosivePaintWhiteTopexplosive_paint_white_top.pngWhite Paintball Explosive
bloxdTextureIdExplosivePaintYellowSideexplosive_paint_yellow_side.pngYellow Paintball Explosive
bloxdTextureIdExplosivePaintYellowTopexplosive_paint_yellow_top.pngYellow Paintball Explosive
bloxdTextureIdExtraCompressedMessyStoneextra_compressed_messy_stone.pngExtra Compressed Messy Stone
bloxdTextureIdFallenCherryLeavesSidefallen_cherry_leaves_side.pngFallen Cherry Leaves
bloxdTextureIdFallenMapleLeavesSidefallen_maple_leaves_side.pngFallen Maple Leaves
bloxdTextureIdFarmlandfarmland.pngTilled Soil
bloxdTextureIdFastBeltSlabSidefast_belt_slab_side.pngFast Belt
bloxdTextureIdFastBeltTopfast_belt_top.pngFast Belt
bloxdTextureIdFastBeltTurnLeftfast_belt_turn_left.pngFast Belt
bloxdTextureIdFastBeltTurnRightfast_belt_turn_right.pngFast Belt
bloxdTextureIdFertilisedSoilfertilised_soil.pngFertilised Soil
bloxdTextureIdFinishBlockfinish_block.pngFinish Block
bloxdTextureIdFireballBlockfireball_block.pngFireball Block
bloxdTextureIdFoodLuckyBlockfood_lucky_block.pngFood Lucky Block
bloxdTextureIdFoodLuckyBlockRarefood_lucky_block_rare.pngRare Food Lucky Block
bloxdTextureIdFoodLuckyBlockSuperfood_lucky_block_super.pngSuper Food Lucky Block
bloxdTextureIdForgeHopperTopforge_hopper_top.pngForge Hopper
bloxdTextureIdFurnaceFrontfurnace_front.pngFurnace
bloxdTextureIdFurnaceSidefurnace_side.pngFurnace
bloxdTextureIdFurnaceTopfurnace_top.pngFurnace
bloxdTextureIdGeneratorSidegenerator_side.pngGenerator
bloxdTextureIdGeneratorSideRunninggenerator_side_running0.png (0-3)Generator
bloxdTextureIdGeneratorTopgenerator_top.pngGenerator
bloxdTextureIdGhostChestBackghost_chest_back.pngGhost Chest
bloxdTextureIdGhostChestFrontghost_chest_front.pngGhost Chest
bloxdTextureIdGhostChestSideghost_chest_side.pngGhost Chest
bloxdTextureIdGhostChestTopghost_chest_top.pngGhost Chest
bloxdTextureIdGhostLuckyBlockghost_lucky_block.pngGhost Lucky Block
bloxdTextureIdGhostMysteryBlockghost_mystery_block.pngGhost Mystery Block
bloxdTextureIdGlassglass.pngGlass
bloxdTextureIdGlassBlackglass_black.pngBlack Glass
bloxdTextureIdGlassBlueglass_blue.pngBlue Glass
bloxdTextureIdGlassBrownglass_brown.pngBrown Glass
bloxdTextureIdGlassCyanglass_cyan.pngCyan Glass
bloxdTextureIdGlassGrayglass_gray.pngGray Glass
bloxdTextureIdGlassGreenglass_green.pngGreen Glass
bloxdTextureIdGlassLightBlueglass_light_blue.pngLight Blue Glass
bloxdTextureIdGlassLightGrayglass_light_gray.pngLight Gray Glass
bloxdTextureIdGlassLimeglass_lime.pngLime Glass
bloxdTextureIdGlassMagentaglass_magenta.pngMagenta Glass
bloxdTextureIdGlassOrangeglass_orange.pngOrange Glass
bloxdTextureIdGlassPinkglass_pink.pngPink Glass
bloxdTextureIdGlassPurpleglass_purple.pngPurple Glass
bloxdTextureIdGlassRedglass_red.pngRed Glass
bloxdTextureIdGlassSilverglass_silver.pngNot listed
bloxdTextureIdGlassWhiteglass_white.pngWhite Glass
bloxdTextureIdGlassYellowglass_yellow.pngYellow Glass
bloxdTextureIdGlowstoneglowstone.pngGolden Decoration
bloxdTextureIdGoldBlockgold_block.pngBlock of Gold
bloxdTextureIdGoldDepositgold_deposit.pngGold Deposit
bloxdTextureIdGoldOregold_ore.pngGold Ore
bloxdTextureIdGraniteBrickgranite_brick.pngGranite Bricks, Granite Bricks Slab, Granite Bricks Stairs
bloxdTextureIdGrassBlockSidegrass_block_side.pngGrass Block
bloxdTextureIdGrassTopgrass_top.pngGrass Block, Grass Slab, Overgrown Grass Block
bloxdTextureIdGravelgravel.pngGravel
bloxdTextureIdGrayConcretegray_concrete.pngGray Concrete, Gray Concrete Slab, Gray Concrete Stairs
bloxdTextureIdGrayGenSpawnCoalgray_gen_spawn_coal.pngGenerator Spawn Block (Gray)
bloxdTextureIdGrayGenSpawnIrongray_gen_spawn_iron.pngGenerator Spawn Block (Gray)
bloxdTextureIdGrayGenSpawnTopgray_gen_spawn_top.pngGenerator Spawn Block (Gray)
bloxdTextureIdGrayGlazedTerracottagray_glazed_terracotta.pngGray Ceramic
bloxdTextureIdGrayPlanksgray_planks.pngGray Planks
bloxdTextureIdGrayPortalgray_portal0.png (0-3)Gray Portal
bloxdTextureIdGraySpawnBlockSidegray_spawn_block_side.pngSpawn Block (Gray)
bloxdTextureIdGraySpawnBlockTopgray_spawn_block_top.pngSpawn Block (Gray)
bloxdTextureIdGreenBricksgreen_bricks.pngGreen Bricks
bloxdTextureIdGreenConcretegreen_concrete.pngGreen Concrete, Green Concrete Slab, Green Concrete Stairs
bloxdTextureIdGreenGlazedTerracottagreen_glazed_terracotta.pngGreen Ceramic
bloxdTextureIdGreenLuckyBlockgreen_lucky_block.pngFood Lucky Block
bloxdTextureIdGreenLuckyBlockRaregreen_lucky_block_rare.pngRare Food Lucky Block
bloxdTextureIdGreenLuckyBlockSupergreen_lucky_block_super.pngSuper Food Lucky Block
bloxdTextureIdGreenPlanksgreen_planks.pngGreen Planks
bloxdTextureIdGreenPortalgreen_portal0.png (0-3)Green Portal
bloxdTextureIdGreenSpawnBlockSidegreen_spawn_block_side.pngSpawn Block (Green)
bloxdTextureIdGreenSpawnBlockTopgreen_spawn_block_top.pngSpawn Block (Green)
bloxdTextureIdGreenStonegreen_stone.pngGreen Stone
bloxdTextureIdGrenadeBlockgrenade_block.pngGrenade
bloxdTextureIdGreyPortalgrey_portal0.png (0-3)Grey Portal
bloxdTextureIdGunLuckyBlockgun_lucky_block.pngGun Lucky Block
bloxdTextureIdHardenedClayhardened_clay.pngBaked Clay
bloxdTextureIdHardenedClayStainedBlackhardened_clay_stained_black.pngBlack Baked Clay
bloxdTextureIdHardenedClayStainedBluehardened_clay_stained_blue.pngBlue Baked Clay
bloxdTextureIdHardenedClayStainedBrownhardened_clay_stained_brown.pngBrown Baked Clay
bloxdTextureIdHardenedClayStainedCyanhardened_clay_stained_cyan.pngCyan Baked Clay
bloxdTextureIdHardenedClayStainedGrayhardened_clay_stained_gray.pngGray Baked Clay
bloxdTextureIdHardenedClayStainedGreenhardened_clay_stained_green.pngGreen Baked Clay
bloxdTextureIdHardenedClayStainedLightBluehardened_clay_stained_light_blue.pngLight Blue Baked Clay
bloxdTextureIdHardenedClayStainedLimehardened_clay_stained_lime.pngLime Baked Clay
bloxdTextureIdHardenedClayStainedMagentahardened_clay_stained_magenta.pngMagenta Baked Clay
bloxdTextureIdHardenedClayStainedOrangehardened_clay_stained_orange.pngOrange Baked Clay
bloxdTextureIdHardenedClayStainedPinkhardened_clay_stained_pink.pngPink Baked Clay
bloxdTextureIdHardenedClayStainedPurplehardened_clay_stained_purple.pngPurple Baked Clay
bloxdTextureIdHardenedClayStainedRedhardened_clay_stained_red.pngRed Baked Clay
bloxdTextureIdHardenedClayStainedSilverhardened_clay_stained_silver.pngLight Gray Baked Clay
bloxdTextureIdHardenedClayStainedWhitehardened_clay_stained_white.pngWhite Baked Clay
bloxdTextureIdHardenedClayStainedYellowhardened_clay_stained_yellow.pngYellow Baked Clay
bloxdTextureIdHarvesterBottomharvester_bottom.pngAuto Harvester
bloxdTextureIdHarvesterLuniteBottomharvester_lunite_bottom.pngLunite Auto Harvester
bloxdTextureIdHarvesterLuniteSide0harvester_lunite_side_0.pngLunite Auto Harvester
bloxdTextureIdHarvesterLuniteSide1harvester_lunite_side_1.pngLunite Auto Harvester
bloxdTextureIdHarvesterLuniteTopharvester_lunite_top.pngLunite Auto Harvester
bloxdTextureIdHarvesterSide0harvester_side0.pngAuto Harvester
bloxdTextureIdHarvesterSide1harvester_side1.pngAuto Harvester
bloxdTextureIdHarvesterTopharvester_top.pngAuto Harvester
bloxdTextureIdHayBlockSidehay_block_side.pngHay Bale
bloxdTextureIdHomesteadCorehomestead_core.pngHomestead Core
bloxdTextureIdHomesteadCoreCaphomestead_core_cap.png_Homestead Core Top
bloxdTextureIdHomesteadCoreCrownhomestead_core_crown.png_Homestead Core Top
bloxdTextureIdHomesteadCoreMidhomestead_core_mid0.png (0-3)_Homestead Core Mid
bloxdTextureIdHyperCompressedMessyStonehyper_compressed_messy_stone.pngHyper Compressed Messy Stone
bloxdTextureIdIceice.pngIce, Melting Ice
bloxdTextureIdIceBrickice_brick.pngIce Bricks, Ice Bricks Slab, Ice Bricks Stairs
bloxdTextureIdIceballBlockiceball_block.pngIceball Block
bloxdTextureIdInvisibleSolidinvisible_solid.pngInvisible Black Light, Invisible Blue Light, Invisible Brown Light, Invisible Cyan Light, Invisible Gray Light, Invisible Green Light, Invisible Light Blue Light, Invisible Light Gray Light, Invisible Lime Light, Invisible Magenta Light, Invisible Orange Light, Invisible Pink Light, Invisible Purple Light, Invisible Red Light, Invisible Sky Light, Invisible Solid, Invisible White Light, Invisible Yellow Light
bloxdTextureIdIronBlockiron_block.pngBlock of Iron
bloxdTextureIdIronChestBackiron_chest_back.pngIron Chest
bloxdTextureIdIronChestFrontiron_chest_front.pngIron Chest
bloxdTextureIdIronChestSideiron_chest_side.pngIron Chest
bloxdTextureIdIronChestTopiron_chest_top.pngIron Chest
bloxdTextureIdIronDepositiron_deposit.pngIron Deposit
bloxdTextureIdIronOreiron_ore.pngIron Ore
bloxdTextureIdIronWatermelonSideiron_watermelon_side.pngIron Watermelon
bloxdTextureIdIronWatermelonTopiron_watermelon_top.pngIron Watermelon
bloxdTextureIdJungleGrassBlockjungle_grass_block.pngJungle Grass Block, Jungle Grass Slab, Overgrown Jungle Grass Block
bloxdTextureIdJungleGrassBlockSidejungle_grass_block_side.pngJungle Grass Block
bloxdTextureIdLapisBlocklapis_block.pngBlock of Lapis Lazuli
bloxdTextureIdLapisOrelapis_ore.pngLapis Lazuli Ore
bloxdTextureIdLavalava0.png (0-7)Lava
bloxdTextureIdLeatherBlockSideleather_block_side.pngLeather Block
bloxdTextureIdLeatherBlockTopleather_block_top.pngLeather Block
bloxdTextureIdLeavesAspenleaves_aspen.pngAspen Leaves
bloxdTextureIdLeavesAspenAutumnleaves_aspen_autumn.pngAutumn Aspen Leaves
bloxdTextureIdLeavesCedarleaves_cedar.pngCedar Leaves
bloxdTextureIdLeavesCherryleaves_cherry.pngCherry Leaves, Fallen Cherry Leaves
bloxdTextureIdLeavesCherryFruityleaves_cherry_fruity.pngFruity Cherry Leaves
bloxdTextureIdLeavesJungleleaves_jungle.pngJungle Leaves
bloxdTextureIdLeavesMangoleaves_mango.pngMango Leaves
bloxdTextureIdLeavesMangoFruityleaves_mango_fruity.pngFruity Mango Leaves
bloxdTextureIdLeavesMapleleaves_maple.pngMaple Leaves
bloxdTextureIdLeavesMapleAutumnleaves_maple_autumn.pngAutumn Maple Leaves, Fallen Maple Leaves
bloxdTextureIdLeavesMapleFruityleaves_maple_fruity.pngFruity Maple Leaves
bloxdTextureIdLeavesPalmleaves_palm.pngPalm Leaves
bloxdTextureIdLeavesPalmFruityleaves_palm_fruity.pngFruity Palm Leaves
bloxdTextureIdLeavesPearleaves_pear.pngPear Leaves
bloxdTextureIdLeavesPearFruityleaves_pear_fruity.pngFruity Pear Leaves
bloxdTextureIdLeavesPineleaves_pine.pngPine Leaves
bloxdTextureIdLeavesPineConeleaves_pine_cone.pngPine Cone Leaves
bloxdTextureIdLeavesPlumleaves_plum.pngPlum Leaves
bloxdTextureIdLeavesPlumFruityleaves_plum_fruity.pngFruity Plum Leaves
bloxdTextureIdLeavesSpectralleaves_spectral.pngSpectral Leaves
bloxdTextureIdLightBlueConcretelight_blue_concrete.pngLight Blue Concrete, Light Blue Concrete Slab, Light Blue Concrete Stairs
bloxdTextureIdLightBlueGlazedTerracottalight_blue_glazed_terracotta.pngLight Blue Ceramic
bloxdTextureIdLightBlueLuckyBlocklight_blue_lucky_block.pngUltra Lucky Block
bloxdTextureIdLightBluePlankslight_blue_planks.pngLight Blue Planks
bloxdTextureIdLightBlueSpawnBlockSidelight_blue_spawn_block_side.pngSpawn Block (Light Blue)
bloxdTextureIdLightBlueSpawnBlockToplight_blue_spawn_block_top.pngSpawn Block (Light Blue)
bloxdTextureIdLightGrayConcretelight_gray_concrete.pngLight Gray Concrete, Light Gray Concrete Slab, Light Gray Concrete Stairs
bloxdTextureIdLightGrayGlazedTerracottalight_gray_glazed_terracotta.pngLight Gray Ceramic
bloxdTextureIdLightGrayPlankslight_gray_planks.pngLight Gray Planks
bloxdTextureIdLightGraySpawnBlockSidelight_gray_spawn_block_side.pngSpawn Block (Light Gray)
bloxdTextureIdLightGraySpawnBlockToplight_gray_spawn_block_top.pngSpawn Block (Light Gray)
bloxdTextureIdLightbluePortallightblue_portal0.png (0-3)Light Blue Portal
bloxdTextureIdLightgrayPortallightgray_portal0.png (0-3)Light Gray Portal
bloxdTextureIdLimeConcretelime_concrete.pngLime Concrete, Lime Concrete Slab, Lime Concrete Stairs
bloxdTextureIdLimeGenSpawnCoallime_gen_spawn_coal.pngGenerator Spawn Block (Lime)
bloxdTextureIdLimeGenSpawnIronlime_gen_spawn_iron.pngGenerator Spawn Block (Lime)
bloxdTextureIdLimeGenSpawnToplime_gen_spawn_top.pngGenerator Spawn Block (Lime)
bloxdTextureIdLimeGlazedTerracottalime_glazed_terracotta.pngLime Ceramic
bloxdTextureIdLimePlankslime_planks.pngLime Planks
bloxdTextureIdLimePortallime_portal0.png (0-3)Lime Portal
bloxdTextureIdLimeSpawnBlockSidelime_spawn_block_side.pngSpawn Block (Lime)
bloxdTextureIdLimeSpawnBlockToplime_spawn_block_top.pngSpawn Block (Lime)
bloxdTextureIdLogAncientMaplelog_ancient_maple.pngAncient Maple Log
bloxdTextureIdLogAspenlog_aspen.pngAspen Log
bloxdTextureIdLogCedarlog_cedar.pngCedar Log
bloxdTextureIdLogCherrylog_cherry.pngCherry Log
bloxdTextureIdLogJunglelog_jungle.pngJungle Log
bloxdTextureIdLogMangolog_mango.pngMango Log
bloxdTextureIdLogMaplelog_maple.pngMaple Log
bloxdTextureIdLogPalmlog_palm.pngPalm Log
bloxdTextureIdLogPearlog_pear.pngPear Log
bloxdTextureIdLogPinelog_pine.pngPine Log
bloxdTextureIdLogPlumlog_plum.pngPlum Log
bloxdTextureIdLogSpectrallog_spectral.pngSpectral Log
bloxdTextureIdLuckyBlockPinkQuestionlucky_block_pink_question.pngPet Lucky Block, Potion Lucky Block
bloxdTextureIdLuckyBlockPinkQuestionRarelucky_block_pink_question_rare.pngRare Potion Lucky Block
bloxdTextureIdLuckyBlockPinkQuestionSuperlucky_block_pink_question_super.pngSuper Potion Lucky Block
bloxdTextureIdLuniteBlocklunite_block.pngBlock of Lunite
bloxdTextureIdLuniteOrelunite_ore.pngLunite Ore
bloxdTextureIdMachineBenchSidemachine_bench_side.pngMachine Bench
bloxdTextureIdMachineBenchTopmachine_bench_top.pngMachine Bench
bloxdTextureIdMachineSidemachine_side.pngAlloy Kiln, Assembler, Crop Harvester, Crusher, Crystal Vat, Drop Pad, Forge Hopper, Generator, Press, Recycler, Shatter Mill, Smelter, Tree Cutter, Volt Engine, Wire Mill
bloxdTextureIdMagentaConcretemagenta_concrete.pngMagenta Concrete, Magenta Concrete Slab, Magenta Concrete Stairs
bloxdTextureIdMagentaGlazedTerracottamagenta_glazed_terracotta.pngMagenta Ceramic
bloxdTextureIdMagentaPlanksmagenta_planks.pngMagenta Planks
bloxdTextureIdMagentaPortalmagenta_portal0.png (0-3)Magenta Portal
bloxdTextureIdMagentaSpawnBlockSidemagenta_spawn_block_side.pngSpawn Block (Magenta)
bloxdTextureIdMagentaSpawnBlockTopmagenta_spawn_block_top.pngSpawn Block (Magenta)
bloxdTextureIdMagmamagma.pngMagma
bloxdTextureIdMailboxFrontmailbox_front.pngMailbox
bloxdTextureIdMailboxFrontFullmailbox_front_full.pngMailbox
bloxdTextureIdMailboxSidemailbox_side.pngMailbox
bloxdTextureIdMangoBlockBottommango_block_bottom.pngMango Block
bloxdTextureIdMangoBlockSidemango_block_side.pngMango Block
bloxdTextureIdMangoBlockTopmango_block_top.pngMango Block
bloxdTextureIdMegaCompressedMessyStonemega_compressed_messy_stone.pngMega Compressed Messy Stone
bloxdTextureIdMelonSidemelon_side.pngMelon
bloxdTextureIdMelonTopmelon_top.pngMelon
bloxdTextureIdMeltingIcemelting_ice.pngMelting Ice
bloxdTextureIdMessyStonemessy_stone.pngMessy Stone, Messy Stone Slab, Messy Stone Stairs
bloxdTextureIdMobSpawnerBlockEmptySidemob_spawner_block_empty_side.pngEmpty Spawner Block
bloxdTextureIdMobSpawnerBlockTopmob_spawner_block_top.pngBear Spawner Block, Camel Spawner Block, Cave Golem Spawner Block, Cow Spawner Block, Crone Spawner Block, Deer Spawner Block, Diamond Goofy Golem Spawner Block, Diamond Guardian Spawner Block, Draugr Huntress Spawner Block, Draugr Knight Spawner Block, Draugr Reaver Spawner Block, Draugr Skeleton Spawner Block, Draugr Warper Spawner Block, Draugr Zombie Spawner Block, Empty Spawner Block, Frost Golem Spawner Block, Frost Skeleton Spawner Block, Frost Wraith Spawner Block, Frost Zombie Spawner Block, Gold Goofy Golem Spawner Block, Gold Guardian Spawner Block, Gold Watermelon Stag Spawner Block, Gorilla Spawner Block, Horse Spawner Block, Iron Goofy Golem Spawner Block, Iron Guardian Spawner Block, Magma Golem Spawner Block, Moonstone Goofy Golem Spawner Block, Moonstone Guardian Spawner Block, Pig Spawner Block, Sheep Spawner Block, Slime Spawner Block, Spirit Bear Spawner Block, Spirit Golem Spawner Block, Spirit Gorilla Spawner Block, Spirit Stag Spawner Block, Spirit Wolf Spawner Block, Stag Spawner Block, Stalker Spawner Block, Tiki Terror Spawner Block, Wildcat Spawner Block, Wolf Spawner Block
bloxdTextureIdMobSpawnerHostileBlockSidemob_spawner_hostile_block_side.pngBear Spawner Block, Cave Golem Spawner Block, Crone Spawner Block, Diamond Guardian Spawner Block, Draugr Huntress Spawner Block, Draugr Knight Spawner Block, Draugr Reaver Spawner Block, Draugr Skeleton Spawner Block, Draugr Warper Spawner Block, Draugr Zombie Spawner Block, Frost Golem Spawner Block, Frost Skeleton Spawner Block, Frost Wraith Spawner Block, Frost Zombie Spawner Block, Gold Guardian Spawner Block, Gold Watermelon Stag Spawner Block, Gorilla Spawner Block, Iron Guardian Spawner Block, Magma Golem Spawner Block, Moonstone Guardian Spawner Block, Stag Spawner Block, Stalker Spawner Block, Tiki Terror Spawner Block
bloxdTextureIdMobSpawnerNeutralBlockSidemob_spawner_neutral_block_side.pngSlime Spawner Block, Spirit Bear Spawner Block, Spirit Golem Spawner Block, Spirit Gorilla Spawner Block, Spirit Stag Spawner Block, Spirit Wolf Spawner Block, Wildcat Spawner Block, Wolf Spawner Block
bloxdTextureIdMobSpawnerPassiveBlockSidemob_spawner_passive_block_side.pngCamel Spawner Block, Cow Spawner Block, Deer Spawner Block, Diamond Goofy Golem Spawner Block, Gold Goofy Golem Spawner Block, Horse Spawner Block, Iron Goofy Golem Spawner Block, Moonstone Goofy Golem Spawner Block, Pig Spawner Block, Sheep Spawner Block
bloxdTextureIdMoonstoneBlockmoonstone_block.pngBlock of Moonstone
bloxdTextureIdMoonstoneChestBackmoonstone_chest_back.pngMoonstone Chest
bloxdTextureIdMoonstoneChestFrontmoonstone_chest_front.pngMoonstone Chest
bloxdTextureIdMoonstoneChestSidemoonstone_chest_side.pngMoonstone Chest
bloxdTextureIdMoonstoneChestTopmoonstone_chest_top.pngMoonstone Chest
bloxdTextureIdMoonstoneExplosiveSidemoonstone_explosive_side.pngMoonstone Explosive
bloxdTextureIdMoonstoneExplosiveTopmoonstone_explosive_top.pngMoonstone Explosive
bloxdTextureIdMoonstoneGenSpawnSidemoonstone_gen_spawn_side.pngGenerator Spawn Block (Moonstone)
bloxdTextureIdMoonstoneGenSpawnTopmoonstone_gen_spawn_top.pngGenerator Spawn Block (Moonstone)
bloxdTextureIdMoonstoneOremoonstone_ore.pngMoonstone Ore
bloxdTextureIdMossyCobblestonemossy_cobblestone.pngMossy Messy Stone, Mossy Stone Slab, Mossy Stone Stairs
bloxdTextureIdMushroomStemmushroom_stem.pngMushroom Stem
bloxdTextureIdMysteryBlockmystery_block.pngMystery Block
bloxdTextureIdNeonBlackneon_black.pngBlack Neon
bloxdTextureIdNeonBlueneon_blue.pngBlue Neon
bloxdTextureIdNeonBrownneon_brown.pngBrown Neon
bloxdTextureIdNeonCyanneon_cyan.pngCyan Neon
bloxdTextureIdNeonGrayneon_gray.pngGray Neon
bloxdTextureIdNeonGreenneon_green.pngGreen Neon
bloxdTextureIdNeonLightBlueneon_light_blue.pngLight Blue Neon
bloxdTextureIdNeonLightGrayneon_light_gray.pngLight Gray Neon
bloxdTextureIdNeonLimeneon_lime.pngLime Neon
bloxdTextureIdNeonMagentaneon_magenta.pngMagenta Neon
bloxdTextureIdNeonOrangeneon_orange.pngOrange Neon
bloxdTextureIdNeonPinkneon_pink.pngPink Neon
bloxdTextureIdNeonPurpleneon_purple.pngPurple Neon
bloxdTextureIdNeonRedneon_red.pngRed Neon
bloxdTextureIdNeonWhiteneon_white.pngWhite Neon
bloxdTextureIdNeonYellowneon_yellow.pngYellow Neon
bloxdTextureIdNetherBricknether_brick.pngDark Red Brick
bloxdTextureIdNetherracknetherrack.pngDark Red Stone
bloxdTextureIdObbyAbsorbBlockobby_absorb_block.pngObby Absorb Block
bloxdTextureIdObbyAbsorbDeathBlockobby_absorb_death_block.pngObby Absorb Death Block
bloxdTextureIdObbyDeathBlockobby_death_block.pngObby Death Block
bloxdTextureIdObsidianobsidian.pngObsidian
bloxdTextureIdOrangeConcreteorange_concrete.pngOrange Concrete, Orange Concrete Slab, Orange Concrete Stairs
bloxdTextureIdOrangeGlazedTerracottaorange_glazed_terracotta.pngOrange Ceramic
bloxdTextureIdOrangeLuckyBlockorange_lucky_block.pngTools Lucky Block
bloxdTextureIdOrangeLuckyBlockRareorange_lucky_block_rare.pngRare Tools Lucky Block
bloxdTextureIdOrangeLuckyBlockSuperorange_lucky_block_super.pngSuper Tools Lucky Block
bloxdTextureIdOrangePlanksorange_planks.pngOrange Planks
bloxdTextureIdOrangePortalorange_portal0.png (0-3)Orange Portal
bloxdTextureIdOrangeSpawnBlockSideorange_spawn_block_side.pngSpawn Block (Orange)
bloxdTextureIdOrangeSpawnBlockToporange_spawn_block_top.pngSpawn Block (Orange)
bloxdTextureIdOreGenSpawnSideore_gen_spawn_side.pngGenerator Spawn Block (Ore)
bloxdTextureIdOreGenSpawnTopore_gen_spawn_top.pngGenerator Spawn Block (Ore)
bloxdTextureIdPackedSnowpacked_snow.pngPacked Snow
bloxdTextureIdPartsBenchSideparts_bench_side.pngParts Bench
bloxdTextureIdPartsBenchTopparts_bench_top.pngParts Bench
bloxdTextureIdPatternedGlassBlackpatterned_glass_black.pngPatterned Black Glass
bloxdTextureIdPatternedGlassBluepatterned_glass_blue.pngPatterned Blue Glass
bloxdTextureIdPatternedGlassBrownpatterned_glass_brown.pngPatterned Brown Glass
bloxdTextureIdPatternedGlassCyanpatterned_glass_cyan.pngPatterned Cyan Glass
bloxdTextureIdPatternedGlassGraypatterned_glass_gray.pngPatterned Gray Glass
bloxdTextureIdPatternedGlassGreenpatterned_glass_green.pngPatterned Green Glass
bloxdTextureIdPatternedGlassLightBluepatterned_glass_light_blue.pngPatterned Light Blue Glass
bloxdTextureIdPatternedGlassLightGraypatterned_glass_light_gray.pngPatterned Light Gray Glass
bloxdTextureIdPatternedGlassLimepatterned_glass_lime.pngPatterned Lime Glass
bloxdTextureIdPatternedGlassMagentapatterned_glass_magenta.pngPatterned Magenta Glass
bloxdTextureIdPatternedGlassOrangepatterned_glass_orange.pngPatterned Orange Glass
bloxdTextureIdPatternedGlassPinkpatterned_glass_pink.pngPatterned Pink Glass
bloxdTextureIdPatternedGlassPurplepatterned_glass_purple.pngPatterned Purple Glass
bloxdTextureIdPatternedGlassRedpatterned_glass_red.pngPatterned Red Glass
bloxdTextureIdPatternedGlassWhitepatterned_glass_white.pngPatterned White Glass
bloxdTextureIdPatternedGlassYellowpatterned_glass_yellow.pngPatterned Yellow Glass
bloxdTextureIdPearBlockBottompear_block_bottom.pngPear Block
bloxdTextureIdPearBlockSidepear_block_side.pngPear Block
bloxdTextureIdPearBlockToppear_block_top.pngPear Block
bloxdTextureIdPetLuckyBlockpet_lucky_block.pngPet Lucky Block
bloxdTextureIdPineConeBlockSidepine_cone_block_side.pngPine Cone Block
bloxdTextureIdPineConeBlockToppine_cone_block_top.pngPine Cone Block
bloxdTextureIdPineGrassBlockpine_grass_block.pngOvergrown Pine Grass Block, Pine Grass Block, Pine Grass Slab
bloxdTextureIdPineGrassBlockSidepine_grass_block_side.pngPine Grass Block
bloxdTextureIdPinkConcretepink_concrete.pngPink Concrete, Pink Concrete Slab, Pink Concrete Stairs
bloxdTextureIdPinkGenSpawnCoalpink_gen_spawn_coal.pngGenerator Spawn Block (Pink)
bloxdTextureIdPinkGenSpawnIronpink_gen_spawn_iron.pngGenerator Spawn Block (Pink)
bloxdTextureIdPinkGenSpawnToppink_gen_spawn_top.pngGenerator Spawn Block (Pink)
bloxdTextureIdPinkGlazedTerracottapink_glazed_terracotta.pngPink Ceramic
bloxdTextureIdPinkPlankspink_planks.pngPink Planks
bloxdTextureIdPinkPortalpink_portal0.png (0-3)Pink Portal
bloxdTextureIdPinkSpawnBlockSidepink_spawn_block_side.pngSpawn Block (Pink)
bloxdTextureIdPinkSpawnBlockToppink_spawn_block_top.pngSpawn Block (Pink)
bloxdTextureIdPlanksAspenplanks_aspen.pngAspen Fence, Aspen Fence Gate, Aspen Slab, Aspen Stairs, Aspen Wood Planks, _Aspen Fence Gate Top, _Aspen Fence Top
bloxdTextureIdPlanksCedarplanks_cedar.pngCedar Fence, Cedar Fence Gate, Cedar Slab, Cedar Stairs, Cedar Wood Planks, _Cedar Fence Gate Top, _Cedar Fence Top
bloxdTextureIdPlanksCherryplanks_cherry.pngCherry Fence, Cherry Fence Gate, Cherry Slab, Cherry Stairs, Cherry Wood Planks, _Cherry Fence Gate Top, _Cherry Fence Top
bloxdTextureIdPlanksJungleplanks_jungle.pngJungle Fence, Jungle Fence Gate, Jungle Slab, Jungle Stairs, Jungle Wood Planks, _Jungle Fence Gate Top, _Jungle Fence Top
bloxdTextureIdPlanksMangoplanks_mango.pngMango Fence, Mango Fence Gate, Mango Slab, Mango Stairs, Mango Wood Planks, _Mango Fence Gate Top, _Mango Fence Top
bloxdTextureIdPlanksMapleplanks_maple.pngBookshelf, Empty Bookshelf, Maple Fence, Maple Fence Gate, Maple Slab, Maple Stairs, Maple Wood Planks, _Maple Fence Gate Top, _Maple Fence Top
bloxdTextureIdPlanksPalmplanks_palm.pngPalm Fence, Palm Fence Gate, Palm Slab, Palm Stairs, Palm Wood Planks, _Palm Fence Gate Top, _Palm Fence Top
bloxdTextureIdPlanksPearplanks_pear.pngPear Fence, Pear Fence Gate, Pear Slab, Pear Stairs, Pear Wood Planks, _Pear Fence Gate Top, _Pear Fence Top
bloxdTextureIdPlanksPineplanks_pine.pngPine Fence, Pine Fence Gate, Pine Slab, Pine Stairs, Pine Wood Planks, _Pine Fence Gate Top, _Pine Fence Top
bloxdTextureIdPlanksPlumplanks_plum.pngPlum Fence, Plum Fence Gate, Plum Slab, Plum Stairs, Plum Wood Planks, _Plum Fence Gate Top, _Plum Fence Top
bloxdTextureIdPlanksSpectralplanks_spectral.pngSpectral Fence, Spectral Fence Gate, Spectral Slab, Spectral Stairs, Spectral Wood Planks, _Spectral Fence Gate Top, _Spectral Fence Top
bloxdTextureIdPlumBlockBottomplum_block_bottom.pngPlum Block
bloxdTextureIdPlumBlockSideplum_block_side.pngPlum Block
bloxdTextureIdPlumBlockTopplum_block_top.pngPlum Block
bloxdTextureIdPodzolToppodzol_top.pngUseless Soil
bloxdTextureIdPotatoBlockpotato_block.pngPotato Block
bloxdTextureIdPotionLuckyBlockpotion_lucky_block.pngPotion Lucky Block
bloxdTextureIdPotionLuckyBlockRarepotion_lucky_block_rare.pngRare Potion Lucky Block
bloxdTextureIdPotionLuckyBlockSuperpotion_lucky_block_super.pngSuper Potion Lucky Block
bloxdTextureIdPressBackpress_back.pngPress
bloxdTextureIdPressFrontpress_front.pngPress
bloxdTextureIdPressSidepress_side.pngPress
bloxdTextureIdPressSideRunningpress_side_running0.png (0-3)Press
bloxdTextureIdPressToppress_top.pngPress
bloxdTextureIdProtectorprotector.pngProtector
bloxdTextureIdProtectorFactionprotector_faction.pngFaction Protector
bloxdTextureIdProtectorTribeprotector_tribe.pngTribe Protector
bloxdTextureIdPumpkinFaceOnpumpkin_face_on.pngJack o'Lantern
bloxdTextureIdPumpkinSidepumpkin_side.pngCarved Pumpkin, Jack o'Lantern, Pumpkin
bloxdTextureIdPumpkinToppumpkin_top.pngCarved Pumpkin, Jack o'Lantern, Pumpkin
bloxdTextureIdPureCoalOrepure_coal_ore.pngPure Coal Ore
bloxdTextureIdPureCopperOrepure_copper_ore.pngPure Copper Ore
bloxdTextureIdPureDiamondOrepure_diamond_ore.pngPure Diamond Ore
bloxdTextureIdPureGoldOrepure_gold_ore.pngPure Gold Ore
bloxdTextureIdPureIronOrepure_iron_ore.pngPure Iron Ore
bloxdTextureIdPureMoonstoneOrepure_moonstone_ore.pngPure Moonstone Ore
bloxdTextureIdPureVoltiteOrepure_voltite_ore.pngPure Voltite Ore
bloxdTextureIdPurpleConcretepurple_concrete.pngPurple Concrete, Purple Concrete Slab, Purple Concrete Stairs
bloxdTextureIdPurpleGlazedTerracottapurple_glazed_terracotta.pngPurple Ceramic
bloxdTextureIdPurpleLuckyBlockpurple_lucky_block.pngBuilding Lucky Block
bloxdTextureIdPurpleLuckyBlockRarepurple_lucky_block_rare.pngRare Building Lucky Block
bloxdTextureIdPurpleLuckyBlockSuperpurple_lucky_block_super.pngSuper Building Lucky Block
bloxdTextureIdPurplePlankspurple_planks.pngPurple Planks
bloxdTextureIdPurplePortalpurple_portal0.png (0-3)Purple Portal
bloxdTextureIdPurpleSpawnBlockSidepurple_spawn_block_side.pngSpawn Block (Purple)
bloxdTextureIdPurpleSpawnBlockToppurple_spawn_block_top.pngSpawn Block (Purple)
bloxdTextureIdQuartzBlockChiseledquartz_block_chiseled.pngChiseled Block of Quartz
bloxdTextureIdQuartzBlockSidequartz_block_side.pngBlock of Quartz
bloxdTextureIdRadarBottomradar_bottom.pngActive Radar, Inactive Radar, Radar, _Active Radar Back, _Inactive Radar Back, _Radar Back
bloxdTextureIdRadarScreenradar_screen0.png (0-3)Active Radar
bloxdTextureIdRadarSideActiveradar_side_active.pngActive Radar, Radar, _Active Radar Back, _Radar Back
bloxdTextureIdRadarSideInactiveradar_side_inactive.pngInactive Radar, _Inactive Radar Back
bloxdTextureIdRadarTopActiveradar_top_active.pngRadar
bloxdTextureIdRadarTopInactiveradar_top_inactive.pngInactive Radar
bloxdTextureIdRecyclerBackrecycler_back.pngRecycler
bloxdTextureIdRecyclerFrontrecycler_front.pngRecycler
bloxdTextureIdRecyclerSiderecycler_side.pngRecycler
bloxdTextureIdRecyclerSideRunningrecycler_side_running0.png (0-3)Recycler
bloxdTextureIdRecyclerToprecycler_top.pngRecycler
bloxdTextureIdRedConcretered_concrete.pngRed Concrete, Red Concrete Slab, Red Concrete Stairs
bloxdTextureIdRedGenSpawnCoalred_gen_spawn_coal.pngGenerator Spawn Block (Red)
bloxdTextureIdRedGenSpawnIronred_gen_spawn_iron.pngGenerator Spawn Block (Red)
bloxdTextureIdRedGenSpawnTopred_gen_spawn_top.pngGenerator Spawn Block (Red)
bloxdTextureIdRedGlazedTerracottared_glazed_terracotta.pngRed Ceramic
bloxdTextureIdRedLuckyBlockred_lucky_block.pngGun Lucky Block, Weapon Lucky Block
bloxdTextureIdRedLuckyBlockRarered_lucky_block_rare.pngRare Weapon Lucky Block
bloxdTextureIdRedLuckyBlockSuperred_lucky_block_super.pngSuper Weapon Lucky Block
bloxdTextureIdRedMushroomBlockred_mushroom_block.pngRed Mushroom Block
bloxdTextureIdRedPlanksred_planks.pngRed Planks
bloxdTextureIdRedPortalred_portal0.png (0-3)Red Portal
bloxdTextureIdRedSandred_sand.pngRed Sand
bloxdTextureIdRedSandstonered_sandstone.pngRed Sandstone, Red Sandstone Slab, Red Sandstone Stairs
bloxdTextureIdRedSandstoneBrickred_sandstone_brick.pngRed Sandstone Bricks, Red Sandstone Bricks Slab, Red Sandstone Bricks Stairs
bloxdTextureIdRedSandstoneTopred_sandstone_top.pngSmooth Red Sandstone, Smooth Red Sandstone Slab, Smooth Red Sandstone Stairs
bloxdTextureIdRedSpawnBlockSidered_spawn_block_side.pngSpawn Block (Red)
bloxdTextureIdRedSpawnBlockTopred_spawn_block_top.pngGoal Block (Red), Spawn Block (Red)
bloxdTextureIdRedstoneLampOffredstone_lamp_off.pngDim Lamp Off
bloxdTextureIdRedstoneLampOnredstone_lamp_on.pngDim Lamp On
bloxdTextureIdRocketBlockrocket_block.pngObby Rocket, Rocket
bloxdTextureIdRockyDirtrocky_dirt.pngRocky Dirt
bloxdTextureIdRopeBlockrope_block.pngRope Block
bloxdTextureIdSandsand.pngSand
bloxdTextureIdSandstoneBricksandstone_brick.pngSandstone Bricks, Sandstone Bricks Slab, Sandstone Bricks Stairs
bloxdTextureIdSandstoneNormalsandstone_normal.pngSandstone, Sandstone Slab, Sandstone Stairs
bloxdTextureIdSandstoneTopsandstone_top.pngSmooth Sandstone, Smooth Sandstone Slab, Smooth Sandstone Stairs
bloxdTextureIdScorpionEggsscorpion_eggs.pngScorpion Eggs Block
bloxdTextureIdShatterMillBackshatter_mill_back.pngShatter Mill
bloxdTextureIdShatterMillFrontshatter_mill_front.pngShatter Mill
bloxdTextureIdShatterMillSideshatter_mill_side.pngShatter Mill
bloxdTextureIdShatterMillSideRunningshatter_mill_side_running0.png (0-3)Shatter Mill
bloxdTextureIdShatterMillTopshatter_mill_top.pngShatter Mill
bloxdTextureIdShopTraderSpawnFaceshop_trader_spawn_face.pngTrader Shop Spawn Block
bloxdTextureIdShopTraderSpawnSideshop_trader_spawn_side.pngTrader Shop Spawn Block
bloxdTextureIdShopTraderSpawnTopshop_trader_spawn_top.pngTrader Shop Spawn Block
bloxdTextureIdShopWizardSpawnFaceshop_wizard_spawn_face.pngWizard Shop Spawn Block
bloxdTextureIdShopWizardSpawnSideshop_wizard_spawn_side.pngWizard Shop Spawn Block
bloxdTextureIdShopWizardSpawnTopshop_wizard_spawn_top.pngWizard Shop Spawn Block
bloxdTextureIdSkyTapBacksky_tap_back.pngSky Tap
bloxdTextureIdSkyTapBottomsky_tap_bottom.pngSky Tap
bloxdTextureIdSkyTapFrontsky_tap_front.pngSky Tap
bloxdTextureIdSkyTapSidesky_tap_side.pngSky Tap
bloxdTextureIdSkyTapSideRunningsky_tap_side_running0.png (0-3)Sky Tap
bloxdTextureIdSkyTapTopsky_tap_top.pngSky Tap
bloxdTextureIdSlabAndesiteBrickSideslab_andesite_brick_side.pngAndesite Bricks Slab
bloxdTextureIdSlabAspenSideslab_aspen_side.pngAspen Slab
bloxdTextureIdSlabBrickSideslab_brick_side.pngBricks Slab
bloxdTextureIdSlabCedarSideslab_cedar_side.pngCedar Slab
bloxdTextureIdSlabCherrySideslab_cherry_side.pngCherry Slab
bloxdTextureIdSlabChiseledRedSandstoneSideslab_chiseled_red_sandstone_side.pngEngraved Red Sandstone Slab
bloxdTextureIdSlabChiseledSandstoneSideslab_chiseled_sandstone_side.pngEngraved Sandstone Slab
bloxdTextureIdSlabCobblestoneSideslab_cobblestone_side.pngMessy Stone Slab
bloxdTextureIdSlabCutRedSandstoneSideslab_cut_red_sandstone_side.pngMarked Red Sandstone Slab
bloxdTextureIdSlabCutSandstoneSideslab_cut_sandstone_side.pngMarked Sandstone Slab
bloxdTextureIdSlabDioriteBrickSideslab_diorite_brick_side.pngDiorite Bricks Slab
bloxdTextureIdSlabDirtSideslab_dirt_side.pngDirt Slab
bloxdTextureIdSlabDryGrassTopSideslab_dry_grass_top_side.pngDry Grass Slab
bloxdTextureIdSlabEngravedAndesiteSideslab_engraved_andesite_side.pngEngraved Andesite Slab
bloxdTextureIdSlabEngravedDioriteSideslab_engraved_diorite_side.pngEngraved Diorite Slab
bloxdTextureIdSlabEngravedGraniteSideslab_engraved_granite_side.pngEngraved Granite Slab
bloxdTextureIdSlabGraniteBrickSideslab_granite_brick_side.pngGranite Bricks Slab
bloxdTextureIdSlabGrassTopSideslab_grass_top_side.pngGrass Slab
bloxdTextureIdSlabIceBrickSideslab_ice_brick_side.pngIce Bricks Slab
bloxdTextureIdSlabJungleGrassTopSideslab_jungle_grass_top_side.pngJungle Grass Slab
bloxdTextureIdSlabJungleSideslab_jungle_side.pngJungle Slab
bloxdTextureIdSlabMangoSideslab_mango_side.pngMango Slab
bloxdTextureIdSlabMapleSideslab_maple_side.pngMaple Slab
bloxdTextureIdSlabMossyCobblestoneSideslab_mossy_cobblestone_side.pngMossy Stone Slab
bloxdTextureIdSlabPalmSideslab_palm_side.pngPalm Slab
bloxdTextureIdSlabPearSideslab_pear_side.pngPear Slab
bloxdTextureIdSlabPineGrassTopSideslab_pine_grass_top_side.pngPine Grass Slab
bloxdTextureIdSlabPineSideslab_pine_side.pngPine Slab
bloxdTextureIdSlabPlumSideslab_plum_side.pngPlum Slab
bloxdTextureIdSlabRedSandstoneBrickSideslab_red_sandstone_brick_side.pngRed Sandstone Bricks Slab
bloxdTextureIdSlabRedSandstoneSideslab_red_sandstone_side.pngRed Sandstone Slab
bloxdTextureIdSlabSandstoneBrickSideslab_sandstone_brick_side.pngSandstone Bricks Slab
bloxdTextureIdSlabSandstoneNormalSideslab_sandstone_normal_side.pngSandstone Slab
bloxdTextureIdSlabSmoothStoneSideslab_smooth_stone_side.pngSmooth Stone Slab
bloxdTextureIdSlabSpectralSideslab_spectral_side.pngSpectral Slab
bloxdTextureIdSlabStoneAndesiteSideslab_stone_andesite_side.pngAndesite Slab
bloxdTextureIdSlabStoneAndesiteSmoothSideslab_stone_andesite_smooth_side.pngSmooth Andesite Slab
bloxdTextureIdSlabStoneDioriteSideslab_stone_diorite_side.pngDiorite Slab
bloxdTextureIdSlabStoneDioriteSmoothSideslab_stone_diorite_smooth_side.pngSmooth Diorite Slab
bloxdTextureIdSlabStoneGraniteSideslab_stone_granite_side.pngGranite Slab
bloxdTextureIdSlabStoneGraniteSmoothSideslab_stone_granite_smooth_side.pngSmooth Granite Slab
bloxdTextureIdSlabStoneSideslab_stone_side.pngStone Slab
bloxdTextureIdSlabStonebrickCarvedSideslab_stonebrick_carved_side.pngEngraved Stone Slab
bloxdTextureIdSlabStonebrickMossySideslab_stonebrick_mossy_side.pngMossy Stone Bricks Slab
bloxdTextureIdSlabStonebrickSideslab_stonebrick_side.pngStone Bricks Slab
bloxdTextureIdSmelterBacksmelter_back.pngSmelter
bloxdTextureIdSmelterFrontsmelter_front.pngSmelter
bloxdTextureIdSmelterSidesmelter_side.pngSmelter
bloxdTextureIdSmelterSideRunningsmelter_side_running0.png (0-3)Smelter
bloxdTextureIdSmelterTopsmelter_top.pngSmelter
bloxdTextureIdSmokesmoke0.png (0-3)Smoke Block
bloxdTextureIdSmoothStonesmooth_stone.pngSmooth Double Stone Slab, Smooth Stone, Smooth Stone Slab, Smooth Stone Stairs
bloxdTextureIdSnowsnow.pngSnow
bloxdTextureIdSnowyMessyStonesnowy_messy_stone.pngSnowy Messy Stone, Snowy Stone Slab
bloxdTextureIdSnowyMessyStoneSidesnowy_messy_stone_side.pngSnowy Stone Slab
bloxdTextureIdSolarPanelBottomsolar_panel_bottom.pngSolar Panel, _Solar Panel NE, _Solar Panel NW, _Solar Panel SE
bloxdTextureIdSolarPanelSidesolar_panel_side.pngSolar Panel, _Solar Panel NE, _Solar Panel NW, _Solar Panel SE
bloxdTextureIdSolarPanelTopsolar_panel_top.pngSolar Panel, _Solar Panel NE, _Solar Panel NW, _Solar Panel SE
bloxdTextureIdSortingGateSlabSidesorting_gate_slab_side.pngSorting Gate
bloxdTextureIdSortingGateTopsorting_gate_top.pngSorting Gate
bloxdTextureIdSplitterSlabSidesplitter_slab_side.pngSplitter
bloxdTextureIdSplitterTopsplitter_top.pngSplitter
bloxdTextureIdSpongesponge.pngSponge
bloxdTextureIdStarframestarframe.pngStarframe, _Starframe Spire
bloxdTextureIdStonestone.pngStone, Stone Slab, Stone Stairs
bloxdTextureIdStoneAndesitestone_andesite.pngAndesite, Andesite Slab, Andesite Stairs
bloxdTextureIdStoneAndesiteSmoothstone_andesite_smooth.pngSmooth Andesite, Smooth Andesite Slab, Smooth Andesite Stairs
bloxdTextureIdStoneDepositstone_deposit.pngStone Deposit
bloxdTextureIdStoneDioritestone_diorite.pngDiorite, Diorite Slab, Diorite Stairs
bloxdTextureIdStoneDioriteSmoothstone_diorite_smooth.pngSmooth Diorite, Smooth Diorite Slab, Smooth Diorite Stairs
bloxdTextureIdStoneGranitestone_granite.pngGranite, Granite Slab, Granite Stairs
bloxdTextureIdStoneGraniteSmoothstone_granite_smooth.pngSmooth Granite, Smooth Granite Slab, Smooth Granite Stairs
bloxdTextureIdStonebrickstonebrick.pngStone Bricks, Stone Bricks Slab, Stone Bricks Stairs
bloxdTextureIdStonebrickCarvedstonebrick_carved.pngEngraved Stone, Engraved Stone Slab, Engraved Stone Stairs
bloxdTextureIdStonebrickCrackedstonebrick_cracked.pngCracked Stone Bricks
bloxdTextureIdStonebrickMossystonebrick_mossy.pngMossy Stone Bricks, Mossy Stone Bricks Slab, Mossy Stone Bricks Stairs
bloxdTextureIdStorageSiloSidestorage_silo_side.pngStorage Silo
bloxdTextureIdStorageSiloTopstorage_silo_top.pngStorage Silo
bloxdTextureIdStrippedAspenLogstripped_aspen_log.pngBarkless Aspen Log
bloxdTextureIdStrippedCedarLogstripped_cedar_log.pngBarkless Cedar Log
bloxdTextureIdStrippedCherryLogstripped_cherry_log.pngBarkless Cherry Log
bloxdTextureIdStrippedJungleLogstripped_jungle_log.pngBarkless Jungle Log
bloxdTextureIdStrippedMangoLogstripped_mango_log.pngBarkless Mango Log
bloxdTextureIdStrippedMapleLogstripped_maple_log.pngBarkless Maple Log
bloxdTextureIdStrippedPalmLogstripped_palm_log.pngBarkless Palm Log
bloxdTextureIdStrippedPearLogstripped_pear_log.pngBarkless Pear Log
bloxdTextureIdStrippedPineLogstripped_pine_log.pngBarkless Pine Log
bloxdTextureIdStrippedPlumLogstripped_plum_log.pngBarkless Plum Log
bloxdTextureIdStrippedSpectralLogstripped_spectral_log.pngBarkless Spectral Log
bloxdTextureIdSuperCompressedMessyStonesuper_compressed_messy_stone.pngSuper Compressed Messy Stone
bloxdTextureIdSuperRocketBlocksuper_rocket_block.pngSuper Rocket
bloxdTextureIdToolBenchSidetool_bench_side.pngTool Bench
bloxdTextureIdToolBenchToptool_bench_top.pngTool Bench
bloxdTextureIdToolsLuckyBlocktools_lucky_block.pngTools Lucky Block
bloxdTextureIdToolsLuckyBlockRaretools_lucky_block_rare.pngRare Tools Lucky Block
bloxdTextureIdToolsLuckyBlockSupertools_lucky_block_super.pngSuper Tools Lucky Block
bloxdTextureIdToxicWastetoxic_waste0.png (0-7)Toxic Waste
bloxdTextureIdToxicWasteBarrelBottomtoxic_waste_barrel_bottom.pngToxic Waste Barrel
bloxdTextureIdToxicWasteBarrelSidetoxic_waste_barrel_side.pngToxic Waste Barrel
bloxdTextureIdToxicWasteBarrelToptoxic_waste_barrel_top0.png (0-3)Toxic Waste Barrel
bloxdTextureIdToxinBallBlocktoxin_ball_block.pngToxin Ball Block
bloxdTextureIdTreeCutterBacktree_cutter_back.pngTree Cutter
bloxdTextureIdTreeCutterBackRunningtree_cutter_back_running0.png (0-3)Tree Cutter
bloxdTextureIdTreeCutterFronttree_cutter_front.pngTree Cutter
bloxdTextureIdTreeCutterSidetree_cutter_side.pngTree Cutter
bloxdTextureIdTreeCutterSideRunningtree_cutter_side_running0.png (0-3)Tree Cutter
bloxdTextureIdTreeCutterToptree_cutter_top.pngTree Cutter
bloxdTextureIdUltraCompressedMessyStoneultra_compressed_messy_stone.pngUltra Compressed Messy Stone
bloxdTextureIdUnloadedunloaded.pngUnloaded
bloxdTextureIdVoltEngineSidevolt_engine_side.pngVolt Engine
bloxdTextureIdVoltEngineSideRunningvolt_engine_side_running0.png (0-3)Volt Engine
bloxdTextureIdVoltEngineTopvolt_engine_top.pngVolt Engine
bloxdTextureIdVoltiteDepositvoltite_deposit.pngVoltite Deposit
bloxdTextureIdVoltiteOrevoltite_ore.pngVoltite Ore
bloxdTextureIdWatermelonSidewatermelon_side.pngWatermelon
bloxdTextureIdWatermelonTopwatermelon_top.pngWatermelon
bloxdTextureIdWeaponLuckyBlockweapon_lucky_block.pngWeapon Lucky Block
bloxdTextureIdWeaponLuckyBlockRareweapon_lucky_block_rare.pngRare Weapon Lucky Block
bloxdTextureIdWeaponLuckyBlockSuperweapon_lucky_block_super.pngSuper Weapon Lucky Block
bloxdTextureIdWhiteConcretewhite_concrete.pngWhite Concrete, White Concrete Slab, White Concrete Stairs
bloxdTextureIdWhiteGenSpawnCoalwhite_gen_spawn_coal.pngGenerator Spawn Block (White)
bloxdTextureIdWhiteGenSpawnIronwhite_gen_spawn_iron.pngGenerator Spawn Block (White)
bloxdTextureIdWhiteGenSpawnTopwhite_gen_spawn_top.pngGenerator Spawn Block (White)
bloxdTextureIdWhiteGlazedTerracottawhite_glazed_terracotta.pngWhite Ceramic
bloxdTextureIdWhitePlankswhite_planks.pngWhite Planks
bloxdTextureIdWhitePortalwhite_portal0.png (0-3)White Portal
bloxdTextureIdWhiteSpawnBlockSidewhite_spawn_block_side.pngSpawn Block (White)
bloxdTextureIdWhiteSpawnBlockTopwhite_spawn_block_top.pngSpawn Block (White)
bloxdTextureIdWireMillBackwire_mill_back.pngWire Mill
bloxdTextureIdWireMillFrontwire_mill_front.pngWire Mill
bloxdTextureIdWireMillSidewire_mill_side.pngWire Mill
bloxdTextureIdWireMillSideRunningwire_mill_side_running0.png (0-3)Wire Mill
bloxdTextureIdWireMillTopwire_mill_top.pngWire Mill
bloxdTextureIdWoolColoredBlackwool_colored_black.pngBlack Wool
bloxdTextureIdWoolColoredBluewool_colored_blue.pngBlue Wool
bloxdTextureIdWoolColoredBrownwool_colored_brown.pngBrown Wool
bloxdTextureIdWoolColoredCyanwool_colored_cyan.pngCyan Wool
bloxdTextureIdWoolColoredGraywool_colored_gray.pngGray Wool
bloxdTextureIdWoolColoredGreenwool_colored_green.pngGreen Wool
bloxdTextureIdWoolColoredLightBluewool_colored_light_blue.pngLight Blue Wool
bloxdTextureIdWoolColoredLightGreywool_colored_light_grey.pngLight Gray Wool
bloxdTextureIdWoolColoredLimewool_colored_lime.pngLime Wool
bloxdTextureIdWoolColoredMagentawool_colored_magenta.pngMagenta Wool
bloxdTextureIdWoolColoredOrangewool_colored_orange.pngOrange Wool
bloxdTextureIdWoolColoredPinkwool_colored_pink.pngPink Wool
bloxdTextureIdWoolColoredPurplewool_colored_purple.pngPurple Wool
bloxdTextureIdWoolColoredRedwool_colored_red.pngRed Wool
bloxdTextureIdWoolColoredWhitewool_colored_white.pngWhite Wool
bloxdTextureIdWoolColoredYellowwool_colored_yellow.pngYellow Wool
bloxdTextureIdYellowConcreteyellow_concrete.pngYellow Concrete, Yellow Concrete Slab, Yellow Concrete Stairs
bloxdTextureIdYellowGenSpawnCoalyellow_gen_spawn_coal.pngGenerator Spawn Block (Yellow)
bloxdTextureIdYellowGenSpawnIronyellow_gen_spawn_iron.pngGenerator Spawn Block (Yellow)
bloxdTextureIdYellowGenSpawnTopyellow_gen_spawn_top.pngGenerator Spawn Block (Yellow)
bloxdTextureIdYellowGlazedTerracottayellow_glazed_terracotta.pngYellow Ceramic
bloxdTextureIdYellowLuckyBlockyellow_lucky_block.pngLucky Block
bloxdTextureIdYellowLuckyBlockRareyellow_lucky_block_rare.pngRare Lucky Block
bloxdTextureIdYellowLuckyBlockSuperyellow_lucky_block_super.pngSuper Lucky Block
bloxdTextureIdYellowPlanksyellow_planks.pngYellow Planks
bloxdTextureIdYellowPortalyellow_portal0.png (0-3)Yellow Portal
bloxdTextureIdYellowSpawnBlockSideyellow_spawn_block_side.pngSpawn Block (Yellow)
bloxdTextureIdYellowSpawnBlockTopyellow_spawn_block_top.pngSpawn Block (Yellow)

Credit

This page is a condensed, rewritten reference. The research is not mine. 1 texture packs on this site use the same pack format. The Bloxd.io API V5 section is the exception: those declarations, comments and example packs come from Bloxd.

Community reference, official source kept separate.

Except for the official files in the Bloxd.io API V5 section, this reference is documented and credited by GlitchHunterCoder, not by Bloxd. The API belongs to the game. The research and write-up belong to the people below.

GlitchHunterCoder also credits _Xenon_, Cannoli and ObiloxYT for the original shader work in the same document. _Xenon_ made the early shaders, Cannoli reverse engineered shader activation, and ObiloxYT helped with how shaders worked and how they were stored. The full thread of findings lives in GlitchHunterCoder's essay, linked above. This community reference is not posted or endorsed by Bloxd. The files in the Bloxd.io API V5 section are authored by Bloxd.

Submissions

Want your pack in here?

Shaders and texture packs from the community. Upload the .zip, pass the checks and the team reviews it. Free accounts get 8 KB for shaders or 200 KB for textures, with 3 uploads a day; server boosters get 12 KB or 500 KB, with 5; Premium users get 80 KB or 1 MB, with 10.

What's new

Prism v1.5.1

Community uploads, player profiles and profile customisation are now open to everyone. Texture uploads are paused while we tighten validation.

v1.5.19 Nov 2026Latest

Public rollout

Community uploads, player profiles and profile customisation are now open to everyone. Texture uploads are paused while we tighten validation.

Now public

  • Community shader uploads are open to every signed-in Discord account.
  • Player profiles are public at /user/<handle>. Display names are unique and become the profile URL.
  • Profile customisation is open to everyone: display name, bio, accent colour and banner.
  • Notifications and badges are live for everyone.
  • Accepted community packs publish straight to the community feed.

Texture uploads paused

  • New texture pack uploads are temporarily disabled for every account while validation is tightened.
  • Existing texture packs stay online, browsable and downloadable.

New in this release

  • A public status page at /status with live checks for the site, downloads, accounts and community services.
  • This changelog. It opens automatically when the site updates and stays available from the footer.
  • A machine-readable status feed at /api/status for uptime monitors.

Shader upload limits

  • Free accounts: 8 KB per shader pack, 3 uploads a day.
  • Discord server boosters: 12 KB per shader pack, 5 uploads a day.
  • Site admins and the site owner skip the daily upload cap.
  • Banners, profile effects, extra fonts and two-tone nameplates remain a Discord booster perk.
v1.5.0Earlier release

Community beta

The first community beta: uploads, player profiles, badges and notifications, with profiles and customisation limited to beta testers.

Community uploads (beta only)

  • Beta testers can upload shader and texture packs from the site.
  • Free users get 8 KB per pack and 3 uploads a day.
  • Discord server boosters get 12 KB per pack and 5 uploads a day.
  • Site admins skip the daily upload cap.

Badges

  • Discord server boosters now have a booster badge.
  • Beta testers have a beta badge.
  • Badges show on account headers, player profiles, pack author rows and comments.

Notifications — available to everyone

  • New notification bell in the header.
  • Get notified about comments, replies, accepted submissions and declined submissions.
  • Mark individual notifications or everything as read.
  • See the latest community releases from the panel.

Player profiles (beta only)

  • Public player pages are now available at /user/<handle>.
  • Beta testers can edit their profile and manage their own submissions.
  • Profile pages were limited to beta testers while the rollout was being finished.

Profile customisation (beta only)

  • Display name, bio, accent colour and profile banner.
  • Custom name fonts and gradient names for Discord server boosters.
  • Site admins can also use the custom profile options.
v1.4.0Earlier release

Beta programme

A Discord beta programme for early builds, with role-gated packs and an application review flow.

Join the beta

  • A new /beta page explains the programme and takes applications.
  • Applications collect availability, experience and what the tester wants to cover.
  • The beta role in Discord is the source of truth for access.

Early builds

  • Beta packs stay hidden from the public and unlock for the beta role.
  • Applications can be reviewed in Discord or from the admin Beta tab.
  • A decision is written back to the same application record so it cannot be reviewed twice.
v1.3.0Earlier release

Author tools

A protected author area with automatic pack metadata, uploads, release states and live publishing.

Publishing

  • Admin area for the site owner and approved contributors.
  • Create, edit and delete packs without a redeploy.
  • Released, beta and coming-soon states, plus featured and YouTube Featured placement.

Uploads and metadata

  • Name, author, version, apiVersion and cover art are read from the uploaded .zip.
  • Posted On stays fixed; Last Updated changes on every save.
  • Pack records and ratings use Supabase when available and fall back to D1.
v1.2.0Earlier release

Comments & community

Discord accounts, comments and replies, moderation tools and an easier way to join the server.

Conversation

  • Sign in with Discord to leave comments and replies on packs.
  • Comment authors get profile links and site badges.
  • Server-side checks block links, slurs and spam, with a posting cooldown.

Moderation

  • Moderators can hide or delete comments from the pack page.
  • The same tools are available in the admin Comments tab.
  • Discord sign-in can add new members to the Prism server automatically.
v1.1.0Earlier release

Texture library

Texture packs got their own catalogue, pages and pairings with shader packs.

Textures

  • A dedicated /textures catalogue and individual texture pack pages.
  • Shader pages can point to a matching texture pack without requiring it.
  • Texture packs install through the same .zip loader and work on their own.

Discovery

  • Texture series filters and cover art for the new catalogue.
  • Coming-soon texture teasers and related texture recommendations.
  • Texture-specific installation and compatibility notes.
v1.0.0Earlier release

Launch

The first public Prism Shaders site: the shader library, pack pages, downloads, ratings and the API reference.

The library

  • Hand-built Bloxd.io shader packs with covers, features, versions and install notes.
  • Search and series filters across the shader catalogue.
  • Featured and YouTube Featured placements on the home page.

Downloads & ratings

  • Per-pack .zip downloads behind a Discord sign-in gate, with a video unlock alternative.
  • Five-star ratings with averages, counts and score breakdowns.
  • Install steps, compatibility notes and the Prism licence.

Developer reference

  • The full Bloxd Shader API reference, versions 1 through 5, with hooks, structs, flags and examples.
  • Community research credited on the page and in the footer.