reze-engine 0.24.1 → 0.25.1

package/src/shaders/passes/depth-prepass.ts

@@ -0,0 +1,57 @@
+// Depth-only prepass for the TRANSPARENT bucket. Transparent color draws keep
+// depth write OFF so self-overlapping sheer cloth blends both layers instead of
+// a triangle-order patchwork — but that leaves no depth record, so anything
+// drawn later (the outline hulls) shows straight through the fabric as black
+// shapes. This pass re-draws the transparent geometry depth-only AFTER its
+// color pass: solid-enough texels (alpha ≥ 0.5) write depth, so outlines get
+// occluded behind fabric exactly like they are behind opaque cloth, while
+// truly sheer texels (a veil) stay non-occluding.
+//
+// Reuses mainPipelineLayout: camera g0b0, diffuseSampler g0b2, skinMats g1b0,
+// diffuse texture g2b0, material uniforms g2b1 — the same bind groups the
+// color draws already set, so drawing it costs no extra binding work.
+
+export const TRANSPARENT_DEPTH_PREPASS_WGSL = /* wgsl */ `
+struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
+struct MaterialUniforms {
+  diffuseColor: vec3f,
+  alpha: f32,
+};
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(2) var diffuseSampler: sampler;
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+@group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
+@group(2) @binding(1) var<uniform> material: MaterialUniforms;
+
+struct VSOut {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+};
+
+@vertex fn vs(
+  @location(0) position: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) uv: vec2f,
+  @location(3) joints0: vec4<u32>,
+  @location(4) weights0: vec4<f32>,
+) -> VSOut {
+  let pos4 = vec4f(position, 1.0);
+  let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
+  let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
+  let w = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var skinned = vec4f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    skinned += (skinMats[joints0[i]] * pos4) * w[i];
+  }
+  var o: VSOut;
+  o.position = camera.projection * camera.view * vec4f(skinned.xyz, 1.0);
+  o.uv = uv;
+  return o;
+}
+
+@fragment fn fs(in: VSOut) {
+  let a = material.alpha * textureSample(diffuseTexture, diffuseSampler, in.uv).a;
+  if (a < 0.5) { discard; }
+}
+`

package/src/shaders/passes/ground.ts

@@ -67,6 +67,14 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
     }
   }
   vis *= 0.04;
+  // Outside the light's frustum there IS no shadow information — the clamped
+  // border samples above compare against unrelated depths and read "shadowed",
+  // darkening the whole far plane with a visible band at the frustum edge
+  // (masked by the opaque surface normally, glaring in green-screen mode where
+  // only the shadow-catcher term renders). Fade to fully lit near the border.
+  let inZ = select(0.0, 1.0, ndc.z > 0.0 && ndc.z < 1.0);
+  let frustum = (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))) * inZ;
+  vis = mix(1.0, vis, frustum);
 
   // Frosted/matte micro-texture
   let noiseVal = fbmNoise(i.worldPos.xz * 3.0);

package/dist/physics-debug.d.ts

@@ -1,30 +0,0 @@
-import type { RezePhysics } from "./physics";
-export declare class PhysicsDebugRenderer {
-    private device;
-    private bindGroup;
-    private wirePipelineSphere;
-    private wirePipelineBox;
-    private wirePipelineCapsule;
-    private wireSphereBuffer;
-    private wireBoxBuffer;
-    private wireCapsuleBuffer;
-    private wireSphereCount;
-    private wireBoxCount;
-    private wireCapsuleCount;
-    private solidPipelineSphere;
-    private solidPipelineBox;
-    private solidPipelineCapsule;
-    private solidSphereBuffer;
-    private solidBoxBuffer;
-    private solidCapsuleBuffer;
-    private solidSphereCount;
-    private solidBoxCount;
-    private solidCapsuleCount;
-    private instanceBuffer;
-    private instanceData;
-    private instanceCapacity;
-    constructor(device: GPUDevice, cameraUniformBuffer: GPUBuffer, presentationFormat: GPUTextureFormat);
-    render(pass: GPURenderPassEncoder, physics: RezePhysics): void;
-    destroy(): void;
-}
-//# sourceMappingURL=physics-debug.d.ts.map

package/dist/physics-debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../src/physics-debug.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAmB5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAc;IAG/B,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAW;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,SAAS,EAC9B,kBAAkB,EAAE,gBAAgB;IA2HtC,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAmI9D,OAAO,IAAI,IAAI;CAShB"}

package/dist/physics-debug.js

@@ -1,526 +0,0 @@
-// Debug overlay drawing every rigidbody as a wireframe + semitransparent solid
-// primitive (sphere / box / capsule), color-coded by type:
-//   yellow = static (FollowBone)
-//   cyan   = kinematic
-//   red    = dynamic
-//
-// Rendered in its own swapchain pass AFTER composite (see Engine.renderPhysicsDebug),
-// so it sits cleanly on top of the final tonemapped image. No depth, no MSAA,
-// no MRT, no interaction with the HDR alpha gate — bodies are always fully
-// visible regardless of camera angle, model occlusion, or stacking. Reads body
-// transforms straight from RezePhysics' SoA store — zero per-frame allocations.
-import { Mat4 } from "./math";
-import { RigidbodyShape, RigidbodyType } from "./physics";
-import { PHYSICS_DEBUG_SHADER_WGSL } from "./shaders/passes/physics-debug";
-const STRIDE_BYTES = 96; // 4 mat4 cols + size+pad + color = 6 vec4
-const STRIDE_FLOATS = STRIDE_BYTES / 4;
-// Per-instance color.alpha is the WIREFRAME alpha (1.0 for crisp edges). Solid
-// pipelines override the SOLID_ALPHA shader constant to ~0.20 so the fill stays
-// gentle where many bodies overlap.
-// Hues chosen so wire+solid both read against the typical pink/grey reze studio
-// scene background. Red [1, 0.3, 0.3] sat too close to the pink bg's hue —
-// solid fill (α≈0.2) blended into the bg and the wire didn't separate from it.
-// Orange-red shifts ~30° on the hue wheel, giving real chroma against pink.
-const COLOR_STATIC = [1.0, 0.85, 0.15, 1.0]; // yellow
-const COLOR_KINEMATIC = [0.25, 0.7, 1.0, 1.0]; // cyan-blue
-const COLOR_DYNAMIC = [1.0, 0.35, 0.0, 1.0]; // orange-red
-const SOLID_ALPHA = 0.2;
-export class PhysicsDebugRenderer {
-    constructor(device, cameraUniformBuffer, presentationFormat) {
-        this.device = device;
-        const wireSphere = buildSphereWireGeometry();
-        const wireBox = buildBoxWireGeometry();
-        const wireCapsule = buildCapsuleWireGeometry();
-        this.wireSphereCount = wireSphere.length / 4;
-        this.wireBoxCount = wireBox.length / 4;
-        this.wireCapsuleCount = wireCapsule.length / 4;
-        const solidSphere = buildSphereSolidGeometry();
-        const solidBox = buildBoxSolidGeometry();
-        const solidCapsule = buildCapsuleSolidGeometry();
-        this.solidSphereCount = solidSphere.length / 4;
-        this.solidBoxCount = solidBox.length / 4;
-        this.solidCapsuleCount = solidCapsule.length / 4;
-        const upload = (label, data) => {
-            const buf = device.createBuffer({
-                label,
-                size: data.byteLength,
-                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-            });
-            device.queue.writeBuffer(buf, 0, data.buffer, data.byteOffset, data.byteLength);
-            return buf;
-        };
-        this.wireSphereBuffer = upload("physics-debug wire sphere", wireSphere);
-        this.wireBoxBuffer = upload("physics-debug wire box", wireBox);
-        this.wireCapsuleBuffer = upload("physics-debug wire capsule", wireCapsule);
-        this.solidSphereBuffer = upload("physics-debug solid sphere", solidSphere);
-        this.solidBoxBuffer = upload("physics-debug solid box", solidBox);
-        this.solidCapsuleBuffer = upload("physics-debug solid capsule", solidCapsule);
-        this.instanceCapacity = 512;
-        this.instanceData = new Float32Array(this.instanceCapacity * STRIDE_FLOATS);
-        this.instanceBuffer = device.createBuffer({
-            label: "physics-debug instances",
-            size: this.instanceCapacity * STRIDE_BYTES,
-            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-        });
-        const bgl = device.createBindGroupLayout({
-            label: "physics-debug bgl",
-            entries: [{ binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: "uniform" } }],
-        });
-        this.bindGroup = device.createBindGroup({
-            label: "physics-debug bg",
-            layout: bgl,
-            entries: [{ binding: 0, resource: { buffer: cameraUniformBuffer } }],
-        });
-        const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bgl] });
-        const shader = device.createShaderModule({
-            label: "physics-debug shader",
-            code: PHYSICS_DEBUG_SHADER_WGSL,
-        });
-        const vertexBuffers = [
-            {
-                arrayStride: 16,
-                attributes: [{ shaderLocation: 0, offset: 0, format: "float32x4" }],
-            },
-            {
-                arrayStride: STRIDE_BYTES,
-                stepMode: "instance",
-                attributes: [
-                    { shaderLocation: 1, offset: 0, format: "float32x4" },
-                    { shaderLocation: 2, offset: 16, format: "float32x4" },
-                    { shaderLocation: 3, offset: 32, format: "float32x4" },
-                    { shaderLocation: 4, offset: 48, format: "float32x4" },
-                    { shaderLocation: 5, offset: 64, format: "float32x4" },
-                    { shaderLocation: 6, offset: 80, format: "float32x4" },
-                ],
-            },
-        ];
-        const targets = [
-            {
-                format: presentationFormat,
-                blend: {
-                    color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
-                    alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
-                },
-            },
-        ];
-        const buildPipeline = (label, kind, topology, solidAlpha) => device.createRenderPipeline({
-            label,
-            layout: pipelineLayout,
-            vertex: {
-                module: shader,
-                entryPoint: "vsMain",
-                buffers: vertexBuffers,
-                constants: { SHAPE_KIND: kind },
-            },
-            fragment: {
-                module: shader,
-                entryPoint: "fsMain",
-                targets,
-                constants: { SOLID_ALPHA: solidAlpha },
-            },
-            primitive: { topology, cullMode: "none" },
-            // No depth attachment, single multisample — pass renders straight to
-            // the swapchain after composite, so the overlay sits on top of the
-            // tonemapped scene without interacting with depth/stencil/MSAA.
-            multisample: { count: 1 },
-        });
-        this.wirePipelineSphere = buildPipeline("physics-debug wire sphere", 0, "line-list", 1.0);
-        this.wirePipelineBox = buildPipeline("physics-debug wire box", 1, "line-list", 1.0);
-        this.wirePipelineCapsule = buildPipeline("physics-debug wire capsule", 2, "line-list", 1.0);
-        this.solidPipelineSphere = buildPipeline("physics-debug solid sphere", 0, "triangle-list", SOLID_ALPHA);
-        this.solidPipelineBox = buildPipeline("physics-debug solid box", 1, "triangle-list", SOLID_ALPHA);
-        this.solidPipelineCapsule = buildPipeline("physics-debug solid capsule", 2, "triangle-list", SOLID_ALPHA);
-    }
-    render(pass, physics) {
-        const rigidbodies = physics.getRigidbodies();
-        const N = rigidbodies.length;
-        if (N === 0)
-            return;
-        const store = physics.getStore();
-        const positions = store.positions;
-        const orientations = store.orientations;
-        if (N > this.instanceCapacity) {
-            this.instanceCapacity = Math.max(N, this.instanceCapacity * 2);
-            this.instanceData = new Float32Array(this.instanceCapacity * STRIDE_FLOATS);
-            this.instanceBuffer.destroy();
-            this.instanceBuffer = this.device.createBuffer({
-                label: "physics-debug instances",
-                size: this.instanceCapacity * STRIDE_BYTES,
-                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-            });
-        }
-        // Two passes: count per-shape, then fill packed by shape so we can issue
-        // 3 instanced draws with vertex-buffer offsets.
-        let sphereCount = 0;
-        let boxCount = 0;
-        let capsuleCount = 0;
-        for (let i = 0; i < N; i++) {
-            const s = rigidbodies[i].shape;
-            if (s === RigidbodyShape.Sphere)
-                sphereCount++;
-            else if (s === RigidbodyShape.Box)
-                boxCount++;
-            else
-                capsuleCount++;
-        }
-        const sphereOffset = 0;
-        const boxOffset = sphereCount;
-        const capsuleOffset = sphereCount + boxCount;
-        const data = this.instanceData;
-        let sIdx = sphereOffset;
-        let bIdx = boxOffset;
-        let cIdx = capsuleOffset;
-        for (let i = 0; i < N; i++) {
-            const rb = rigidbodies[i];
-            const i3 = i * 3;
-            const i4 = i * 4;
-            let slot;
-            if (rb.shape === RigidbodyShape.Sphere)
-                slot = sIdx++;
-            else if (rb.shape === RigidbodyShape.Box)
-                slot = bIdx++;
-            else
-                slot = cIdx++;
-            const dst = slot * STRIDE_FLOATS;
-            // Model matrix: rotation from quat into [dst..dst+15], then translation.
-            Mat4.fromQuatInto(orientations[i4 + 0], orientations[i4 + 1], orientations[i4 + 2], orientations[i4 + 3], data, dst);
-            data[dst + 12] = positions[i3 + 0];
-            data[dst + 13] = positions[i3 + 1];
-            data[dst + 14] = positions[i3 + 2];
-            // size + pad
-            data[dst + 16] = rb.size.x;
-            data[dst + 17] = rb.size.y;
-            data[dst + 18] = rb.size.z;
-            data[dst + 19] = 0;
-            const c = rb.type === RigidbodyType.Static
-                ? COLOR_STATIC
-                : rb.type === RigidbodyType.Kinematic
-                    ? COLOR_KINEMATIC
-                    : COLOR_DYNAMIC;
-            data[dst + 20] = c[0];
-            data[dst + 21] = c[1];
-            data[dst + 22] = c[2];
-            data[dst + 23] = c[3];
-        }
-        this.device.queue.writeBuffer(this.instanceBuffer, 0, data.buffer, data.byteOffset, N * STRIDE_BYTES);
-        pass.setBindGroup(0, this.bindGroup);
-        // Solid fills first (gentle ~20% alpha for shape ID), wireframe edges on top
-        // (95% alpha for crisp silhouette).
-        if (sphereCount > 0) {
-            const off = sphereOffset * STRIDE_BYTES;
-            const size = sphereCount * STRIDE_BYTES;
-            pass.setPipeline(this.solidPipelineSphere);
-            pass.setVertexBuffer(0, this.solidSphereBuffer);
-            pass.setVertexBuffer(1, this.instanceBuffer, off, size);
-            pass.draw(this.solidSphereCount, sphereCount);
-            pass.setPipeline(this.wirePipelineSphere);
-            pass.setVertexBuffer(0, this.wireSphereBuffer);
-            pass.setVertexBuffer(1, this.instanceBuffer, off, size);
-            pass.draw(this.wireSphereCount, sphereCount);
-        }
-        if (boxCount > 0) {
-            const off = boxOffset * STRIDE_BYTES;
-            const size = boxCount * STRIDE_BYTES;
-            pass.setPipeline(this.solidPipelineBox);
-            pass.setVertexBuffer(0, this.solidBoxBuffer);
-            pass.setVertexBuffer(1, this.instanceBuffer, off, size);
-            pass.draw(this.solidBoxCount, boxCount);
-            pass.setPipeline(this.wirePipelineBox);
-            pass.setVertexBuffer(0, this.wireBoxBuffer);
-            pass.setVertexBuffer(1, this.instanceBuffer, off, size);
-            pass.draw(this.wireBoxCount, boxCount);
-        }
-        if (capsuleCount > 0) {
-            const off = capsuleOffset * STRIDE_BYTES;
-            const size = capsuleCount * STRIDE_BYTES;
-            pass.setPipeline(this.solidPipelineCapsule);
-            pass.setVertexBuffer(0, this.solidCapsuleBuffer);
-            pass.setVertexBuffer(1, this.instanceBuffer, off, size);
-            pass.draw(this.solidCapsuleCount, capsuleCount);
-            pass.setPipeline(this.wirePipelineCapsule);
-            pass.setVertexBuffer(0, this.wireCapsuleBuffer);
-            pass.setVertexBuffer(1, this.instanceBuffer, off, size);
-            pass.draw(this.wireCapsuleCount, capsuleCount);
-        }
-    }
-    destroy() {
-        this.wireSphereBuffer.destroy();
-        this.wireBoxBuffer.destroy();
-        this.wireCapsuleBuffer.destroy();
-        this.solidSphereBuffer.destroy();
-        this.solidBoxBuffer.destroy();
-        this.solidCapsuleBuffer.destroy();
-        this.instanceBuffer.destroy();
-    }
-}
-// ── Geometry builders ─────────────────────────────────────────────────────────
-// Each vertex is vec4(unitPos.xyz, axialAnchor) packed as 4 floats.
-function buildSphereWireGeometry() {
-    const segs = 32;
-    const out = new Float32Array(3 * segs * 2 * 4); // 3 great circles
-    let p = 0;
-    for (let plane = 0; plane < 3; plane++) {
-        for (let i = 0; i < segs; i++) {
-            const a0 = (i / segs) * Math.PI * 2;
-            const a1 = ((i + 1) / segs) * Math.PI * 2;
-            const c0 = Math.cos(a0), s0 = Math.sin(a0);
-            const c1 = Math.cos(a1), s1 = Math.sin(a1);
-            let p0x = 0, p0y = 0, p0z = 0;
-            let p1x = 0, p1y = 0, p1z = 0;
-            if (plane === 0) {
-                p0x = c0;
-                p0y = s0;
-                p1x = c1;
-                p1y = s1;
-            }
-            else if (plane === 1) {
-                p0x = c0;
-                p0z = s0;
-                p1x = c1;
-                p1z = s1;
-            }
-            else {
-                p0y = c0;
-                p0z = s0;
-                p1y = c1;
-                p1z = s1;
-            }
-            out[p++] = p0x;
-            out[p++] = p0y;
-            out[p++] = p0z;
-            out[p++] = 0;
-            out[p++] = p1x;
-            out[p++] = p1y;
-            out[p++] = p1z;
-            out[p++] = 0;
-        }
-    }
-    return out;
-}
-function buildBoxWireGeometry() {
-    const edges = [
-        // 4 along X
-        [-1, -1, -1, +1, -1, -1], [-1, -1, +1, +1, -1, +1],
-        [-1, +1, -1, +1, +1, -1], [-1, +1, +1, +1, +1, +1],
-        // 4 along Y
-        [-1, -1, -1, -1, +1, -1], [+1, -1, -1, +1, +1, -1],
-        [-1, -1, +1, -1, +1, +1], [+1, -1, +1, +1, +1, +1],
-        // 4 along Z
-        [-1, -1, -1, -1, -1, +1], [+1, -1, -1, +1, -1, +1],
-        [-1, +1, -1, -1, +1, +1], [+1, +1, -1, +1, +1, +1],
-    ];
-    const out = new Float32Array(edges.length * 2 * 4);
-    let p = 0;
-    for (const e of edges) {
-        out[p++] = e[0];
-        out[p++] = e[1];
-        out[p++] = e[2];
-        out[p++] = 0;
-        out[p++] = e[3];
-        out[p++] = e[4];
-        out[p++] = e[5];
-        out[p++] = 0;
-    }
-    return out;
-}
-function buildCapsuleWireGeometry() {
-    const ringSegs = 32;
-    const arcSegs = 16;
-    // 2 cap rings + 4 hemisphere arcs + 4 cylinder verticals
-    const lineCount = ringSegs * 2 + arcSegs * 4 + 4;
-    const out = new Float32Array(lineCount * 2 * 4);
-    let p = 0;
-    const push = (x, y, z, axial) => {
-        out[p++] = x;
-        out[p++] = y;
-        out[p++] = z;
-        out[p++] = axial;
-    };
-    // Top ring (axial=+1) in XZ plane
-    for (let i = 0; i < ringSegs; i++) {
-        const a0 = (i / ringSegs) * Math.PI * 2;
-        const a1 = ((i + 1) / ringSegs) * Math.PI * 2;
-        push(Math.cos(a0), 0, Math.sin(a0), +1);
-        push(Math.cos(a1), 0, Math.sin(a1), +1);
-    }
-    // Bottom ring (axial=-1)
-    for (let i = 0; i < ringSegs; i++) {
-        const a0 = (i / ringSegs) * Math.PI * 2;
-        const a1 = ((i + 1) / ringSegs) * Math.PI * 2;
-        push(Math.cos(a0), 0, Math.sin(a0), -1);
-        push(Math.cos(a1), 0, Math.sin(a1), -1);
-    }
-    // Top cap arcs in XY and YZ planes (θ ∈ [0, π], pos = (cosθ, sinθ, 0) etc.)
-    for (let i = 0; i < arcSegs; i++) {
-        const t0 = (i / arcSegs) * Math.PI;
-        const t1 = ((i + 1) / arcSegs) * Math.PI;
-        push(Math.cos(t0), Math.sin(t0), 0, +1);
-        push(Math.cos(t1), Math.sin(t1), 0, +1);
-    }
-    for (let i = 0; i < arcSegs; i++) {
-        const t0 = (i / arcSegs) * Math.PI;
-        const t1 = ((i + 1) / arcSegs) * Math.PI;
-        push(0, Math.sin(t0), Math.cos(t0), +1);
-        push(0, Math.sin(t1), Math.cos(t1), +1);
-    }
-    // Bottom cap arcs
-    for (let i = 0; i < arcSegs; i++) {
-        const t0 = (i / arcSegs) * Math.PI;
-        const t1 = ((i + 1) / arcSegs) * Math.PI;
-        push(Math.cos(t0), -Math.sin(t0), 0, -1);
-        push(Math.cos(t1), -Math.sin(t1), 0, -1);
-    }
-    for (let i = 0; i < arcSegs; i++) {
-        const t0 = (i / arcSegs) * Math.PI;
-        const t1 = ((i + 1) / arcSegs) * Math.PI;
-        push(0, -Math.sin(t0), Math.cos(t0), -1);
-        push(0, -Math.sin(t1), Math.cos(t1), -1);
-    }
-    // 4 cylinder verticals: bottom rim (axial=-1) → top rim (+1) at fixed θ
-    push(+1, 0, 0, -1);
-    push(+1, 0, 0, +1);
-    push(-1, 0, 0, -1);
-    push(-1, 0, 0, +1);
-    push(0, 0, +1, -1);
-    push(0, 0, +1, +1);
-    push(0, 0, -1, -1);
-    push(0, 0, -1, +1);
-    return out;
-}
-// ── Solid (triangle-list) geometry builders ─────────────────────────────────
-// Each vertex is vec4(unitPos.xyz, axialAnchor) — same layout as wireframe.
-// UV sphere — stacks × slices quads, each split into 2 triangles. Polar quads
-// degenerate to triangles, which the GPU silently drops.
-function buildSphereSolidGeometry() {
-    const stacks = 12;
-    const slices = 18;
-    const out = new Float32Array(stacks * slices * 6 * 4);
-    let p = 0;
-    const vert = (phi, theta) => {
-        out[p++] = Math.cos(phi) * Math.cos(theta);
-        out[p++] = Math.sin(phi);
-        out[p++] = Math.cos(phi) * Math.sin(theta);
-        out[p++] = 0;
-    };
-    for (let s = 0; s < stacks; s++) {
-        const phi0 = -Math.PI / 2 + (s / stacks) * Math.PI;
-        const phi1 = -Math.PI / 2 + ((s + 1) / stacks) * Math.PI;
-        for (let l = 0; l < slices; l++) {
-            const th0 = (l / slices) * Math.PI * 2;
-            const th1 = ((l + 1) / slices) * Math.PI * 2;
-            vert(phi0, th0);
-            vert(phi1, th0);
-            vert(phi1, th1);
-            vert(phi0, th0);
-            vert(phi1, th1);
-            vert(phi0, th1);
-        }
-    }
-    return out;
-}
-// 6 cube faces × 2 triangles × 3 verts = 36 verts.
-function buildBoxSolidGeometry() {
-    const faces = [
-        // +X face
-        [+1, -1, -1, +1, +1, -1, +1, +1, +1, +1, -1, +1],
-        // -X face
-        [-1, -1, -1, -1, -1, +1, -1, +1, +1, -1, +1, -1],
-        // +Y face
-        [-1, +1, -1, -1, +1, +1, +1, +1, +1, +1, +1, -1],
-        // -Y face
-        [-1, -1, -1, +1, -1, -1, +1, -1, +1, -1, -1, +1],
-        // +Z face
-        [-1, -1, +1, +1, -1, +1, +1, +1, +1, -1, +1, +1],
-        // -Z face
-        [-1, -1, -1, -1, +1, -1, +1, +1, -1, +1, -1, -1],
-    ];
-    const out = new Float32Array(faces.length * 6 * 4);
-    let p = 0;
-    const v = (x, y, z) => {
-        out[p++] = x;
-        out[p++] = y;
-        out[p++] = z;
-        out[p++] = 0;
-    };
-    for (const f of faces) {
-        // f = [a, b, c, d] as 4 corners; emit tris (a,b,c) (a,c,d)
-        v(f[0], f[1], f[2]);
-        v(f[3], f[4], f[5]);
-        v(f[6], f[7], f[8]);
-        v(f[0], f[1], f[2]);
-        v(f[6], f[7], f[8]);
-        v(f[9], f[10], f[11]);
-    }
-    return out;
-}
-// Capsule: two hemispheres at axial=±1 + cylinder side connecting their equators.
-// Vertex shader does: world.y = unit.y * radius + halfHeight * axial.
-function buildCapsuleSolidGeometry() {
-    const slices = 18;
-    const capStacks = 6;
-    const cylTris = slices * 2; // 1 stack of quads → 2 tris/slice
-    const capTris = capStacks * slices * 2;
-    const totalVerts = (cylTris + capTris * 2) * 3;
-    const out = new Float32Array(totalVerts * 4);
-    let p = 0;
-    const v = (x, y, z, axial) => {
-        out[p++] = x;
-        out[p++] = y;
-        out[p++] = z;
-        out[p++] = axial;
-    };
-    // Cylinder side: two rings at axial=±1, both at unit y=0.
-    for (let l = 0; l < slices; l++) {
-        const th0 = (l / slices) * Math.PI * 2;
-        const th1 = ((l + 1) / slices) * Math.PI * 2;
-        const c0 = Math.cos(th0), s0 = Math.sin(th0);
-        const c1 = Math.cos(th1), s1 = Math.sin(th1);
-        // bottom-left, top-left, top-right
-        v(c0, 0, s0, -1);
-        v(c0, 0, s0, +1);
-        v(c1, 0, s1, +1);
-        // bottom-left, top-right, bottom-right
-        v(c0, 0, s0, -1);
-        v(c1, 0, s1, +1);
-        v(c1, 0, s1, -1);
-    }
-    // Top hemisphere (axial=+1): φ ∈ [0, π/2], pos = (cosφ cosθ, sinφ, cosφ sinθ).
-    for (let s = 0; s < capStacks; s++) {
-        const ph0 = (s / capStacks) * (Math.PI / 2);
-        const ph1 = ((s + 1) / capStacks) * (Math.PI / 2);
-        for (let l = 0; l < slices; l++) {
-            const th0 = (l / slices) * Math.PI * 2;
-            const th1 = ((l + 1) / slices) * Math.PI * 2;
-            const a = (ph, th) => [
-                Math.cos(ph) * Math.cos(th), Math.sin(ph), Math.cos(ph) * Math.sin(th),
-            ];
-            const p00 = a(ph0, th0), p10 = a(ph1, th0), p11 = a(ph1, th1), p01 = a(ph0, th1);
-            v(p00[0], p00[1], p00[2], +1);
-            v(p10[0], p10[1], p10[2], +1);
-            v(p11[0], p11[1], p11[2], +1);
-            v(p00[0], p00[1], p00[2], +1);
-            v(p11[0], p11[1], p11[2], +1);
-            v(p01[0], p01[1], p01[2], +1);
-        }
-    }
-    // Bottom hemisphere (axial=-1): same but y = -sinφ.
-    for (let s = 0; s < capStacks; s++) {
-        const ph0 = (s / capStacks) * (Math.PI / 2);
-        const ph1 = ((s + 1) / capStacks) * (Math.PI / 2);
-        for (let l = 0; l < slices; l++) {
-            const th0 = (l / slices) * Math.PI * 2;
-            const th1 = ((l + 1) / slices) * Math.PI * 2;
-            const a = (ph, th) => [
-                Math.cos(ph) * Math.cos(th), -Math.sin(ph), Math.cos(ph) * Math.sin(th),
-            ];
-            const p00 = a(ph0, th0), p10 = a(ph1, th0), p11 = a(ph1, th1), p01 = a(ph0, th1);
-            v(p00[0], p00[1], p00[2], -1);
-            v(p11[0], p11[1], p11[2], -1);
-            v(p10[0], p10[1], p10[2], -1);
-            v(p00[0], p00[1], p00[2], -1);
-            v(p01[0], p01[1], p01[2], -1);
-            v(p11[0], p11[1], p11[2], -1);
-        }
-    }
-    return out;
-}

package/dist/shaders/passes/physics-debug.d.ts

@@ -1,2 +0,0 @@
-export declare const PHYSICS_DEBUG_SHADER_WGSL = "\nstruct CameraUniforms {\n  view: mat4x4f,\n  projection: mat4x4f,\n  viewPos: vec3f,\n  _pad: f32,\n};\n\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n\noverride SHAPE_KIND: u32 = 0u;\noverride SOLID_ALPHA: f32 = 1.0;\n\nstruct VsIn {\n  @location(0) unit: vec4f,       // xyz = unit pos; w = capsule axial anchor\n  @location(1) modelCol0: vec4f,\n  @location(2) modelCol1: vec4f,\n  @location(3) modelCol2: vec4f,\n  @location(4) modelCol3: vec4f,\n  @location(5) size: vec4f,       // xyz = size; w unused\n  @location(6) color: vec4f,\n};\n\nstruct VsOut {\n  @builtin(position) pos: vec4f,\n  @location(0) color: vec4f,\n};\n\n@vertex\nfn vsMain(in: VsIn) -> VsOut {\n  let model = mat4x4f(in.modelCol0, in.modelCol1, in.modelCol2, in.modelCol3);\n  var local: vec3f;\n  if (SHAPE_KIND == 1u) {\n    local = in.unit.xyz * in.size.xyz;\n  } else if (SHAPE_KIND == 2u) {\n    // PMX capsule: size.x = radius, size.y = full cylinder height. Bullet 2.x's\n    // btCapsuleShape(radius, height) stores height/2 internally, so the actual\n    // collision cylinder spans \u00B1size.y/2 \u2014 halve here to match.\n    let r = in.size.x;\n    let halfH = in.size.y * 0.5;\n    local = vec3f(in.unit.x * r, in.unit.y * r + halfH * in.unit.w, in.unit.z * r);\n  } else {\n    local = in.unit.xyz * in.size.x;\n  }\n  let world = model * vec4f(local, 1.0);\n  var out: VsOut;\n  out.pos = camera.projection * camera.view * world;\n  out.color = in.color;\n  return out;\n}\n\n@fragment\nfn fsMain(in: VsOut) -> @location(0) vec4f {\n  return vec4f(in.color.rgb, in.color.a * SOLID_ALPHA);\n}\n";
-//# sourceMappingURL=physics-debug.d.ts.map

package/dist/shaders/passes/physics-debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/physics-debug.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,yBAAyB,2kDAuDrC,CAAA"}