Walk sources from highest to lowest priority, return first match.

Simple 32-bit integer hash, one multiplication and XOR-shift.

Decompose a world-space block position into `(chunk_coord, local_coord)`. `chunk_coord` = `floor(pos / 16)` — which 16³ subchunk contains this block.

Append a source. Later additions override earlier ones.

Look up a value by its string identifier.

Build a `RenderPipeline` from a shader. Shared by both the regular (filled) and wireframe (line) pipelines. The only differences are `polygon_mode` a

Convert identifier to numeric ID. Returns `0` for unregistered identifiers (air by convention).

Convert numeric ID back to identifier. Returns `None` if the ID is unregistered (shouldn't happen with valid data).

Builder-style: associate an identifier with static bytes.

Base terrain height, rolling hills.

Clone the raw block data array (for sending to mesh worker thread).

Create the `wgpu` adapter from the instance and surface.

Create the `wgpu` device and queue from the adapter.

Create the `wgpu` instance.

Create the `wgpu` surface configuration from the window size and surface.

Fractal Brownian Motion — summed octaves for natural-looking terrain.

Fast path: return the raw numeric block ID without registry lookup.

Register a key press or release.

Check if a block position is air (fast path, no Identifier allocation).

Collect all identifiers across sources. Higher-priority sources win for duplicates (last-added overwrites).

Runs on the worker thread. Receives MeshTasks, tessellates block data into TexturedVertex arrays, sends results back.

Smooth 2D noise in [0, 1] via bilinear interpolation. `scale` controls frequency — smaller = larger features.

Generate at most `budget` pending chunks per frame.

Look up UV coordinates for a block identifier. FIXME: This fallback to `{id}_top` is a stopgap until we implement block models (JSON files defining p

Draw one frame. Acquires the next swapchain texture, clears it to sky blue, runs the render pass (depth + color), and presents. Returns `Err(())` if

Handle window resize: reconfigure the swapchain and recreate the depth buffer to match the new size.

Convert an identifier to a filesystem path: `{root}/assets/{namespace}/{path}`

Entry point. Initializes logging, creates the event loop, and blocks. Uses `ControlFlow::Poll` for continuous rendering (max FPS).

Convert the current key state into a `MovementRecord` for camera movement.

Generate 6 `TexturedVertex` (2 triangles) for a single block face. `quad_center`: world-space center of the face. `uv_aa`, `uv_bb`: texture UV rectan

Get the four corner positions for a given face, offset by `bias`. `(face as u8).ilog2()` maps the bitflag enum value to the QUADS index: XP=0b000001

Now we use data directly from the input manager to update the camera position This is temporary until we define the player's state.

Load/unload chunks based on player world position. When the player crosses a chunk boundary, this queues new chunks for generation. Actual generation

Create the window instance for creating the surface of `wgpu`.

Raw device events (mouse motion for camera rotation).

Get the block identifier at a world position.

Returns the `VertexBufferLayout` describing this vertex format.

Convenience: get both the numeric ID and the value in one call.

Reference: [https://minecraft.wiki/w/Chunk_format] Format: YZX From xyz to Index of the block array.

Initialize wgpu, create the surface, and wire up the `WorldRenderer`. Returns `None` if no suitable GPU adapter is found.

Load WGSL source from the `ResourceManager`, compile it, and record the fragment/vertex entry point names.

Assign the next available numeric ID and register the value.

Bind pipeline and draw all chunk meshes. `rpass` is set up by `RenderState` with the correct color/depth attachments.

Called once at startup. Creates the window and initializes wgpu.