@voxelize/core

Enumerations

BlockRuleLogic

Core Classes

Effects Classes

Other Classes

Utils Classes

Interfaces

Type Aliases

ArgMetadata

Ƭ ArgMetadata: Object

Metadata extracted from a Zod schema for UI purposes.

Type declaration

Name	Type
`defaultValue?`	`string` \| `number` \| `boolean`
`name`	`string`
`options?`	`string`[]
`required`	`boolean`
`tabComplete?`	(`currentValue`: `string`, `context`: `TabCompleteContext`) => `string`[]
`type`	`"string"` \| `"number"` \| `"enum"` \| `"boolean"`

ArmOptions

Ƭ ArmOptions: Object

Type declaration

Name	Type
`armColor?`	`string` \| `THREE.Color`
`armObject?`	`THREE.Object3D`
`armObjectOptions`	`ArmObjectOptions`
`armTexture?`	`THREE.Texture`
`blockObjectOptions?`	`ArmObjectOptions`
`customObjectOptions?`	`Record`<`string`, `ArmObjectOptions`>
`minOccluderDepth?`	`number`
`receiveHeldObjectShadows?`	`boolean`
`receiveShadows?`	`boolean`

ArmsOptions

Ƭ ArmsOptions: ColorCanvasBoxOptions & { shoulderDrop?: number ; shoulderGap?: number }

Parameters to create a character's arms. Defaults to:

{
  gap: 0.1 * CHARACTER_SCALE,
  layers: 1,
  side: THREE.DoubleSide,
  width: 0.25 * CHARACTER_SCALE,
  widthSegments: 8,
  height: 0.5 * CHARACTER_SCALE,
  heightSegments: 16,
  depth: 0.25 * CHARACTER_SCALE,
  depthSegments: 8,
  shoulderGap: 0.05 * CHARACTER_SCALE,
  shoulderDrop: 0.25 * CHARACTER_SCALE,
}

ArrowOptions

Ƭ ArrowOptions: Object

Parameters to create an arrow.

Type declaration

Name	Type	Description
`color`	`string` \| `Color`	The color of the arrow. Defaults to `red`.
`coneHeight`	`number`	The height of the head of the arrow. Defaults to `0.2`.
`coneRadius`	`number`	The radius of the head of the arrow. Defaults to `0.2`.
`height`	`number`	The height of the body of the arrow. Defaults to `0.8`.
`radius`	`number`	The radius of the body of the arrow. Defaults to `0.1`.

ArtFunction

Ƭ ArtFunction: (context: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void

A function to programmatically draw on a canvas.

Type declaration

▸ (context, canvas): void

Parameters

Name	Type
`context`	`CanvasRenderingContext2D`
`canvas`	`HTMLCanvasElement`

Returns

void

Block

Ƭ Block: Object

A block type in the world. This is defined by the server.

Type declaration

Name	Type	Description
`aabbs`	`AABB`[]	A list of axis-aligned bounding boxes that this block has.
`blueLightLevel`	`number`	The blue light level of the block.
`castsShadow`	`boolean` \| `null`	Whether this block is drawn into the sun's shadow maps. `null` defers to blockCastsShadow's rule of thumb; a block the rule gets wrong (a door: see-through to the mesher, a plank slab to the eye) says so here. Mirrors the server `casts_shadow` field.
`coupledParts`	`CoupledPart`[]	The other voxels of the multi-voxel unit this block is one part of — a door's other leaf, a tall flower's other half. Empty for an ordinary block. The server keeps such units whole at update intake; the client mirrors that in `World.updateVoxels` so predictions land on the same voxels. Mirrors the server `coupled_parts` field.
`dynamicFn`	(`pos`: `Coords3`) => { `aabbs`: `Block`[`"aabbs"`] ; `faces`: `Block`[`"faces"`] ; `isTransparent`: `Block`[`"isTransparent"`] }	-
`dynamicPatterns`	`BlockDynamicPattern`[]	-
`faces`	{ `corners`: { `pos`: [`number`, `number`, `number`] ; `uv`: `number`[] }[] ; `dir`: [`number`, `number`, `number`] ; `emissive?`: `number` ; `independent`: `boolean` ; `isolated`: `boolean` ; `name`: `string` ; `range`: `UV` ; `textureGroup`: `string` \| `null` }[]	A list of block face data that this block has.
`fluidFlowForce`	`number`	The force applied to entities in this fluid, pushing them in the flow direction.
`greenLightLevel`	`number`	The green light level of the block.
`groundFrictionMultiplier`	`number`	Multiplier applied to entity ground friction while standing on this block. 1 is normal grip; lower values are slipperier.
`id`	`number`	The block id.
`independentFaces`	`Set`<`string`>	A set of block face names that are independent (high resolution or animated). This is generated on the client side.
`isAnimated`	`boolean`	Whether every voxel of this block is meshed as its own geometry (never merged into the chunk's shared buffers) so `World.blockAnimations` can move one voxel's faces on their own — a door leaf swinging on its hinge. Mirrors the server `is_animated` field.
`isClimbable`	`boolean`	Whether or not can entities climb this block.
`isCoupledAnchor`	`boolean`	Whether this part is its unit's anchor: the part that is placed, picked and dropped, and whose rotation and stage the other parts follow.
`isDynamic`	`boolean`	Whether or not does the block generate dynamic faces or AABB's. If this is true, the block will use `dynamicFn` to generate the faces and AABB's.
`isEmpty`	`boolean`	Whether or not is this block empty. By default, only "air" is empty.
`isEntity`	`boolean`	-
`isFluid`	`boolean`	Whether or not is the block a fluid block.
`isLight`	`boolean`	Whether or not is this block a light source.
`isOpaque`	`boolean`	Whether or not is this block opaque (not transparent).
`isPassable`	`boolean`	Whether or not should physics ignore this block.
`isPlant`	`boolean`	Whether this block is plant decoration — a grass tuft, a flower, a crop. The mesher uses it to jitter diagonal faces; the renderer uses it to decide what WorldClientOptions.plantDetailDistance may stop drawing.
`isSeeThrough`	`boolean`	Whether or not is this block see-through (can be opaque and see-through at the same time).
`isTransparent`	[`boolean`, `boolean`, `boolean`, `boolean`, `boolean`, `boolean`]	Whether or not is this block transparent viewing from all six sides. The sides are defined as PX, PY, PZ, NX, NY, NZ.
`isWaterloggable`	`boolean`	Whether this block can hold the world's waterlogging fluid alongside itself. Whether a given voxel actually does is per-voxel state, read with `World.getVoxelWaterloggedAt`.
`isWaterloggingFluid`	`boolean`	Whether this is the fluid that waterlogging fills voxels with.
`isolatedFaces`	`Set`<`string`>	-
`lightAttenuation`	`number`	Optical density for Beer-Lambert light transmission through this block. `0` keeps normal air rules. `1` is leaves-scale. `2` is water-scale.
`name`	`string`	The name of the block.
`redLightLevel`	`number`	The red light level of the block.
`rotatable`	`boolean`	Whether or not is the block rotatable.
`stackGroup`	`number`	Vertical-run id shared by blocks that should shade/sway as one column (peony bottom+top, kelp+lantern). Zero means the block never stacks. Mirrors the server `stack_group` field.
`transparentStandalone`	`boolean`	-
`yRotatable`	`boolean`	Whether or not the block is rotatable around the y-axis (has to face either PX or NX).
`yRotatableSegments`	`"All"` \| `"Eight"` \| `"Four"`	-

BlockAnimation

Ƭ BlockAnimation: Object

Type declaration

Name	Type	Description
`axis`	`Coords3`	The hinge axis, in the same frame; it turns with the block.
`durationMs`	`number`	How long a move between two rest poses takes.
`easing?`	`BlockAnimationEasing`	Progress curve over 0..1; defaults to easeOutCubic.
`pivot`	`Coords3`	The hinge point, in the block's unrotated 0..1 frame.
`restPose`	(`state`: `BlockAnimationState`) => `BlockRestPose`	-

BlockAnimationEasing

Ƭ BlockAnimationEasing: (t: number) => number

Type declaration

▸ (t): number

Parameters

Name	Type
`t`	`number`

Returns

number

BlockAnimationState

Ƭ BlockAnimationState: Object

The voxel state a rest pose is asked for.

Type declaration

Name	Type	Description
`raw`	`number`	The packed voxel word, for anything the two fields below leave out.
`rotation`	`BlockRotation`	-
`stage`	`number`	-

BlockAnimationsSnapshot

Ƭ BlockAnimationsSnapshot: Object

The state BlockAnimations.snapshot reports.

Type declaration

Name	Type	Description
`activeCount`	`number`	-
`registered`	`string`[]	Lower-cased block names with a declared motion.
`trackedCount`	`number`	-
`voxels`	{ `angle`: `number` ; `block`: `string` ; `isMoving`: `boolean` ; `progress`: `number` ; `restAngle`: `number` ; `stage`: `number` ; `voxel`: `Coords3` }[]	-

BlockEntityUpdateData

Ƭ BlockEntityUpdateData<T>: Object

Type parameters

Name
`T`

Type declaration

Name	Type
`etype`	`string`
`id`	`string`
`newValue`	`T` \| `null`
`oldValue`	`T` \| `null`
`operation`	`EntityOperation`
`voxel`	`Coords3`

BlockEntityUpdateListener

Ƭ BlockEntityUpdateListener<T>: (args: BlockEntityUpdateData<T>) => void

Type parameters

Name
`T`

Type declaration

▸ (args): void

Parameters

Name	Type
`args`	`BlockEntityUpdateData`<`T`>

Returns

void

BlockRestPose

Ƭ BlockRestPose: Object

Where a state's geometry rests, relative to the stage-0 geometry: turned angle radians about the hinge, and displaced by offset (block-local, before the block's rotation).

Type declaration

Name	Type
`angle`	`number`
`offset?`	`Coords3`

BlockRule

Ƭ BlockRule: { type: "none" } | { type: "simple" } & BlockSimpleRule | { logic: BlockRuleLogic ; rules: BlockRule[] ; type: "combination" }

BlockSimpleRule

Ƭ BlockSimpleRule: Object

Type declaration

Name	Type
`id?`	`number`
`offset`	`Coords3`
`rotation?`	`BlockRotation` \| `SerializedBlockRotation`
`stage?`	`number`

BlockUpdate

Ƭ BlockUpdate: Object

A block update to make on the server.

Type declaration

Name	Type	Description
`isWaterlogged?`	`boolean`	Whether the updated voxel holds the world's waterlogging fluid alongside its block.
`rotation?`	`number`	The optional rotation of the updated block.
`stage?`	`number`	The optional stage of the updated block.
`type`	`number`	The voxel type.
`vx`	`number`	The voxel x-coordinate.
`vy`	`number`	The voxel y-coordinate.
`vz`	`number`	The voxel z-coordinate.
`waterlogLevel?`	`number`	The level of the waterlogging fluid the updated voxel holds, 0 through 7.
`yRotation?`	`number`	The optional y-rotation of the updated block.

BlockUpdateListener

Ƭ BlockUpdateListener: (args: { newValue: number ; oldValue: number ; source: "client" | "server" ; voxel: Coords3 }) => void

Type declaration

▸ (args): void

Parameters

Name	Type
`args`	`Object`
`args.newValue`	`number`
`args.oldValue`	`number`
`args.source`	`"client"` \| `"server"`
`args.voxel`	`Coords3`

Returns

void

BlockUpdateWithSource

Ƭ BlockUpdateWithSource: Object

Type declaration

Name	Type
`source`	`"client"` \| `"server"`
`update`	`BlockUpdate`

BodyOptions

Ƭ BodyOptions: ColorCanvasBoxOptions

Parameters to create a character's body. Defaults to:

{
  gap: 0.1 * CHARACTER_SCALE,
  layers: 1,
  side: THREE.DoubleSide,
  width: 1 * CHARACTER_SCALE,
  widthSegments: 16,
}

where CHARACTER_SCALE is 0.9.

BoundingBox

Ƭ BoundingBox: Object

Type declaration

Name	Type
`min`	`Coords3`
`shape`	`Coords3`

BoxSides

The sides of a canvas box.

"all" means all six sides, and "sides" means all the sides except the top and bottom.

CSSMeasurement

Ƭ CSSMeasurement: `${number}${string}`

A CSS measurement. E.g. "30px", "51em"

CameraPerspective

Ƭ CameraPerspective: "px" | "nx" | "py" | "ny" | "pz" | "nz" | "pxy" | "nxy" | "pxz" | "nxz" | "pyz" | "nyz" | "pxyz" | "nxyz"

CanvasBoxOptions

Ƭ CanvasBoxOptions: Object

Parameters to create a canvas box.

Type declaration

Name	Type	Description
`depth?`	`number`	The depth of the box. Defaults to whatever `width` is.
`depthSegments?`	`number`	The depth segments of the box, which is the number of pixels of the canvases along the depth. Defaults to whatever `widthSegments` is.
`gap`	`number`	The gap between the layers of the box. Defaults to `0`.
`height?`	`number`	The height of the box. Defaults to whatever `width` is.
`heightSegments?`	`number`	The height segments of the box, which is the number of pixels of the canvases along the height. Defaults to whatever `widthSegments` is.
`layers`	`number`	The number of layers of this box. Defaults to `1`.
`receiveShadows?`	`boolean`	Whether this canvas box should receive shadows. Defaults to `false`.
`side`	`Side`	The side of the box to render. Defaults to `THREE.FrontSide`.
`texelsPerBlock?`	`number`	Texture pixels per world unit. When set, `widthSegments`, `heightSegments` and `depthSegments` are derived from the box's dimensions at this density (at least one texel each), so every face has square texels whatever the box's proportions. Without it a 0.3 x 0.14 x 0.06 box gets the same `widthSegments` along all three axes and its texture is squashed on every non-square face. Prefer this over hand-picked segment counts for anything that is not a cube.
`transparent?`	`boolean`	Whether or not should this canvas box be rendered as transparent. Defaults to `false`.
`underwaterFog?`	`boolean`	Whether this canvas box tints toward the ambient water color while the camera is submerged, matching the underwater look of instanced entities. Defaults to `false`.
`width`	`number`	THe width of the box. Defaults to `1`.
`widthSegments`	`number`	The width segments of the box, which is the number of pixels of the canvases along the width. Defaults to `8`.

CharacterOptions

Ƭ CharacterOptions: Object

Parameters to create a character.

Type declaration

Name	Type	Description
`arms?`	`Partial`<`ArmsOptions`>	Parameters to create the character's arms.
`body?`	`Partial`<`BodyOptions`>	Parameters to create the character's body.
`head?`	`Partial`<`HeadOptions`>	Parameters to create the character's head.
`idleArmSwing?`	`number`	The speed at which the arms swing when the character is idle. Defaults to `0.06`.
`legs?`	`Partial`<`LegOptions`>	Parameters to create the character's legs.
`nameTagOptions?`	`Partial`<`NameTagOptions`>	-
`positionLerp?`	`number`	The lerp factor of the character's position change, expressed per frame at 60 FPS and renormalized to the real frame delta. Defaults to `0.7`.
`receiveShadows?`	`boolean`	Whether this character should receive shadows. Defaults to `false`.
`rotationLerp?`	`number`	The lerp factor of the character's rotation change, expressed per frame at 60 FPS and renormalized to the real frame delta. Defaults to `0.2`.
`swimEnterLerp?`	`number`	Lerp factor when entering the swimming pose. Defaults to `0.12`.
`swimExitLerp?`	`number`	Lerp factor when exiting the swimming pose. Defaults to `0.05`.
`swimmingSpeed?`	`number`	The speed at which the arms stroke when the character is swimming. Defaults to `1.8`.
`swingLerp?`	`number`	The lerp factor of the swinging motion of the arms and legs. Defaults to `0.8`.
`walkingSpeed?`	`number`	The speed at which the arms swing when the character is moving. Defaults to `1.4`.

ChunkDataEventData

Ƭ ChunkDataEventData: Object

Type declaration

Name	Type
`chunk`	`Chunk`
`coords`	`Coords2`

ChunkEventData

Ƭ ChunkEventData: Object

Type declaration

Name	Type
`allMeshes`	`Map`<`number`, `Mesh`[]>
`chunk`	`Chunk`
`coords`	`Coords2`

ChunkMeshEventData

Ƭ ChunkMeshEventData: Object

Type declaration

Name	Type
`chunk`	`Chunk`
`coords`	`Coords2`
`level`	`number`
`meshes`	`Mesh`[]

ChunkMeshUpdateEventData

Ƭ ChunkMeshUpdateEventData: ChunkMeshEventData & { reason: ChunkUpdateReason }

ChunkRegionArenasOptions

Ƭ ChunkRegionArenasOptions: Object

Tunables for the per-region BatchedMesh arenas that batch every shared-opaque chunk section into one multi-draw call per region.

Type declaration

Name	Type	Description
`growthFactor`	`number`	Factor a full arena's capacity is multiplied by when it grows. Growth re-uploads the region's buffers, so it should be rare: geometric growth bounds the number of growth events logarithmically.
`indexPerVertexRatio`	`number`	Index capacity per vertex of capacity. Quad geometry uses six indices for every four vertices, hence the 1.5 default.
`initialVertexCapacity`	`number`	Vertex capacity a region arena is created with. Arenas grow geometrically from here, so this is a floor, not a limit.
`regionSizeInChunks`	`number`	The width and depth of a region, in chunk columns. Every section whose chunk falls inside the same region shares one `BatchedMesh`.
`slotSlack`	`number`	Multiplier applied to a section's vertex/index count when reserving its arena slot, so small remeshes update in place instead of reallocating.

ChunkRequestCandidate

Ƭ ChunkRequestCandidate: Object

Type declaration

Name	Type
`cx`	`number`
`cz`	`number`
`distanceSquared`	`number`
`isInView`	`boolean`

ChunkSharedPoolStats

Ƭ ChunkSharedPoolStats: Object

Type declaration

Name	Type
`bytesAllocated`	`number`
`isActive`	`boolean`
`maxSlots`	`number`
`usedSlots`	`number`

ChunkStage

Ƭ ChunkStage: { requestedAt: number ; sentAt: number | null ; stage: "requested" } | { arrivedAt: number | null ; data: ChunkProtocol ; receivedAt: number ; requestedAt: number | null ; sentAt: number | null ; source: "update" | "load" ; stage: "processing" } | { arrivedAt: number | null ; chunk: Chunk ; loadedAt: number ; receivedAt: number | null ; requestedAt: number | null ; sentAt: number | null ; stage: "loaded" }

ChunkUpdateEventData

Ƭ ChunkUpdateEventData: ChunkEventData & { reason: ChunkUpdateReason }

ChunkUpdateReason

Ƭ ChunkUpdateReason: "voxel" | "light"

ClickOccasion

Ƭ ClickOccasion: "mousedown" | "mouseup"

The occasion a mouse click listener fires on. Mirrors InputOccasion for the keyboard: press and release are separate lanes, so a listener can tell a tap from a hold.

ClickType

Ƭ ClickType: "left" | "middle" | "right"

Three types of clicking for mouse input listening.

CloudsOptions

Ƭ CloudsOptions: Object

Parameters used to create a new Clouds instance.

Type declaration

Name	Type	Description
`alpha`	`number`	The opacity of the clouds. Defaults to `0.8`.
`bottomShade`	`number`	Brightness of the underside of a cloud block relative to its top, `0..1`. Defaults to `0.7`.
`cloudHeight`	`number`	The y-height at which the clouds are generated. Defaults to `256`.
`color`	`string`	The color of the clouds. Defaults to `#fff`.
`count`	`number`	The horizontal count of how many cloud blocks are along each edge of a cloud cell, `count` * `count` per cell. Defaults to `16`. The whole cloud sheet therefore spans `width` * `count` * `dimensions[0]` blocks: it is `width`, not this, that adds cells.
`dimensions`	`Coords3`	The dimension of each cloud block. Defaults to `[20, 20, 20]`.
`endFadeFarRatio`	`number`	-
`endFadeNearRatio`	`number`	-
`falloff`	`number`	The noise falloff factor used to generate the clouds. Defaults to `0.9`.
`height`	`number`	The vertical count of how many cloud blocks are in a cloud cell. This is also used to determine the overall count of cloud blocks of all the clouds. Defaults to `3`.
`lerpFactor`	`number`	The lerp factor used to translate cloud blocks from their original position to their new position. Defaults to `0.3`.
`noiseScale`	`number`	The scale of the noise used to generate the clouds. Defaults to `0.08`.
`octaves`	`number`	The number of octaves used to generate the noise. Defaults to `5`.
`seed`	`number`	The seed used to generate the clouds. Defaults to `-1`.
`sideShade`	`number`	Brightness of the vertical faces of a cloud block relative to its top, `0..1`. Defaults to `0.86`.
`speedFactor`	`number`	The speed at which the clouds move. Defaults to `8`.
`sunTint`	`number`	Extra brightness given to faces pointing at the sun, as a fraction. Defaults to `0.12`.
`threshold`	`number`	The threshold at which noise values are considered to be "cloudy" and should generate a new cloud block. Defaults to `0.05`.
`uCameraSubmersion?`	`ShaderUniform`<`number`>	-
`uCameraWaterPlaneY?`	`ShaderUniform`<`number`>	-
`uCloudEndFadeFar?`	`ShaderUniform`<`number`>	-
`uCloudEndFadeNear?`	`ShaderUniform`<`number`>	-
`uCloudFogDistanceScale?`	`ShaderUniform`<`number`>	-
`uFogColor?`	`ShaderUniform`<`Color`>	An object that is used as the uniform for the clouds fog color shader.
`uFogFar?`	`ShaderUniform`<`number`>	An object that is used as the uniform for the clouds fog far shader.
`uFogHeightDensity?`	`ShaderUniform`<`number`>	-
`uFogHeightOrigin?`	`ShaderUniform`<`number`>	-
`uFogNear?`	`ShaderUniform`<`number`>	An object that is used as the uniform for the clouds fog near shader.
`uSkyFogBottomColor?`	`ShaderUniform`<`Color`>	-
`uSkyFogDimension?`	`ShaderUniform`<`number`>	-
`uSkyFogExponent?`	`ShaderUniform`<`number`>	-
`uSkyFogExponent2?`	`ShaderUniform`<`number`>	-
`uSkyFogMiddleColor?`	`ShaderUniform`<`Color`>	-
`uSkyFogOffset?`	`ShaderUniform`<`number`>	-
`uSkyFogStrength?`	`ShaderUniform`<`number`>	-
`uSkyFogTopColor?`	`ShaderUniform`<`Color`>	-
`uSkyFogVoidOffset?`	`ShaderUniform`<`number`>	-
`uSunColor?`	`ShaderUniform`<`Color`>	-
`uSunDirection?`	`ShaderUniform`<`Vector3`>	-
`uSunlightIntensity?`	`ShaderUniform`<`number`>	-
`uUnderwaterAmbient?`	`ShaderUniform`<`Color`>	-
`verticalNoiseScale?`	`number`	The scale of the noise along the vertical axis. Defaults to `noiseScale`. Raise it above `noiseScale` for a shallow deck: a handful of layers span almost no noise at the horizontal scale, so every column fills to the same layer and the top comes out perfectly flat.
`width`	`number`	The number of cloud cells along each axis of the grid, `width` * `width` in total. Defaults to `8`.

CommandInfo

Ƭ CommandInfo<T>: Object

Information about a command including its processor and documentation.

Type parameters

Name	Type
`T`	extends `ZodObject`<`Record`<`string`, `ZodTypeAny`>> = `ZodObject`<`Record`<`string`, `never`>>

Type declaration

Name	Type
`aliases`	`string`[]
`args`	`T`
`category?`	`string`
`description`	`string`
`flags`	`string`[]
`isHidden`	`boolean`
`isTabCompletePreFiltered`	`boolean`
`process`	(`args`: `z.infer`<`T`>) => `void`
`tabComplete`	`Partial`<`Record`<`string`, (`currentValue`: `string`, `context`: `TabCompleteContext`) => `string`[]>>

CommandOptions

Ƭ CommandOptions<T>: Object

Type parameters

Name	Type
`T`	extends `ZodObject`<`Record`<`string`, `ZodTypeAny`>> = `ZodObject`<`Record`<`string`, `never`>>

Type declaration

Name	Type
`aliases?`	`string`[]
`args?`	`T`
`category?`	`string`
`description`	`string`
`flags?`	`string`[]
`isHidden?`	`boolean`
`isTabCompletePreFiltered?`	`boolean`
`tabComplete?`	`Partial`<`Record`<keyof `z.infer`<`T`>, (`currentValue`: `string`, `context`: `TabCompleteContext`) => `string`[]>>

Coords2

Ƭ Coords2: [number, number]

Coords3

Ƭ Coords3: [number, number, number]

CoupledPart

Ƭ CoupledPart: Object

One other voxel a coupled block is stored together with: where it sits relative to this block's voxel, and the block id it must hold. Mirrors the server CoupledPart.

Type declaration

Name	Type
`id`	`number`
`offset`	`Coords3`

CreatureBodyOptions

Ƭ CreatureBodyOptions: ColorCanvasBoxOptions

CreatureHeadOptions

Ƭ CreatureHeadOptions: ColorCanvasBoxOptions & { faceColor: Color | string ; neckGap?: number }

CreatureLegOptions

Ƭ CreatureLegOptions: ColorCanvasBoxOptions & { betweenLegsGap?: number ; frontBackGap?: number }

CreatureOptions

Ƭ CreatureOptions: Object

Type declaration

Name	Type
`body?`	`Partial`<`CreatureBodyOptions`>
`head?`	`Partial`<`CreatureHeadOptions`>
`idleLegSwing?`	`number`
`legs?`	`Partial`<`CreatureLegOptions`>
`nameTagOptions?`	`Partial`<`NameTagOptions`>
`positionLerp?`	`number`
`rotationLerp?`	`number`
`swingLerp?`	`number`
`walkingSpeed?`	`number`

CullOptionsType

Ƭ CullOptionsType: Object

Type declaration

Name	Type
`dimensions`	`Coords3`
`max`	`Coords3`
`min`	`Coords3`
`realMax`	`Coords3`
`realMin`	`Coords3`

CustomChunkShaderMaterial

Ƭ CustomChunkShaderMaterial: ShaderMaterial & { map: Texture }

Custom shader material for chunks, simply a ShaderMaterial from ThreeJS with a map texture. Keep in mind that if you want to change its map, you also have to change its uniforms.map.

DebugOptions

Ƭ DebugOptions: Object

Type declaration

Name	Type
`asyncPeriod?`	`number`
`containerId?`	`string`
`dataClass?`	`string`
`dataStyles?`	`StyleDecl`
`entriesClass?`	`string`
`entriesStyles?`	`StyleDecl`
`lineClass?`	`string`
`lineStyles?`	`StyleDecl`
`newLineStyles?`	`StyleDecl`
`onByDefault?`	`boolean`
`showVoxelize?`	`boolean`
`stats?`	`boolean`
`statsStyles?`	`StyleDecl`

DeepPartial

Ƭ DeepPartial<T>: { [P in keyof T]?: DeepPartial<T[P]> }

Type parameters

Name
`T`

EntitiesOptions

Ƭ EntitiesOptions: Object

Type declaration

Name	Type	Description
`stalenessTimeoutSeconds`	`number`	Seconds an entity may go without any server message before it is considered lost and released. Covers dropped out-of-range and delete notifications so no entity can stay frozen forever.
`streamSilenceGraceSeconds`	`number`	Seconds of total message silence after which staleness releases are suspended, so reconnects and tab suspensions do not purge live entities.

EntityLivenessOptions

Ƭ EntityLivenessOptions: Object

Type declaration

Name	Type	Description
`stalenessTimeoutSeconds`	`number`	Seconds an entity may go without any message before it is considered lost and released. The server keep-alive cadence is roughly one second, so this should comfortably exceed several missed keep-alives.
`streamSilenceGraceSeconds`	`number`	Seconds of total message silence after which staleness judgment is suspended. A quiet stream means the connection itself is degraded (disconnect, tab suspension), not that individual entities were lost.

EntityMetadata

Ƭ EntityMetadata: Object

Type declaration

Name	Type
`rigidBody?`	`EntityRigidBodyMetadata`

EntityRigidBodyMetadata

Ƭ EntityRigidBodyMetadata: Object

Type declaration

Name	Type
`fluidRatio`	`number`
`isInFluid`	`boolean`

Event

Ƭ Event: Object

A Voxelize event from the server.

Type declaration

Name	Type	Description
`name`	`string`	The name to identify the event.
`payload?`	`EventPayload`	Additional information of the event.

EventHandler

Ƭ EventHandler<TPayload>: (payload: TPayload) => void

The handler for an event sent from the Voxelize server.

Type parameters

Name	Type
`TPayload`	`EventPayload`

Type declaration

▸ (payload): void

Parameters

Name	Type
`payload`	`TPayload`

Returns

void

EventPayload

Ƭ EventPayload: JsonPrimitive | { [key: string]: EventPayload | undefined; } | EventPayload[]

FindSimilarOptions

Ƭ FindSimilarOptions: Object

Type declaration

Name	Type
`maxSuggestions?`	`number`

FluidQuery

Ƭ FluidQuery: (vx: number, vy: number, vz: number) => boolean

Type declaration

▸ (vx, vy, vz): boolean

Parameters

Name	Type
`vx`	`number`
`vy`	`number`
`vz`	`number`

Returns

boolean

FormatSuggestionOptions

Ƭ FormatSuggestionOptions: Object

Type declaration

Name	Type
`maxFallbackItems?`	`number`

HeadOptions

Ƭ HeadOptions: ColorCanvasBoxOptions & { faceColor: Color | string ; neckGap?: number }

HeapReader

Ƭ HeapReader: () => HeapSample | null

Reads the current heap, or returns null when the engine exposes no heap numbers at all (every non-Chromium browser).

Type declaration

▸ (): HeapSample | null

Returns

HeapSample | null

HeapSample

Ƭ HeapSample: Object

A single reading of the renderer's JavaScript heap.

Type declaration

Name	Type
`limitBytes`	`number`
`usedBytes`	`number`

ImageResolver

Ƭ ImageResolver: (name: string) => string

Type declaration

▸ (name): string

Parameters

Name	Type
`name`	`string`

Returns

string

InputOccasion

Ƭ InputOccasion: "keydown" | "keypress" | "keyup"

The occasion that the input should be fired.

InputSpecifics

Ƭ InputSpecifics: Object

The specific options of the key to listen to.

Type declaration

Name	Type	Description
`checkType?`	`"key"` \| `"code"`	The type of key to check for. Defaults to `key`.
`identifier?`	`string`	A special identifier to tag this input with. This is useful for removing specific inputs from the input listener later on.
`occasion?`	`InputOccasion`	The occasion that the input should be fired. Defaults to `keydown`.

IsolatedFaceEntry

Ƭ IsolatedFaceEntry<TMaterial>: Object

Type parameters

Name
`TMaterial`

Type declaration

Name	Type
`blockId`	`number`
`createdAt`	`number`
`faceName`	`string`
`material`	`TMaterial`
`state`	`SurfaceState`
`voxel`	`Coords3`

ItemRendererFactory

Ƭ ItemRendererFactory: (itemDef: ItemDef, world: World) => ItemRenderer

Type declaration

▸ (itemDef, world): ItemRenderer

Parameters

Name	Type
`itemDef`	`ItemDef`
`world`	`World`

Returns

ItemRenderer

ItemSlotsOptions

Ƭ ItemSlotsOptions: Object

Type declaration

Name	Type
`activatedByDefault`	`boolean`
`focusFirstByDefault`	`boolean`
`horizontalCount`	`number`
`perspective`	`CameraPerspective`
`scrollable?`	`boolean`
`slotClass`	`string`
`slotFocusClass`	`string`
`slotGap`	`number`
`slotHeight`	`number`
`slotHoverClass`	`string`
`slotMargin`	`number`
`slotPadding`	`number`
`slotStyles`	`Partial`<`CSSStyleDeclaration`>
`slotSubscriptClass`	`string`
`slotSubscriptStyles`	`Partial`<`CSSStyleDeclaration`>
`slotWidth`	`number`
`verticalCount`	`number`
`wrapperClass`	`string`
`wrapperPadding`	`number`
`wrapperStyles`	`Partial`<`CSSStyleDeclaration`>
`zoom`	`number`

LegOptions

Ƭ LegOptions: ColorCanvasBoxOptions & { betweenLegsGap?: number }

Parameters to create the legs of a character. Defaults to:

{
  gap: 0.1 * CHARACTER_SCALE,
  layers: 1,
  side: THREE.DoubleSide,
  width: 0.25 * CHARACTER_SCALE,
  widthSegments: 3,
  height: 0.25 * CHARACTER_SCALE,
  heightSegments: 3,
  depth: 0.25 * CHARACTER_SCALE,
  depthSegments: 3,
  betweenLegsGap: 0.2 * CHARACTER_SCALE,
}

where CHARACTER_SCALE is 0.9.

LightBatch

Ƭ LightBatch: Object

Type declaration

Name	Type	Description
`batchId`	`number`	-
`completedJobs`	`number`	-
`jobs`	`LightJob`[]	-
`pendingDispatch`	`LightJob`[]	Jobs of this batch that have not been handed to a worker yet. Dispatch serializes every chunk the job's bounding box covers, so jobs wait here as cheap descriptors instead of as multi-megabyte copies.
`results`	`LightBatchResult`[]	-
`startSequenceId`	`number`	-
`totalJobs`	`number`	-

LightBatchResult

Ƭ LightBatchResult: Object

Type declaration

Name	Type
`borderNeighbors`	`LightWorkerBorderNeighbor`[]
`boundingBox`	`BoundingBox`
`color`	`LightColor`
`modifiedChunks`	`LightWorkerModifiedChunk`[]

LightColor

Ƭ LightColor: "RED" | "GREEN" | "BLUE" | "SUNLIGHT"

Sunlight or the color of torch light.

LightConeInput

Ƭ LightConeInput: Object

Type declaration

Name	Type	Description
`angleDeg`	`number`	Full outer cone angle in degrees.
`color`	`Color`	-
`direction`	`Vector3`	-
`innerRatio`	`number`	Inner (full-brightness) cone angle as a fraction of the outer angle.
`intensity`	`number`	-
`origin`	`Vector3`	-
`range`	`number`	-
`scatterStrength`	`number`	-
`submersion`	`number`	0 above water to 1 submerged; drives extinction and beam glow.

LightConeUniformBinding

Ƭ LightConeUniformBinding: LightConeUniforms[keyof LightConeUniforms]

LightConeUniforms

Ƭ LightConeUniforms: Object

Type declaration

Name	Type
`coneColors`	{ `value`: `Color`[] }
`coneColors.value`	`Color`[]
`coneCount`	{ `value`: `number` }
`coneCount.value`	`number`
`coneDirections`	{ `value`: `Vector3`[] }
`coneDirections.value`	`Vector3`[]
`coneOrigins`	{ `value`: `Vector4`[] }
`coneOrigins.value`	`Vector4`[]
`coneShapes`	{ `value`: `Vector4`[] }
`coneShapes.value`	`Vector4`[]

LightHandle

Ƭ LightHandle: number

Stable identity of a registered local light. Packed index:20 | generation:12; 0 is the invalid handle. Handles are plain numbers: storable, comparable, and allocation-free.

LightJob

Ƭ LightJob: Object

Type declaration

Name	Type
`batchId`	`number`
`boundingBox`	`BoundingBox`
`color`	`LightColor`
`jobId`	`string`
`lightOps`	{ `floods`: `LightNode`[] ; `removals`: `Coords3`[] }
`lightOps.floods`	`LightNode`[]
`lightOps.removals`	`Coords3`[]
`retryCount`	`number`
`startSequenceId`	`number`

LightNode

Ƭ LightNode: Object

Type declaration

Name	Type
`level`	`number`
`voxel`	`Coords3`

LightOperations

Ƭ LightOperations: Object

Type declaration

Name	Type
`floods`	{ `blue`: `LightNode`[] ; `green`: `LightNode`[] ; `red`: `LightNode`[] ; `sunlight`: `LightNode`[] }
`floods.blue`	`LightNode`[]
`floods.green`	`LightNode`[]
`floods.red`	`LightNode`[]
`floods.sunlight`	`LightNode`[]
`hasOperations`	`boolean`
`removals`	{ `blue`: `Coords3`[] ; `green`: `Coords3`[] ; `red`: `Coords3`[] ; `sunlight`: `Coords3`[] }
`removals.blue`	`Coords3`[]
`removals.green`	`Coords3`[]
`removals.red`	`Coords3`[]
`removals.sunlight`	`Coords3`[]

LightQualityTier

off is the user-facing disable: exactly the legacy flood-lit frame plus emissive faces. potato is the identical-looking low-end fallback tier — same rendering, kept separate so a device auto-downgrade and an explicit user setting remain distinguishable.

LightShadowPolicy

Ƭ LightShadowPolicy: "none" | "voxelMask" | "shadowMap"

LightShape

Ƭ LightShape: "point" | "spot" | "capsule"

LightShinedOptions

Ƭ LightShinedOptions: Object

Type declaration

Name	Type	Description
`lerpFactor`	`number`	The lerping factor of the brightness of each mesh. Defaults to `0.1`.
`maxBrightness`	`number`	The maximum brightness cap for the light effect. Defaults to `2.5`.
`resampleDistance`	`number`	Movement in blocks past which an object is resampled immediately instead of waiting out its interval: light data is voxel-grained, so a fast mover can cross into differently-lit voxels between scheduled samples. Defaults to `0.5`.
`sampleIntervalFrames`	`number`	Frames between fresh light samples for a stationary object. Each sample pays a sun raycast, a water-column walk, and a local-light query, while the sampled color is only ever consumed through the per-frame `lerpFactor` smoothing — a filter whose settling time is already several frames long, so a stationary object cannot display the difference between "sampled every frame" and "sampled every few frames". Objects are phase-staggered so the samples spread across frames instead of bunching. Defaults to `4`.

LightWorkerBorderNeighbor

Ƭ LightWorkerBorderNeighbor: Object

Type declaration

Name	Type
`coords`	`Coords2`
`maxY`	`number`
`minY`	`number`

LightWorkerModifiedChunk

Ƭ LightWorkerModifiedChunk: Object

Type declaration

Name	Type
`coords`	`Coords2`
`lights`	`Uint32Array`
`maxY`	`number`
`minY`	`number`

LightWorkerResult

Ƭ LightWorkerResult: Object

Type declaration

Name	Type	Description
`appliedDeltas`	{ `lastSequenceId`: `number` }	-
`appliedDeltas.lastSequenceId`	`number`	-
`borderNeighbors`	`LightWorkerBorderNeighbor`[]	Chunks the job did not write light into but whose meshes read a voxel it did: a light set in a chunk's border column shades the faces of the chunk next door (and the diagonal one at a corner). They carry no lights to merge — only the y-range to remesh.
`jobId`	`string`	-
`modifiedChunks`	`LightWorkerModifiedChunk`[]	-

MemoryPressureOptions

Ƭ MemoryPressureOptions: Object

Type declaration

Name	Type	Description
`recoveryHeapRatio`	`number`	Ratio at or below which pressure is considered relieved. Kept under MemoryPressureOptions.sheddingHeapRatio so the monitor has hysteresis instead of flapping around a single threshold.
`sampleIntervalMs`	`number`	Milliseconds between heap samples. Zero or less disables the watchdog.
`shedCooldownMs`	`number`	Minimum milliseconds between two shed actions while pressure persists.
`sheddingHeapRatio`	`number`	`usedJSHeapSize / jsHeapSizeLimit` at or above which the renderer is treated as under pressure and load shedding begins. A worker that runs out of V8 heap takes the whole renderer process down with it, so this sits well below the limit rather than near it.
`sheddingSampleCount`	`number`	Consecutive over-threshold samples required before shedding engages, so one transient spike (a large chunk batch mid-flight) does not throw away work that was about to be collected anyway.

MemoryPressureStatus

Ƭ MemoryPressureStatus: Object

Type declaration

Name	Type	Description
`heapLimitBytes`	`number`	-
`heapRatio`	`number`	-
`heapUsedBytes`	`number`	-
`isHeapReadable`	`boolean`	False on engines that expose no heap numbers; the monitor stays inert.
`isUnderPressure`	`boolean`	-
`shedCount`	`number`	-

MemoryPressureVerdict

Ƭ MemoryPressureVerdict: "steady" | "shed" | "relieved"

What a sample concluded: shed asks the owner to drop load now, relieved says pressure is over, steady means do nothing.

MeshApplyStats

Ƭ MeshApplyStats: Object

Cumulative cost of turning finished mesh results into live scene geometry (buildChunkMesh), the main-thread half of every remesh. bytes counts the geometry attribute payload applied, which is what the GPU upload scales with. Cumulative since world init so a caller can difference two reads.

Type declaration

Name	Type
`bytes`	`number`
`count`	`number`
`maxMs`	`number`
`totalMs`	`number`

MeshResultType

Ƭ MeshResultType: Object

Type declaration

Name	Type
`indices`	`Float32Array`
`normals`	`Float32Array`
`positions`	`Float32Array`

MeshTransferBenchmarkIteration

Ƭ MeshTransferBenchmarkIteration: Object

Type declaration

Name	Type
`inputBytes`	`number`
`outputBytes`	`number`
`serializeMs`	`number`
`totalMs`	`number`
`workerMs`	`number`

MeshTransferBenchmarkModeResult

Ƭ MeshTransferBenchmarkModeResult: Object

Type declaration

Name	Type
`avgSerializeMs`	`number`
`avgTotalMs`	`number`
`avgWorkerMs`	`number`
`isSharedArrayBufferAvailable`	`boolean`
`iterations`	`MeshTransferBenchmarkIteration`[]
`measuredIterations`	`number`
`p50TotalMs`	`number`
`p95TotalMs`	`number`
`strategy`	`WorkerTransferStrategy`
`totalInputBytes`	`number`
`totalOutputBytes`	`number`
`warmupIterations`	`number`

MeshTransferBenchmarkOptions

Ƭ MeshTransferBenchmarkOptions: Object

Type declaration

Name	Type
`cx`	`number`
`cz`	`number`
`level?`	`number`
`measuredIterations?`	`number`
`warmupIterations?`	`number`

MeshTransferBenchmarkResult

Ƭ MeshTransferBenchmarkResult: Object

Type declaration

Name	Type
`cx`	`number`
`cz`	`number`
`level`	`number`
`serializeSpeedup`	`number`
`shared`	`MeshTransferBenchmarkModeResult`
`speedup`	`number`
`transfer`	`MeshTransferBenchmarkModeResult`

MeshTransferDispatch

Ƭ MeshTransferDispatch: (cx: number, cz: number, level: number) => Promise<{ geometries: object[] ; inputBytes: number ; outputBytes: number ; serializeMs: number ; workerMs: number } | null>

Type declaration

▸ (cx, cz, level): Promise<{ geometries: object[] ; inputBytes: number ; outputBytes: number ; serializeMs: number ; workerMs: number } | null>

Parameters

Name	Type
`cx`	`number`
`cz`	`number`
`level`	`number`

Returns

Promise<{ geometries: object[] ; inputBytes: number ; outputBytes: number ; serializeMs: number ; workerMs: number } | null>

MeshWorkerTransferSample

Ƭ MeshWorkerTransferSample: Object

Type declaration

Name	Type
`at`	`number`
`inputBytes`	`number`
`outputBytes`	`number`
`serializeMs`	`number`
`strategy`	`WorkerTransferStrategy`
`totalMs`	`number`
`workerMs`	`number`

MeshWorkerTransferStats

Ƭ MeshWorkerTransferStats: Object

Type declaration

Name	Type
`jobCount`	`number`
`recentSamples`	`MeshWorkerTransferSample`[]
`strategy`	`WorkerTransferStrategy`
`totalInputBytes`	`number`
`totalOutputBytes`	`number`
`totalSerializeMs`	`number`
`totalWorkerMs`	`number`

NameTagOptions

Ƭ NameTagOptions: Object

Parameters to create a name tag.

Type declaration

Name	Type	Description
`backgroundColor?`	`string`	The background color of the name tag. Defaults to `0x00000077`.
`color?`	`string`	The color of the name tag. Defaults to `0xffffff`.
`fontFace?`	`string`	The font face to create the name tag. Defaults to `"monospace"`.
`fontSize?`	`number`	The font size to create the name tag. Defaults to `0.1`.
`yOffset?`	`number`	The y-offset of the nametag moved upwards. Defaults to `0`.

NetworkConnectionOptions

Ƭ NetworkConnectionOptions: Object

Type declaration

Name	Type	Description
`getTicket?`	() => `Promise`<`string` \| `null`>	-
`reconnectTimeout?`	`number`	Milliseconds between reconnection attempts after the socket drops. Defaults to DEFAULT_RECONNECT_TIMEOUT_MS; pass 0 to disable automatic reconnection.
`secret?`	`string`	-
`ticket?`	`string` \| `null`	Signed session ticket proving who this client is (id, name, role, ...). Sent as `?ticket=` on the socket upgrade and in the WebRTC offer. A server with session authentication derives the client id from it and ignores `client_id`; without one the client is admitted only where the server trusts client-chosen ids.
`useWebRTC?`	`boolean`	-

NetworkOptions

Ƭ NetworkOptions: Object

Type declaration

Name	Type	Description
`joinRetryTimeout`	`number`	Milliseconds a (re)join handshake may await its INIT before the join request is sent again.
`maxBacklogFactor`	`number`	-
`maxPacketsPerTick`	`number`	-
`maxPendingCommandPackets`	`number`	Upper bound on command packets (see COMMAND_PACKET_TYPES) held for retry after a send raced a closing socket. Beyond it the oldest are dropped loudly and counted in Network.droppedCommandCount: bounded loss beats unbounded buffering, but a command must never vanish in silence.
`maxQueuedPackets`	`number`	Upper bound on buffered inbound packets. Beyond it the oldest packets are dropped: the interest/keep-alive protocol re-converges on fresh state, so bounded loss beats unbounded memory growth when processing stalls.

ParsedRegistry

Ƭ ParsedRegistry: Object

Type declaration

Name	Type
`blocksById`	[`number`, `any`][]
`blocksByName`	[`string`, `any`][]
`idMap`	[`number`, `string`][]
`nameMap`	[`string`, `number`][]

PartialRecord

Ƭ PartialRecord<K, T>: { [P in K]?: T }

Type parameters

Name	Type
`K`	extends keyof `any`
`T`	`T`

PeersOptions

Ƭ PeersOptions: Object

Parameters to customize the peers manager.

Type declaration

Name	Type	Description
`autoAddToSelf`	`boolean`	-
`countSelf`	`boolean`	Whether or not should the client themselves be counted as "updated". In other words, whether or not should the update function be called on the client's own data. Defaults to `false`.
`updateChildren`	`boolean`	Whether or not should the peers manager automatically call `update` on any children mesh. Defaults to `true`.

PerspectiveOptions

Ƭ PerspectiveOptions: Object

Parameters to create a new Perspective instance.

Type declaration

Name	Type	Description
`blockMargin`	`number`	The margin between the camera and any block that the camera is colliding with. This prevents the camera from clipping into blocks. Defaults to `0.3`.
`ignoreFluids`	`boolean`	Whether or not should the camera ignore fluid block collisions. Defaults to `true`.
`ignoreSeeThrough`	`boolean`	Whether or not should the camera ignore see-through block collisions. Defaults to `true`.
`maxDistance`	`number`	The maximum distance the camera can go from the player's center. Defaults to `5`.
`swimDistanceBonus`	`number`	Extra camera distance while swimming in second/third person. Defaults to `3`.
`zoomInLerp`	`number`	Per-frame factor (at 60 fps) the camera closes toward a nearer obstruction. High, so a wall swinging in behind the player never shows the inside of a block. Defaults to `0.85`.
`zoomOutDelay`	`number`	Seconds the view must stay clear before the camera starts easing back out. A gap in a fence or canopy shorter than this never moves the camera at all, so a row of posts behind the player reads as one obstruction rather than a pump per post. Defaults to `0.25`.
`zoomOutLerp`	`number`	Per-frame factor (at 60 fps) the camera eases back out once an obstruction clears. Low on purpose: the voxel raycast behind the player flips between hit and miss in discrete steps as they walk past posts, trunks, and canopy gaps, and a symmetric fast lerp turned every flip into a visible zoom pump. Snapping in and gliding out merges those into one dip. Defaults to `0.12`.

PortraitOptions

Ƭ PortraitOptions: Object

Parameters to create a portrait with.

Type declaration

Name	Type	Description
`height`	`number`	The height of the portrait canvas. Defaults to `100` pixels.
`lightRotationOffset`	`number`	The rotation around the y axis about the camera. This is used to calculate the position of the light. Defaults to `-Math.PI / 8`.
`perspective`	`CameraPerspective`	The position of where the camera should be looking at. Defaults to `pxyz`, which means that the camera will be looking at the center of the object from the positive x, y, and z axis scaled by the zoom.
`renderOnce`	`boolean`	Whether or not should this portrait only render once. Defaults to `false`.
`width`	`number`	The width of the portrait canvas. Defaults to `100` pixels.
`zoom`	`number`	The arbitrary zoom from the camera to the object. This is used to calculate the zoom of the camera. Defaults to `1`.

ProcessedUpdate

Ƭ ProcessedUpdate: Object

Type declaration

Name	Type
`newBlock`	`Block`
`newId`	`number`
`newRotation`	`BlockRotation`
`oldBlock`	`Block`
`oldId`	`number`
`oldRotation`	`BlockRotation`
`oldStage`	`number`
`stage`	`number`
`voxel`	`Coords3`

ProtocolWS

Ƭ ProtocolWS: WebSocket & { sendEvent: (event: any) => boolean }

RigidControlState

Ƭ RigidControlState: Object

The state of which a Voxelize Controls is in.

Type declaration

Name	Type	Description
`crouching`	`boolean`	Whether if the client is attempting to crouch, if the crouch key is pressed. Defaults to `false`.
`currentJumpTime`	`number`	The current amount of time spent in the air from jump. Defaults to `0`.
`heading`	`number`	In radians, the heading y-rotation of the client. Defaults to `0`.
`isJumping`	`boolean`	Whether or not is the client jumping, in the air. Defaults to `false`.
`jumpCount`	`number`	How many times has the client jumped. Defaults to `0`.
`jumping`	`boolean`	Whether if the client is attempting to jump, if the jump key is pressed. Defaults to `false`.
`running`	`boolean`	Whether if the client is running. Defaults to `false`.
`sprinting`	`boolean`	Whether if the client is attempting to sprint, if the sprint key is pressed. Defaults to `false`.

RigidControlsOptions

Ƭ RigidControlsOptions: Object

Parameters to initialize the Voxelize Controls.

Type declaration

Name	Type	Description
`airJumps`	`number`	How many times can a client jump in the air. Defaults to `0`.
`airMoveMult`	`number`	The factor applied to the movements of the client in air, such as while half-jump. Defaults to `0.7`.
`alwaysSprint`	`boolean`	Sprint factor would be on always. Defaults to `false`.
`autoJump`	`boolean`	Jump automatically at a ledge too tall to step onto but low enough for a jump to clear, the way voxel games with an auto-jump option do. The jump is a real one through the normal jump path, started ahead of the ledge so the feet pass its top on the way up instead of bumping the face first. Off while crouching, swimming, climbing, flying, or walking backwards. Defaults to `true`.
`autoJumpCooldown`	`number`	Milliseconds after an automatic jump before another may fire. Defaults to `100`.
`autoJumpFacingDot`	`number`	Cosine between the look direction and the travel direction below which auto-jump stays off, so walking backwards into a ledge never hops onto it blind. Pure strafing (cosine 0) still hops. Defaults to `-0.15`.
`autoJumpLookahead`	`number`	Seconds of travel scanned ahead for a jumpable ledge. The jump fires as soon as a ledge enters this window, so it must exceed the time the jump takes to rise past the tallest auto-jumpable ledge (about 0.24 s for 1.2 blocks at the default impulse and gravity). Defaults to `0.3`.
`autoJumpMaxHeight`	`number`	Tallest rise auto-jump attempts, in blocks. Kept under what the jump actually clears (the apex from `jumpImpulse` against gravity, 1.29 at the defaults) so the landing has margin. Defaults to `1.2`.
`autoJumpMinLookahead`	`number`	Minimum scan distance in blocks, so a client standing against a ledge still hops the moment it starts walking into it. Defaults to `0.2`.
`bodyDepth`	`number`	The depth of the client's avatar. Defaults to `0.8` blocks.
`bodyHeight`	`number`	The height of the client's avatar. Defaults to `1.55` blocks.
`bodyWidth`	`number`	The width of the client's avatar. Defaults to `0.8` blocks.
`crouchBodyHeight`	`number`	The height of the client's avatar when crouching. Defaults to `bodyHeight * 0.83`.
`crouchFactor`	`number`	The factor to the movement speed when crouch is applied. Defaults to `0.6`.
`eyeHeight`	`number`	The ratio to `bodyHeight` at which the camera is placed from the ground. Defaults at `0.9193548387096774`.
`fluidPushForce`	`number`	The force upwards when a client tries to jump in water. Defaults to `0.3`.
`flyClimbSpeedPenalty`	`number`	Fraction of fly speed lost at a straight-up climb when pitch steering is active, trading speed for altitude. Defaults to `0`.
`flyDiveSpeedBoost`	`number`	Extra speed multiplier granted at a straight-down dive when pitch steering is active. `1.2` means a vertical dive flies at `2.2x` the base fly speed. Scales quadratically with dive steepness. Defaults to `0`.
`flyForce`	`number`	The level of force at which a client flies at. Defaults to `80`.
`flyImpulse`	`number`	The level impulse of which a client flies at. Defaults to `2.5`.
`flyInertia`	`number`	The inertia of a client when they're flying. Defaults to `6`.
`flyPitchSteering`	`number`	How much the camera pitch steers fly movement, from `0` (movement stays horizontal) to `1` (movement follows the full look vector, elytra-style). Defaults to `0`.
`flySpeed`	`number`	The level of speed at which a client flies at. Defaults to `40`.
`initialDirection`	`Coords3`	-
`initialPosition`	`Coords3`	Initial position of the client. Defaults to `(0, 80, 10)`.
`jumpForce`	`number`	The level of force applied to the client when jumping. Defaults to `1`.
`jumpImpulse`	`number`	The level of impulse at which the client jumps upwards. Defaults to `8`.
`jumpTime`	`number`	The time, in milliseconds, that a client can be jumping. Defaults to `50`ms.
`maxPolarAngle`	`number`	Maximum polar angle that camera can look up to. Defaults to `Math.PI * 0.99`
`maxSpeed`	`number`	The maximum level of speed of a client. Default is `6` .
`minPolarAngle`	`number`	Minimum polar angle that camera can look down to. Defaults to `Math.PI * 0.01`.
`moveForce`	`number`	The level of force of which the client can move at. Default is `30`.
`positionLerp`	`number`	The interpolation factor of the client's position. Defaults to `1.0`.
`responsiveness`	`number`	The level of responsiveness of a client to movements. Default is `240`.
`restoreFootSnapEpsilon`	`number`	-
`rotationLerp`	`number`	The interpolation factor of the client's rotation. Defaults to `0.9`.
`runningFriction`	`number`	Default running friction of a client. Defaults to `0.1`.
`sensitivity`	`number`	The mouse sensitivity. Defaults to `100`.
`sprintFactor`	`number`	The factor to the movement speed when sprint is applied. Defaults to `1.4`.
`standingFriction`	`number`	Default standing friction of a client. Defaults to `4`.
`stepEyeClearance`	`number`	Height, in blocks, the eye always keeps above the top of a step it just climbed while it eases up after the body. Caps how far the eye may trail when a staircase stacks steps faster than they settle, so the camera never sinks into the tread it stands on. Defaults to `0.25`.
`stepGrazeRatio`	`number`	Along-face to into-face motion ratio above which contact with a ledge is a graze that slides along it rather than an approach that steps onto it. `4` ignores approaches shallower than ~14°, so brushing a block while walking past does not pop the client onto it. `0` steps on any blocked contact. Defaults to `4`.
`stepHeight`	`number`	How tall a client can step up. Defaults to `0.5`.
`stepSmoothTime`	`number`	How long, in milliseconds, the eye takes to close 95% of a one-block auto-step; smaller steps settle proportionally faster (a half slab in half the time). The body itself climbs the step in a single physics tick; this eases only the eye (and what follows it: the streamed position, the third-person character) up after it on a critically damped spring, so the rise is an S-curve with no pop and no overshoot at any frame rate. `0` snaps the eye with the body. Defaults to `250`.
`swimAABBLerp`	`number`	Lerp factor for the swim hitbox height transition. Defaults to `0.08`.
`swimBodyHeight`	`number`	Collision height while swimming. Defaults to `0.4`.
`swimForce`	`number`	Force applied while swimming. Defaults to `28`.
`swimFriction`	`number`	Friction while swimming and moving. Defaults to `0.05`.
`swimIdleStandDelay`	`number`	Time without swim movement input before returning to an upright pose. Defaults to `3000`.
`swimRestoreGraceFrames`	`number`	Frames to keep the swim AABB after restoring a saved swimming session. Defaults to `2`.
`swimSpeed`	`number`	Target speed while swimming. Defaults to `4.5`.
`swimSubmersionRatio`	`number`	Minimum ratio of the body submerged before swimming mechanics activate. Defaults to `0.95`.

SectionExtentOptions

Ƭ SectionExtentOptions: Object

Type declaration

Name	Type
`chunkSize`	`number`
`maxHeight`	`number`
`subChunks`	`number`

SectionVisibilityGraphOptions

Ƭ SectionVisibilityGraphOptions: Object

Type declaration

Name	Type
`chunkSize`	`number`
`maxHeight`	`number`
`subChunks`	`number`

SerializedBlockRotation

Ƭ SerializedBlockRotation: { [K in "PX" | "NX" | "PY" | "NY" | "PZ" | "NZ"]?: number }

The wire shape of a block rotation inside server-authored block rules: the Rust BlockRotation enum serializes as a single-key object mapping the axis to the y-rotation angle in radians, e.g. { "PX": 0 }.

SerializedRegistry

Ƭ SerializedRegistry: string | SerializedRegistryPayload

The wire form of a registry: a JSON string (what serialize returns) or, for tests and in-process callers, the already-parsed payload.

SerializedRegistryPayload

Ƭ SerializedRegistryPayload: Object

Type declaration

Name	Type
`blocksById`	[`number`, `any`][]
`idMap`	[`number`, `string`][]
`nameMap`	[`string`, `number`][]
`version`	`number`

ShadowInvalidationCause

SkyOptions

Ƭ SkyOptions: Object

Type declaration

Name	Type	Description
`dimension`	`number`	The dimension of the dodecahedron sky. The inner canvas box is 0.8 times this dimension.
`lerpFactor`	`number`	The lerp factor for the sky gradient. The sky gradient is updated every frame by lerping the current color to the target color. set by the `setTopColor`, `setMiddleColor`, and `setBottomColor` methods.
`textureBloomIntensity`	`number`	The emissive boost applied to painted sky texels above `textureBloomThreshold`. Defaults to `2.0`.
`textureBloomThreshold`	`number`	The luminance at which painted sky textures begin to feed bloom. Defaults to `0.72`.
`transitionSpan`	`number`	-

SkyShadingCycleData

Ƭ SkyShadingCycleData: Object

Type declaration

Name	Type
`color`	{ `bottom`: `Color` \| `string` ; `middle`: `Color` \| `string` ; `top`: `Color` \| `string` }
`color.bottom`	`Color` \| `string`
`color.middle`	`Color` \| `string`
`color.top`	`Color` \| `string`
`name`	`string`
`skyOffset`	`number`
`start`	`number`
`voidOffset`	`number`

SlotContent

Ƭ SlotContent: { type: "empty" } | { count: number ; id: number ; type: "block" } | { count: number ; data?: Record<string, unknown> ; id: number ; type: "item" }

SoundEffectEventHandler

Ƭ SoundEffectEventHandler: (payload: SoundEffectEventPayload) => void

Type declaration

▸ (payload): void

Parameters

Name	Type
`payload`	`SoundEffectEventPayload`

Returns

void

SoundEffectEventPayload

Ƭ SoundEffectEventPayload: Object

Type declaration

Name	Type
`id`	`string`
`pitch?`	`number`
`position?`	[`number`, `number`, `number`]
`radius?`	`number`
`sourceClientId?`	`string`
`volume?`	`number`

SurfaceKind

Ƭ SurfaceKind: "atlas-slot" | "own-face" | "isolated-face"

SurfaceState

Ƭ SurfaceState: "unknown" | "default" | "fallback" | "painted"

unknown: the checker.
default: an isolated face wearing its face's default art while it waits for the voxel's own paint (blank paper, an empty frame).
fallback: painted by World.fillUnpaintedSurfaces, not by its own texture.
painted: its own art.

SurfaceTally

Ƭ SurfaceTally: Object

Type declaration

Name	Type
`default`	`number`
`fallback`	`number`
`painted`	`number`
`total`	`number`
`unknown`	`number`

TabCompleteContext

Ƭ TabCompleteContext: Object

Options for adding a command.

Type declaration

Name	Type
`args`	`Record`<`string`, `string`>

TargetType

Ƭ TargetType: "All" | "Player" | "Entity"

TextureCensus

Ƭ TextureCensus: Object

Type declaration

Name	Type	Description
`atlasSlots`	`SurfaceTally`	-
`isolatedFaces`	`SurfaceTally`	-
`ownFaces`	`SurfaceTally`	-
`unpainted`	`UnpaintedSurface`[]	Every surface not wearing its own art, worst first.

TextureFillResult

Ƭ TextureFillResult: Object

Type declaration

Name	Type
`color`	`string`
`filled`	{ `atlasSlots`: `number` ; `isolatedFaces`: `number` ; `ownFaces`: `number` }
`filled.atlasSlots`	`number`
`filled.isolatedFaces`	`number`
`filled.ownFaces`	`number`

TextureInfo

Ƭ TextureInfo: Object

Type declaration

Name	Type
`blockId`	`number`
`blockName`	`string`
`canvas`	`HTMLCanvasElement` \| `null`
`faceName`	`string`
`materialKey`	`string`
`range`	`UV` \| `null`
`type`	`"shared"` \| `"independent"` \| `"isolated"`

TransparencyFlags

Ƭ TransparencyFlags: Object

Type declaration

Name	Type
`isFluid`	`boolean`
`isSeeThrough`	`boolean`
`lightAttenuation`	`number`
`transparentStandalone`	`boolean`

TransparentSortClassification

Ƭ TransparentSortClassification: "single-plane" | "plane-triggers" | "distance"

How a translucent mesh decides when to re-sort:

"single-plane" — every face lies in one plane, so no camera ray can ever hit two faces; the mesh never needs sorting.
"plane-triggers" — all faces are axis-aligned quads. A valid painter's order can only change when the camera crosses one of the mesh's distinct face planes, so re-sorts fire on plane crossings instead of distance moved (Sodium's trigger model).
"distance" — geometry with non-axis-aligned faces falls back to the original re-sort-every-half-block behavior.

TransparentSortStats

Ƭ TransparentSortStats: Object

Cumulative main-thread cost of per-face translucency sorting across all meshes since page load: how many sorts ran, their total/max milliseconds, and the number of faces pushed through the radix sort. Difference two reads for a window; a camera strafe re-sorts every mesh each time it crosses the movement threshold, which is exactly the cost this exists to expose.

Type declaration

Name	Type
`count`	`number`
`faces`	`number`
`maxMs`	`number`
`totalMs`	`number`

UV

Ƭ UV: Object

The UV range of a texture on the texture atlas.

Type declaration

Name	Type	Description
`endU`	`number`	The ending U coordinate of the texture.
`endV`	`number`	The ending V coordinate of the texture.
`startU`	`number`	The starting U coordinate of the texture.
`startV`	`number`	The starting V coordinate of the texture.

UnpaintedSurface

Ƭ UnpaintedSurface: Object

Type declaration

Name	Type	Description
`ageMs?`	`number`	Isolated faces only: how long the material has existed.
`blockId`	`number`	-
`blockName`	`string`	-
`faceName`	`string`	-
`kind`	`SurfaceKind`	-
`state`	`Exclude`<`SurfaceState`, `"painted"`>	-
`textureGroup`	`string` \| `null`	-
`voxel?`	`Coords3`	Isolated faces only: the voxel whose face this is.

VoxelDelta

Ƭ VoxelDelta: Object

Type declaration

Name	Type
`coords`	`Coords3`
`newRotation?`	`BlockRotation`
`newStage?`	`number`
`newVoxel`	`number`
`oldRotation?`	`BlockRotation`
`oldStage?`	`number`
`oldVoxel`	`number`
`sequenceId`	`number`
`timestamp`	`number`

VoxelInteractOptions

Ƭ VoxelInteractOptions: Object

Parameters to customize the VoxelInteract instance.

Type declaration

Name	Type	Description
`highlightColor`	`Color`	The color of the highlight. Defaults to `0xffffff`.
`highlightLerp`	`number`	The lerping factor of the highlight. Defaults to `0.8`.
`highlightOpacity`	`number`	The opacity of the highlight. Defaults to `0.8`.
`highlightScale`	`number`	The scale of the block highlight. Defaults to `1.002`.
`highlightType`	`"box"` \| `"outline"`	The type of the block highlight. Box would be a semi-transparent box, while outline would be 12 lines that outline the block's AABB union. Defaults to `"box"`.
`ignoreFluids`	`boolean`	Whether or not should the VoxelInteract instance ignore fluids when raycasting. Defaults to `true`.
`inverseDirection`	`boolean`	Whether or not should the VoxelInteract instance reverse the raycasting direction. Defaults to `false`.
`potentialVisuals`	`boolean`	`Debug` Whether or not should there be arrows indicating the potential block placement's orientations. Defaults to `false`.
`reachDistance`	`number`	The maximum distance of reach for the VoxelInteract instance. Defaults to `32`.

VoxelLightVolumeOptions

Ƭ VoxelLightVolumeOptions: Object

Type declaration

Name	Type
`chunkSize`	`number`
`maxChunk`	[`number`, `number`]
`maxHeight`	`number`
`maxLightLevel`	`number`
`minChunk`	[`number`, `number`]

WaterChannelCoefficients

Ƭ WaterChannelCoefficients: Object

Per-channel coefficients for Beer-Lambert water extinction, expressed per block (~meter) of water. All water rendering derives from this one table.

Type declaration

Name	Type
`blue`	`number`
`green`	`number`
`red`	`number`

WaterColumnSample

Ƭ WaterColumnSample: Object

Type declaration

Name	Type
`depth`	`number`
`surfaceY`	`number`

WaterOpticsFrameInput

Ƭ WaterOpticsFrameInput: Object

Type declaration

Name	Type
`cameraX`	`number`
`cameraY`	`number`
`cameraZ`	`number`
`deltaSeconds`	`number`
`isFluidAt`	`FluidQuery`
`sunStrength`	`number`

WorkerPoolJob

Ƭ WorkerPoolJob: Object

A worker pool job is queued to a worker pool and is executed by a worker.

Type declaration

Name	Type	Description
`buffers?`	`Transferable`[]	Any array buffers (transferable) that are passed to the worker.
`message`	`any`	A JSON serializable object that is passed to the worker.
`resolve`	(`value`: `any`) => `void`	-
`timeoutMs?`	`number`	Milliseconds this job may run before its worker is presumed dead. A worker that OOMs mid-job dies without any error event, which used to leave the slot occupied and the job unresolved forever (frozen lighting/meshing). On timeout the worker is replaced and the job resolves `null`.

WorkerPoolOptions

Ƭ WorkerPoolOptions: Object

Parameters to create a worker pool.

Type declaration

Name	Type	Description
`maxQueuedJobs?`	`number`	Jobs allowed to wait for a free worker before the oldest are shed (resolved `null`, exactly like a dead worker). Left undefined the queue is unbounded, which is only safe when the caller gates dispatch on WorkerPool.availableCount: every queued job holds its serialized payload alive, so a caller that enqueues faster than workers drain turns the queue into an unbounded allocation. Opt in only from callers that treat a `null` result as a retryable failure.
`maxWorker`	`number`	The maximum number of workers to create. Defaults to `8`.
`name?`	`string`	The name prefix for workers in this pool. Workers will be named `{name}-0`, `{name}-1`, etc. Shows up in DevTools for debugging.

WorkerTransferConfig

Ƭ WorkerTransferConfig: Object

Type declaration

Name	Type
`maxRecentSamples`	`number`
`mode`	`WorkerTransferMode`

WorkerTransferMode

Ƭ WorkerTransferMode: "auto" | WorkerTransferStrategy

WorkerTransferStrategy

Ƭ WorkerTransferStrategy: "transfer" | "shared"

WorldChunkEvents

Ƭ WorldChunkEvents: Object

Type declaration

Name	Type
`chunk-data-loaded`	(`data`: `ChunkDataEventData`) => `void`
`chunk-loaded`	(`data`: `ChunkEventData`) => `void`
`chunk-mesh-loaded`	(`data`: `ChunkMeshEventData`) => `void`
`chunk-mesh-unloaded`	(`data`: `ChunkMeshEventData`) => `void`
`chunk-mesh-updated`	(`data`: `ChunkMeshUpdateEventData`) => `void`
`chunk-unloaded`	(`data`: `ChunkEventData`) => `void`
`chunk-updated`	(`data`: `ChunkUpdateEventData`) => `void`

WorldClientOptions

Ƭ WorldClientOptions: Object

The client-side options to create a world. These are client-side only and can be customized to specific use.

Type declaration

Name	Type	Description
`chunkCullShadowSafeDistance`	`number`	Blocks within which chunks stay visible even when the camera is looking away from them, because geometry behind the camera still casts shadows into the view. Defaults to `160` blocks, comfortably past the shadow cascades' 128-block reach; shorten it below that and near shadows start vanishing as the player turns. In blocks rather than chunks so that a world choosing a coarser chunk size does not silently pin hundreds of chunks visible.
`chunkLoadExponent`	`number`	The exponent applied to the ratio that chunks are loaded, which would then be used to determine whether an angle to a chunk is worth loading. Defaults to `8`.
`chunkRerequestIntervalMs`	`number`	How long a requested chunk may go unanswered before the request is presumed lost and reissued, in milliseconds. Defaults to `5000`ms.
`chunkUniformsOverwrite`	`Partial`<`ChunkRenderer`[`"uniforms"`]>	The uniforms to overwrite the default chunk material uniforms. Defaults to `{}`.
`clientOnlyMeshing`	`boolean`	Whether to use client-only meshing. When true, chunks are always meshed locally. When false, server-provided meshes are used for initial chunk load. Defaults to `true`.
`cloudsOptions`	`Partial`<`CloudsOptions`>	The options to create the clouds. Defaults to `{}`.
`defaultRenderRadius`	`number`	The default render radius of the world, in chunks. Change this through `world.renderRadius`. Defaults to `8` chunks.
`deltaRetentionTime`	`number`	How long to retain delta history in milliseconds. Defaults to 5000ms.
`distantDetailCullBelowY`	`number` \| `null`	World Y under which distant chunks are left unmeshed, trading the terrain below it for a much larger render radius. Only chunks farther away than nearDetailRadius are culled; the ones around the player always mesh to the ground, and a chunk fills in the rest as the player approaches. `null` (the default) meshes everything everywhere. Culling leaves the underside of distant terrain open, so this is only invisible when something opaque sits over the cut — a cloud deck whose lowest surface is above the cut line. Set it above that and distant mountains read as hollow shells. For the same reason the cull applies only while the player is above this line. Underneath it the deck is no longer in the way, so the world meshes in full and gives up the range until they climb back over it. Only applies under clientOnlyMeshing; server-meshed worlds render what they are sent.
`distantDetailCullHysteresis`	`number`	How far above distantDetailCullBelowY the player must climb before culling resumes, having dropped below it. Falling below the line always suspends culling immediately — the gap only delays switching it back on, so that standing at the line does not flip the two states frame by frame. Defaults to `8` blocks.
`fogCullSlack`	`number`	Blocks past the fog far edge a section may reach before fog culling hides it, absorbing the difference between a section's center distance and the nearest fragment the fog actually shades.
`fogFarRenderRatio`	`number`	Fraction of render distance where horizon fog fully hides terrain. Defaults to `0.78`.
`fogNearRenderRatio`	`number`	Fraction of render distance where horizon fog starts. Defaults to `0.45`.
`isCullingChunksByFog`	`boolean`	Whether the occlusion walk also prunes sections past the fog's far edge, where every fragment already resolves to pure fog color.
`isCullingChunksByFrustum`	`boolean`	Whether whole chunk subtrees are hidden while the camera cannot see them. three.js culls per mesh, but it pays to walk the scene graph first: every node is visited by the matrix pass and the culling pass whether or not it ends up drawn, and a wide render radius is tens of thousands of visits per frame. Testing one box per chunk and hiding the ones that miss lets the renderer skip those branches outright. Requires a camera to be passed to World.update; without one there is nothing to cull against and every chunk stays visible.
`isCullingChunksByOcclusion`	`boolean`	Whether to hide chunk sections the camera provably cannot see through the terrain, walking the mesher-reported face-connectivity graph outward from the camera's own section (Sodium-style occlusion culling). An enclosed interior stops drawing the world around it. Requires WorldClientOptions.isCullingChunksByFrustum, since the walk also carries the frustum test.
`lightJobRetryLimit`	`number`	Maximum number of retries for stale light jobs before falling back to sync. Defaults to 3.
`lightJobTimeoutMs`	`number`	Milliseconds a light worker job may run before its worker is presumed dead (an OOMed worker dies without any error event) and replaced. Defaults to `20000`.
`localLights`	`Partial`<`LocalLightsOptions`>	Budgets, capacities, and quality tier of the local light emitter system (`world.localLights`). See LocalLightsOptions for the knobs; defaults make an unconfigured world pay nothing.
`maxChunkRequestsPerUpdate`	`number`	The maximum chunk requests this world can request from the server per world update. Defaults to `12` chunks.
`maxDetailRefinementsPerUpdate`	`number`	How many chunks may have their culled levels queued for meshing per world update. Refinement is spread over frames and ordered nearest-first so walking into a region never lands as one burst of mesh jobs. Defaults to `4` chunks.
`maxImmediateServerUpdates`	`number`	Server update batches larger than this are drained through the incremental per-frame update queue instead of being applied (and relit) synchronously in one shot. Defaults to `500` updates.
`maxLightWorkers`	`number`	Maximum concurrent light workers. Defaults to 2.
`maxLightsUpdateTime`	`number`	-
`maxMeshesPerUpdate`	`number`	-
`maxOptimisticClientUpdates`	`number`	Client batches larger than this skip the optimistic local apply (with its per-frame relight) and stream straight to the server; the world catches up from the server's tick-batched echo. Keeps bulk edits (WorldEdit) from freezing the tab and guarantees the whole batch is on the wire before any reload. Defaults to `4000` updates.
`maxProcessesPerUpdate`	`number`	The maximum amount of chunks received from the server that can be processed per world update. By process, it means to be turned into a `Chunk` instance. Defaults to `8` chunks.
`maxQueuedWorkerJobs`	`number`	Jobs allowed to wait for a free mesh or light worker before the oldest are shed. Dispatch is already gated on free worker slots, so this is the backstop that keeps a future caller from parking unbounded serialized chunk payloads in a pool queue. Defaults to `8`.
`maxUpdatesPerUpdate`	`number`	The maximum voxel updates that can be sent to the server per world update. Defaults to `1000` updates.
`maxUrgentMeshWorkers`	`number`	Dedicated mesh workers reserved for client-originated voxel edits.
`maxVoxelHistoryPerVoxel`	`number`	Previous values retained per voxel. Defaults to `4`.
`maxVoxelHistoryVoxels`	`number`	Distinct voxels tracked by World.getPreviousValueAt. The history is a debugging convenience, not gameplay state, so it evicts oldest-first instead of growing with every voxel a session ever edits. Defaults to `4096`.
`memoryPressure`	`Partial`<`MemoryPressureOptions`>	Renderer heap watchdog thresholds. See MemoryPressureOptions.
`mergeChunkGeometries`	`boolean`	Whether to merge chunk geometries to reduce draw calls. Useful for mobile. Defaults to false.
`meshApplyBudgetMs`	`number`	Per-frame time budget for applying completed regular mesh results on the main thread, in milliseconds. At least one result always applies per frame; the budget is checked after each apply. Urgent (player-edit) results and the initial join flow bypass the budget entirely. Defaults to `3`.
`meshJobTimeoutMs`	`number`	Milliseconds a mesh worker job may run before its worker is presumed dead and replaced. Defaults to `30000`.
`minLightLevel`	`number`	The minimum light level even when sunlight and torch light levels are at zero. Defaults to `0.04`.
`nearDetailRadius`	`number`	Chunk radius within which every sub-chunk level is meshed regardless of distantDetailCullBelowY. Defaults to `10` chunks.
`plantDetailDistance`	`number` \| `null`	Block distance out to which plant decoration (grass tufts, flowers — any block the registry marks `isPlant`) is drawn. Beyond it those meshes are hidden. `null` (the default) draws them everywhere. Plants cannot share a mesh with the terrain: each species is its own double-sided alpha-tested material, so a chunk with grass and two flower species costs three extra draw calls no matter how few blocks are in them. Across a wide render disc that is most of the frame's draw calls spent on geometry a metre wide, which past a couple of hundred blocks covers well under a pixel. This hides whole meshes rather than fading them, so set it past the point where a tuft is still resolvable or the boundary reads as a moving edge in the ground cover.
`regionArenas`	`ChunkRegionArenasOptions` \| `null`	Region buffer arenas for the shared-opaque chunk bucket. See ChunkRegionArenasOptions. `null` disables batching and keeps per-section meshes.
`skyOptions`	`Partial`<`SkyOptions`>	The options to create the sky. Defaults to `{}`.
`statsSyncInterval`	`number`	The interval between each time the world requests the server for its stats. Defaults to 500ms.
`sunlightChangeSpan`	`number`	The fraction of the day that sunlight takes to change from appearing to disappearing or disappearing to appearing. Defaults to `0.1`.
`sunlightEndTimeFrac`	`number`	The fraction of the day that sunlight starts to disappear. Defaults to `0.7`.
`sunlightStartTimeFrac`	`number`	The fraction of the day that sunlight starts to appear. Defaults to `0.25`.
`swayProfileCapacity`	`number`	Slots in the shared cutout buckets' sway-profile uniform table (one vec4 pair each). Slot 0 is reserved for "no sway", so a world can register one fewer distinct profile than this. Defaults to `16`.
`textureUnitDimension`	`number`	The default dimension to a single unit of a block face texture. If any texture loaded is greater, it will be downscaled to this resolution. Defaults to `8` pixels.
`timeForceThreshold`	`number`	The threshold to force the server's time to the client's time. Defaults to `0.1`.
`unpaintedFallbackColor`	`string`	The flat colour World.fillUnpaintedSurfaces paints over a surface still wearing the magenta-and-black unknown checker when there is no better default to give it. A quiet warm grey by default, so a stage with a missing texture reads as unfinished rather than broken.
`useLightWorkers`	`boolean`	Whether to use web workers for light calculations. Defaults to true.

WorldFogRange

Ƭ WorldFogRange: Object

Type declaration

Name	Type
`far`	`number`
`near`	`number`

WorldMemoryCounters

Ƭ WorldMemoryCounters: Object

A snapshot of every queue and in-flight set in the voxel update -> relight -> remesh pipeline. See World.getMemoryCounters.

Type declaration

Name	Type	Description
`activeLightBatchPendingJobs`	`number`	-
`activeLightBatchUndispatchedJobs`	`number`	-
`blockUpdatesApplied`	`number`	Cumulative since world init, so a caller can difference two reads to charge a burst of activity (a water spread, a bulk fill) with exactly the voxel writes and light work it caused.
`blockUpdatesQueue`	`number`	-
`blockUpdatesToEmit`	`number`	-
`lightJobHighWaterChunks`	`number`	-
`lightJobQueue`	`number`	-
`lightJobsScheduled`	`number`	-
`lightQueue`	`number`	-
`lightQueuedBytes`	`number`	-
`lightSeedsAnalyzed`	`number`	Removal + flood seeds handed to the light engine, all colors.
`lightWorking`	`number`	-
`loadedChunks`	`number`	-
`memoryPressure`	`MemoryPressureStatus`	-
`meshDirtyKeys`	`number`	-
`meshInFlightJobs`	`number`	-
`meshQueue`	`number`	-
`meshQueuedBytes`	`number`	-
`meshWorking`	`number`	-
`urgentMeshQueue`	`number`	-
`urgentMeshQueuedBytes`	`number`	-
`urgentMeshWorking`	`number`	-
`voxelDeltaChunks`	`number`	-
`voxelDeltaTotal`	`number`	-
`voxelHistoryVoxels`	`number`	-

WorldOptions

Ƭ WorldOptions: WorldClientOptions & WorldServerOptions

The options to create a world. This consists of WorldClientOptions and WorldServerOptions.

WorldServerOptions

Ƭ WorldServerOptions: Object

The options defined on the server-side, passed to the client on network joining.

Type declaration

Name	Type	Description
`airDrag`	`number`	The air drag of everything physical.
`chunkSize`	`number`	The width and depth of a chunk, in blocks.
`doesTickTime`	`boolean`	-
`fluidDensity`	`number`	The density of the fluid in this world.
`fluidDrag`	`number`	The fluid drag of everything physical.
`gravity`	`number`[]	The gravity of everything physical in this world.
`maxChunk`	[`number`, `number`]	The maximum chunk coordinate of this world, inclusive.
`maxHeight`	`number`	The height of a chunk, in blocks.
`maxLightLevel`	`number`	The maximum light level that propagates in this world, including sunlight and torch light.
`minBounceImpulse`	`number`	The minimum bouncing impulse of everything physical in this world.
`minChunk`	[`number`, `number`]	The minimum chunk coordinate of this world, inclusive.
`subChunks`	`number`	The number of sub-chunks that divides a chunk vertically.
`timePerDay`	`number`	The time per day in seconds.
`waterLevel`	`number`	The nominal water level of this world, in blocks.

Variables

ABOVE_SURFACE_WATER_FOG_FRAGMENT

• Const ABOVE_SURFACE_WATER_FOG_FRAGMENT: string

The above-surface counterpart of UNDERWATER_FOG_FRAGMENT: the same Beer-Lambert in-scattering fog, but for water-exposed terrain seen from outside the surface. It fades a submerged fragment toward the water's own depth-filtered in-scattered color along the sub-surface segment of the view ray. The scatter target darkens spectrally with the fragment's depth instead of sending every long ray toward the bright surface teal, so deep water reads as ocean rather than milky water.

Expects outgoingLight, uCameraSubmersion, uUnderwaterAmbient, vWaterExposed, and vertex-interpolated vAboveSurfaceWaterTransmit in scope. The vertex stage computes the expensive ray length and exponential; transmission varies smoothly enough across a voxel face to interpolate. Runs before sky/height fog so nearer air fog layers on top.

BLOCK_LIGHT_OWNERSHIP_GAIN

• Const BLOCK_LIGHT_OWNERSHIP_GAIN: 1.5

Safety gain on the analytic claim when it suppresses the baked flood term: the two models approximate the same sources with different falloff curves, so ownership must saturate decisively near a source (fully analytic — N·L and shadows undiluted) while still fading smoothly to the flood look at the claim's edge. Shared by the chunk shader and the CPU entity mirror; change neither side alone.

BLUE_LIGHT

• Const BLUE_LIGHT: "BLUE"

The string representation of blue light.

BOX_SIDES

• Const BOX_SIDES: BoxSides[]

The six default faces of a canvas box.

CHUNK_RENDER_QUALITY

• Const CHUNK_RENDER_QUALITY: Object

Type declaration

Name	Type
`highResolutionLocalLightsPerCell`	`2`
`highResolutionPixelThreshold`	`2100000`

CONNECTIVITY_FULL

• Const CONNECTIVITY_FULL: 32767

All fifteen unordered face pairs connected — the encoding for a section the eye passes straight through (all air, or not yet meshed).

DEFAULT_BLOCK_MAX_STACK

• Const DEFAULT_BLOCK_MAX_STACK: 64

EMISSIVE_LEVELS

• Const EMISSIVE_LEVELS: [number, number, number, number]

The four strengths an emissive face can render at, indexed by the two AO bits under the vertex emissive bit. Mirrors EMISSIVE_LEVELS in crates/mesher/src/mesher/vertex_light.rs; change neither side alone.

ENTITY_SHADOW_DISTANCE

• Const ENTITY_SHADOW_DISTANCE: 32

Blocks from the player within which entities cast dynamic shadows. The cascade entity refresh and the caller's decision of whether any entity is worth a refresh at all must agree on this number, or entities outside it trigger full cascade re-renders for shadows that are then distance-culled before drawing.

ENTITY_SHADOW_FRAGMENT_PARS

• Const ENTITY_SHADOW_FRAGMENT_PARS: "\nuniform sampler2D uShadowMap0;\nuniform sampler2D uShadowMap1;\nuniform sampler2D uShadowMap2;\nuniform float uCascadeSplit0;\nuniform float uCascadeSplit1;\nuniform float uCascadeSplit2;\nuniform float uShadowBias;\nuniform float uShadowNormalBias;\nuniform float uShadowStrength;\nuniform float uSunlightIntensity;\nuniform vec3 uSunDirection;\nuniform vec3 uSunColor;\nuniform float uMinOccluderDepth;\n\nvarying vec4 vShadowCoord0;\nvarying vec4 vShadowCoord1;\nvarying vec4 vShadowCoord2;\nvarying float vViewDepth;\n\n\nconst vec2 SHADOW_POISSON_DISK[8] = vec2[8](\n vec2(-0.94201624, -0.39906216),\n vec2(0.94558609, -0.76890725),\n vec2(-0.094184101, -0.92938870),\n vec2(0.34495938, 0.29387760),\n vec2(-0.91588581, 0.45771432),\n vec2(-0.81544232, -0.87912464),\n vec2(0.97484398, 0.75648379),\n vec2(0.44323325, -0.97511554)\n);\n\n\n\nfloat shadowMapEdgeFade(vec3 coord) {\n float fadeWidth = 0.08;\n float fx = smoothstep(0.0, fadeWidth, coord.x) * smoothstep(0.0, fadeWidth, 1.0 - coord.x);\n float fy = smoothstep(0.0, fadeWidth, coord.y) * smoothstep(0.0, fadeWidth, 1.0 - coord.y);\n return fx * fy;\n}\n\nfloat sampleShadowMapFast(sampler2D shadowMap, vec4 shadowCoord, float bias) {\n vec3 coord = shadowCoord.xyz / shadowCoord.w;\n coord = coord * 0.5 + 0.5;\n\n if (coord.x < 0.0 || coord.x > 1.0 || coord.y < 0.0 || coord.y > 1.0 || coord.z < 0.0 || coord.z > 1.0) {\n return 1.0;\n }\n\n vec2 texelSize = vec2(1.0) / vec2(textureSize(shadowMap, 0));\n\n float shadow = (coord.z - bias > texture(shadowMap, coord.xy).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(-1.0, -1.0)).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(1.0, -1.0)).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(-1.0, 1.0)).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(1.0, 1.0)).r) ? 0.0 : 1.0;\n\n shadow /= 5.0;\n return mix(1.0, shadow, shadowMapEdgeFade(coord));\n}\n\nfloat sampleShadowMapPCSS(sampler2D shadowMap, vec4 shadowCoord, float bias) {\n vec3 coord = shadowCoord.xyz / shadowCoord.w;\n coord = coord * 0.5 + 0.5;\n\n if (coord.x < 0.0 || coord.x > 1.0 || coord.y < 0.0 || coord.y > 1.0 || coord.z < 0.0 || coord.z > 1.0) {\n return 1.0;\n }\n\n vec2 texelSize = vec2(1.0) / vec2(textureSize(shadowMap, 0));\n\n float blockerSum = 0.0;\n float blockerCount = 0.0;\n float searchRadius = 3.0;\n for (int i = 0; i < 4; i++) {\n vec2 offset = SHADOW_POISSON_DISK[i * 2] * texelSize * searchRadius;\n float sampleDepth = texture(shadowMap, coord.xy + offset).r;\n float blockerDiff = coord.z - sampleDepth;\n if (blockerDiff > bias && blockerDiff >= uMinOccluderDepth) {\n blockerSum += sampleDepth;\n blockerCount += 1.0;\n }\n }\n\n if (blockerCount < 0.5) {\n return 1.0;\n }\n\n float avgBlockerDepth = blockerSum / blockerCount;\n float penumbraSize = (coord.z - avgBlockerDepth) / avgBlockerDepth;\n float filterRadius = clamp(penumbraSize * 2.0, 1.0, 3.0);\n\n float spatialNoise = fract(sin(dot(coord.xy, vec2(12.9898, 78.233))) * 43758.5453);\n float angle = spatialNoise * 6.283185;\n float s = sin(angle);\n float c = cos(angle);\n mat2 rotation = mat2(c, -s, s, c);\n\n float centerDepth = texture(shadowMap, coord.xy).r;\n float centerDiff = coord.z - centerDepth;\n float shadow = (centerDiff > bias && centerDiff >= uMinOccluderDepth) ? 0.0 : 1.0;\n for (int i = 0; i < 8; i++) {\n vec2 offset = rotation * SHADOW_POISSON_DISK[i] * texelSize * filterRadius;\n float depth = texture(shadowMap, coord.xy + offset).r;\n float depthDiff = coord.z - depth;\n shadow += (depthDiff > bias && depthDiff >= uMinOccluderDepth) ? 0.0 : 1.0;\n }\n\n shadow /= 9.0;\n return mix(1.0, shadow, shadowMapEdgeFade(coord));\n}\n\n\nfloat getEntityShadow(vec3 worldNormal) {\n float effectiveStrength = uShadowStrength * uSunlightIntensity;\n \n if (effectiveStrength < 0.01) {\n return 1.0;\n }\n\n float cosTheta = clamp(dot(worldNormal, uSunDirection), 0.0, 1.0);\n float bias = uShadowBias + uShadowNormalBias * (1.0 - cosTheta);\n\n float rawShadow = sampleShadowMapPCSS(uShadowMap0, vShadowCoord0, bias);\n\n float maxEntityDist = uCascadeSplit1;\n if (vViewDepth > maxEntityDist) {\n return 1.0;\n }\n float fadeStart = maxEntityDist * 0.7;\n if (vViewDepth > fadeStart) {\n float t = (vViewDepth - fadeStart) / (maxEntityDist - fadeStart);\n rawShadow = mix(rawShadow, 1.0, t);\n }\n\n float shadow = mix(1.0, rawShadow, effectiveStrength * 0.65);\n return max(shadow, 0.6);\n}\n"

ENTITY_SHADOW_VERTEX_MAIN

• Const ENTITY_SHADOW_VERTEX_MAIN: "\nvec4 shadowWorldPos = vec4(worldPosition.xyz + uWorldOffset, 1.0);\nvShadowCoord0 = uShadowMatrix0 * shadowWorldPos;\nvShadowCoord1 = uShadowMatrix1 * shadowWorldPos;\nvShadowCoord2 = uShadowMatrix2 * shadowWorldPos;\nvec4 viewPos = viewMatrix * vec4(worldPosition.xyz, 1.0);\nvViewDepth = -viewPos.z;\n"

ENTITY_SHADOW_VERTEX_PARS

• Const ENTITY_SHADOW_VERTEX_PARS: "\nuniform mat4 uShadowMatrix0;\nuniform mat4 uShadowMatrix1;\nuniform mat4 uShadowMatrix2;\nuniform vec3 uWorldOffset;\n\nvarying vec4 vShadowCoord0;\nvarying vec4 vShadowCoord1;\nvarying vec4 vShadowCoord2;\nvarying float vViewDepth;\n"

FLOW_CREST_PHASE_PER_HEIGHT

• Const FLOW_CREST_PHASE_PER_HEIGHT: number

Radians of flow-crest phase per block of rest height: one full crest every WATER_OPTICS.flowCrestSpacingBlocks blocks on a sheet falling a full stage per block.

FLUID_SPILL_CORNER_MIN_HEIGHT

• Const FLUID_SPILL_CORNER_MIN_HEIGHT: number

Rest height within its voxel above which a fluid surface vertex is a spill corner — one the mesher raised to the full block because fluid stands on a voxel sharing it, so the sheet meets the wall of the block pouring onto it. A resting surface sits at WATER_OPTICS.fluidSurfaceHeight and every flow stage only lowers it, so nothing else reaches past this midpoint. The vertex stage leaves these corners out of the wave: the wall edge they are welded to sits on its voxel floor and cannot move with them.

FROZEN_METADATA_KEY

• Const FROZEN_METADATA_KEY: "frozen"

Metadata key the server sets on entities pinned by the freeze mechanic. While true, the client must hold the entity's pose: its class update (animation clocks, interpolation) is skipped entirely.

GREEN_LIGHT

• Const GREEN_LIGHT: "GREEN"

The string representation of green light.

INVALID_LIGHT_HANDLE

• Const INVALID_LIGHT_HANDLE: LightHandle = 0

INVALID_LOCAL_LIGHT_HANDLE

• Const INVALID_LOCAL_LIGHT_HANDLE: number = INVALID_LIGHT_HANDLE

LIGHT_CONES

• Const LIGHT_CONES: Readonly<{ lambertWrap: 0.25 = 0.25; maxCones: 8 = 8; minCosDelta: 0.001 = 1e-3; scatterSamples: 4 = 4 }>

Engine-side budget and falloff shaping for dynamic spot-light cones (flashlights, vehicle headlights). The cone list is rebuilt every frame by the game; shaders iterate a small fixed array so the cost stays flat.

LIGHT_CONES_FUNCTIONS

• Const LIGHT_CONES_FUNCTIONS: string

Shared per-cone response: quadratic angular falloff between the inner and outer cone, squared-quadratic distance falloff to zero at range, and Beer-Lambert extinction from the cone origin scaled by the origin's submersion so underwater beams die out physically while dry beams carry.

uConeOrigins[i] = (origin.xyz, submersion); uConeShapes[i] = (cosOuter, 1/(cosInner-cosOuter), range, scatterStrength).

LIGHT_CONES_SCATTER_FRAGMENT

• Const LIGHT_CONES_SCATTER_FRAGMENT: "\nif (uConeCount > 0) {\n vec3 lcViewRay = vWorldPosition.xyz - cameraPosition;\n float lcViewDist = max(length(lcViewRay), 1e-4);\n gl_FragColor.rgb += lightConeScatter(cameraPosition, lcViewRay / lcViewDist, lcViewDist);\n}\n"

Adds the in-scattered beam glow after fog. Expects vWorldPosition, cameraPosition, and gl_FragColor in scope. Scatter strength is the game's per-cone knob: this is how a beam is seen in air — real spotlights are invisible between lens and surface unless the air itself scatters some light toward the eye (dust, haze), which this term estimates. Submersion additionally applies water extinction along the path, so underwater beams bloom hard and die short.

LIGHT_CONES_UNIFORM_DECLARATIONS

• Const LIGHT_CONES_UNIFORM_DECLARATIONS: string

LIGHT_FLAG_FLICKER

• Const LIGHT_FLAG_FLICKER: 4

LIGHT_FLAG_MASKED

• Const LIGHT_FLAG_MASKED: 2

LIGHT_FLAG_SHADOW_REQUEST

• Const LIGHT_FLAG_SHADOW_REQUEST: 8

LIGHT_FLAG_STATIC

• Const LIGHT_FLAG_STATIC: 1

LIGHT_QUALITY_TIERS

• Const LIGHT_QUALITY_TIERS: Record<LightQualityTier, Pick<LocalLightsOptions, "maxClusteredLights" | "maxLightsPerCell" | "analyticRadius" | "fluidSpecularStrength" | "maxShadowedLights" | "shadowAtlasSize" | "shadowSlotSize" | "shadowLedgerUnitsPerFrame"> & { blockLightOwnership: number }>

Tier presets are data only: applying one changes pack-time caps and uniforms, never shaders. potato turns the clustered layer off entirely, rendering exactly the pre-local-lights frame plus emissive faces.

LOCAL_LIGHTS_DEBUG_FUNCTIONS

• Const LOCAL_LIGHTS_DEBUG_FUNCTIONS: "\n\nfloat localShadowDebugProbe(int llRec, vec3 llPos, vec3 llNormal) {\n vec4 llT4 = texelFetch(uLightData, ivec2(4, llRec), 0);\n int llSlot = int(floor(llT4.x + 0.5));\n if (llSlot < 0) return 1.0;\n vec4 llT5 = texelFetch(uLightData, ivec2(5, llRec), 0);\n vec3 llLightPos = texelFetch(uLightData, ivec2(0, llRec), 0).xyz;\n // Same slope-scaled normal offset as the real sampler, or grazing floors\n // stripe with acne in the debug view.\n vec3 llToL = normalize(llLightPos - llPos);\n float llNdl = clamp(dot(llNormal, llToL), 0.0, 1.0);\n float llSlope = clamp(sqrt(1.0 - llNdl * llNdl) / max(llNdl, 0.05), 0.0, 8.0);\n float llTexelWorld =\n (2.0 * llT5.y * max(length(llPos - llLightPos), llT4.w)) / uLocalShadowParams.y;\n vec3 llRel = llPos\n + llNormal * (uLocalShadowParams.w * llTexelWorld * (1.0 + llSlope))\n - llLightPos;\n vec3 llA = abs(llRel);\n int llFace;\n float llW;\n vec2 llUv;\n if (llA.x >= llA.y && llA.x >= llA.z) {\n llFace = llRel.x > 0.0 ? 0 : 1;\n llW = llA.x;\n llUv = vec2(llRel.x > 0.0 ? llRel.z : -llRel.z, llRel.y);\n } else if (llA.y >= llA.z) {\n llFace = llRel.y > 0.0 ? 2 : 3;\n llW = llA.y;\n llUv = vec2(llRel.y > 0.0 ? llRel.x : -llRel.x, llRel.z);\n } else {\n llFace = llRel.z > 0.0 ? 4 : 5;\n llW = llA.z;\n llUv = vec2(llRel.z > 0.0 ? -llRel.x : llRel.x, llRel.y);\n }\n if (llW <= llT4.w) return 1.0;\n if ((int(llT4.y + 0.5) & (1 << llFace)) == 0) return 1.0;\n vec2 llFaceUv = clamp((llUv / (llW * llT5.y)) * 0.5 + 0.5, 0.02, 0.98);\n float llPerRow = floor(uLocalShadowParams.x / uLocalShadowParams.y + 0.5);\n int llCell = llSlot * 12 + llFace;\n vec2 llBaseUv = (vec2(\n mod(float(llCell), llPerRow), floor(float(llCell) / llPerRow)\n ) + llFaceUv) * uLocalShadowParams.y / uLocalShadowParams.x;\n float llZn = texture(uLocalShadowAtlas, llBaseUv).r * 2.0 - 1.0;\n float llStored = (2.0 * llT5.x * llT4.w)\n / (llT5.x + llT4.w - llZn * (llT5.x - llT4.w));\n float llBias = uLocalShadowParams.z + llTexelWorld * (0.75 + llSlope);\n return (llW - llBias > llStored) ? 0.0 : 1.0;\n}\n\n\nvec3 localLightDebugColor(\n vec3 llPos, vec3 llBase, vec3 llNormal, vec3 llFlood, vec3 llCluster, float llRemainder\n) {\n if (uLocalLightDebugMode < 0.5) return llBase;\n if (uLocalLightDebugMode > 5.5) {\n // Mode 6: flood-ownership remainder — white where the legacy flood term\n // still renders, black where the analytic layer owns the fragment.\n return vec3(llRemainder);\n }\n int llCell = localLightCell(llPos);\n if (uLocalLightDebugMode < 1.5) {\n // Cell occupancy heatmap: black 0, green 1-2, yellow 3-5, red 6+.\n if (llCell < 0) return llBase * 0.2;\n int llCount = 0;\n for (int s = 0; s < 8; s++) {\n if (localLightSlot(llCell, s) == 0) break;\n llCount++;\n }\n vec3 llRamp = llCount == 0\n ? vec3(0.05)\n : llCount <= 2\n ? vec3(0.1, 0.8, 0.2)\n : llCount <= 5\n ? vec3(0.9, 0.8, 0.1)\n : vec3(0.9, 0.15, 0.1);\n return mix(llBase, llRamp, 0.75);\n }\n if (uLocalLightDebugMode < 2.5) {\n // Isolated clustered contribution (the main pass already computed it).\n return llCluster;\n }\n if (uLocalLightDebugMode < 3.5) {\n // Flood leak mask the masked lights multiply by.\n return vec3(smoothstep(0.0, uLocalMaskKnee, max(max(llFlood.r, llFlood.g), llFlood.b)));\n }\n // Modes 4 and 5 share one walk over the cell's shadowed lights, probing\n // each one's cached static map once.\n if (llCell < 0) return uLocalLightDebugMode < 4.5 ? llBase * 0.2 : vec3(1.0);\n vec3 llTint = llBase * 0.15;\n float llVisAll = 1.0;\n for (int s = 0; s < 8; s++) {\n int llRec = localLightSlot(llCell, s);\n if (llRec == 0) break;\n llRec -= 1;\n vec4 llT1d = texelFetch(uLightData, ivec2(1, llRec), 0);\n int llFlagsD = int(llT1d.w + 0.5);\n if ((llFlagsD & 4) == 0) continue;\n vec4 llT0d = texelFetch(uLightData, ivec2(0, llRec), 0);\n vec3 llToLd = llT0d.xyz - llPos;\n if (dot(llToLd, llToLd) >= llT0d.w * llT0d.w) continue;\n float llVisD = localShadowDebugProbe(llRec, llPos, llNormal);\n llVisAll *= llVisD;\n vec4 llT4d = texelFetch(uLightData, ivec2(4, llRec), 0);\n int llSlotD = int(floor(llT4d.x + 0.5));\n vec3 llSlotColor = llSlotD == 0 ? vec3(1.0, 0.3, 0.2)\n : llSlotD == 1 ? vec3(0.2, 1.0, 0.3)\n : llSlotD == 2 ? vec3(0.25, 0.4, 1.0)\n : vec3(1.0, 0.9, 0.2);\n llTint += llSlotColor * (0.2 + 0.8 * llVisD) * 0.6;\n }\n return uLocalLightDebugMode < 4.5 ? llTint : vec3(llVisAll);\n}\n"

LOCAL_LIGHTS_FUNCTIONS

• Const LOCAL_LIGHTS_FUNCTIONS: string

The clustered local light response. localLightCell resolves a world position to its grid cell (or -1 outside the window); the surface and specular functions walk the cell's fixed slot list, breaking at the first empty slot, so an empty world costs one integer compare per fragment.

Record layout (one row per selected light, six RGBA32F texels): t0 = [x, y, z, range] t1 = [ri, gi, b*i, flags] flags: 1 masked | 2 flicker | 4 shadowed | shape << 4 (a static shadow holder carries masked and shadowed: the diffuse ladder prefers its atlas, while the fluid specular pass occludes by the mask so the atlas sampler stays inlined exactly once) t2 = spot [dir.xyz, cosOuter] / capsule [end offset.xyz, 0] t3 = [flickerSpeed, flickerAmplitude, flickerPhase, spotInvCosDelta] t4 = [shadow slot (-1 none), static face mask, dynamic face mask, near] t5 = [far, guard tanHalf, 0, 0]

Shadow lookup mirrors the camera construction in shadow-atlas.ts (face bases, guard FOV, GL perspective depth); change neither side alone. Depth compares run in linear light-space distance so bias is a world unit, not a resolution- and range-dependent NDC fudge.

LOCAL_LIGHTS_UNIFORM_DECLARATIONS

• Const LOCAL_LIGHTS_UNIFORM_DECLARATIONS: "\nuniform highp usampler2D uLightGrid;\nuniform sampler2D uLightData;\nuniform vec3 uLightGridOrigin;\nuniform vec3 uLightGridDims;\nuniform float uLightGridCellSize;\nuniform int uClusteredLightCount;\nuniform float uLocalMaskKnee;\nuniform float uLocalSpecularStrength;\n// 0..1: how strongly analytic claims suppress the baked flood term.\nuniform float uLocalOwnership;\nuniform float uLocalLightDebugMode;\nuniform sampler2D uLocalShadowAtlas;\n// [atlas px, cell px, linear depth bias (blocks), normal bias (texels)]\nuniform vec4 uLocalShadowParams;\n// [pcf radius (texels), shadow strength, unused, unused]\nuniform vec4 uLocalShadowParams2;\n"

MAX_CLUSTERED_LIGHTS

• Const MAX_CLUSTERED_LIGHTS: 255

Hard ceiling of the clustered set: grid slots hold rank + 1 in a byte.

MAX_LIGHTS_PER_CELL

• Const MAX_LIGHTS_PER_CELL: 8

Compile-time slot count of the shader loop. Quality tiers cap how many slots the CPU fills, never this constant, so no tier change recompiles.

NX_ROTATION

• Const NX_ROTATION: 3

The numerical representation of the negative X rotation.

NY_ROTATION

• Const NY_ROTATION: 1

The numerical representation of the negative Y rotation.

NZ_ROTATION

• Const NZ_ROTATION: 5

The numerical representation of the negative Z rotation.

OPAQUE_RENDER_ORDER

• Const OPAQUE_RENDER_ORDER: 100

POINT_FACE_GUARD_TAN_HALF

• Const POINT_FACE_GUARD_TAN_HALF: 1.04

Half-FOV tangent of a point-light cube face. Exactly 90° would put shared cube edges precisely on the map border, where PCF taps clamp; the 4 % guard band renders a sliver past the edge so filtered lookups near a face boundary still land on real depth. The sampling reconstruction uses the same constant, so render and lookup always agree.

POSITION_BLOCK_BIAS

• Const POSITION_BLOCK_BIAS: 32

Compact vertex format for chunk geometry, adapted from Sodium's compact vertex layout. Positions store as unsigned 16-bit fixed point in 1/positionUnitsPerBlock block units, biased by POSITION_BLOCK_BIAS blocks so face geometry that pokes slightly outside its section (rotated plant crosses, dynamic-pattern parts) stays representable. The scale is derived per world from its section extent — Sodium can hardcode one scale because its sections are always 16 blocks tall, but a world here may run a single 352-block sub-chunk, and a fixed scale wide enough for the small case silently wraps every vertex above the u16 ceiling in the tall one. UVs store as normalized u16 (the atlas keeps every vertex UV inside [0, 1]; greedy tiling reconstructs its repeat from world position in the fragment shader). Normals store as normalized i8. Together with the i32 packed light this is 17 bytes of attributes per vertex, down from 36.

The dequantization scale and bias live in the mesh (or arena instance) matrix, never in the shader: the CSM depth pass renders the whole scene through one scene.overrideMaterial and can only be correct if the transform carries the mapping back to block space. Chunk materials still receive POSITION_UNITS_PER_BLOCK as a define because sway and wave displacement math reads the raw position attribute before any matrix applies.

Geometry that the transparent sorter rewrites on the main thread (fluids and depth-non-writing see-through blocks such as glass) keeps full f32 attributes: the sorter's per-face keys read positions directly, and those buckets are a small fraction of the scene. isMainThreadSortedBlock mirrors the depthWrite rule in chunk-materials.ts exactly — every material therefore serves either only quantized or only float meshes.

PX_ROTATION

• Const PX_ROTATION: 2

The numerical representation of the positive X rotation.

PY_ROTATION

• Const PY_ROTATION: 0

The numerical representation of the positive Y rotation.

PZ_ROTATION

• Const PZ_ROTATION: 4

The numerical representation of the positive Z rotation.

RED_LIGHT

• Const RED_LIGHT: "RED"

The string representation of red light.

SCENE_OVERLAY_LAYER

• Const SCENE_OVERLAY_LAYER: 30

Name	Type
`fragment`	`string`
`vertex`	`string`

SHADOW_FACE_FORWARD

• Const SHADOW_FACE_FORWARD: readonly [number, number, number][]

Cube-face bases for local point-light shadows, index-matched between this table (which builds the render cameras) and the reconstruction in shader.ts (which turns a fragment position back into a face UV + depth). The basis is right-handed for a camera looking down forward (right × up = -forward); change neither side alone.

Faces: 0 +X, 1 -X, 2 +Y, 3 -Y, 4 +Z, 5 -Z.

SHADOW_FACE_RIGHT

• Const SHADOW_FACE_RIGHT: readonly [number, number, number][]

SHADOW_FACE_UP

• Const SHADOW_FACE_UP: readonly [number, number, number][]

SHADOW_POISSON_DISK

• Const SHADOW_POISSON_DISK: "\nconst vec2 SHADOW_POISSON_DISK[8] = vec2[8](\n vec2(-0.94201624, -0.39906216),\n vec2(0.94558609, -0.76890725),\n vec2(-0.094184101, -0.92938870),\n vec2(0.34495938, 0.29387760),\n vec2(-0.91588581, 0.45771432),\n vec2(-0.81544232, -0.87912464),\n vec2(0.97484398, 0.75648379),\n vec2(0.44323325, -0.97511554)\n);\n"

SHADOW_SAMPLE_FUNCTIONS

• Const SHADOW_SAMPLE_FUNCTIONS: "\nfloat shadowMapEdgeFade(vec3 coord) {\n float fadeWidth = 0.08;\n float fx = smoothstep(0.0, fadeWidth, coord.x) * smoothstep(0.0, fadeWidth, 1.0 - coord.x);\n float fy = smoothstep(0.0, fadeWidth, coord.y) * smoothstep(0.0, fadeWidth, 1.0 - coord.y);\n return fx * fy;\n}\n\nfloat sampleShadowMapFast(sampler2D shadowMap, vec4 shadowCoord, float bias) {\n vec3 coord = shadowCoord.xyz / shadowCoord.w;\n coord = coord * 0.5 + 0.5;\n\n if (coord.x < 0.0 || coord.x > 1.0 || coord.y < 0.0 || coord.y > 1.0 || coord.z < 0.0 || coord.z > 1.0) {\n return 1.0;\n }\n\n vec2 texelSize = vec2(1.0) / vec2(textureSize(shadowMap, 0));\n\n float shadow = (coord.z - bias > texture(shadowMap, coord.xy).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(-1.0, -1.0)).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(1.0, -1.0)).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(-1.0, 1.0)).r) ? 0.0 : 1.0;\n shadow += (coord.z - bias > texture(shadowMap, coord.xy + texelSize * vec2(1.0, 1.0)).r) ? 0.0 : 1.0;\n\n shadow /= 5.0;\n return mix(1.0, shadow, shadowMapEdgeFade(coord));\n}\n\nfloat sampleShadowMapPCSS(sampler2D shadowMap, vec4 shadowCoord, float bias) {\n vec3 coord = shadowCoord.xyz / shadowCoord.w;\n coord = coord * 0.5 + 0.5;\n\n if (coord.x < 0.0 || coord.x > 1.0 || coord.y < 0.0 || coord.y > 1.0 || coord.z < 0.0 || coord.z > 1.0) {\n return 1.0;\n }\n\n vec2 texelSize = vec2(1.0) / vec2(textureSize(shadowMap, 0));\n\n float blockerSum = 0.0;\n float blockerCount = 0.0;\n float searchRadius = 3.0;\n for (int i = 0; i < 4; i++) {\n vec2 offset = SHADOW_POISSON_DISK[i * 2] * texelSize * searchRadius;\n float sampleDepth = texture(shadowMap, coord.xy + offset).r;\n float blockerDiff = coord.z - sampleDepth;\n if (blockerDiff > bias && blockerDiff >= uMinOccluderDepth) {\n blockerSum += sampleDepth;\n blockerCount += 1.0;\n }\n }\n\n if (blockerCount < 0.5) {\n return 1.0;\n }\n\n float avgBlockerDepth = blockerSum / blockerCount;\n float penumbraSize = (coord.z - avgBlockerDepth) / avgBlockerDepth;\n float filterRadius = clamp(penumbraSize * 2.0, 1.0, 3.0);\n\n float spatialNoise = fract(sin(dot(coord.xy, vec2(12.9898, 78.233))) * 43758.5453);\n float angle = spatialNoise * 6.283185;\n float s = sin(angle);\n float c = cos(angle);\n mat2 rotation = mat2(c, -s, s, c);\n\n float centerDepth = texture(shadowMap, coord.xy).r;\n float centerDiff = coord.z - centerDepth;\n float shadow = (centerDiff > bias && centerDiff >= uMinOccluderDepth) ? 0.0 : 1.0;\n for (int i = 0; i < 8; i++) {\n vec2 offset = rotation * SHADOW_POISSON_DISK[i] * texelSize * filterRadius;\n float depth = texture(shadowMap, coord.xy + offset).r;\n float depthDiff = coord.z - depth;\n shadow += (depthDiff > bias && depthDiff >= uMinOccluderDepth) ? 0.0 : 1.0;\n }\n\n shadow /= 9.0;\n return mix(1.0, shadow, shadowMapEdgeFade(coord));\n}\n"

SHARED_CUTOUT_MATERIAL_KEY

• Const SHARED_CUTOUT_MATERIAL_KEY: "shared-cutout"

SHARED_CUTOUT_PLANT_MATERIAL_KEY

• Const SHARED_CUTOUT_PLANT_MATERIAL_KEY: "shared-cutout-plant"

SHARED_OPAQUE_MATERIAL_KEY

• Const SHARED_OPAQUE_MATERIAL_KEY: "shared-opaque"

SKY_FOG_COMMON_UNIFORM_DECLARATIONS

• Const SKY_FOG_COMMON_UNIFORM_DECLARATIONS: "\nuniform vec3 uFogColor;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform float uFogHeightOrigin;\nuniform float uFogHeightDensity;\nuniform vec3 uSkyFogTopColor;\nuniform vec3 uSkyFogMiddleColor;\nuniform vec3 uSkyFogBottomColor;\nuniform float uSkyFogOffset;\nuniform float uSkyFogVoidOffset;\nuniform float uSkyFogExponent;\nuniform float uSkyFogExponent2;\nuniform float uSkyFogDimension;\nuniform float uSkyFogStrength;\nuniform float uChunkReveal;\n\nuniform float uCameraSubmersion;\nuniform float uCameraWaterPlaneY;\nuniform vec3 uUnderwaterAmbient;\n\n"

Sky-fog uniforms minus the sun trio, for shaders whose lighting chunk already declares uSunDirection, uSunColor, and uSunlightIntensity (e.g. entity materials composing this alongside their shadow chunk).

SKY_FOG_FRAGMENT

• Const SKY_FOG_FRAGMENT: string

SKY_FOG_SUN_UNIFORM_DECLARATIONS

• Const SKY_FOG_SUN_UNIFORM_DECLARATIONS: "\nuniform vec3 uSunDirection;\nuniform vec3 uSunColor;\nuniform float uSunlightIntensity;\n"

SKY_FOG_UNIFORM_DECLARATIONS

• Const SKY_FOG_UNIFORM_DECLARATIONS: "\n\nuniform vec3 uFogColor;\nuniform float uFogNear;\nuniform float uFogFar;\nuniform float uFogHeightOrigin;\nuniform float uFogHeightDensity;\nuniform vec3 uSkyFogTopColor;\nuniform vec3 uSkyFogMiddleColor;\nuniform vec3 uSkyFogBottomColor;\nuniform float uSkyFogOffset;\nuniform float uSkyFogVoidOffset;\nuniform float uSkyFogExponent;\nuniform float uSkyFogExponent2;\nuniform float uSkyFogDimension;\nuniform float uSkyFogStrength;\nuniform float uChunkReveal;\n\nuniform float uCameraSubmersion;\nuniform float uCameraWaterPlaneY;\nuniform vec3 uUnderwaterAmbient;\n\n\n\nuniform vec3 uSunDirection;\nuniform vec3 uSunColor;\nuniform float uSunlightIntensity;\n\n"

SPOT_GUARD_SCALE

• Const SPOT_GUARD_SCALE: 1.05

The same guard applied to a spot cone's authored outer angle.

SUNLIGHT

• Const SUNLIGHT: "SUNLIGHT"

The string representation of sunlight.

TRANSPARENT_FLUID_RENDER_ORDER

• Const TRANSPARENT_FLUID_RENDER_ORDER: 100001

TRANSPARENT_RENDER_ORDER

• Const TRANSPARENT_RENDER_ORDER: 100000

UNDERWATER_FOG_FRAGMENT

• Const UNDERWATER_FOG_FRAGMENT: string

Per-channel exponential (Beer-Lambert) fog along the camera's underwater view path. Expects vWorldPosition, cameraPosition, and gl_FragColor in scope. The path is clamped at the waterline plane so geometry above the surface only receives fog for the submerged segment of the ray.

UNDERWATER_FOG_UNIFORM_DECLARATIONS

• Const UNDERWATER_FOG_UNIFORM_DECLARATIONS: "\nuniform float uCameraSubmersion;\nuniform float uCameraWaterPlaneY;\nuniform vec3 uUnderwaterAmbient;\n"

VOXELIZE_BUILTIN_SOUND_EFFECT_EVENT

• Const VOXELIZE_BUILTIN_SOUND_EFFECT_EVENT: "vox-builtin:sound-effect"

VOXEL_NEIGHBORS

• Const VOXEL_NEIGHBORS: number[][]

WATER_DOWNWELLING_EXTINCTION_GLSL

• Const WATER_DOWNWELLING_EXTINCTION_GLSL: string

WATER_OPTICS

• Const WATER_OPTICS: Readonly<{ aboveSurfaceScatterDepthScale: 0.3 = 0.3; airSideFaceAlphaScale: 0.42 = 0.42; airSideFaceGlossScale: 0 = 0.0; airSideFaceTintMix: 0.85 = 0.85; baseWaveFadeEndBlocks: 256 = 256; baseWaveFadeStartBlocks: 144 = 144; causticDepthFalloff: 0.7 = 0.7; causticLensSlope: 0.1 = 0.1; causticStrength: 0.35 = 0.35; crestHighlightFull: 0.95 = 0.95; crestHighlightStart: 0.62 = 0.62; depthSmoothingSpeed: 7 = 7; distantFresnelFactor: 0.55 = 0.55; downwellingExtinction: { blue: number = 0.048; green: number = 0.1; red: number = 0.38 } ; floorAbsorptionMaxDepth: 4 = 4; floorAbsorptionPathScale: 1.6 = 1.6; flowBandSpeed: 6.5 = 6.5; flowCrestSpacingBlocks: 1.5 = 1.5; flowSlopeAmplitude: 0.09 = 0.09; flowStreakStrength: 0.4 = 0.4; fluidStageDropoff: 0.1 = 0.1; fluidSurfaceHeight: 0.875 = 0.875; fresnelAlphaStrength: 0.65 = 0.65; grazingBumpKeep: 0.3 = 0.3; lightFilterFloor: 0.04 = 0.04; maxSurfaceScanBlocks: 96 = 96; nightScatterFloor: 0.06 = 0.06; reflectionFoldbackExponent: 8 = 8; reflectionFoldbackStrength: 0.5 = 0.5; refractedSurfaceAlphaFloor: 0.8 = 0.8; refractionFullStrengthCos: 0.85 = 0.85; refractionGrazingCutoffCos: 0.3 = 0.3; refractionMaxDrawingBufferPixels: 8000000 = 8_000_000; refractionSlopeScale: 2 = 2.0; rippleFadeEndBlocks: 96 = 96; rippleFadeStartBlocks: 48 = 48; ripplePatchFloor: 0.3 = 0.3; scatterFillBase: 0.03 = 0.03; scatterFillSunStrength: 0.2 = 0.2; shallowScatterDensity: 0.5 = 0.5; shallowScatterMaxMix: 0.35 = 0.35; skyFadeExtinction: 0.1 = 0.1; specularBroadBaseStrength: 0.04 = 0.04; specularBroadTopStrength: 0.06 = 0.06; specularMediumStrength: 0.12 = 0.12; submergedWallAlphaScale: 0.55 = 0.55; submersionFallSpeed: 11 = 11; submersionRiseSpeed: 16 = 16; sunGlintFarStartCos: 0.95 = 0.95; sunGlintFarStrength: 0.3 = 0.3; sunGlintFullCos: 0.9998 = 0.9998; sunGlintStartCos: 0.996 = 0.996; sunGlintStrength: 0.9 = 0.9; surfaceAbsorptionScale: 0.55 = 0.55; surfaceAlphaFloor: 0.58 = 0.58; surfaceNormalLayers: { bump: number = 0.05; drift: number[] ; rotation: number = 0.0; stretch: number[] ; tileBlocks: number = 40 }[] ; surfaceNormalTexture: { anisotropy: number = 4; gain: number = 0.5; latticePeriod: number = 4; octaves: number = 2; ridgeSharpness: number = 1.3; seed: number = 1337; size: number = 256 } ; surfaceScatterColor: "#37b6c5" = "#37b6c5"; viewExtinctionScale: 0.85 = 0.85; wallPathBlocks: 1 = 1.0; waterlineFadeDepth: 0.12 = 0.12; wetFloorDarken: 0.8 = 0.8 }>

The single source of truth for how water absorbs and scatters light.

Every underwater visual — fog color and density, terrain and entity light attenuation, sky dome fading, first-person prop tinting — is derived from these values so the whole scene stays physically coherent.

WATER_SURFACE_NORMAL_LAYERS_GLSL

• Const WATER_SURFACE_NORMAL_LAYERS_GLSL: string

Samples every WATER_OPTICS.surfaceNormalLayers entry of the slope map at the fragment's wPos.xz for waterSeconds, accumulating the decoded, bump-weighted slopes into waterSlopeSum (declared by the caller). Each layer's texel stays in scope as waterTexel<i> so the height channel can be read for crest highlights without a second lookup; the first layer's height also gates the last layer's bump into patches (WATER_OPTICS.ripplePatchFloor). The red and green channels decode rg * 2 - 1 to -1..1, the tile's steepest facet at ±1 (see water-normal-texture.ts).

WATER_SURFACE_SCATTER_COLOR

• Const WATER_SURFACE_SCATTER_COLOR: Color

WATER_SURFACE_SCATTER_GLSL

• Const WATER_SURFACE_SCATTER_GLSL: string

WATER_VIEW_EXTINCTION

• Const WATER_VIEW_EXTINCTION: WaterChannelCoefficients

WATER_VIEW_EXTINCTION_GLSL

• Const WATER_VIEW_EXTINCTION_GLSL: string

Y_ROT_MAP

• Const Y_ROT_MAP: [number, number][] = []

A rotational map used to get the closest y-rotation representation to a y-rotation value.

Rotation value -> index

Y_ROT_MAP_EIGHT

• Const Y_ROT_MAP_EIGHT: [number, number][] = []

Y_ROT_MAP_FOUR

• Const Y_ROT_MAP_FOUR: [number, number][] = []

Y_ROT_SEGMENTS

• Const Y_ROT_SEGMENTS: 16

The amount of Y-rotation segments should be allowed for y-rotatable blocks. In other words, the amount of times the block can be rotated around the y-axis within 360 degrees.

The accepted Y-rotation values will be from 0 to Y_ROTATION_SEGMENTS - 1.

artFunctions

• Const artFunctions: Object

A preset of art functions to draw on canvas boxes.

Type declaration

Name	Type
`drawCrown`	`ArtFunction`
`drawMoon`	(`moonRadius`: `number`, `moonColor`: `string`, `phase`: `number`) => (`context`: `CanvasRenderingContext2D`, `canvas`: `HTMLCanvasElement`) => `void`
`drawStars`	(`starCount`: `number`, `starColors`: `string`[]) => (`context`: `CanvasRenderingContext2D`, `canvas`: `HTMLCanvasElement`) => `void`
`drawSun`	(`sunRadius`: `number`, `sunColor`: `string`) => (`context`: `CanvasRenderingContext2D`, `canvas`: `HTMLCanvasElement`) => `void`

customShaders

• Const customShaders: Object

Type declaration

Name	Type
`sway`	(`options`: `Partial`<{ `amplitude`: `number` ; `rooted`: `boolean` ; `scale`: `number` ; `speed`: `number` ; `yScale`: `number` }>) => { `fragmentShader`: `string` = baseShaders.fragment; `vertexShader`: `string` }
`swayCross`	(`options`: `Partial`<{ `amplitude`: `number` ; `rooted`: `boolean` ; `scale`: `number` ; `speed`: `number` ; `yScale`: `number` }>) => { `fragmentShader`: `string` = baseShaders.fragment; `vertexShader`: `string` }

defaultArmsOptions

• Const defaultArmsOptions: ArmsOptions

defaultBodyOptions

• Const defaultBodyOptions: BodyOptions

defaultCharacterOptions

• Const defaultCharacterOptions: CharacterOptions

defaultCreatureBodyOptions

• Const defaultCreatureBodyOptions: CreatureBodyOptions

defaultCreatureHeadOptions

• Const defaultCreatureHeadOptions: CreatureHeadOptions

defaultCreatureLegOptions

• Const defaultCreatureLegOptions: CreatureLegOptions

defaultCreatureOptions

• Const defaultCreatureOptions: CreatureOptions

defaultHeadOptions

• Const defaultHeadOptions: HeadOptions

defaultLegsOptions

• Const defaultLegsOptions: LegOptions

defaultLocalLightsOptions

• Const defaultLocalLightsOptions: LocalLightsOptions

defaultMemoryPressureOptions

• Const defaultMemoryPressureOptions: MemoryPressureOptions

defaultWorldClientOptions

• Const defaultWorldClientOptions: WorldClientOptions

restArgsSchema

• Const restArgsSchema: ZodObject<{ rest: ZodOptional<ZodString> }, "strip", ZodTypeAny, { rest?: string }, { rest?: string }>

Schema for commands that take a free-form string input. Use this for commands that need the raw rest string.

transparentSortStats

• Const transparentSortStats: TransparentSortStats

Functions

TRANSPARENT_SORT

▸ TRANSPARENT_SORT(object): (a: TransparentSortItem, b: TransparentSortItem) => number

Parameters

Name	Type
`object`	`Object3D`<`Object3DEventMap`>

Returns

fn

▸ (a, b): number

Parameters

Name	Type
`a`	`TransparentSortItem`
`b`	`TransparentSortItem`

Returns

number

analyzeLightOperations

▸ analyzeLightOperations(world, processedUpdates): LightOperations

Parameters

Name	Type
`world`	`VoxelLightVolume`
`processedUpdates`	`ProcessedUpdate`[]

Returns

LightOperations

annotateIncomingMessages

▸ annotateIncomingMessages(messages, byteSizes): void

Parameters

Name	Type
`messages`	`MessageProtocol`[]
`byteSizes`	`number`[]

Returns

void

applyQuantizedPositionDefine

▸ applyQuantizedPositionDefine(material, unitsPerBlock): void

Chunk geometry that is not main-thread sorted arrives with fixed-point positions whose dequantization lives in the mesh matrix. The shader still needs the scale for displacement math (sway, waves) that reads the raw position attribute before any matrix applies; without the define the shader's fallback of 1.0 treats positions as block-space floats.

Parameters

Name	Type
`material`	`ShaderMaterial`
`unitsPerBlock`	`number`

Returns

void

blockCastsShadow

▸ blockCastsShadow(block): boolean

Whether a block's geometry is drawn into the sun's shadow maps. The block may say so itself (castsShadow); otherwise the rule of thumb: solids and light-attenuating cutouts (leaves) cast, fluids and clear see-through blocks (glass, barriers) do not.

Parameters

Name	Type
`block`	`Pick`<`Block`, `"castsShadow"` \| `"isFluid"` \| `"isSeeThrough"` \| `"lightAttenuation"`>

Returns

boolean

blockLightFloodRemainder

▸ blockLightFloodRemainder(args): number

CPU mirror of the chunk shader's flood-remainder computation: the fraction of the baked flood term a point keeps, given the analytic luminance claim at that point (unfaded, scaled by the effective ownership), the raw flood level (0..1, max channel), and the window-rim fade (LocalLightSample.windowFade). Matches the shader exactly: the owned remainder uses the smoothstep denominator, then mixes toward 1 by the rim fade — the same crossfade the analytic contribution rides, so the combined block light stays continuous across the rim on entities and blocks alike. Callers may reuse one scratch args object; nothing is retained.

Parameters

Name	Type
`args`	`Object`
`args.floodLevel`	`number`
`args.scaledClaim`	`number`
`args.windowFade`	`number`

Returns

number

blockSlot

▸ blockSlot(id, count): SlotContent

Parameters

Name	Type
`id`	`number`
`count`	`number`

Returns

SlotContent

buildLightJobs

▸ buildLightJobs(lightOps, startSequenceId, batchId, options, allocateJobId): LightJob[]

Parameters

Name	Type
`lightOps`	`LightOperations`
`startSequenceId`	`number`
`batchId`	`number`
`options`	`VoxelLightVolumeOptions`
`allocateJobId`	(`color`: `LightColor`) => `string`

Returns

LightJob[]

canvasBoxSegments

▸ canvasBoxSegments(dims, texelsPerBlock): Object

Segment (texel) counts for a box painted at texelsPerBlock pixels per world unit: each axis gets as many texels as its length asks for, at least one, so every face has square texels whatever the box's proportions. This is what CanvasBoxOptions.texelsPerBlock resolves to.

Parameters

Name	Type
`dims`	`Object`
`dims.depth`	`number`
`dims.height`	`number`
`dims.width`	`number`
`texelsPerBlock`	`number`

Returns

Object

Name	Type
`depthSegments`	`number`
`heightSegments`	`number`
`widthSegments`	`number`

colorTemperatureToRgb

▸ colorTemperatureToRgb(kelvin): [number, number, number]

Kelvin to linear RGB, Tanner Helland's fit, normalized so the hottest channel is 1. Evaluated once per registration, never per frame.

Parameters

Name	Type
`kelvin`	`number`

Returns

[number, number, number]

compareChunkRequestPriority

▸ compareChunkRequestPriority(a, b): number

Parameters

Name	Type
`a`	`ChunkRequestCandidate`
`b`	`ChunkRequestCandidate`

Returns

number

configurePerfLogging

▸ configurePerfLogging(isEnabled): void

Parameters

Name	Type
`isEnabled`	`boolean`

Returns

void

countLightSeeds

▸ countLightSeeds(ops): number

Every removal and flood seed across all colors — the work a batch buys.

Parameters

Name	Type
`ops`	`LightOperations`

Parameters

Name	Type
`baseShaders`	`Object`
`baseShaders.fragment`	`string`
`baseShaders.vertex`	`string`
`options`	`Partial`<{ `amplitude`: `number` ; `rooted`: `boolean` ; `scale`: `number` ; `speed`: `number` ; `yScale`: `number` }>

Returns

Object

Name	Type
`fragmentShader`	`string`
`vertexShader`	`string`

createSwayTableShader

▸ createSwayTableShader(baseShaders, profileCapacity): Object

Table-driven variant of createSwayShader for the shared cutout buckets: instead of compiling one material per species with its sway constants baked into the source, every quad carries a swayProfile attribute indexing a vec4-pair uniform table (params: speed, amplitude, scale, yScale; flags: rooted, cross shading). Profile 0 is reserved as "no sway" so geometry without a registered profile — and geometry whose material never binds the attribute, which WebGL defaults to 0 — stays still.

Cross-quad plants historically used a separate fragment (fixed sun incidence, no face shade); that difference rides the profile's cross flag through the vCrossShading varying so one program serves both shapes.

Parameters

Name	Type
`baseShaders`	`Object`
`baseShaders.fragment`	`string`
`baseShaders.vertex`	`string`
`profileCapacity`	`number`

Returns

Object

Name	Type
`fragmentShader`	`string`
`vertexShader`	`string`

expandCoupledUpdates

▸ expandCoupledUpdates(view, updates): BlockUpdate[]

Expand a batch of block updates so every coupled unit it touches changes whole — the client-side mirror of the server's update intake, so a local prediction lands on exactly the voxels the authoritative echo will.

For each update, in order:

a coupled block being written brings its unit along: the anchor materialises its parts into free voxels (or the write is dropped when one is occupied) and its rotation and stage flow to the partners; a non-anchor part written without its anchor is dropped;
a coupled block being replaced by a different id takes its remaining partners with it.

A voxel the batch already writes is never second-guessed: the batch's own word for it wins. The result is idempotent, so callers may expand once to inspect the outcome and hand the expanded list back to updateVoxels.

Parameters

Name	Type
`view`	`CoupledWorldView`
`updates`	`BlockUpdate`[]

Returns

BlockUpdate[]

findSimilar

▸ findSimilar(target, available, options?): string[]

Parameters

Name	Type
`target`	`string`
`available`	`string`[]
`options`	`FindSimilarOptions`

Returns

string[]

floodLight

▸ floodLight(world, queue, color, min?, max?): void

Parameters

Name	Type
`world`	`VoxelLightVolume`
`queue`	`LightNode`[]
`color`	`LightColor`
`min?`	`Coords3`
`max?`	`Coords3`

Returns

void

foldLightJobsBack

▸ foldLightJobsBack(accumulated, jobs): LightOperations | null

Put built jobs back into an operation set — the inverse of buildLightJobs.

A memory-pressure shed drops a job's serialized chunk copies, which is the allocation that matters, but it must not drop the seeds the job carried: they describe voxel changes that are already applied and already meshed with their old light, and nothing else ever comes back for them. A pit cut into stone under pressure used to stay black until a reload, because the shed nulled the pending ops and the log counted them as zero. Boxes and clusters are recomputed when the seeds are built into jobs again, so only the seeds need to survive.

Parameters

Name	Type
`accumulated`	`LightOperations`
`jobs`	`Pick`<`LightJob`, `"color"` \| `"lightOps"`>[]

Returns

LightOperations | null

formatSuggestion

▸ formatSuggestion(suggestions, allAvailable, options?): string

Parameters

Name	Type
`suggestions`	`string`[]
`allAvailable`	`string`[]
`options`	`FormatSuggestionOptions`

Returns

string

getDownwellingTransmittance

▸ getDownwellingTransmittance(depth, out): Color

Parameters

Name	Type
`depth`	`number`
`out`	`Color`

Returns

Color

getEffectiveScatterStrength

▸ getEffectiveScatterStrength(sunStrength): number

Parameters

Name	Type
`sunStrength`	`number`

Returns

number

getImageComp

▸ getImageComp(item): ImageComp | undefined

Parameters

Name	Type
`item`	`ItemDef`

Returns

ImageComp | undefined

getItemComponent

▸ getItemComponent<T>(item, key): T | undefined

Type parameters

Name
`T`

Parameters

Name	Type
`item`	`ItemDef`
`key`	`string`

Name	Type
`isCrossOriginIsolated`	`boolean`
`isSharedArrayBufferAvailable`	`boolean`
`mode`	`WorkerTransferMode`
`pool`	`ChunkSharedPoolStats`
`stats`	`MeshWorkerTransferStats` \| `Record`<`WorkerTransferStrategy`, `MeshWorkerTransferStats`>
`strategy`	`WorkerTransferStrategy`

getSlotData

▸ getSlotData<T>(slot, key): T | undefined

Type parameters

Name
`T`

Parameters

Name	Type
`slot`	`SlotContent`
`key`	`string`

Returns

T | undefined

getSlotDurability

▸ getSlotDurability(slot): number | undefined

Parameters

Name	Type
`slot`	`SlotContent`

Returns

number | undefined

getSunDiscDirection

▸ getSunDiscDirection(timeOfDay, target): Vector3

Direction from the viewer to the centre of the painted sun disc for a time of day (0 midnight, 0.25 sunrise, 0.5 noon, 0.75 sunset). The disc is the centre of the sky box's bottom face, and Sky.update spins the box about Z by one turn per day, so the sun points straight down at midnight, rises along +X, stands at the zenith at noon and sets along -X. The moon is the top face, diametrically opposite.

This is where the disc is drawn. The shading light (ShaderLightingUniforms.sunDirection) is deliberately not this: it is held above a minimum elevation, tilted off the sun's plane, and blended toward the moon through twilight so terrain shading and shadows stay readable. Anything that has to line up with the disc the player sees — a reflection on water — reads this instead.

Parameters

Name	Type
`timeOfDay`	`number`
`target`	`Vector3`

Returns

Vector3

getUnderwaterAmbientColor

▸ getUnderwaterAmbientColor(depth, sunStrength, out): Color

Parameters

Name	Type
`depth`	`number`
`sunStrength`	`number`
`out`	`Color`

Returns

Color

getVisibleDiscDirection

▸ getVisibleDiscDirection(timeOfDay, target): Vector3

The celestial disc above the horizon: the sun while it is up, the moon (its antipode) once it has set. The choice flips at the instant both sit on the horizon, and nothing shows it: a disc at zero elevation only mirrors into a ray that is itself horizontal.

Parameters

Name	Type
`timeOfDay`	`number`
`target`	`Vector3`

Returns

Vector3

hasItemComponent

▸ hasItemComponent(item, key): boolean

Parameters

Name	Type
`item`	`ItemDef`
`key`	`string`

Returns

boolean

hasSlotData

▸ hasSlotData(slot, key): boolean

Parameters

Name	Type
`slot`	`SlotContent`
`key`	`string`

Returns

boolean

isCoupledPart

▸ isCoupledPart(block): boolean

Whether block is a non-anchor part of a coupled unit — a door's top leaf, a tall flower's bloom. Such a block is never placed, picked, or dropped on its own; see resolveCoupledAnchor.

Parameters

Name	Type
`block`	`Block`

Returns

boolean

isEntityMetadataFrozen

▸ isEntityMetadataFrozen(metadata): boolean

Parameters

Name	Type
`metadata`	`MutableMetadata`

Returns

boolean

isMainThreadSortedBlock

▸ isMainThreadSortedBlock(block): boolean

Parameters

Name	Type
`block`	`TransparencyFlags`

Returns

boolean

isOwnTextureFace

▸ isOwnTextureFace(face): boolean

Whether a face carries a whole texture of its own instead of a slot in the shared atlas. Independent faces own one per block face; isolated faces own one per voxel, plus the face-keyed default below for when there is no voxel to ask (a held block, a drop, an inventory thumbnail).

Parameters

Name	Type	Description
`face`	`Object`	-
`face.corners`	{ `pos`: [`number`, `number`, `number`] ; `uv`: `number`[] }[]	-
`face.dir`	[`number`, `number`, `number`]	-
`face.emissive?`	`number`	Emissive output of this face; `0` shades normally. Declared server-side with the block and rendered full-bright by the chunk shader.
`face.independent`	`boolean`	-
`face.isolated`	`boolean`	-
`face.name`	`string`	-
`face.range`	`UV`	-
`face.textureGroup`	`string`	-

linearizeShadowDepth

▸ linearizeShadowDepth(depth01, near, far): number

Linear view depth stored at a face texel, back from hardware depth 0..1.

Parameters

Name	Type
`depth01`	`number`
`near`	`number`
`far`	`number`

Returns

number

loadChunkMaterials

▸ loadChunkMaterials(world): Promise<void>

Parameters

Name	Type
`world`	`ChunkMaterialHost` & { `getBlockById`: (`id`: `number`) => `Block` ; `registry`: `Registry` }

Returns

Promise<void>

logChatRendered

▸ logChatRendered(chat): void

Parameters

Name	Type
`chat`	`ChatProtocol`

Returns

void

logChatWireSend

▸ logChatWireSend(message, byteSize): void

Parameters

Name	Type
`message`	`MessageProtocol`
`byteSize`	`number`

Returns

void

logIncomingMessage

▸ logIncomingMessage(message): void

Parameters

Name	Type
`message`	`MessageProtocol`

Returns

void

logPerf

▸ logPerf(event, fields?): void

Parameters

Name	Type
`event`	`string`
`fields`	`Record`<`string`, `PerfField`>

Returns

void

makeChunkMaterialKey

▸ makeChunkMaterialKey(world, id, faceName?, voxel?): string

Parameters

Name	Type
`world`	`Object`
`world.getBlockById`	(`id`: `number`) => `Block`
`world.hasCustomBlockMaterial`	(`id`: `number`) => `boolean`
`id`	`number`
`faceName?`	`string`
`voxel?`	`Coords3`

Returns

string

makeChunkShaderMaterial

▸ makeChunkShaderMaterial(world, fragmentShader?, vertexShader?, uniforms?): CustomChunkShaderMaterial

Parameters

Name	Type
`world`	`ChunkMaterialHost`
`fragmentShader?`	`string`
`vertexShader?`	`string`
`uniforms`	`Record`<`string`, `Uniform`<`any`>>

Returns

CustomChunkShaderMaterial

makeOwnFaceTexture

▸ makeOwnFaceTexture(source): Texture

The texture an own-texture face should carry for source. Block art is pixel art, so a texture minted here samples the way the atlas does. Mint one per material rather than sharing: the sharing that matters — one GPU upload per image — already happens at the texture's source.

Parameters

Name	Type
`source`	`Color` \| `Texture`<`unknown`> \| `HTMLImageElement`

Returns

Texture

makeSceneColorTexture

▸ makeSceneColorTexture(width?, height?, isSRGB?): FramebufferTexture

Parameters

Name	Type	Default value
`width`	`number`	`1`
`height`	`number`	`1`
`isSRGB`	`boolean`	`false`

Returns

FramebufferTexture

makeShadowFaceProjection

▸ makeShadowFaceProjection(out, tanHalf, near, far): Matrix4

Compute the perspective projection for a shadow face camera. Standard GL frustum, aspect 1; tanHalf is the half-FOV tangent (guard included).

Parameters

Name	Type
`out`	`Matrix4`
`tanHalf`	`number`
`near`	`number`
`far`	`number`

Returns

Matrix4

markSelfIlluminated

▸ markSelfIlluminated(material): void

Mark a material as its own light source, so the voxel-light effects leave it alone. A lamp lens, a screen, or a glowing sign must not be multiplied by the light around it: that would put the emitter out in exactly the dark it was lit for. Honored by LightShined and by the Arm's held-object lighting and shadow shaders.

Parameters

Name	Type
`material`	`Material`

Returns

void

measureWaterColumn

▸ measureWaterColumn(isFluidAt, x, y, z): WaterColumnSample | null

Parameters

Name	Type
`isFluidAt`	`FluidQuery`
`x`	`number`
`y`	`number`
`z`	`number`

Returns

WaterColumnSample | null

mergeLightOperations

▸ mergeLightOperations(existing, newOps): LightOperations

Parameters

Name	Type
`existing`	`LightOperations`
`newOps`	`LightOperations`

Returns

LightOperations

mergeSingleColorResult

▸ mergeSingleColorResult(chunk, lights, color, boundingBox): void

Parameters

Name	Type
`chunk`	`Chunk`
`lights`	`Uint32Array`<`ArrayBufferLike`>
`color`	`LightColor`
`boundingBox`	`BoundingBox`

Returns

void

orientPointFaceCamera

▸ orientPointFaceCamera(camera, view): void

Orient camera for a point-light cube face using the shared basis table. The camera's matrices are written directly (no lookAt) so the orientation is bit-identical to what the shader reconstruction assumes.

Named-args view: hot callers keep a scratch object and mutate it in place.

Parameters

Name	Type
`camera`	`PerspectiveCamera`
`view`	`Object`
`view.face`	`number`
`view.far`	`number`
`view.light`	[`number`, `number`, `number`]
`view.near`	`number`
`view.tanHalf`	`number`

Returns

void

orientSpotCamera

▸ orientSpotCamera(camera, view): void

Derive the spot-light shadow basis from its direction, with the same deterministic up-reference rule the shader uses: world +Y unless the axis is near-vertical, then world +Z.

Named-args view: hot callers keep a scratch object and mutate it in place.

Parameters

Name	Type
`camera`	`PerspectiveCamera`
`view`	`Object`
`view.direction`	[`number`, `number`, `number`]
`view.far`	`number`
`view.light`	[`number`, `number`, `number`]
`view.near`	`number`
`view.tanHalf`	`number`

Returns

void

positionUnitsPerBlock

▸ positionUnitsPerBlock(options): number

Parameters

Name	Type
`options`	`SectionExtentOptions`

Returns

number

prepareTransparentMesh

▸ prepareTransparentMesh(mesh): TransparentMeshData | null

Parameters

Name	Type
`mesh`	`Mesh`<`BufferGeometry`<`NormalBufferAttributes`, `BufferGeometryEventMap`>, `Material` \| `Material`[], `Object3DEventMap`>

Returns

TransparentMeshData | null

projectPointLightFragment

▸ projectPointLightFragment(lightX, lightY, lightZ, worldX, worldY, worldZ, tanHalf): { face: number ; u: number ; v: number ; w: number } | null

CPU mirror of the shader's face selection and UV/depth reconstruction, kept next to the camera builders so a unit test can assert that a world point projected through the camera lands on the same face UV and linear depth this function (and therefore the GLSL) computes.

Returns null when the point projects outside the face's guarded frustum.

Parameters

Name	Type
`lightX`	`number`
`lightY`	`number`
`lightZ`	`number`
`worldX`	`number`
`worldY`	`number`
`worldZ`	`number`
`tanHalf`	`number`

Returns

{ face: number ; u: number ; v: number ; w: number } | null

quantizeNormals

▸ quantizeNormals(normals): Int8Array

Parameters

Name	Type
`normals`	`Float32Array`<`ArrayBufferLike`>

Returns

Int8Array

quantizePositions

▸ quantizePositions(positions, unitsPerBlock): Uint16Array

Parameters

Name	Type
`positions`	`number`[] \| `Float32Array`<`ArrayBufferLike`>
`unitsPerBlock`	`number`

Returns

Uint16Array

quantizeUvs

▸ quantizeUvs(uvs): Uint16Array

Parameters

Name	Type
`uvs`	`number`[] \| `Float32Array`<`ArrayBufferLike`>

Returns

Uint16Array

readChromiumHeap

▸ readChromiumHeap(): HeapSample

Returns

HeapSample

removeLight

▸ removeLight(world, voxel, color): void

Parameters

Name	Type
`world`	`VoxelLightVolume`
`voxel`	`Coords3`
`color`	`LightColor`

Returns

void

removeLightsBatch

▸ removeLightsBatch(world, voxels, color): void

Batch remove light from multiple voxels that previously emitted the same light color. This drastically improves performance when many contiguous light sources are removed at once.

Parameters

Name	Type
`world`	`VoxelLightVolume`
`voxels`	`Coords3`[]
`color`	`LightColor`

Returns

void

requestWorkerAnimationFrame

▸ requestWorkerAnimationFrame(callback): number

Parameters

Name	Type
`callback`	() => `void`

Returns

number

resolveCoupledAnchor

▸ resolveCoupledAnchor(view, block): Block

The anchor of the coupled unit block belongs to — the part a player holds, places, and is paid in drops. A block that is not coupled, or is the anchor itself, resolves to itself, so item and pick paths can call this for every block.

Parameters

Name	Type
`view`	`Pick`<`CoupledWorldView`, `"getBlockById"`>
`block`	`Block`

Returns

Block

runMeshTransferBenchmark

▸ runMeshTransferBenchmark(dispatch, getChunk, options): Promise<MeshTransferBenchmarkResult>

Parameters

Name	Type
`dispatch`	`MeshTransferDispatch`
`getChunk`	(`cx`: `number`, `cz`: `number`) => `Chunk`
`options`	`MeshTransferBenchmarkOptions`

Returns

Promise<MeshTransferBenchmarkResult>

setOwnFaceTexture

▸ setOwnFaceTexture(material, texture): void

Point an own-texture face's material at texture.

Parameters

Name	Type
`material`	`CustomChunkShaderMaterial`
`texture`	`Texture`<`unknown`>

Returns

void

setPerfWorld

▸ setPerfWorld(world): void

Parameters

Name	Type
`world`	`string`

Returns

void

setSlotData

▸ setSlotData<T>(slot, key, value): SlotContent

Type parameters

Name
`T`

Parameters

Name	Type
`slot`	`SlotContent`
`key`	`string`
`value`	`T`

Returns

SlotContent

setWorkerInterval

▸ setWorkerInterval(func, interval): () => void

Parameters

Name	Type
`func`	() => `void`
`interval`	`number`

Returns

fn

▸ (): void

Returns

void

setupTransparentSorting

▸ setupTransparentSorting(object): void

Parameters

Name	Type
`object`	`Object3D`<`Object3DEventMap`>

Returns

void

sharedCutoutMaterialKeyFor

▸ sharedCutoutMaterialKeyFor(block): string | null

The shared bucket a depth-writing cutout block collapses into, or null for blocks that keep a per-id material. Plants live apart from leaves so the plant-radius culling can hide a section's plants without taking its canopy down, and because the two halves disagree on shadow casting (skipShadow is a material property). Standalone cutouts that neither sway nor attenuate light — doors, decor — stay per-id: folding them in would silently change their shadow behavior.

Parameters

Name	Type
`block`	`Block`

Returns

string | null

sortTransparentMesh

▸ sortTransparentMesh(mesh, data, camera): void

Parameters

Name	Type
`mesh`	`Mesh`<`BufferGeometry`<`NormalBufferAttributes`, `BufferGeometryEventMap`>, `Material` \| `Material`[], `Object3DEventMap`>
`data`	`TransparentMeshData`
`camera`	`Camera`

Returns

void

sortUnpainted

▸ sortUnpainted(surfaces): UnpaintedSurface[]

Parameters

Name	Type
`surfaces`	`UnpaintedSurface`[]

Returns

UnpaintedSurface[]

stampChatPerf

▸ stampChatPerf(chat): void

Parameters

Name	Type
`chat`	`ChatProtocol`

Returns

void

stripLocalLightsFromFragment

▸ stripLocalLightsFromFragment(fragment): string

Compile the local-lights layer entirely out of a composed chunk fragment: the uniform/function/debug sources vanish, the ownership block becomes the legacy flood expressions, and the guarded cluster blend, fluid specular add, and debug tail disappear. The result is the "local lights never existed" program the render-diff harness compares against the shipped program at the off tier — byte-identical output is the contract (see scripts/render-off-parity.mjs).

Parameters

Name	Type
`fragment`	`string`

Returns

string

tallyState

▸ tallyState(tally, state): void

Parameters

Name	Type
`tally`	`SurfaceTally`
`state`	`SurfaceState`

Returns

void

updateEntityShadowUniforms

▸ updateEntityShadowUniforms(target, source): void

Parameters

Name	Type
`target`	`EntityShadowUniforms`
`source`	`ShaderLightingUniforms`

Returns

void

updateUnderwaterFogUniforms

▸ updateUnderwaterFogUniforms(target, source): void

Parameters

Name	Type
`target`	`UnderwaterFogUniforms`
`source`	`UnderwaterFogSource`

Returns

void

Enumerations
Core Classes
Effects Classes
Other Classes
Utils Classes
Interfaces
Type Aliases
Variables
Functions

Enumerations​

Core Classes​

Effects Classes​

Other Classes​

Utils Classes​

Interfaces​

Type Aliases​

ArgMetadata​

Type declaration​

ArmOptions​

Type declaration​

ArmsOptions​

ArrowOptions​

Type declaration​

ArtFunction​

Type declaration​

Parameters​

Returns​

Block​

Type declaration​

BlockAnimation​

Type declaration​

BlockAnimationEasing​

Type declaration​

Parameters​

Returns​

BlockAnimationState​

Type declaration​

BlockAnimationsSnapshot​

Type declaration​

BlockEntityUpdateData​

Type parameters​

Type declaration​

BlockEntityUpdateListener​

Type parameters​

Type declaration​

Parameters​

Returns​

BlockRestPose​

Type declaration​

BlockRule​

BlockSimpleRule​

Type declaration​

BlockUpdate​

Type declaration​

BlockUpdateListener​

Type declaration​

Parameters​

Returns​

BlockUpdateWithSource​

Type declaration​

BodyOptions​

BoundingBox​

Type declaration​

BoxSides​

CSSMeasurement​

CameraPerspective​

CanvasBoxOptions​

Type declaration​

CharacterOptions​

Type declaration​

ChunkDataEventData​

Type declaration​

ChunkEventData​

Type declaration​

ChunkMeshEventData​

Type declaration​

ChunkMeshUpdateEventData​

ChunkRegionArenasOptions​

Type declaration​

ChunkRequestCandidate​

Type declaration​

ChunkSharedPoolStats​

Type declaration​

ChunkStage​

ChunkUpdateEventData​

ChunkUpdateReason​

ClickOccasion​

ClickType​

CloudsOptions​

Enumerations

Core Classes

Effects Classes

Other Classes

Utils Classes

Interfaces

Type Aliases

ArgMetadata

Type declaration

ArmOptions

Type declaration

ArmsOptions

ArrowOptions

Type declaration

ArtFunction

Type declaration

Parameters

Returns

Block

Type declaration

BlockAnimation

Type declaration

BlockAnimationEasing

Type declaration

Parameters

Returns

BlockAnimationState

Type declaration

BlockAnimationsSnapshot

Type declaration

BlockEntityUpdateData

Type parameters

Type declaration

BlockEntityUpdateListener

Type parameters

Type declaration

Parameters

Returns

BlockRestPose

Type declaration

BlockRule

BlockSimpleRule

Type declaration

BlockUpdate

Type declaration

BlockUpdateListener

Type declaration

Parameters

Returns

BlockUpdateWithSource

Type declaration

BodyOptions

BoundingBox

Type declaration

BoxSides

CSSMeasurement

CameraPerspective

CanvasBoxOptions

Type declaration

CharacterOptions

Type declaration

ChunkDataEventData

Type declaration

ChunkEventData

Type declaration

ChunkMeshEventData

Type declaration

ChunkMeshUpdateEventData

ChunkRegionArenasOptions

Type declaration

ChunkRequestCandidate

Type declaration

ChunkSharedPoolStats

Type declaration

ChunkStage

ChunkUpdateEventData

ChunkUpdateReason

ClickOccasion

ClickType

CloudsOptions