@netforge/engine 0.0.0-stage → 0.1.0

package/dist/runtime/styles/handdrawn/textures.js

@@ -0,0 +1,150 @@
+/**
+ * Procedural textures for the hand-drawn style, generated in JS (no DOM,
+ * no files, deterministic from a seed): a tileable noise field the line
+ * wobble, wet edges and hatching read, and a sheet of paper with grain and
+ * fibres the whole frame is printed on. Original work, so no licence
+ * question.
+ */
+import { DataTexture, LinearFilter, RepeatWrapping, RGBAFormat, UnsignedByteType } from "three/webgpu";
+/** A small seeded generator (mulberry32). */
+export function seeded(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Tileable value noise on a `size` grid with `cells` lattice cells per side, fractal over `octaves`. Values 0..1. */
+export function tileNoise(size, cells, octaves, rnd) {
+    const out = new Float32Array(size * size);
+    let amp = 1;
+    let total = 0;
+    let c = cells;
+    for (let o = 0; o < octaves; o++) {
+        const lattice = new Float32Array(c * c);
+        for (let i = 0; i < lattice.length; i++)
+            lattice[i] = rnd();
+        const step = size / c;
+        for (let y = 0; y < size; y++) {
+            const gy = y / step;
+            const y0 = Math.floor(gy) % c;
+            const y1 = (y0 + 1) % c;
+            const fy = gy - Math.floor(gy);
+            const sy = fy * fy * (3 - 2 * fy);
+            for (let x = 0; x < size; x++) {
+                const gx = x / step;
+                const x0 = Math.floor(gx) % c;
+                const x1 = (x0 + 1) % c;
+                const fx = gx - Math.floor(gx);
+                const sx = fx * fx * (3 - 2 * fx);
+                const a = lattice[y0 * c + x0] ?? 0;
+                const b = lattice[y0 * c + x1] ?? 0;
+                const d = lattice[y1 * c + x0] ?? 0;
+                const e = lattice[y1 * c + x1] ?? 0;
+                const v = (a + (b - a) * sx) * (1 - sy) + (d + (e - d) * sx) * sy;
+                out[y * size + x] = (out[y * size + x] ?? 0) + v * amp;
+            }
+        }
+        total += amp;
+        amp *= 0.5;
+        c *= 2;
+    }
+    for (let i = 0; i < out.length; i++)
+        out[i] = (out[i] ?? 0) / total;
+    return out;
+}
+function dataTexture(data, size) {
+    const t = new DataTexture(data, size, size, RGBAFormat, UnsignedByteType);
+    t.wrapS = RepeatWrapping;
+    t.wrapT = RepeatWrapping;
+    t.magFilter = LinearFilter;
+    t.minFilter = LinearFilter;
+    t.generateMipmaps = false;
+    t.needsUpdate = true;
+    return t;
+}
+/** Stretch a noise field so it spans 0..1 (value noise bunches around the middle). */
+function contrast(f) {
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (const v of f) {
+        if (v < lo)
+            lo = v;
+        if (v > hi)
+            hi = v;
+    }
+    const k = hi - lo > 1e-6 ? 1 / (hi - lo) : 1;
+    for (let i = 0; i < f.length; i++)
+        f[i] = ((f[i] ?? 0) - lo) * k;
+    return f;
+}
+/**
+ * Noise for the style's shaders, 256 px and tileable: R low (wobble, wet
+ * edges), G mid (line pressure and breaks), B fine (stroke jitter), A white.
+ */
+export function noiseData(seed = 11, size = 256) {
+    const rnd = seeded(seed);
+    const r = contrast(tileNoise(size, 4, 3, rnd));
+    const g = contrast(tileNoise(size, 8, 3, rnd));
+    const b = contrast(tileNoise(size, 32, 2, rnd));
+    const data = new Uint8Array(size * size * 4);
+    for (let i = 0; i < size * size; i++) {
+        data[i * 4] = Math.round((r[i] ?? 0) * 255);
+        data[i * 4 + 1] = Math.round((g[i] ?? 0) * 255);
+        data[i * 4 + 2] = Math.round((b[i] ?? 0) * 255);
+        data[i * 4 + 3] = Math.floor(rnd() * 256);
+    }
+    return data;
+}
+/**
+ * Cold-pressed paper, 512 px and tileable: R is the surface (1 = the top of
+ * the tooth, lower = valleys and fibres), G a slower mottle for the sheet's
+ * tone, B the tooth alone (where pigment granulates).
+ */
+export function paperData(seed = 5, size = 512) {
+    const rnd = seeded(seed);
+    const tooth = contrast(tileNoise(size, 64, 2, rnd));
+    const mottle = contrast(tileNoise(size, 4, 4, rnd));
+    const surface = new Float32Array(size * size);
+    for (let i = 0; i < surface.length; i++)
+        surface[i] = 0.9 + 0.1 * (tooth[i] ?? 0);
+    // Fibres: short soft curves, a little darker or lighter than the sheet.
+    const wrap = (v) => ((Math.round(v) % size) + size) % size;
+    for (let f = 0; f < 1400; f++) {
+        let x = rnd() * size;
+        let y = rnd() * size;
+        let a = rnd() * Math.PI * 2;
+        const len = 6 + rnd() * 26;
+        const dv = rnd() < 0.7 ? -(0.03 + rnd() * 0.05) : 0.03 + rnd() * 0.03;
+        for (let s = 0; s < len; s++) {
+            const i = wrap(y) * size + wrap(x);
+            surface[i] = Math.min(1, Math.max(0, (surface[i] ?? 0) + dv * (1 - Math.abs(s / len - 0.5))));
+            a += (rnd() - 0.5) * 0.35;
+            x += Math.cos(a);
+            y += Math.sin(a);
+        }
+    }
+    const data = new Uint8Array(size * size * 4);
+    for (let i = 0; i < size * size; i++) {
+        data[i * 4] = Math.round((surface[i] ?? 0) * 255);
+        data[i * 4 + 1] = Math.round((mottle[i] ?? 0) * 255);
+        data[i * 4 + 2] = Math.round((tooth[i] ?? 0) * 255);
+        data[i * 4 + 3] = 255;
+    }
+    return data;
+}
+let noiseTex = null;
+let paperTex = null;
+/** The shared noise texture (built once per page). */
+export function noiseTexture() {
+    noiseTex ??= dataTexture(noiseData(), 256);
+    return noiseTex;
+}
+/** The shared paper texture (built once per page). */
+export function paperTexture() {
+    paperTex ??= dataTexture(paperData(), 512);
+    return paperTex;
+}

package/dist/runtime/styles/handdrawn/vfx.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Effects drawn by hand: every particle is a painted fleck with an inked
+ * rim (no soft glow dots), smoke is a scribbled puff, scorches are ink
+ * blots, splats are watercolour blooms with a dark tide line, and rings
+ * are brush circles with dry-brush gaps. Same pools and draws as the
+ * engine's effects; only their fragment shading changes.
+ */
+import type { Texture } from "three/webgpu";
+import type { ParticleShade } from "../../render/particles.js";
+import type { DecalLook, RingLook } from "../kit.js";
+/** Painted flecks and scribbled puffs, drawn with normal blending (the stack multiplies in each particle's alive flag). */
+export declare function particleLook(noise: Texture): ParticleShade;
+export declare function decalLook(noise: Texture): DecalLook;
+export declare function ringLook(noise: Texture): RingLook;

package/dist/runtime/styles/handdrawn/vfx.js

@@ -0,0 +1,73 @@
+import { abs, atan, clamp, cos, float, length, max, min, mix, select, smoothstep, texture, vec2, vec3 } from "three/tsl";
+import { linearRgb, PIGMENTS } from "./palette.js";
+const inkLinear = () => vec3(...linearRgb(PIGMENTS.sepia));
+/** Colours arrive linear and sometimes boosted for bloom: bring them back to paint (0..1, a touch muted). */
+function paintColor(c) {
+    const k = max(max(c.x, c.y), max(c.z, float(1e-3)));
+    const unboosted = c.div(max(k, float(1)));
+    return mix(unboosted, vec3(0.5, 0.45, 0.4).mul(unboosted.x.add(unboosted.y).add(unboosted.z).div(3)), 0.12).mul(1.15);
+}
+/** Painted flecks and scribbled puffs, drawn with normal blending (the stack multiplies in each particle's alive flag). */
+export function particleLook(noise) {
+    const shade = ({ uv, t, color, blend }) => {
+        const p = uv.sub(0.5).mul(2);
+        // A slightly lumpy outline so no two flecks are perfect circles.
+        const lump = texture(noise, uv.mul(0.35).add(t.mul(0.05))).b.sub(0.5).mul(0.22);
+        const d = length(p).add(lump);
+        if (blend === "add") {
+            // A painted fleck: solid paint, an inked rim, shrinking as it dies.
+            const edge = float(0.82).sub(t.mul(0.25));
+            const fill = float(1).sub(smoothstep(edge.sub(0.08), edge, d));
+            // The rim is a thin pen ring: on a big fleck it reads as ink, on a speck it stays a touch of shade (no dirt dots in a crowd).
+            const rim = smoothstep(edge.sub(0.2), edge.sub(0.06), d).mul(fill);
+            const paint = paintColor(color).mul(1.25);
+            const col = mix(paint, inkLinear(), rim.mul(0.45));
+            return { color: col, opacity: fill.mul(float(1).sub(smoothstep(0.75, 1, t))), blend: "alpha" };
+        }
+        // Smoke and dust: a pale scribbled puff with a broken pencil rim.
+        const fill = float(1).sub(smoothstep(0.7, 0.84, d));
+        const rim = smoothstep(0.52, 0.74, d).mul(fill).mul(smoothstep(0.35, 0.55, texture(noise, uv.mul(0.6)).g));
+        const wash = mix(paintColor(color), vec3(0.86, 0.82, 0.74), 0.55);
+        const col = mix(wash, inkLinear(), rim.mul(0.6));
+        return { color: col, opacity: fill.mul(0.55).mul(float(1).sub(t)), blend: "alpha" };
+    };
+    return { shade };
+}
+export function decalLook(noise) {
+    return ({ uv, r, angle, kind, t, color, shape, opacity }) => {
+        const n = texture(noise, uv.mul(0.5).add(vec2(cos(angle).mul(0.01), 0))).r;
+        const fade = float(1).sub(smoothstep(0.55, 1, t));
+        // Scorch: an ink blot with a crisp, ragged edge and a few spatters.
+        const blot = smoothstep(0.32, 0.4, shape.add(n.sub(0.5).mul(0.25)));
+        const spat = smoothstep(0.82, 0.86, texture(noise, uv.mul(1.7)).a).mul(smoothstep(1, 0.6, r)).mul(smoothstep(0.4, 0.7, r));
+        const scorchA = max(blot, spat).mul(0.85);
+        // Splat: a watercolour bloom, pale inside, dark tide line at its edge.
+        const bloom = smoothstep(0.3, 0.42, shape.add(n.sub(0.5).mul(0.3)));
+        const inner = smoothstep(0.45, 0.85, shape);
+        const splatA = bloom.mul(0.42).add(bloom.sub(inner).mul(0.45));
+        // Ring: a brush circle with dry-brush gaps.
+        const band = float(1).sub(smoothstep(0.03, 0.07, abs(r.sub(0.8).add(n.sub(0.5).mul(0.06)))));
+        const dry = smoothstep(0.25, 0.45, texture(noise, vec2(angle.mul(0.16), r.mul(0.2))).g);
+        const ringA = band.mul(dry);
+        const a = select(kind.lessThan(0.5), scorchA, select(kind.lessThan(1.5), splatA, ringA));
+        const tone = paintColor(color);
+        const col = select(kind.lessThan(0.5), mix(inkLinear(), tone, 0.25), select(kind.lessThan(1.5), mix(tone, tone.mul(0.6), bloom.sub(inner)), mix(tone, inkLinear(), 0.35)));
+        return { color: col, opacity: clamp(a.mul(opacity).mul(fade).mul(1.25), 0, 1), blending: "normal" };
+    };
+}
+export function ringLook(noise) {
+    return ({ uv, r, t, alive, color }) => {
+        const p = uv.sub(0.5);
+        const ang = atan(p.y, p.x);
+        const n = texture(noise, vec2(ang.mul(0.21), t.mul(0.1))).g;
+        // A brush stroke around the circle: thick at the start, thinning as it spreads, with gaps.
+        const width = mix(float(0.13), float(0.05), t);
+        const centre = float(0.9).add(n.sub(0.5).mul(0.05));
+        const band = float(1).sub(smoothstep(width.mul(0.5), width, abs(r.sub(centre))));
+        const dry = smoothstep(0.22, 0.4, n);
+        const inkRim = smoothstep(width.mul(0.15), width.mul(0.55), abs(r.sub(centre))).mul(band);
+        const paint = paintColor(color).mul(1.2);
+        const col = mix(paint, inkLinear(), min(inkRim.mul(0.8), float(0.8)));
+        return { color: col, opacity: band.mul(dry).mul(float(1).sub(t)).mul(alive), blending: "normal" };
+    };
+}

package/dist/runtime/styles/index.d.ts

@@ -0,0 +1,9 @@
+import type { StyleKit } from "./kit.js";
+export type { FieldSpec, PillarSpec, DecalLook, DecalLookInput, LookOutput, RingLook, RingLookInput, StyleContext, StyledPillar, StyleKit, StylePost, StylePostInput, StyleSession, StyleShape, StyleShapeName, StyleStack, SurfaceKind, SurfaceOptions, WorldTheme, } from "./kit.js";
+/** One entry per art style. Keep it a plain map. */
+export declare const STYLE_KITS: Readonly<Record<string, StyleKit>>;
+/** The art style a template draws in: a known `?style=` on the URL wins over the game's declared style. */
+export declare function pickStyle(declared: string, requested: string | null | undefined): string;
+/** The kit for a style, or null (low-poly, or a style with no kit yet). */
+export declare function styleKit(style: string | null | undefined): StyleKit | null;
+export * as voxel from "./voxel/index.js";

package/dist/runtime/styles/index.js

@@ -0,0 +1,32 @@
+/**
+ * Art styles: what a game declared with
+ * `style: "<name>"` draws with, beyond its library models. Each style lives
+ * in its own folder and registers one entry in STYLE_KITS (the one
+ * registry). createRenderStack({ style }) applies a kit's render hooks
+ * (look, post, session); templates read `stack.kit` (or `styleKit(style)`)
+ * for its world builders, falling back to their own drawing for anything a
+ * kit leaves out. Low-poly is the templates' own drawing and has no kit.
+ */
+import { STYLES } from "../../api/schemas.js";
+import { handdrawnKit } from "./handdrawn/index.js";
+import { pixelKit } from "./pixel/index.js";
+import { ps1Kit } from "./ps1/index.js";
+import { toonKit } from "./toon/index.js";
+import { voxelKit } from "./voxel/kit.js";
+/** One entry per art style. Keep it a plain map. */
+export const STYLE_KITS = {
+    handdrawn: handdrawnKit,
+    pixel: pixelKit,
+    ps1: ps1Kit,
+    toon: toonKit,
+    voxel: voxelKit,
+};
+/** The art style a template draws in: a known `?style=` on the URL wins over the game's declared style. */
+export function pickStyle(declared, requested) {
+    return requested && STYLES.includes(requested) ? requested : declared;
+}
+/** The kit for a style, or null (low-poly, or a style with no kit yet). */
+export function styleKit(style) {
+    return (style && STYLE_KITS[style]) || null;
+}
+export * as voxel from "./voxel/index.js";

package/dist/runtime/styles/kit.d.ts

@@ -0,0 +1,193 @@
+/**
+ * What an art style gives the runtime and a template.
+ * One interface for every style, two halves, every member optional:
+ *
+ *  - render hooks, applied by createRenderStack({ style }) (render/stack.ts
+ *    is the one place that looks a style up): `stack`/`look` presets, and
+ *    `attach`, a per-renderer session that may wrap or replace the frame,
+ *    add post stages, and reshade particles;
+ *  - world builders a template asks for (`field`, `pillar`, `shape`...).
+ *
+ * A template draws anything a kit leaves out its own way, so a style can
+ * grow one piece at a time and a template never breaks on a missing piece.
+ */
+import type { BufferGeometry, Camera, Material, Node, Object3D, PassNode, Scene, Texture, UniformNode, Vector2, WebGPURenderer } from "three/webgpu";
+import type { RendererHandle } from "../renderer.js";
+import type { Atmosphere } from "../render/atmosphere.js";
+import type { ParticleShade } from "../render/particles.js";
+import type { PostFX } from "../render/post.js";
+import type { Look, LookPreset } from "../render/presets.js";
+import type { QualityTier } from "../render/quality.js";
+import type { RenderStackOptions } from "../render/stack.js";
+/** Words a template passes so one kit can dress different places: "meadow" (EMBERWATCH's night field), "yard" (VOLTYARD's lot). */
+export type WorldTheme = string;
+/** The play field: a square of half size `half` m with a wall `wallHeight` tall, and `outside` m of dressed ground past it. */
+export interface FieldSpec {
+    readonly half: number;
+    readonly wallHeight: number;
+    readonly outside: number;
+    readonly theme: WorldTheme;
+    /** Draw the wall (default true). */
+    readonly wall?: boolean;
+    /** Pillars standing in the field, so ground clutter keeps clear of them. */
+    readonly pillars?: readonly PillarSpec[];
+}
+/** One pillar or post (sim metres). */
+export interface PillarSpec {
+    readonly x: number;
+    readonly z: number;
+    readonly radius: number;
+    readonly height: number;
+}
+/** A pillar as drawn: its body (own material, so the template can fade it), the pieces on top, and where its flame burns (null: none). */
+export interface StyledPillar {
+    readonly body: Object3D;
+    readonly fade: readonly Material[];
+    readonly top: readonly Object3D[];
+    readonly flame: readonly [number, number, number] | null;
+}
+/** A shape a template draws instanced (bolts, blades, chunks, props). */
+export interface StyleShape {
+    readonly geometry: BufferGeometry;
+    readonly material: Material;
+}
+/** Template machinery shapes a style may redraw. */
+export type StyleShapeName = "bolt" | "lance" | "blade" | "pellet" | "shard" | "chunk" | "rock" | "stump" | "barrel" | "crate" | "lantern" | "flame";
+/** Overrides for the render stack under one look preset, plus the style's opinion on sun shadows. */
+export interface StyleStack extends Partial<Pick<RenderStackOptions, "lighting" | "atmosphere" | "grade" | "makeParticles">> {
+    /** Sun shadows suit the style (a template may still turn them off for speed). */
+    readonly shadows?: boolean;
+}
+/** What a style's session is attached to (one renderer, one scene). */
+export interface StyleContext {
+    readonly handle: RendererHandle;
+    readonly renderer: WebGPURenderer;
+    readonly scene: Scene;
+    readonly camera: Camera;
+    readonly tier: QualityTier;
+    /** The look preset in use. */
+    readonly preset: LookPreset;
+    /** The stack's post (grade, hurt pulse, vignette), when there is one. */
+    readonly post?: PostFX;
+    /** The stack's fog and sky, when there is one. */
+    readonly atmosphere?: Atmosphere;
+    /** Library id to URL (the template's LibraryClient), for the style's own textures. Absent or null: no library, use fallbacks. */
+    readonly resolve?: (id: string) => string | null;
+}
+/** What the post stages can read: the scene pass, sampleable at any uv. */
+export interface StylePostInput {
+    /** Scene colour (linear HDR) as a texture node: `.sample(uv)` reads a neighbour. */
+    readonly color: Node<"vec4"> & {
+        sample(uv: Node<"vec2">): Node<"vec4">;
+    };
+    /** Scene depth (0..1 perspective depth) as a texture node. */
+    readonly depth: Node<"vec4"> & {
+        sample(uv: Node<"vec2">): Node<"vec4">;
+    };
+    /** One render pixel in uv units. */
+    readonly texel: UniformNode<"vec2", Vector2>;
+    readonly near: UniformNode<"float", number>;
+    readonly far: UniformNode<"float", number>;
+}
+/** Post-graph hooks, in graph order: called whenever the post stack rebuilds its node graph. */
+export interface StylePost {
+    /** Configure the scene pass before anything samples it (extra MRT outputs, draw hooks). */
+    scenePass?(pass: PassNode): void;
+    /** HDR stage before bloom and grade: the colour to use instead of the scene pass. */
+    scene?(input: StylePostInput): Node<"vec4">;
+    /** Change the HDR colour (after bloom and outline, before the grade). */
+    color?(rgb: Node<"vec3">, pass: PassNode): Node<"vec3">;
+    /** Display stage, after tone mapping (sRGB 0..1): lines, paper, print. */
+    display?(color: Node<"vec4">, input: StylePostInput): Node<"vec4">;
+}
+/** What a ground decal's look can read (GroundDecals). */
+export interface DecalLookInput {
+    readonly uv: Node<"vec2">;
+    /** Radius from the centre, 0..1 at the quad's edge. */
+    readonly r: Node<"float">;
+    /** Angle around the centre, radians, with the decal's random seed added. */
+    readonly angle: Node<"float">;
+    /** 0 scorch, 1 splat, 2 ring. */
+    readonly kind: Node<"float">;
+    /** 0 at birth, 1 at the end of its life. */
+    readonly t: Node<"float">;
+    readonly color: Node<"vec3">;
+    /** The engine's own shape mask, 0..1 (for styles that keep the shapes). */
+    readonly shape: Node<"float">;
+    /** Peak opacity times alive. */
+    readonly opacity: Node<"float">;
+}
+/** What a shockwave ring's look can read (GroundRings). */
+export interface RingLookInput {
+    readonly uv: Node<"vec2">;
+    readonly r: Node<"float">;
+    readonly t: Node<"float">;
+    readonly alive: Node<"float">;
+    readonly color: Node<"vec3">;
+}
+/** A decal or ring look's answer: colour and opacity nodes, and the blend to draw with. */
+export interface LookOutput {
+    readonly color: Node<"vec3">;
+    readonly opacity: Node<"float">;
+    readonly blending?: "add" | "normal";
+}
+export type DecalLook = (n: DecalLookInput) => LookOutput;
+export type RingLook = (n: RingLookInput) => LookOutput;
+/**
+ * Surfaces templates build themselves and may ask the style for: ground
+ * (a natural field), floor (paving), wall, stone, and glow (a pool of
+ * light on the ground, white with alpha, which the template tints).
+ */
+export type SurfaceKind = "ground" | "floor" | "wall" | "stone" | "glow";
+export interface SurfaceOptions {
+    /** Metres one repeat of the texture covers (the template sets repeat). */
+    readonly tile?: number;
+    /** A hint at what the place is ("forest field", "power yard"). */
+    readonly mood?: string;
+}
+/** One style attached to one renderer and scene (StyleKit.attach). */
+export interface StyleSession {
+    /** Draw a frame in the style: `draw` is the stack's own render (post or straight to the canvas). Omitted: the stack draws. */
+    render?(draw: () => void): void;
+    /** Post stages (the stack keeps post on at every tier when the kit says `needsPost`). */
+    readonly post?: StylePost;
+    /** Shapes and colours for the GPU particles (sparks, puffs, stars). */
+    readonly particles?: ParticleShade;
+    /** Shading for ground decals (scorches, splats) and shockwave rings. */
+    readonly decals?: DecalLook;
+    readonly rings?: RingLook;
+    /** Every frame, before drawing (real seconds since the page opened). */
+    frame?(seconds: number): void;
+    /** The game switched look preset. */
+    setPreset?(preset: LookPreset): void;
+    /** A texture for a template-built surface, or null to keep the template's own. */
+    surface?(kind: SurfaceKind, opts?: SurfaceOptions): Texture | null;
+    /** The render size in device pixels changed. */
+    setSize?(width: number, height: number): void;
+    /** The quality tier changed. */
+    setQuality?(tier: QualityTier): void;
+    dispose(): void;
+}
+export interface StyleKit {
+    readonly id: string;
+    /** Render stack overrides for a look preset (merged over `look`, under the template's own options). */
+    stack?(preset: LookPreset): StyleStack;
+    /** The style's whole version of a look preset: lighting, atmosphere and grade together. */
+    look?(preset: LookPreset): Look;
+    /** The style's picture lives in post: keep post on at the low tier (without bloom). */
+    readonly needsPost?: boolean;
+    /** Bloom by default in this style (a game's `look.bloom` still wins). Default true. */
+    readonly bloom?: boolean;
+    /** false: the style draws its own lines, so the stack's outline stays off. */
+    readonly outline?: boolean;
+    /** Attach the style to a renderer and scene: draw-time materials, post stages, particle look. */
+    attach?(ctx: StyleContext): StyleSession;
+    /** The field's floor, the dressed ground past it, and its wall. Add the result to the scene. */
+    field?(spec: FieldSpec): Object3D[];
+    /** Height of the style's ground at (x, z) for a field built by `field`, so scenery past the wall stands on it. */
+    groundHeight?(spec: FieldSpec, x: number, z: number): number;
+    /** One pillar. */
+    pillar?(spec: PillarSpec, theme: WorldTheme, index: number): StyledPillar;
+    /** A template machinery shape in the style, or null to keep the template's own. */
+    shape?(name: StyleShapeName): StyleShape | null;
+}

package/dist/runtime/styles/kit.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/styles/pixel/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The pixel art style. The scene renders into a
+ * low-resolution target, one pixel of it per sprite texel at the camera's
+ * focus, and every pixel goes to the screen as a hard square block: no
+ * filtering, no blur, one pixel scale for the whole picture. The colour is
+ * then snapped to the style's 16-colour palette (the library build snaps
+ * the sprites to the same one) with a 4x4 ordered dither, so lit 3D ground,
+ * walls and effects read as one piece of pixel art with the sprites.
+ *
+ * Sprites (render/sprite.ts) are resized by `spriteScale` here each frame,
+ * so a sprite texel is exactly one low-resolution pixel.
+ */
+import { PerspectiveCamera, Vector3 } from "three/webgpu";
+import type { StyleKit } from "../kit.js";
+/**
+ * The pixel style's palette (DawnBringer 16). The asset library's
+ * manifest/pixel.json carries the same list; its test keeps them equal.
+ */
+export declare const PIXEL_PALETTE: readonly string[];
+export interface PixelStyleOptions {
+    /** Sprite texels (and so screen pixels of the low-res picture) per metre at the focus. Default 1 / SPRITE_TEXEL (16). */
+    readonly texelsPerMetre?: number;
+    /** Dither on the world's band edges, in light (0..1). Default 0.025. */
+    readonly dither?: number;
+    /** Sprite saturation before the palette snap. Default 1.25. */
+    readonly saturation?: number;
+    /** Light levels the world steps through: two dark field tones, then the light pools. Default [0.08, 0.14, 0.3, 0.52, 0.82]. */
+    readonly bands?: readonly number[];
+    /** Fewest low-res rows, so a tiny window stays legible. Default 120. */
+    readonly minRows?: number;
+}
+/**
+ * The integer block size (screen pixels per low-res pixel) that puts
+ * `texelsPerMetre` low-res rows on each metre of a view `viewMetres` tall.
+ */
+export declare function pixelBlock(bufferHeight: number, viewMetres: number, texelsPerMetre: number, minRows?: number): number;
+/** Height in metres the camera sees at the ground point it looks at (perspective cameras; orthographic: its frustum). */
+export declare function viewMetres(camera: PerspectiveCamera | {
+    isOrthographicCamera?: boolean;
+    top?: number;
+    bottom?: number;
+    zoom?: number;
+}, forward: Vector3, position: Vector3): number;
+/** The pixel style with its options. */
+export declare function createPixelStyle(o?: PixelStyleOptions): StyleKit;
+export declare const pixelKit: StyleKit;