reze-engine 0.50.2 → 0.50.3

package/dist/physics/autofit.js

@@ -1,501 +0,0 @@
-import { Vec3, Quat, Mat4 } from "../math";
-import { RigidbodyShape, RigidbodyType } from "./types";
-const DEFAULTS = {
-    minProtrusion: 0.05,
-    maxProtrusionRatio: 1.0,
-    minVertices: 24,
-    quantile: 0.02,
-    minGain: 0.1,
-    minDirectionality: 0.5,
-    lobeCos: 0.5,
-    minConcentration: 1.3,
-    maxShapesPerBody: 3,
-    radiusQuantile: 0.5,
-    lobeDepthFraction: 0.45,
-};
-const VERTEX_STRIDE = 8;
-/**
- * Fit supplementary colliders for every bone-following body whose own mesh
- * escapes it.
- *
- * `vertices` is the model's interleaved vertex buffer (stride 8, position
- * first) and `skinning` its joints/weights — both in PMX bind pose, the same
- * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
- *
- * Returns one entry per body it chose to supplement; the caller appends
- * `.body` to the rigid body list before constructing RezePhysics.
- */
-export function fitSupplementaryColliders(rigidbodies, vertices, skinning, options = {}) {
-    const opt = { ...DEFAULTS, ...options };
-    const vertexCount = vertices.length / VERTEX_STRIDE;
-    if (vertexCount === 0)
-        return [];
-    // Bucket vertices by their dominant bone once. Every body then reads only the
-    // mesh it stands in for, instead of the pass being O(bodies × vertices).
-    const byBone = new Map();
-    for (let i = 0; i < vertexCount; i++) {
-        let bestW = -1;
-        let bestB = -1;
-        for (let k = 0; k < 4; k++) {
-            const w = skinning.weights[i * 4 + k];
-            if (w > bestW) {
-                bestW = w;
-                bestB = skinning.joints[i * 4 + k];
-            }
-        }
-        if (bestB < 0)
-            continue;
-        const list = byBone.get(bestB);
-        if (list === undefined)
-            byBone.set(bestB, [i]);
-        else
-            list.push(i);
-    }
-    const out = [];
-    for (let b = 0; b < rigidbodies.length; b++) {
-        const rb = rigidbodies[b];
-        // Only bone-following proxies. A dynamic body IS the cloth — it has no
-        // skinned surface of its own to escape from.
-        if (rb.type === RigidbodyType.Dynamic && rb.mass > 0)
-            continue;
-        if (rb.boneIndex < 0)
-            continue;
-        const owned = byBone.get(rb.boneIndex);
-        if (owned === undefined || owned.length < opt.minVertices)
-            continue;
-        // Fit repeatedly, each pass measuring against what the earlier ones cover.
-        const covered = [];
-        for (let pass = 0; pass < opt.maxShapesPerBody; pass++) {
-            const fitted = fitOne(rb, b, owned, vertices, opt, covered);
-            if (fitted === null)
-                break;
-            covered.push(fitted.local);
-            out.push(fitted.result);
-        }
-    }
-    return out;
-}
-// Scratch, reused across bodies.
-const _local = [];
-function fitOne(rb, index, owned, vertices, opt, covered) {
-    const q = Quat.fromEuler(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z);
-    const radius = shapeRadius(rb);
-    if (radius <= 0)
-        return null;
-    const maxProtrusion = radius * opt.maxProtrusionRatio;
-    // Collect protruding vertices in the SOURCE BODY's local frame. Working in
-    // that frame rather than the bone's means the fitted box inherits the
-    // proxy's own orientation, which is already aligned with the limb — no
-    // covariance fit, and no second convention to keep straight.
-    //
-    // Each one is stored with the direction it escapes in (the gradient of the
-    // signed distance), because which way the mesh escapes is what decides
-    // whether this is a feature worth fitting at all.
-    _local.length = 0;
-    let deepest = 0;
-    let seedX = 0, seedY = 1, seedZ = 0;
-    let sumProtrusion = 0;
-    for (let n = 0; n < owned.length; n++) {
-        const o = owned[n] * VERTEX_STRIDE;
-        _v.x = vertices[o] - rb.shapePosition.x;
-        _v.y = vertices[o + 1] - rb.shapePosition.y;
-        _v.z = vertices[o + 2] - rb.shapePosition.z;
-        // Into the body's local frame: rotate by the conjugate.
-        Quat.rotateVecInvInto(q, _v, _r);
-        const px = _r.x, py = _r.y, pz = _r.z;
-        const sd = coveredSignedDistance(rb, covered, px, py, pz);
-        if (sd <= opt.minProtrusion || sd > maxProtrusion)
-            continue;
-        coveredOutwardDir(rb, covered, px, py, pz, _r);
-        // Seed the lobe on the DEEPEST vertex, not the mean direction. A pelvis
-        // escapes its capsule at the back by 0.53 and at the front by 0.14, so the
-        // mean cancels below any usable threshold and the butt — the whole point —
-        // is never fitted. The deepest point is always ON the feature.
-        if (sd > deepest) {
-            deepest = sd;
-            seedX = _r.x;
-            seedY = _r.y;
-            seedZ = _r.z;
-        }
-        sumProtrusion += sd;
-        _local.push(px, py, pz, _r.x, _r.y, _r.z, sd);
-    }
-    let found = _local.length / 7;
-    if (found < opt.minVertices)
-        return null;
-    // Averaged over the PROTRUDING vertices, deliberately — the question being
-    // asked is "is the deepest lobe deeper than protrusion typically is on this
-    // body", which is exactly the test that separates a butt from a hairstyle.
-    //
-    // Averaging over all the body's vertices instead was tried and is worse: it
-    // lifts every ratio, and measured on 托特 it scored the head's hair (2.4–4.2)
-    // ABOVE the pelvis (2.85), so no threshold could separate them and the pass
-    // fitted 33 bodies including three around the hair.
-    //
-    // The known blind spot is a mesh that escapes in exactly one place at uniform
-    // depth: the lobe IS the whole protruding set, so the ratio is 1 and nothing
-    // is fitted. Real skin always has a gradient, and for a pass that adds bodies
-    // to someone else's rig, declining when the evidence is ambiguous is the
-    // right way to be wrong.
-    const meanProtrusion = sumProtrusion / found;
-    // Settle the lobe axis: take everything within lobeCos of the seed, recentre
-    // on that set's depth-weighted mean direction, repeat. Two passes is enough —
-    // the seed already sits on the feature, this only centres it.
-    let mdx = seedX, mdy = seedY, mdz = seedZ;
-    for (let pass = 0; pass < 2; pass++) {
-        let ax = 0, ay = 0, az = 0;
-        for (let i = 0; i < found; i++) {
-            const s = i * 7;
-            if (_local[s + 3] * mdx + _local[s + 4] * mdy + _local[s + 5] * mdz < opt.lobeCos)
-                continue;
-            const wgt = _local[s + 6];
-            ax += _local[s + 3] * wgt;
-            ay += _local[s + 4] * wgt;
-            az += _local[s + 5] * wgt;
-        }
-        const len = Math.sqrt(ax * ax + ay * ay + az * az);
-        if (len < 1e-9)
-            break;
-        mdx = ax / len;
-        mdy = ay / len;
-        mdz = az / len;
-    }
-    // Keep only the lobe. Fitting the whole protruding shell would wrap the limb
-    // and put box corners out in open air on the side that was already covered.
-    // Depth floor for the lobe's core, relative to the deepest point IN the lobe
-    // (not the body's overall deepest, which may sit in a different direction).
-    let lobeDeepest = 0;
-    for (let i = 0; i < found; i++) {
-        const s = i * 7;
-        if (_local[s + 3] * mdx + _local[s + 4] * mdy + _local[s + 5] * mdz < opt.lobeCos)
-            continue;
-        if (_local[s + 6] > lobeDeepest)
-            lobeDeepest = _local[s + 6];
-    }
-    const depthFloor = lobeDeepest * opt.lobeDepthFraction;
-    let w = 0;
-    let lobeSum = 0;
-    let dirX = 0, dirY = 0, dirZ = 0;
-    for (let i = 0; i < found; i++) {
-        const s = i * 7;
-        if (_local[s + 3] * mdx + _local[s + 4] * mdy + _local[s + 5] * mdz < opt.lobeCos)
-            continue;
-        if (_local[s + 6] < depthFloor)
-            continue;
-        lobeSum += _local[s + 6];
-        dirX += _local[s + 3];
-        dirY += _local[s + 4];
-        dirZ += _local[s + 5];
-        _local[w * 3 + 0] = _local[s + 0];
-        _local[w * 3 + 1] = _local[s + 1];
-        _local[w * 3 + 2] = _local[s + 2];
-        w++;
-    }
-    found = w;
-    if (found < opt.minVertices)
-        return null;
-    // Concentration: is this lobe actually a FEATURE, or is the whole mesh
-    // uniformly outside its proxy? Hair around a skull escapes by a similar depth
-    // in every direction, so its deepest lobe is no deeper than typical and the
-    // ratio sits near 1. A butt is markedly deeper than the pelvis average. This
-    // is what stops the pass from boxing a hairstyle.
-    //
-    // Only the FIRST pass is judged on it. The question it answers — is this
-    // proxy standing in for this mesh at all — is settled once per body. Later
-    // passes are filling in what the first capsule could not reach, and by then
-    // the remaining protrusion is evenly spread by construction, so re-applying
-    // the test would reject every one of them and cap coverage at a single
-    // capsule. They still have to clear minGain and the vertex count.
-    const concentration = meanProtrusion > 1e-6 ? lobeSum / found / meanProtrusion : 0;
-    if (covered.length === 0 && concentration < opt.minConcentration)
-        return null;
-    const directionality = Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ) / found;
-    if (directionality < opt.minDirectionality)
-        return null;
-    // Quantile-clipped extent per axis.
-    const lo = [0, 0, 0];
-    const hi = [0, 0, 0];
-    const axis = new Array(found);
-    for (let a = 0; a < 3; a++) {
-        for (let i = 0; i < found; i++)
-            axis[i] = _local[i * 3 + a];
-        axis.sort((x, y) => x - y);
-        const k = Math.min(found - 1, Math.floor(found * opt.quantile));
-        lo[a] = axis[k];
-        hi[a] = axis[found - 1 - k];
-    }
-    const hx = (hi[0] - lo[0]) * 0.5;
-    const hy = (hi[1] - lo[1]) * 0.5;
-    const hz = (hi[2] - lo[2]) * 0.5;
-    if (hx <= 0 || hy <= 0 || hz <= 0)
-        return null;
-    const cx = (hi[0] + lo[0]) * 0.5;
-    const cy = (hi[1] + lo[1]) * 0.5;
-    const cz = (hi[2] + lo[2]) * 0.5;
-    // Fit a CAPSULE, not a box, and keep the source body's own orientation.
-    //
-    // A box fitted to a curved lobe puts its eight corners out in open air — on
-    // 托特's butt the worst corner measured 0.81 units from the nearest skin
-    // vertex, and cloth resting on that corner would float further off the body
-    // than the clipping it was added to fix. A capsule has no corners.
-    //
-    // Reusing the source rotation verbatim is what makes this cheap AND correct.
-    // PMX capsules are Y-aligned in their own frame, and a proxy's axis already
-    // runs along its limb — 下半身 is a transverse pill across the hips, which is
-    // exactly the way a butt lobe runs. Inheriting the rotation means no
-    // covariance fit and, more to the point, no quaternion→Euler conversion whose
-    // convention could disagree with the loader's.
-    // Radius from the lobe's own perpendicular spread, at a quantile — NOT from
-    // the enclosing half-extent.
-    //
-    // This is what decides whether the result looks right. A capsule inflates
-    // equally in every direction perpendicular to its axis, so sizing the radius
-    // to ENCLOSE the lobe makes a wide shallow patch into a fat capsule: it only
-    // needed to reach the butt's depth, but it also grew to the butt's width, and
-    // the surplus is surface standing off the skin everywhere else. Measured on
-    // 托特's pelvis that was 0.68 units of standoff, which reads as a skirt
-    // hovering in idle — trading a clipping artifact for a worse one.
-    //
-    // Taking a quantile of the actual distances puts the capsule's surface
-    // through the lobe rather than around it. The deepest points end up slightly
-    // outside it, which the next pass picks up.
-    const perp = new Array(found);
-    for (let i = 0; i < found; i++) {
-        const dx = _local[i * 3] - cx;
-        const dz = _local[i * 3 + 2] - cz;
-        perp[i] = Math.sqrt(dx * dx + dz * dz);
-    }
-    perp.sort((a, b) => a - b);
-    const fitRadius = perp[Math.min(found - 1, Math.floor(found * opt.radiusQuantile))];
-    if (fitRadius <= 0)
-        return null;
-    // size.y is the FULL cylinder length between cap centres, so the capsule
-    // spans h + 2r along the axis. Solve for the lobe's own extent.
-    const cyl = Math.max(0, hy * 2 - fitRadius * 2);
-    // Gain and overshoot at the capsule's six axis extremes: how far it reaches
-    // past the shape it supplements, and how far it sits from the surface it was
-    // fitted to. Overshoot is the number to watch if a result looks puffy.
-    let gain = 0;
-    let overshoot = 0;
-    const half = cyl * 0.5;
-    const probes = [
-        [cx + fitRadius, cy, cz], [cx - fitRadius, cy, cz],
-        [cx, cy + half + fitRadius, cz], [cx, cy - half - fitRadius, cz],
-        [cx, cy, cz + fitRadius], [cx, cy, cz - fitRadius],
-    ];
-    for (const [px, py, pz] of probes) {
-        const sd = coveredSignedDistance(rb, covered, px, py, pz);
-        if (sd > gain)
-            gain = sd;
-        // Only the part of the capsule that reaches OUTSIDE the original shape is
-        // new collision surface. A probe pointing inward has no skin vertex near it
-        // by construction — the lobe is a patch on the outside — and counting it
-        // would report overshoot for geometry that is buried in the character.
-        if (sd <= 0)
-            continue;
-        let nearest = Infinity;
-        for (let i = 0; i < found; i++) {
-            const dx = _local[i * 3] - px;
-            const dy = _local[i * 3 + 1] - py;
-            const dz = _local[i * 3 + 2] - pz;
-            const d2 = dx * dx + dy * dy + dz * dz;
-            if (d2 < nearest)
-                nearest = d2;
-        }
-        const d = Math.sqrt(nearest);
-        if (d > overshoot)
-            overshoot = d;
-    }
-    if (gain < opt.minGain)
-        return null;
-    // Back out to bind-pose world. Orientation is copied verbatim from the source
-    // rather than converted — the capsule is expressed in that frame, and
-    // re-deriving Euler angles would only introduce a convention to get wrong.
-    _v.x = cx;
-    _v.y = cy;
-    _v.z = cz;
-    Quat.rotateVecInto(q, _v, _r);
-    const wx = rb.shapePosition.x + _r.x;
-    const wy = rb.shapePosition.y + _r.y;
-    const wz = rb.shapePosition.z + _r.z;
-    const result = {
-        sourceIndex: index,
-        sourceName: rb.name,
-        vertexCount: owned.length,
-        protrudingCount: found,
-        maxProtrusion: deepest,
-        gain,
-        directionality,
-        concentration,
-        overshoot,
-        body: {
-            name: `${rb.name}__fit`,
-            englishName: `${rb.englishName}__fit`,
-            boneIndex: rb.boneIndex,
-            // Same group and mask as the body it supplements: it must be visible to
-            // exactly the cloth that was already meant to collide with this limb, and
-            // invisible to whatever the rigger excluded.
-            group: rb.group,
-            collisionMask: rb.collisionMask,
-            shape: RigidbodyShape.Capsule,
-            // PMX capsule semantics: size.x is the radius, size.y the FULL cylinder
-            // length between cap centres (Bullet halves it internally), size.z unused.
-            size: new Vec3(fitRadius, cyl, fitRadius),
-            shapePosition: new Vec3(wx, wy, wz),
-            shapeRotation: new Vec3(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z),
-            // Static: it follows its bone and never integrates. Mass 0 keeps it out
-            // of the dynamic path entirely.
-            mass: 0,
-            linearDamping: 0,
-            angularDamping: 0,
-            restitution: rb.restitution,
-            friction: rb.friction,
-            type: RigidbodyType.Static,
-            bodyOffsetMatrixInverse: Mat4.identity(),
-        },
-    };
-    return { result, local: { cx, cy, cz, radius: fitRadius, cyl } };
-}
-/** Smallest characteristic dimension — the "how wide is this proxy" scale the
- *  protrusion cap is judged against. */
-function shapeRadius(rb) {
-    switch (rb.shape) {
-        case RigidbodyShape.Sphere:
-            return rb.size.x;
-        case RigidbodyShape.Capsule:
-            return rb.size.x;
-        case RigidbodyShape.Box:
-            return Math.min(rb.size.x, rb.size.y, rb.size.z);
-        default:
-            return 0;
-    }
-}
-/** Signed distance to a Y-axis capsule centred at (cx,cy,cz), in the same
- *  local frame. `cyl` is the full length between cap centres. */
-function capsuleSignedDistance(c, px, py, pz) {
-    const half = c.cyl * 0.5;
-    const dy = py - c.cy;
-    const t = dy > half ? half : dy < -half ? -half : dy;
-    const ax = px - c.cx;
-    const az = pz - c.cz;
-    const by = dy - t;
-    return Math.sqrt(ax * ax + by * by + az * az) - c.radius;
-}
-/** Distance to the UNION of the source shape and everything already fitted to
- *  it. Union is a min over signed distances, so a later pass sees only what is
- *  still exposed. */
-function coveredSignedDistance(rb, covered, px, py, pz) {
-    let best = localSignedDistance(rb, px, py, pz);
-    for (let i = 0; i < covered.length; i++) {
-        const d = capsuleSignedDistance(covered[i], px, py, pz);
-        if (d < best)
-            best = d;
-    }
-    return best;
-}
-/** Outward direction from whichever member of the union is nearest — the
- *  gradient of coveredSignedDistance. */
-function coveredOutwardDir(rb, covered, px, py, pz, out) {
-    let best = localSignedDistance(rb, px, py, pz);
-    let nearest = -1;
-    for (let i = 0; i < covered.length; i++) {
-        const d = capsuleSignedDistance(covered[i], px, py, pz);
-        if (d < best) {
-            best = d;
-            nearest = i;
-        }
-    }
-    if (nearest < 0) {
-        localOutwardDir(rb, px, py, pz, out);
-        return;
-    }
-    // Same construction as localOutwardDir, for the winning capsule.
-    const c = covered[nearest];
-    const half = c.cyl * 0.5;
-    const dy = py - c.cy;
-    const t = dy > half ? half : dy < -half ? -half : dy;
-    const dx = px - c.cx;
-    const dz = pz - c.cz;
-    const by = dy - t;
-    const len = Math.sqrt(dx * dx + by * by + dz * dz);
-    if (len > 1e-9) {
-        out.x = dx / len;
-        out.y = by / len;
-        out.z = dz / len;
-    }
-    else {
-        out.x = 0;
-        out.y = 1;
-        out.z = 0;
-    }
-}
-/** Direction a body-local point escapes the shape in — the gradient of the
- *  signed distance, i.e. the unit vector from its closest surface point. */
-function localOutwardDir(rb, px, py, pz, out) {
-    let dx, dy, dz;
-    switch (rb.shape) {
-        case RigidbodyShape.Capsule: {
-            const half = rb.size.y * 0.5;
-            const t = py > half ? half : py < -half ? -half : py;
-            dx = px;
-            dy = py - t;
-            dz = pz;
-            break;
-        }
-        case RigidbodyShape.Box: {
-            dx = px - Math.max(-rb.size.x, Math.min(rb.size.x, px));
-            dy = py - Math.max(-rb.size.y, Math.min(rb.size.y, py));
-            dz = pz - Math.max(-rb.size.z, Math.min(rb.size.z, pz));
-            break;
-        }
-        default: {
-            dx = px;
-            dy = py;
-            dz = pz;
-            break;
-        }
-    }
-    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
-    if (len > 1e-9) {
-        out.x = dx / len;
-        out.y = dy / len;
-        out.z = dz / len;
-    }
-    else {
-        out.x = 0;
-        out.y = 1;
-        out.z = 0;
-    }
-}
-/** Signed distance from a body-local point to the shape's surface; > 0 outside. */
-function localSignedDistance(rb, px, py, pz) {
-    switch (rb.shape) {
-        case RigidbodyShape.Sphere:
-            return Math.sqrt(px * px + py * py + pz * pz) - rb.size.x;
-        case RigidbodyShape.Capsule: {
-            // PMX capsules are Y-aligned and size.y is the FULL cylinder length
-            // between cap centres, so the segment runs ±size.y/2.
-            const half = rb.size.y * 0.5;
-            const t = py > half ? half : py < -half ? -half : py;
-            const dy = py - t;
-            return Math.sqrt(px * px + dy * dy + pz * pz) - rb.size.x;
-        }
-        case RigidbodyShape.Box: {
-            // size is half-extents for boxes.
-            const qx = Math.abs(px) - rb.size.x;
-            const qy = Math.abs(py) - rb.size.y;
-            const qz = Math.abs(pz) - rb.size.z;
-            const ox = Math.max(qx, 0), oy = Math.max(qy, 0), oz = Math.max(qz, 0);
-            const outside = Math.sqrt(ox * ox + oy * oy + oz * oz);
-            return outside + Math.min(Math.max(qx, qy, qz), 0);
-        }
-        default:
-            return -Infinity;
-    }
-}
-// Rotation goes through Quat.rotateVecInto / rotateVecInvInto rather than
-// open-coded component formulas — this pass runs once at load, so there is
-// nothing to win by hand-rolling it and a sign error here would misplace every
-// fitted body.
-const _v = new Vec3(0, 0, 0);
-const _r = new Vec3(0, 0, 0);

package/dist/shaders/passes/field-blit.d.ts

@@ -1,26 +0,0 @@
-/**
- * The field layer, drawn INTO the scene.
- *
- * Field effects render into their own targets at their own resolution — that
- * part was always right. What was wrong was where the result landed: the
- * composite sampled it AFTER tone mapping, which is why a field effect could
- * never bloom, could never light anything, and tone mapped differently from the
- * particle and ribbon mounts drawing the same kind of glow.
- *
- * Two draws inside the scene pass — background before any geometry, foreground
- * after all of it — so the bloom pyramid sees field effects and one tone map
- * covers the whole frame.
- *
- * NO DEPTH, neither written nor tested. A foreground is handed the scene's
- * depth as a parameter and does its own occlusion; testing it here would
- * occlude it a second time, and a background has nothing to test against.
- *
- * COVERAGE IS CLAMPED HERE. Additive field effects SUM their coverage into the
- * layer (see FIELD_LAYER_BLEND_ADDITIVE), which is what stops the composite's
- * unpremultiply from dividing colour by nothing — but N additive effects can
- * sum past 1, and the layer is rgba16float so nothing stopped it on the way in.
- * A coverage above 1 would darken what the layer is drawn over by more than
- * fully covering it.
- */
-export declare function fieldBlitShaderWgsl(): string;
-//# sourceMappingURL=field-blit.d.ts.map

package/dist/shaders/passes/field-blit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"field-blit.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/field-blit.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAuC5C"}

package/dist/shaders/passes/field-blit.js

@@ -1,65 +0,0 @@
-import { sceneFsOutWgsl } from "./scene-contract";
-/**
- * The field layer, drawn INTO the scene.
- *
- * Field effects render into their own targets at their own resolution — that
- * part was always right. What was wrong was where the result landed: the
- * composite sampled it AFTER tone mapping, which is why a field effect could
- * never bloom, could never light anything, and tone mapped differently from the
- * particle and ribbon mounts drawing the same kind of glow.
- *
- * Two draws inside the scene pass — background before any geometry, foreground
- * after all of it — so the bloom pyramid sees field effects and one tone map
- * covers the whole frame.
- *
- * NO DEPTH, neither written nor tested. A foreground is handed the scene's
- * depth as a parameter and does its own occlusion; testing it here would
- * occlude it a second time, and a background has nothing to test against.
- *
- * COVERAGE IS CLAMPED HERE. Additive field effects SUM their coverage into the
- * layer (see FIELD_LAYER_BLEND_ADDITIVE), which is what stops the composite's
- * unpremultiply from dividing colour by nothing — but N additive effects can
- * sum past 1, and the layer is rgba16float so nothing stopped it on the way in.
- * A coverage above 1 would darken what the layer is drawn over by more than
- * fully covering it.
- */
-export function fieldBlitShaderWgsl() {
-    return /* wgsl */ `
-@group(0) @binding(0) var _rzLayer: texture_2d<f32>;
-@group(0) @binding(1) var _rzLayerSamp: sampler;
-// (bloom, _, fullW, fullH). The size is the SCENE target's, not the layer's:
-// the layer is often half resolution, and normalised uv is what makes that
-// invisible.
-@group(0) @binding(2) var<uniform> _rzBlitU: vec4f;
-
-@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
-  let x = f32((vi & 1u) << 2u) - 1.0;
-  let y = f32((vi & 2u) << 1u) - 1.0;
-  return vec4f(x, y, 0.0, 1.0);
-}
-
-${sceneFsOutWgsl()}
-@fragment fn fs(@builtin(position) fragCoord: vec4f) -> FSOut {
-  var out: FSOut;
-  // Bilinear, because the layer is usually half resolution and the whole point
-  // of that choice is that low-frequency effects upsample invisibly.
-  let uv = fragCoord.xy / max(_rzBlitU.zw, vec2f(1.0));
-  let c = textureSampleLevel(_rzLayer, _rzLayerSamp, uv, 0.0);
-  let cov = clamp(c.a, 0.0, 1.0);
-  // PREMULTIPLIED, and blitted with a premultiplied-over blend — the field
-  // targets have been premultiplied since N effects had to compose into them
-  // associatively. Handing this to the material blend would scale rgb by alpha
-  // a second time and every layer would come out dark.
-  out.color = vec4f(max(c.rgb, vec3f(0.0)), cov);
-  // The aux target: bloom mask, then coverage. THIS is what finally makes
-  // // @bloom mean something on a field effect — the flag has been parsed and
-  // ignored for every mount but particles and ribbons, which is the kind of
-  // author-surface lie the install-time guards exist to kill.
-  //
-  // The mask is written UNWEIGHTED and the blend weights it by src.a — the
-  // convention the materials already follow (they write vec4f(1, 1, 0, alpha)).
-  out.mask = vec4f(_rzBlitU.x, 1.0, 0.0, cov);
-  return out;
-}
-`;
-}

package/dist/shaders/passes/ground-noise.d.ts

@@ -1,7 +0,0 @@
-/**
- * The tile as 8-bit luminance, plus its mip chain (box-filtered, which is exact
- * for a repeating texture). Mips are the point as much as the speed: procedural
- * noise has no mip chain, so at grazing angles it shimmered.
- */
-export declare function buildGroundNoiseMips(): Uint8Array[];
-//# sourceMappingURL=ground-noise.d.ts.map

package/dist/shaders/passes/ground-noise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ground-noise.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground-noise.ts"],"names":[],"mappings":"AAkDA;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,EAAE,CAsCnD"}