box(w: ?, h: ?, d: ?) → void

face(c: ?, n: ?) → void

plane(w: ?, d: ?, uvTile: ?) → void

XZ ground plane facing +Y.

grid(opts: ?) → void

XZ ground grid facing +Y: a dense uniform core with geometrically expanding outer cells, for shader-displaced surfaces (ocean, terrain) that need detail near the action and a horizon far away. UVs carry the undisplaced xz so a vertex shader can hand exact field coordinates to its fragment stage. opts: { innerHalf, innerCells, outerCells, growth }

inside(geom: ?) → void

Flip a geom inside-out (reversed winding + negated normals) so it renders from within — skydomes, environment shells.

sphere(r: ?, segs: ?, rings: ?) → void

cylinder(r: ?, h: ?, segs: ?) → void

cap(y: ?, ny: ?) → void

caps

torus(R: ?, r: ?, segs: ?, rings: ?) → void

lathe(profile: ?, segs: ?) → void

Surface of revolution around Y from a 2D profile of { radius, y } points (bowls, vases, rims, lampshades). Normals are the profile's in-plane normal (-dy, dr), so traversal direction sets which side faces out: an inner wall traversed bottom→rim lights from inside, an outer wall traversed rim→bottom lights from outside. UVs: u = revolution fraction, v = profile fraction.

nhash(x: ?, y: ?, z: ?, seed: ?) → void

CPU value noise (one-time generation cost; seeded, deterministic).

vnoise3(x: ?, y: ?, z: ?, seed: ?) → void

lerp(a: ?, b: ?, t: ?) → void

rock(opts: ?) → void

Faceted rock: a lat/long sphere displaced along its radius by seeded value noise, emitted flat-shaded (per-face normals) so the silhouette reads as chiseled stone. UVs survive displacement — uv.x = azimuth fraction, uv.y = height fraction (top 0 → bottom 1) — so rock shaders can carve bands and moss masks in a stable parameterization. opts: { r?, sx?, sy?, sz?, segs?, rings?, seed?, rough?, detail?, taper? }

tri(p1: ?, p2: ?, p3: ?) → void

pointCloud(points: ?) → void

Octahedron point cloud, encoded for GPU vertex animation: one tiny octahedron per point whose vertex NORMAL is the unit offset from the point's center and whose uv is (seed, size) — a vertex shader recovers the center as position - normal * uv.y and animates it freely while normals stay valid under translation. points: { { x, y, z, seed, size }, ... }

buildTangents(P: ?, N: ?, U: ?, I: ?) → void

A runtime mesh built from positions/normals/uvs alone carries a tangent channel of ZEROES — the channel is allocated and nothing is derived into it — and a zero tangent makes the shader's tangent-to-world basis degenerate. A normal map on such a mesh does not merely do nothing: it drives the shading normal to garbage, and the surface goes black wherever the map is strongest. Every normal-mapped surface built through this helper depends on the basis being built here, from the same triangles and UVs the shader samples through. Lengyel's method: accumulate each triangle's UV-space tangent onto its three vertices, then orthonormalize against the vertex normal.

mesh(geom: ?, name: ?) → void

material(opts: ?) → void

opts: { shader?, props?, render?, textures?, key? } → MaterialHandle (guid = key)

setMatProp(mat: ?, name: ?, value: ?) → void

spawnMesh(mesh: ?, mat: ?, opts: ?) → void

Spawn an entity rendering (mesh, mat). opts: { name?, pos?, rot?, scale?, castsShadows?, visible? }

qrotate(q: ?, vx: ?, vy: ?, vz: ?) → void

Rotate vector (vx,vy,vz) by quat {x,y,z,w}; returns three numbers.

qmul(a: ?, b: ?) → void

merge(parts: ?) → void

Merge geometry parts into one geom, baking per-part transforms. parts: { { geom, pos = {x,y,z}?, rot = quat?, scale = number|{x,y,z}? }, ... } Normals are scale-corrected (inverse scale + renormalize) then rotated.

quatY(rad: ?) → void

quatAxis(ax: ?, ay: ?, az: ?, rad: ?) → void