reze-engine 0.62.1 → 0.64.0

package/dist/unity/stage.js

@@ -0,0 +1,375 @@
+// A game stage drawn by its own shaders: the package ag-rip's stage_native.py
+// writes from a recording of the game's scene — its meshes, textures and
+// materials as the game holds them, every renderer at its place, and the
+// translated shader variants each material's passes use.
+//
+// This is the compare page's renderer (agtools/web/agplay) inside the engine,
+// with one difference that matters: nothing here is recorded per frame. The
+// camera, the clock, the sun and lamps and the cascades are the engine's, turned
+// into the game's globals by globals.ts; the stage brings only what is its own —
+// geometry, materials, and its scene settings (fog, tint, ambient, environment
+// cube), which it hands the engine to set for every native draw.
+//
+// SPACE. Meshes and renderer matrices stay in the game's world, as recorded:
+// the globals carry the engine's camera into it (globals.ts, gameToEngine), so
+// a native draw lands where the game drew it, as the MMD export places it.
+//
+// SHADOWS. Every caster draws its material's own SHADOWCASTER pass into the
+// engine's cascade tiles, as the game drew its own atlas — alpha-tested leaves
+// cast their leaves, not their quads.
+import { gameToEngine, invert4, mul4, scale4, flipY } from "./globals";
+const MAIN_MODES = ["ALWAYS", "FORWARDBASE"];
+export class NativeStage {
+    constructor(device, pkg) {
+        this.device = device;
+        this.buffers = [];
+        this.textures = [];
+        this.opaque = [];
+        this.transparent = [];
+        this.casters = [];
+        this.name = pkg.name;
+        this.pkg = pkg;
+        this.bounds = {
+            min: [Infinity, Infinity, Infinity],
+            max: [-Infinity, -Infinity, -Infinity],
+        };
+        this.zero = device.createBuffer({
+            label: "native stage: zero stream",
+            size: 64,
+            usage: GPUBufferUsage.VERTEX,
+        });
+        this.white = device.createBuffer({
+            label: "native stage: white stream",
+            size: 64,
+            usage: GPUBufferUsage.VERTEX,
+            mappedAtCreation: true,
+        });
+        new Float32Array(this.white.getMappedRange()).fill(1);
+        this.white.unmap();
+        this.buffers.push(this.zero, this.white);
+    }
+    /**
+     * 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 async load(device, pkg, read, hosts, tools, onProgress) {
+        if (pkg.kind !== "unity-native-stage")
+            throw new Error("not a native stage package");
+        const st = new NativeStage(device, pkg);
+        // Progress by weight, not by file: a 2048² picture is most of a second to
+        // decode, a shader or a small mesh nothing — so pictures weigh their
+        // megapixels, everything else one unit of a quarter of one.
+        const texWeight = (t) => Math.max(0.25, ((t.cube ? 6 : 1) * t.width * t.height) / (1 << 20));
+        const total = 0.25 * (pkg.shaders.length + pkg.meshes.length) + pkg.textures.reduce((s, t) => s + texWeight(t), 0);
+        let done = 0;
+        const tick = (w = 0.25) => onProgress?.((done += w), total);
+        const text = async (p) => new TextDecoder().decode(await read(p));
+        const shaders = new Map();
+        await Promise.all(pkg.shaders.map(async (n) => {
+            const [vert, frag, info] = await Promise.all([
+                text(`shaders/${n}.vert.wgsl`),
+                text(`shaders/${n}.frag.wgsl`),
+                text(`shaders/${n}.json`),
+            ]);
+            shaders.set(n, { name: n, vert, frag, info: JSON.parse(info) });
+            tick();
+        }));
+        const casterShaders = new Set();
+        for (const m of pkg.materials)
+            for (const p of m.passes)
+                if (p.lightMode === "SHADOWCASTER")
+                    casterShaders.add(p.shader);
+        for (const [n, s] of shaders) {
+            if (casterShaders.has(n))
+                hosts.shadow.register(s);
+            else
+                hosts.scene.register(s);
+        }
+        const meshes = new Map();
+        await Promise.all(pkg.meshes.map(async (m) => {
+            const data = await read(`meshes/${m.id}.bin`);
+            const buffer = device.createBuffer({
+                label: `native stage mesh ${m.id}`,
+                size: Math.max(16, Math.ceil(data.byteLength / 4) * 4),
+                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+            });
+            device.queue.writeBuffer(buffer, 0, data, 0, data.byteLength & ~3);
+            st.buffers.push(buffer);
+            meshes.set(m.id, { info: m, buffer });
+            tick();
+        }));
+        const textures = new Map();
+        await Promise.all(pkg.textures.map(async (t) => {
+            try {
+                textures.set(t.id, await st.loadTexture(t, read, tools.mipmaps));
+            }
+            catch (e) {
+                console.warn(`native stage: texture ${t.id} ${t.name}:`, e);
+            }
+            tick(texWeight(t));
+        }));
+        st.build(meshes, textures, tools.fallback);
+        return st;
+    }
+    async loadTexture(t, read, mipmaps) {
+        const d = this.device;
+        const full = Math.max(1, Math.floor(Math.log2(Math.max(t.width, t.height))) + 1);
+        const format = t.hdr ? "rgba16float" : t.srgb ? "rgba8unorm-srgb" : "rgba8unorm";
+        if (t.cube) {
+            // Every face and mip as recorded: face-major <id>_f<face>_m<mip>.bin, RGBA16F
+            // rows along WebGPU's face directions (AGDlcRecord's AGCubeFace).
+            const mips = t.mipsExported || 1;
+            const texture = d.createTexture({
+                label: `native stage ${t.name}`,
+                size: [t.width, t.height, 6],
+                format,
+                mipLevelCount: mips,
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            await Promise.all(t.files.map(async (file, k) => {
+                const face = Math.floor(k / mips);
+                const mip = k % mips;
+                const s = Math.max(1, t.width >> mip);
+                const data = await read(`textures/${file}`);
+                d.queue.writeTexture({ texture, origin: [0, 0, face], mipLevel: mip }, data, { bytesPerRow: s * 8, rowsPerImage: s }, [s, s, 1]);
+            }));
+            this.textures.push(texture);
+            const sampler = d.createSampler({
+                magFilter: "linear",
+                minFilter: "linear",
+                mipmapFilter: "linear",
+            });
+            return {
+                texture,
+                view: texture.createView({ dimension: "cube" }),
+                sampler,
+            };
+        }
+        const mips = t.hdr ? 1 : full;
+        const texture = d.createTexture({
+            label: `native stage ${t.name}`,
+            size: [t.width, t.height],
+            format,
+            mipLevelCount: mips,
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+        });
+        const data = await read(`textures/${t.files[0]}`);
+        if (t.hdr) {
+            // Raw RGBA16F rows as Unity holds them (row 0 is v 0): as they are.
+            d.queue.writeTexture({ texture }, data, { bytesPerRow: t.width * 8 }, [t.width, t.height]);
+        }
+        else {
+            // A PNG runs top down; Unity's row 0 is the bottom (v 0): flipped on the way in.
+            const bmp = await createImageBitmap(new Blob([data]), {
+                imageOrientation: "flipY",
+                colorSpaceConversion: "none",
+                premultiplyAlpha: "none",
+                // A picture swapped into the folder need not be the size it replaced.
+                resizeWidth: t.width,
+                resizeHeight: t.height,
+                resizeQuality: "high",
+            });
+            d.queue.copyExternalImageToTexture({ source: bmp }, { texture }, [t.width, t.height]);
+            bmp.close();
+            if (mips > 1)
+                mipmaps(texture, mips);
+        }
+        this.textures.push(texture);
+        const wrap = {
+            Repeat: "repeat",
+            Clamp: "clamp-to-edge",
+            Mirror: "mirror-repeat",
+            MirrorOnce: "mirror-repeat",
+        }[t.wrap ?? "Repeat"] ?? "repeat";
+        const filter = t.filter === "Point" ? "nearest" : "linear";
+        const trilinear = t.filter === "Trilinear";
+        const sampler = d.createSampler({
+            addressModeU: wrap,
+            addressModeV: wrap,
+            magFilter: filter,
+            minFilter: filter,
+            mipmapFilter: trilinear ? "linear" : "nearest",
+            maxAnisotropy: filter === "linear" && trilinear ? Math.min(16, Math.max(1, t.aniso || 1)) : 1,
+        });
+        return { texture, view: texture.createView(), sampler };
+    }
+    /** Every renderer's draws, resolved once: the stage does not move. */
+    build(meshes, textures, fallback) {
+        const pkg = this.pkg;
+        const s = pkg.scale;
+        const mats = new Map(pkg.materials.map((m) => [m.id, m]));
+        const globalViews = {};
+        const globalSamplers = {};
+        for (const [slot, id] of Object.entries(pkg.globalTextures)) {
+            const t = textures.get(id);
+            if (t) {
+                globalViews[slot] = t.view;
+                globalSamplers[slot] = t.sampler;
+            }
+        }
+        for (const r of pkg.renderers) {
+            const mesh = meshes.get(r.mesh);
+            if (!mesh)
+                continue;
+            const m = r.matrix;
+            // centre and corners of the mesh box, to engine units
+            const b = mesh.info.bounds;
+            const cx = b.center[0], cy = b.center[1], cz = b.center[2];
+            const center = [
+                -(m[0] * cx + m[4] * cy + m[8] * cz + m[12]) * s,
+                (m[1] * cx + m[5] * cy + m[9] * cz + m[13]) * s,
+                -(m[2] * cx + m[6] * cy + m[10] * cz + m[14]) * s,
+            ];
+            const ex = b.size[0] / 2, ey = b.size[1] / 2, ez = b.size[2] / 2;
+            const half = [0, 1, 2].map((i) => (Math.abs(m[i]) * ex + Math.abs(m[4 + i]) * ey + Math.abs(m[8 + i]) * ez) * s);
+            const world = Float32Array.from(m);
+            const det = m[0] * (m[5] * m[10] - m[9] * m[6]) - m[4] * (m[1] * m[10] - m[9] * m[2]) + m[8] * (m[1] * m[6] - m[5] * m[2]);
+            const perDraw = {
+                unity_ObjectToWorld: world,
+                unity_WorldToObject: invert4(world),
+                unity_WorldTransformParams: [0, 0, 0, det < 0 ? -1 : 1],
+                unity_LightData: [0, 0, 0, 0],
+                unity_LightIndices: [
+                    [0, 0, 0, 0],
+                    [0, 0, 0, 0],
+                ],
+                unity_RenderingLayer: new Uint32Array([r.layers >>> 0, 0, 0, 0]),
+                unity_LODFade: [1, 1, 0, 0],
+                ...r.values,
+            };
+            this.addItems(r, mesh, perDraw, center, mats, globalViews, globalSamplers, textures, fallback);
+            if (r.castShadows) {
+                for (let i = 0; i < 3; i++) {
+                    this.bounds.min[i] = Math.min(this.bounds.min[i], center[i] - half[i]);
+                    this.bounds.max[i] = Math.max(this.bounds.max[i], center[i] + half[i]);
+                }
+            }
+        }
+    }
+    addItems(r, mesh, perDraw, center, mats, globalViews, globalSamplers, textures, fallback) {
+        r.materials.forEach((mid, sub) => {
+            const mat = mid ? mats.get(mid) : undefined;
+            if (!mat || sub >= mesh.info.submeshes.length)
+                return;
+            const views = {
+                ...globalViews,
+            };
+            const samplers = {
+                ...globalSamplers,
+            };
+            // an empty slot reads what the shader declared it defaults to
+            for (const [slot, def] of Object.entries(mat.defaults ?? {}))
+                views[slot] = fallback[def] ?? fallback.white;
+            for (const [slot, id] of [...Object.entries(mat.textures), ...Object.entries(r.textures)]) {
+                const t = textures.get(id);
+                if (!t)
+                    continue;
+                views[slot] = t.view;
+                samplers[slot] = t.sampler;
+            }
+            for (const pass of mat.passes) {
+                const item = {
+                    renderer: r,
+                    material: mat,
+                    sub,
+                    mesh,
+                    pass,
+                    perDraw,
+                    textures: views,
+                    samplers,
+                    center,
+                    key: `stage|${r.id}|${sub}|${pass.lightMode}|${pass.shader}`,
+                };
+                if (pass.lightMode === "SHADOWCASTER") {
+                    if (r.castShadows)
+                        this.casters.push(item);
+                }
+                else if (MAIN_MODES.includes(pass.lightMode)) {
+                    ;
+                    (mat.queue > 2500 ? this.transparent : this.opaque).push(item);
+                }
+            }
+        });
+    }
+    streams(host, it) {
+        const info = it.mesh.info;
+        return host.inputs(it.pass.shader).map(({ semantic }) => {
+            const st = info.streams[semantic];
+            if (!st) {
+                // A missing vertex colour reads white, as Unity binds it; anything else zero.
+                return {
+                    buffer: semantic === "COLOR" ? this.white : this.zero,
+                    offset: 0,
+                    stride: 0,
+                    format: "float32x4",
+                };
+            }
+            const n = st[1];
+            return {
+                buffer: it.mesh.buffer,
+                offset: st[0],
+                stride: n * 4,
+                format: (n === 1 ? "float32" : `float32x${n}`),
+            };
+        });
+    }
+    draw(pass, host, it, globals, frame, keySuffix = "") {
+        const sm = it.mesh.info.submeshes[it.sub];
+        host.draw(pass, {
+            shader: it.pass.shader,
+            state: it.pass.state,
+            streams: this.streams(host, it),
+            index: { buffer: it.mesh.buffer, format: "uint32", offset: sm.offset, count: sm.count },
+            sources: [it.perDraw, it.material.values, globals],
+            textures: { ...it.textures, ...frame },
+            samplers: it.samplers,
+            key: it.key + keySuffix,
+            pass: keySuffix || "main",
+        });
+    }
+    /** One cascade tile of the engine's atlas: every caster's SHADOWCASTER pass. */
+    drawShadow(pass, host, globals, cascade, viewProj, engineScale) {
+        const vp = flipY(mul4(viewProj, gameToEngine(engineScale)));
+        // ShadowUtils.GetShadowBias as the game set it: half a texel along the light
+        // and half a texel in along the normal, a texel being this tile's width in
+        // game units over its resolution (2048).
+        const rowLen = Math.hypot(vp[0], vp[4], vp[8]);
+        const texel = rowLen > 0 ? 2 / rowLen / 2048 : 0;
+        const g = {
+            ...globals,
+            unity_MatrixVP: vp,
+            unity_MatrixV: scale4(1),
+            unity_MatrixP: vp,
+            glstate_matrix_projection: vp,
+            sim_ShadowBias: [0.5 * texel, -0.5 * texel, 0, 0],
+        };
+        for (const it of this.casters)
+            this.draw(pass, host, it, g, {}, `|c${cascade}`);
+    }
+    /** The opaque queue, front to back within each queue. */
+    drawOpaque(pass, host, globals, frame, eye) {
+        const d = (it) => (it.center[0] - eye[0]) ** 2 + (it.center[1] - eye[1]) ** 2 + (it.center[2] - eye[2]) ** 2;
+        const list = this.opaque.slice().sort((a, b) => a.material.queue - b.material.queue || d(a) - d(b));
+        for (const it of list)
+            this.draw(pass, host, it, globals, frame);
+    }
+    /** The transparent queue, back to front within each queue. */
+    drawTransparent(pass, host, globals, frame, eye) {
+        const d = (it) => (it.center[0] - eye[0]) ** 2 + (it.center[1] - eye[1]) ** 2 + (it.center[2] - eye[2]) ** 2;
+        const list = this.transparent.slice().sort((a, b) => a.material.queue - b.material.queue || d(b) - d(a));
+        for (const it of list)
+            this.draw(pass, host, it, globals, frame);
+    }
+    destroy(hosts) {
+        for (const h of hosts)
+            h.release("stage|");
+        const bufs = this.buffers;
+        const texs = this.textures;
+        void this.device.queue.onSubmittedWorkDone().then(() => {
+            for (const b of bufs)
+                b.destroy();
+            for (const t of texs)
+                t.destroy();
+        });
+    }
+}

package/dist/unity/state.d.ts

@@ -0,0 +1,22 @@
+/** A pass's state as the exporter writes it: each key's ShaderLab arguments. */
+export type PassState = Record<string, (string | number)[]>;
+export declare function blendFactor(v: string | number | undefined): GPUBlendFactor;
+export declare function blendOp(v: string | number | undefined): GPUBlendOperation;
+export declare function compare(v: string | number | undefined, fallback?: GPUCompareFunction): GPUCompareFunction;
+/** A ZTest, flipped when the depth buffer is reversed — as Unity flips it on D3D. */
+export declare function depthCompare(v: string | number | undefined, reversed: boolean): GPUCompareFunction;
+export declare function stencilOp(v: string | number | undefined): GPUStencilOperation;
+export declare function cull(v: string | number | undefined): GPUCullMode;
+export declare function zwrite(v: string | number | undefined): boolean;
+/** Unity ColorWriteMask (A 1, B 2, G 4, R 8, or letters) to WebGPU's (R 1, G 2, B 4, A 8). */
+export declare function colorMask(v: string | number | undefined): number;
+/** The colour blend a pass declares, or undefined for opaque (One Zero). */
+export declare function blendState(st: PassState): GPUBlendState | undefined;
+/** The stencil a pass declares, or undefined when it touches none. */
+export declare function stencilState(st: PassState): {
+    face: GPUStencilFaceState;
+    read: number;
+    write: number;
+    ref: number;
+} | undefined;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/unity/state.ts"],"names":[],"mappings":"AAKA,gFAAgF;AAChF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,CAAA;AA8B3D,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,cAAc,CAI1E;AAGD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,iBAAiB,CAKzE;AAiBD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,QAAQ,GAAE,kBAA6B,GAAG,kBAAkB,CAInH;AAQD,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAGlG;AAuBD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,mBAAmB,CAI7E;AAGD,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,WAAW,CAMhE;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAI9D;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAQhE;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,EAAE,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,CAkBnE;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAa/H"}

package/dist/unity/state.js

@@ -0,0 +1,170 @@
+// A Unity pass's fixed-function state (Blend, ZTest, Cull, Stencil, ColorMask,
+// Offset), as its ShaderLab names or UnityEngine.Rendering enum numbers, into
+// WebGPU's. Ported from the compare page's unity.js, where these were checked
+// draw for draw against the game's frames.
+const BLEND = [
+    "zero",
+    "one",
+    "dst",
+    "src",
+    "one-minus-dst",
+    "src-alpha",
+    "one-minus-src",
+    "dst-alpha",
+    "one-minus-dst-alpha",
+    "src-alpha-saturated",
+    "one-minus-src-alpha",
+];
+const BLEND_NAMES = {
+    zero: "zero",
+    one: "one",
+    dstcolor: "dst",
+    srccolor: "src",
+    oneminusdstcolor: "one-minus-dst",
+    srcalpha: "src-alpha",
+    oneminussrccolor: "one-minus-src",
+    dstalpha: "dst-alpha",
+    oneminusdstalpha: "one-minus-dst-alpha",
+    srcalphasaturate: "src-alpha-saturated",
+    oneminussrcalpha: "one-minus-src-alpha",
+};
+const isNum = (v) => typeof v === "number" || /^-?\d+(\.\d+)?$/.test(String(v));
+export function blendFactor(v) {
+    if (v == null)
+        return "one";
+    if (isNum(v))
+        return BLEND[Math.round(+v)] ?? "one";
+    return BLEND_NAMES[String(v).toLowerCase()] ?? "one";
+}
+const BLEND_OP = ["add", "subtract", "reverse-subtract", "min", "max"];
+export function blendOp(v) {
+    if (v == null)
+        return "add";
+    if (isNum(v))
+        return BLEND_OP[+v] ?? "add";
+    const s = String(v).toLowerCase();
+    return s === "sub" ? "subtract" : s === "revsub" ? "reverse-subtract" : s === "min" ? "min" : s === "max" ? "max" : "add";
+}
+// CompareFunction: 0 Disabled 1 Never 2 Less 3 Equal 4 LessEqual 5 Greater 6 NotEqual 7 GreaterEqual 8 Always
+const CMP = [null, "never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
+const CMP_NAMES = {
+    never: 1,
+    less: 2,
+    equal: 3,
+    lequal: 4,
+    lessequal: 4,
+    greater: 5,
+    notequal: 6,
+    gequal: 7,
+    greaterequal: 7,
+    always: 8,
+    disabled: 8,
+};
+export function compare(v, fallback = "always") {
+    const n = v != null && isNum(v) ? +v : CMP_NAMES[String(v ?? "").toLowerCase()];
+    if (n == null)
+        return fallback;
+    return CMP[n] ?? "always";
+}
+const REVERSE = {
+    less: "greater",
+    "less-equal": "greater-equal",
+    greater: "less",
+    "greater-equal": "less-equal",
+};
+/** A ZTest, flipped when the depth buffer is reversed — as Unity flips it on D3D. */
+export function depthCompare(v, reversed) {
+    const c = compare(v ?? "LEqual", "less-equal");
+    return reversed ? (REVERSE[c] ?? c) : c;
+}
+// StencilOp: 0 Keep 1 Zero 2 Replace 3 IncrSat 4 DecrSat 5 Invert 6 IncrWrap 7 DecrWrap
+const SOP = [
+    "keep",
+    "zero",
+    "replace",
+    "increment-clamp",
+    "decrement-clamp",
+    "invert",
+    "increment-wrap",
+    "decrement-wrap",
+];
+const SOP_NAMES = {
+    keep: 0,
+    zero: 1,
+    replace: 2,
+    incrsat: 3,
+    decrsat: 4,
+    invert: 5,
+    incrwrap: 6,
+    decrwrap: 7,
+};
+export function stencilOp(v) {
+    if (v == null)
+        return "keep";
+    const n = isNum(v) ? +v : SOP_NAMES[String(v).toLowerCase()];
+    return SOP[n ?? 0] ?? "keep";
+}
+// CullMode: 0 Off 1 Front 2 Back
+export function cull(v) {
+    if (v == null)
+        return "back";
+    const s = String(v).toLowerCase();
+    if (s === "0" || s === "off")
+        return "none";
+    if (s === "1" || s === "front")
+        return "front";
+    return "back";
+}
+export function zwrite(v) {
+    if (v == null)
+        return true;
+    const s = String(v).toLowerCase();
+    return !(s === "0" || s === "off" || s === "false");
+}
+/** Unity ColorWriteMask (A 1, B 2, G 4, R 8, or letters) to WebGPU's (R 1, G 2, B 4, A 8). */
+export function colorMask(v) {
+    if (v == null)
+        return 0xf;
+    const s = String(v).toUpperCase();
+    if (/^\d+$/.test(s)) {
+        const n = +s;
+        return (n & 8 ? 1 : 0) | (n & 4 ? 2 : 0) | (n & 2 ? 4 : 0) | (n & 1 ? 8 : 0);
+    }
+    return (s.includes("R") ? 1 : 0) | (s.includes("G") ? 2 : 0) | (s.includes("B") ? 4 : 0) | (s.includes("A") ? 8 : 0);
+}
+/** The colour blend a pass declares, or undefined for opaque (One Zero). */
+export function blendState(st) {
+    const b = st.Blend?.map(String);
+    if (!b?.length || b[0].toLowerCase() === "off")
+        return undefined;
+    const color = {
+        srcFactor: blendFactor(b[0]),
+        dstFactor: blendFactor(b[1] ?? "zero"),
+        operation: blendOp(st.BlendOp?.[0]),
+    };
+    const alpha = b.length >= 4
+        ? {
+            srcFactor: blendFactor(b[2]),
+            dstFactor: blendFactor(b[3]),
+            operation: blendOp(st.BlendOp?.[1] ?? st.BlendOp?.[0]),
+        }
+        : color;
+    const opaque = (c) => c.srcFactor === "one" && c.dstFactor === "zero";
+    return opaque(color) && opaque(alpha) ? undefined : { color, alpha };
+}
+/** The stencil a pass declares, or undefined when it touches none. */
+export function stencilState(st) {
+    if (!st.StencilRef && !st.StencilComp)
+        return undefined;
+    return {
+        face: {
+            compare: compare(st.StencilComp?.[0] ?? "Always"),
+            passOp: stencilOp(st.StencilPass?.[0]),
+            failOp: stencilOp(st.StencilFail?.[0]),
+            depthFailOp: stencilOp(st.StencilZFail?.[0]),
+        },
+        read: +(st.StencilReadMask?.[0] ?? 255),
+        write: +(st.StencilWriteMask?.[0] ?? 255),
+        ref: st.StencilRef ? +st.StencilRef[0] : 0,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.62.1",
+  "version": "0.64.0",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",