reze-engine 0.62.1 → 0.64.0

package/dist/unity/looks.js

@@ -0,0 +1,295 @@
+// Native looks: a model dressed in the game's own materials.
+//
+// A look names translated shader variants (host.ts), the shared images they
+// sample (ramps, matcaps), and per material the passes it draws and the values
+// it carries — what a game character's material held, with the model's own
+// texture standing in for its _MainTex. Optionally a CharacterRig, which makes
+// the model a character in the game's sense (character.ts).
+//
+// The frame, as the game's CharacterFeature lays it out after the opaques:
+//   1. every native opaque material's passes (Outline, ForwardBase), in queue
+//      order — after the engine's own opaque bundle, so both share one depth;
+//   2. CharHairShadow, CharFaceShadow, CharHairTransE, each over every
+//      material that has one (the hair's shadow on the face, by stencil);
+//   3. the eyes' see-through-hair passes, Override1 for all, then 2, then 3;
+// and the transparent queue in the engine's transparent phase. Shadows are the
+// engine's: a native material still casts through its pass.
+import { UNITY_SKIN_WGSL, tangentsFor } from "./skin";
+import { characterBlock } from "./character";
+import { engineToGame, gameToEngine } from "./globals";
+const OPAQUE_MODES = ["ALWAYS", "FORWARDBASE"];
+const CHARACTER_MODES = ["CHARHAIRSHADOW", "CHARFACESHADOW", "CHARHAIRTRANSE"];
+const OVERRIDE_MODES = ["OVERRIDE1", "OVERRIDE2", "OVERRIDE3"];
+export class NativeLooks {
+    constructor(device, host) {
+        this.device = device;
+        this.installs = new Map();
+        this.globals = {};
+        this.frameTextures = {};
+        this.scale = 8;
+        this.host = host;
+        this.skinPipeline = device.createComputePipeline({
+            label: "native skinning",
+            layout: "auto",
+            compute: {
+                module: device.createShaderModule({
+                    label: "native skinning",
+                    code: UNITY_SKIN_WGSL,
+                }),
+                entryPoint: "main",
+            },
+        });
+        this.zero = device.createBuffer({
+            label: "native zero stream",
+            size: 64,
+            usage: GPUBufferUsage.VERTEX,
+        });
+        this.white = device.createBuffer({
+            label: "native white stream",
+            size: 64,
+            usage: GPUBufferUsage.VERTEX,
+            mappedAtCreation: true,
+        });
+        new Float32Array(this.white.getMappedRange()).fill(1);
+        this.white.unmap();
+    }
+    get size() {
+        return this.installs.size;
+    }
+    has(model) {
+        return this.installs.has(model);
+    }
+    /** Is this model's material drawn by its native look? */
+    dresses(model, material) {
+        const i = this.installs.get(model);
+        return !!i && i.dressed.some((d) => d.draw.materialName === material);
+    }
+    install(model, look) {
+        this.remove(model.name);
+        const d = this.device;
+        for (const s of look.shaders)
+            this.host.register(s);
+        const views = new Map();
+        const textures = [];
+        for (const [key, t] of Object.entries(look.textures)) {
+            const tex = d.createTexture({
+                label: `${model.name}: ${key}`,
+                size: [t.width, t.height],
+                format: t.srgb ? "rgba8unorm-srgb" : "rgba8unorm",
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            d.queue.writeTexture({ texture: tex }, t.data, { bytesPerRow: t.width * 4 }, [t.width, t.height]);
+            textures.push(tex);
+            views.set(key, tex.createView());
+        }
+        const n = model.vertices.length / 8;
+        const buf = (label, floats, usage) => d.createBuffer({
+            label: `${model.name}: ${label}`,
+            size: Math.max(16, floats * 4),
+            usage,
+        });
+        const out = GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX;
+        const pos = buf("native position", n * 3, out);
+        const nrm = buf("native normal", n * 3, out);
+        const tan = buf("native tangent", n * 4, out);
+        const restTan = buf("rest tangent", n * 4, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+        d.queue.writeBuffer(restTan, 0, tangentsFor(model.vertices, model.indices));
+        const params = d.createBuffer({
+            label: `${model.name}: skin params`,
+            size: 16,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        d.queue.writeBuffer(params, 0, new Uint32Array([n, 0, 0, 0]));
+        const skinBind = d.createBindGroup({
+            label: `${model.name}: native skinning`,
+            layout: this.skinPipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: params } },
+                { binding: 1, resource: { buffer: model.vertexBuffer } },
+                { binding: 2, resource: { buffer: model.jointsBuffer } },
+                { binding: 3, resource: { buffer: model.weightsBuffer } },
+                { binding: 4, resource: { buffer: model.skinMatrixBuffer } },
+                { binding: 5, resource: { buffer: restTan } },
+                { binding: 6, resource: { buffer: pos } },
+                { binding: 7, resource: { buffer: nrm } },
+                { binding: 8, resource: { buffer: tan } },
+            ],
+        });
+        const dressed = [];
+        for (const draw of model.draws) {
+            const spec = look.materials.find((m) => m.materials.includes(draw.materialName));
+            if (spec)
+                dressed.push({ draw, spec });
+        }
+        this.installs.set(model.name, {
+            model,
+            look,
+            views,
+            textures,
+            pos,
+            nrm,
+            tan,
+            restTan,
+            params,
+            skinBind,
+            dressed,
+            block: {},
+        });
+    }
+    remove(name) {
+        const i = this.installs.get(name);
+        if (!i)
+            return;
+        this.installs.delete(name);
+        this.host.release(`${name}|`);
+        const bufs = [i.pos, i.nrm, i.tan, i.restTan, i.params];
+        const texs = i.textures;
+        // Freed once the GPU is done with the frames that may still name them.
+        void this.device.queue.onSubmittedWorkDone().then(() => {
+            for (const b of bufs)
+                b.destroy();
+            for (const t of texs)
+                t.destroy();
+        });
+    }
+    /**
+     * Before the scene pass: skin every dressed model and compute each
+     * character's block; the frame's Unity globals come computed (engine.ts).
+     */
+    prepare(encoder, globals, scale, textures) {
+        if (!this.installs.size)
+            return;
+        this.scale = scale;
+        this.globals = globals;
+        this.frameTextures = textures;
+        const pass = encoder.beginComputePass({ label: "native skinning" });
+        pass.setPipeline(this.skinPipeline);
+        for (const i of this.installs.values()) {
+            pass.setBindGroup(0, i.skinBind);
+            pass.dispatchWorkgroups(Math.ceil(i.model.vertices.length / 8 / 64));
+            i.block = i.look.rig
+                ? characterBlock(i.look.rig, i.model.headSkin(), i.model.headRest, scale)
+                : {
+                    unity_RenderingLayer: new Uint32Array([i.model.layers >>> 0, 0, 0, 0]),
+                };
+        }
+        pass.end();
+    }
+    streams(i, shader) {
+        return this.host.inputs(shader).map(({ semantic }) => {
+            if (semantic === "POSITION")
+                return {
+                    buffer: i.pos,
+                    offset: 0,
+                    stride: 12,
+                    format: "float32x3",
+                };
+            if (semantic === "NORMAL")
+                return {
+                    buffer: i.nrm,
+                    offset: 0,
+                    stride: 12,
+                    format: "float32x3",
+                };
+            if (semantic === "TANGENT")
+                return {
+                    buffer: i.tan,
+                    offset: 0,
+                    stride: 16,
+                    format: "float32x4",
+                };
+            if (semantic === "TEXCOORD0")
+                return {
+                    buffer: i.model.vertexBuffer,
+                    offset: 24,
+                    stride: 32,
+                    format: "float32x2",
+                };
+            // A missing vertex colour reads white, as Unity binds it; any other
+            // missing stream reads zero.
+            if (semantic === "COLOR")
+                return {
+                    buffer: this.white,
+                    offset: 0,
+                    stride: 0,
+                    format: "float32x4",
+                };
+            return {
+                buffer: this.zero,
+                offset: 0,
+                stride: 0,
+                format: "float32x4",
+            };
+        });
+    }
+    drawPass(pass, i, d, p) {
+        if (i.model.hidden(d.draw.materialName))
+            return;
+        const s = this.scale;
+        const perDraw = {
+            // The skinned streams are in engine units; the game's world is 1/scale of them.
+            unity_ObjectToWorld: engineToGame(s),
+            unity_WorldToObject: gameToEngine(s),
+            unity_WorldTransformParams: [0, 0, 0, 1],
+            unity_LightData: [0, 0, 0, 0],
+            unity_LightIndices: [
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+            ],
+            unity_LODFade: [1, 1, 0, 0],
+        };
+        const textures = {
+            ...this.frameTextures,
+        };
+        for (const [slot, key] of Object.entries(d.spec.textures))
+            textures[slot] = key === "@diffuse" ? d.draw.diffuse : i.views.get(key);
+        this.host.draw(pass, {
+            shader: p.shader,
+            state: p.state,
+            streams: this.streams(i, p.shader),
+            index: {
+                buffer: i.model.indexBuffer,
+                format: "uint32",
+                offset: d.draw.firstIndex * 4,
+                count: d.draw.count,
+            },
+            sources: [perDraw, i.block, d.spec.values, this.globals],
+            textures,
+            key: `${i.model.name}|${d.draw.materialName}|${p.lightMode}|${p.shader}`,
+            pass: "main",
+        });
+    }
+    /** Every dressed material whose queue is in range, in queue order. */
+    each(opaque) {
+        const out = [];
+        for (const i of this.installs.values())
+            for (const d of i.dressed)
+                if (d.spec.queue <= 2500 === opaque)
+                    out.push({ i, d });
+        return out.sort((a, b) => a.d.spec.queue - b.d.spec.queue);
+    }
+    /** After the engine's opaque phase: the opaques, then the character passes. */
+    drawOpaque(pass) {
+        if (!this.installs.size)
+            return;
+        const list = this.each(true);
+        for (const { i, d } of list)
+            for (const p of d.spec.passes)
+                if (OPAQUE_MODES.includes(p.lightMode))
+                    this.drawPass(pass, i, d, p);
+        for (const mode of [...CHARACTER_MODES, ...OVERRIDE_MODES])
+            for (const { i, d } of list)
+                for (const p of d.spec.passes)
+                    if (p.lightMode === mode)
+                        this.drawPass(pass, i, d, p);
+    }
+    /** In the engine's transparent phase. */
+    drawTransparent(pass) {
+        if (!this.installs.size)
+            return;
+        for (const { i, d } of this.each(false))
+            for (const p of d.spec.passes)
+                if (OPAQUE_MODES.includes(p.lightMode))
+                    this.drawPass(pass, i, d, p);
+    }
+}

package/dist/unity/skin.d.ts

@@ -0,0 +1,9 @@
+export declare const UNITY_SKIN_WGSL = "\nstruct Params { count: u32, _a: u32, _b: u32, _c: u32 }\n@group(0) @binding(0) var<uniform> P: Params;\n@group(0) @binding(1) var<storage, read> verts: array<f32>;      // pos(3) nrm(3) uv(2)\n@group(0) @binding(2) var<storage, read> joints: array<u32>;     // uint16x4: two words\n@group(0) @binding(3) var<storage, read> weights: array<u32>;    // unorm8x4: one word\n@group(0) @binding(4) var<storage, read> skinMats: array<mat4x4f>;\n@group(0) @binding(5) var<storage, read> tangents: array<f32>;   // rest tangent(4)\n@group(0) @binding(6) var<storage, read_write> outPos: array<f32>;\n@group(0) @binding(7) var<storage, read_write> outNrm: array<f32>;\n@group(0) @binding(8) var<storage, read_write> outTan: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3u) {\n  let v = id.x;\n  if (v >= P.count) { return; }\n  let p = vec4f(verts[v * 8u], verts[v * 8u + 1u], verts[v * 8u + 2u], 1.0);\n  let n = vec3f(verts[v * 8u + 3u], verts[v * 8u + 4u], verts[v * 8u + 5u]);\n  let t = vec4f(tangents[v * 4u], tangents[v * 4u + 1u], tangents[v * 4u + 2u], tangents[v * 4u + 3u]);\n  let j01 = joints[v * 2u];\n  let j23 = joints[v * 2u + 1u];\n  let j = vec4u(j01 & 0xffffu, j01 >> 16u, j23 & 0xffffu, j23 >> 16u);\n  var w = unpack4x8unorm(weights[v]);\n  // Renormalised as the material vertex stage does: PMX ships unnormalised\n  // weights on extras, and a sum of zero is the bind pose.\n  let s = w.x + w.y + w.z + w.w;\n  w = select(vec4f(1.0, 0.0, 0.0, 0.0), w / s, s > 0.0001);\n  var sp = vec3f(0.0);\n  var sn = vec3f(0.0);\n  var st = vec3f(0.0);\n  for (var k = 0u; k < 4u; k++) {\n    let m = skinMats[j[k]];\n    let r = mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz);\n    sp += (m * p).xyz * w[k];\n    sn += (r * n) * w[k];\n    st += (r * t.xyz) * w[k];\n  }\n  // Degenerate blends (opposing bones at 50/50) cancel to zero; up, not NaN.\n  let ln = dot(sn, sn);\n  let lt = dot(st, st);\n  sn = select(vec3f(0.0, 1.0, 0.0), sn * inverseSqrt(ln), ln > 1e-12);\n  st = select(vec3f(1.0, 0.0, 0.0), st * inverseSqrt(lt), lt > 1e-12);\n  outPos[v * 3u] = sp.x; outPos[v * 3u + 1u] = sp.y; outPos[v * 3u + 2u] = sp.z;\n  outNrm[v * 3u] = sn.x; outNrm[v * 3u + 1u] = sn.y; outNrm[v * 3u + 2u] = sn.z;\n  outTan[v * 4u] = st.x; outTan[v * 4u + 1u] = st.y; outTan[v * 4u + 2u] = st.z; outTan[v * 4u + 3u] = t.w;\n}\n";
+/**
+ * Per-vertex tangents (xyz, w = handedness) from positions, normals and uvs,
+ * accumulated per triangle and orthogonalised against the normal — the
+ * standard construction, which is what a mesh imported without tangents gets
+ * in Unity too. `verts` is the engine's interleaved layout (8 floats).
+ */
+export declare function tangentsFor(verts: Float32Array, indices: Uint32Array | Uint16Array): Float32Array;
+//# sourceMappingURL=skin.d.ts.map

package/dist/unity/skin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skin.d.ts","sourceRoot":"","sources":["../../src/unity/skin.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe,g0EA8C3B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CA0DjG"}

package/dist/unity/skin.js

@@ -0,0 +1,117 @@
+// Skinned vertex streams for native (game-shader) materials.
+//
+// The engine skins in the vertex stage of its own material shaders, from the
+// bone palette (skinMats) and the post-morph vertex buffer. A game shader skins
+// nothing: Unity hands it world-space-ready POSITION / NORMAL / TANGENT streams
+// from its SkinnedMeshRenderer. So a model that wears native materials is
+// skinned once per frame here, by compute, into three plain vertex buffers the
+// game shaders read as Unity's — the same streams the compare page feeds them.
+//
+// Inputs are the engine's own buffers, untouched: the interleaved vertex
+// buffer (position, normal, uv — 8 floats, morphs already applied), the joints
+// (uint16x4, two words a vertex), the weights (unorm8x4, one word) and the
+// skin matrices. Tangents are not in the engine's vertex format; they are
+// derived once at install (tangentsFor) and skinned here with the normal.
+export const UNITY_SKIN_WGSL = /* wgsl */ `
+struct Params { count: u32, _a: u32, _b: u32, _c: u32 }
+@group(0) @binding(0) var<uniform> P: Params;
+@group(0) @binding(1) var<storage, read> verts: array<f32>;      // pos(3) nrm(3) uv(2)
+@group(0) @binding(2) var<storage, read> joints: array<u32>;     // uint16x4: two words
+@group(0) @binding(3) var<storage, read> weights: array<u32>;    // unorm8x4: one word
+@group(0) @binding(4) var<storage, read> skinMats: array<mat4x4f>;
+@group(0) @binding(5) var<storage, read> tangents: array<f32>;   // rest tangent(4)
+@group(0) @binding(6) var<storage, read_write> outPos: array<f32>;
+@group(0) @binding(7) var<storage, read_write> outNrm: array<f32>;
+@group(0) @binding(8) var<storage, read_write> outTan: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+  let v = id.x;
+  if (v >= P.count) { return; }
+  let p = vec4f(verts[v * 8u], verts[v * 8u + 1u], verts[v * 8u + 2u], 1.0);
+  let n = vec3f(verts[v * 8u + 3u], verts[v * 8u + 4u], verts[v * 8u + 5u]);
+  let t = vec4f(tangents[v * 4u], tangents[v * 4u + 1u], tangents[v * 4u + 2u], tangents[v * 4u + 3u]);
+  let j01 = joints[v * 2u];
+  let j23 = joints[v * 2u + 1u];
+  let j = vec4u(j01 & 0xffffu, j01 >> 16u, j23 & 0xffffu, j23 >> 16u);
+  var w = unpack4x8unorm(weights[v]);
+  // Renormalised as the material vertex stage does: PMX ships unnormalised
+  // weights on extras, and a sum of zero is the bind pose.
+  let s = w.x + w.y + w.z + w.w;
+  w = select(vec4f(1.0, 0.0, 0.0, 0.0), w / s, s > 0.0001);
+  var sp = vec3f(0.0);
+  var sn = vec3f(0.0);
+  var st = vec3f(0.0);
+  for (var k = 0u; k < 4u; k++) {
+    let m = skinMats[j[k]];
+    let r = mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz);
+    sp += (m * p).xyz * w[k];
+    sn += (r * n) * w[k];
+    st += (r * t.xyz) * w[k];
+  }
+  // Degenerate blends (opposing bones at 50/50) cancel to zero; up, not NaN.
+  let ln = dot(sn, sn);
+  let lt = dot(st, st);
+  sn = select(vec3f(0.0, 1.0, 0.0), sn * inverseSqrt(ln), ln > 1e-12);
+  st = select(vec3f(1.0, 0.0, 0.0), st * inverseSqrt(lt), lt > 1e-12);
+  outPos[v * 3u] = sp.x; outPos[v * 3u + 1u] = sp.y; outPos[v * 3u + 2u] = sp.z;
+  outNrm[v * 3u] = sn.x; outNrm[v * 3u + 1u] = sn.y; outNrm[v * 3u + 2u] = sn.z;
+  outTan[v * 4u] = st.x; outTan[v * 4u + 1u] = st.y; outTan[v * 4u + 2u] = st.z; outTan[v * 4u + 3u] = t.w;
+}
+`;
+/**
+ * Per-vertex tangents (xyz, w = handedness) from positions, normals and uvs,
+ * accumulated per triangle and orthogonalised against the normal — the
+ * standard construction, which is what a mesh imported without tangents gets
+ * in Unity too. `verts` is the engine's interleaved layout (8 floats).
+ */
+export function tangentsFor(verts, indices) {
+    const n = verts.length / 8;
+    const tan = new Float64Array(n * 3);
+    const bit = new Float64Array(n * 3);
+    for (let i = 0; i + 2 < indices.length; i += 3) {
+        const a = indices[i], b = indices[i + 1], c = indices[i + 2];
+        const p = (v, k) => verts[v * 8 + k];
+        const e1 = [p(b, 0) - p(a, 0), p(b, 1) - p(a, 1), p(b, 2) - p(a, 2)];
+        const e2 = [p(c, 0) - p(a, 0), p(c, 1) - p(a, 1), p(c, 2) - p(a, 2)];
+        const du1 = p(b, 6) - p(a, 6), dv1 = p(b, 7) - p(a, 7);
+        const du2 = p(c, 6) - p(a, 6), dv2 = p(c, 7) - p(a, 7);
+        const det = du1 * dv2 - du2 * dv1;
+        if (Math.abs(det) < 1e-12)
+            continue;
+        const r = 1 / det;
+        for (const v of [a, b, c]) {
+            for (let k = 0; k < 3; k++) {
+                tan[v * 3 + k] += (e1[k] * dv2 - e2[k] * dv1) * r;
+                bit[v * 3 + k] += (e2[k] * du1 - e1[k] * du2) * r;
+            }
+        }
+    }
+    const out = new Float32Array(n * 4);
+    for (let v = 0; v < n; v++) {
+        const nx = verts[v * 8 + 3], ny = verts[v * 8 + 4], nz = verts[v * 8 + 5];
+        let tx = tan[v * 3], ty = tan[v * 3 + 1], tz = tan[v * 3 + 2];
+        const d = tx * nx + ty * ny + tz * nz;
+        tx -= nx * d;
+        ty -= ny * d;
+        tz -= nz * d;
+        let len = Math.hypot(tx, ty, tz);
+        if (len < 1e-12) {
+            // Any direction perpendicular to the normal: a surface with no uv
+            // gradient has no tangent to speak of, and a zero one is NaN downstream.
+            const ax = Math.abs(nx) < 0.9 ? 1 : 0;
+            tx = ax ? 0 : -nz;
+            ty = ax ? nz : 0;
+            tz = ax ? -ny : nx;
+            len = Math.hypot(tx, ty, tz) || 1;
+        }
+        tx /= len;
+        ty /= len;
+        tz /= len;
+        // Handedness: whether the bitangent agrees with n × t.
+        const cx = ny * tz - nz * ty, cy = nz * tx - nx * tz, cz = nx * ty - ny * tx;
+        const w = cx * bit[v * 3] + cy * bit[v * 3 + 1] + cz * bit[v * 3 + 2] < 0 ? -1 : 1;
+        out.set([tx, ty, tz, w], v * 4);
+    }
+    return out;
+}

package/dist/unity/stage.d.ts

@@ -0,0 +1,148 @@
+import { NativeHost, type NativeValue } from "./host";
+import type { PassState } from "./state";
+export type NativeStageMesh = {
+    id: string;
+    vertexCount: number;
+    /** Semantic -> [byte offset, components] (float32). */
+    streams: Record<string, [number, number]>;
+    submeshes: {
+        offset: number;
+        count: number;
+        topology?: string;
+    }[];
+    bounds: {
+        center: [number, number, number];
+        size: [number, number, number];
+    };
+};
+export type NativeStageTexture = {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    hdr: number;
+    srgb: number;
+    cube: number;
+    wrap?: string;
+    filter?: string;
+    mips?: number;
+    mipsExported?: number;
+    aniso?: number;
+    files: string[];
+};
+export type NativeStageMaterial = {
+    id: string;
+    name: string;
+    shader: string;
+    queue: number;
+    passes: {
+        lightMode: string;
+        shader: string;
+        state: PassState;
+    }[];
+    values: Record<string, NativeValue>;
+    textures: Record<string, string>;
+    /** An empty slot's stand-in, per the shader: white, black, grey, bump. */
+    defaults?: Record<string, string>;
+};
+export type NativeStageRenderer = {
+    id: string;
+    path: string;
+    mesh: string;
+    materials: (string | null)[];
+    /** Object to world, game units, column-major. */
+    matrix: number[];
+    layers: number;
+    castShadows: number;
+    receiveShadows: number;
+    values: Record<string, NativeValue>;
+    textures: Record<string, string>;
+};
+export type NativeStageLights = {
+    main: {
+        direction: [number, number, number];
+        color: [number, number, number];
+        shadow: number;
+    };
+    additional: {
+        position: [number, number, number];
+        range: number;
+        color: [number, number, number];
+        type: "point" | "spot";
+        aim?: [number, number, number];
+        cosOuter?: number;
+        cosInner?: number;
+        unity?: {
+            spotDir: number[];
+            colorW: number;
+            extra: number[];
+            worldToLight: number[] | null;
+            lightType: number;
+            simSpotDir?: number[] | null;
+            simColorW?: number;
+        };
+    }[];
+};
+/** stage.json, as stage_native.py writes it. */
+export type NativeStagePackage = {
+    version: number;
+    kind: "unity-native-stage";
+    name: string;
+    source?: string;
+    /** Engine units per game unit. */
+    scale: number;
+    keywords: string[];
+    shaders: string[];
+    meshes: NativeStageMesh[];
+    textures: NativeStageTexture[];
+    materials: NativeStageMaterial[];
+    renderers: NativeStageRenderer[];
+    lights: NativeStageLights;
+    settings: Record<string, NativeValue>;
+    globalTextures: Record<string, string>;
+};
+/** Reads one file of the package by its path inside it (stage.json's folder). */
+export type NativeStageReader = (path: string) => Promise<ArrayBuffer>;
+export declare class NativeStage {
+    private device;
+    readonly name: string;
+    readonly pkg: NativeStagePackage;
+    /** Engine-unit box around everything that casts, for the cascades. */
+    readonly bounds: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    private buffers;
+    private textures;
+    private opaque;
+    private transparent;
+    private casters;
+    private zero;
+    private white;
+    private constructor();
+    /**
+     * Load a package: every mesh and texture it names through `read`, every
+     * shader registered with the hosts (the scene pass's and the shadow atlas's).
+     */
+    static load(device: GPUDevice, pkg: NativeStagePackage, read: NativeStageReader, hosts: {
+        scene: NativeHost;
+        shadow: NativeHost;
+    }, tools: {
+        mipmaps: (t: GPUTexture, levels: number) => void;
+        fallback: Record<string, GPUTextureView>;
+    }, onProgress?: (done: number, total: number) => void): Promise<NativeStage>;
+    private loadTexture;
+    /** Every renderer's draws, resolved once: the stage does not move. */
+    private build;
+    private addItems;
+    private streams;
+    private draw;
+    /** One cascade tile of the engine's atlas: every caster's SHADOWCASTER pass. */
+    drawShadow(pass: GPURenderPassEncoder, host: NativeHost, globals: Record<string, NativeValue>, cascade: number, viewProj: ArrayLike<number>, engineScale: number): void;
+    /** The opaque queue, front to back within each queue. */
+    drawOpaque(pass: GPURenderPassEncoder, host: NativeHost, globals: Record<string, NativeValue>, frame: Record<string, GPUTextureView | undefined>, eye: [number, number, number]): void;
+    /** The transparent queue, back to front within each queue. */
+    drawTransparent(pass: GPURenderPassEncoder, host: NativeHost, globals: Record<string, NativeValue>, frame: Record<string, GPUTextureView | undefined>, eye: [number, number, number]): void;
+    destroy(hosts: NativeHost[]): void;
+}
+//# sourceMappingURL=stage.d.ts.map

package/dist/unity/stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../../src/unity/stage.ts"],"names":[],"mappings":"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"}