@multiplekex/shallot 0.1.12 → 0.2.0

package/src/standard/render/instance.ts

@@ -0,0 +1,214 @@
+import type { ComputeNode, ExecutionContext } from "../compute";
+
+const WORKGROUP_SIZE = 64;
+
+const shader = /* wgsl */ `
+struct ShapeAABB {
+    minX: f32,
+    minY: f32,
+    minZ: f32,
+    _pad0: u32,
+    maxX: f32,
+    maxY: f32,
+    maxZ: f32,
+    _pad1: u32,
+}
+
+struct InstanceAABB {
+    minX: f32,
+    minY: f32,
+    minZ: f32,
+    _pad0: u32,
+    maxX: f32,
+    maxY: f32,
+    maxZ: f32,
+    _pad1: u32,
+}
+
+@group(0) @binding(0) var<storage, read> matrices: array<mat4x4<f32>>;
+@group(0) @binding(1) var<storage, read> sizes: array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> shapes: array<u32>;
+@group(0) @binding(3) var<storage, read> shapeAABBs: array<ShapeAABB>;
+@group(0) @binding(4) var<storage, read> entityCount: array<u32>;
+@group(0) @binding(5) var<storage, read_write> instanceAABBs: array<InstanceAABB>;
+@group(0) @binding(6) var<storage, read_write> instanceInverses: array<mat4x4<f32>>;
+
+fn scaleColumns(m: mat4x4<f32>, s: vec3<f32>) -> mat4x4<f32> {
+    return mat4x4<f32>(
+        m[0] * s.x,
+        m[1] * s.y,
+        m[2] * s.z,
+        m[3]
+    );
+}
+
+fn transformPoint(p: vec3<f32>, m: mat4x4<f32>) -> vec3<f32> {
+    return (m * vec4<f32>(p, 1.0)).xyz;
+}
+
+fn transformAABB(aabbMin: vec3<f32>, aabbMax: vec3<f32>, m: mat4x4<f32>) -> array<vec3<f32>, 2> {
+    let corners = array<vec3<f32>, 8>(
+        vec3<f32>(aabbMin.x, aabbMin.y, aabbMin.z),
+        vec3<f32>(aabbMin.x, aabbMin.y, aabbMax.z),
+        vec3<f32>(aabbMin.x, aabbMax.y, aabbMin.z),
+        vec3<f32>(aabbMin.x, aabbMax.y, aabbMax.z),
+        vec3<f32>(aabbMax.x, aabbMin.y, aabbMin.z),
+        vec3<f32>(aabbMax.x, aabbMin.y, aabbMax.z),
+        vec3<f32>(aabbMax.x, aabbMax.y, aabbMin.z),
+        vec3<f32>(aabbMax.x, aabbMax.y, aabbMax.z)
+    );
+
+    var newMin = vec3<f32>(1e30, 1e30, 1e30);
+    var newMax = vec3<f32>(-1e30, -1e30, -1e30);
+
+    for (var i = 0u; i < 8u; i++) {
+        let t = transformPoint(corners[i], m);
+        newMin = min(newMin, t);
+        newMax = max(newMax, t);
+    }
+
+    return array<vec3<f32>, 2>(newMin, newMax);
+}
+
+fn inverse4x4(m: mat4x4<f32>) -> mat4x4<f32> {
+    let m00 = m[0][0]; let m10 = m[0][1]; let m20 = m[0][2]; let m30 = m[0][3];
+    let m01 = m[1][0]; let m11 = m[1][1]; let m21 = m[1][2]; let m31 = m[1][3];
+    let m02 = m[2][0]; let m12 = m[2][1]; let m22 = m[2][2]; let m32 = m[2][3];
+    let m03 = m[3][0]; let m13 = m[3][1]; let m23 = m[3][2]; let m33 = m[3][3];
+
+    let c00 = m11 * (m22 * m33 - m32 * m23) - m21 * (m12 * m33 - m32 * m13) + m31 * (m12 * m23 - m22 * m13);
+    let c01 = -(m01 * (m22 * m33 - m32 * m23) - m21 * (m02 * m33 - m32 * m03) + m31 * (m02 * m23 - m22 * m03));
+    let c02 = m01 * (m12 * m33 - m32 * m13) - m11 * (m02 * m33 - m32 * m03) + m31 * (m02 * m13 - m12 * m03);
+    let c03 = -(m01 * (m12 * m23 - m22 * m13) - m11 * (m02 * m23 - m22 * m03) + m21 * (m02 * m13 - m12 * m03));
+
+    let c10 = -(m10 * (m22 * m33 - m32 * m23) - m20 * (m12 * m33 - m32 * m13) + m30 * (m12 * m23 - m22 * m13));
+    let c11 = m00 * (m22 * m33 - m32 * m23) - m20 * (m02 * m33 - m32 * m03) + m30 * (m02 * m23 - m22 * m03);
+    let c12 = -(m00 * (m12 * m33 - m32 * m13) - m10 * (m02 * m33 - m32 * m03) + m30 * (m02 * m13 - m12 * m03));
+    let c13 = m00 * (m12 * m23 - m22 * m13) - m10 * (m02 * m23 - m22 * m03) + m20 * (m02 * m13 - m12 * m03);
+
+    let c20 = m10 * (m21 * m33 - m31 * m23) - m20 * (m11 * m33 - m31 * m13) + m30 * (m11 * m23 - m21 * m13);
+    let c21 = -(m00 * (m21 * m33 - m31 * m23) - m20 * (m01 * m33 - m31 * m03) + m30 * (m01 * m23 - m21 * m03));
+    let c22 = m00 * (m11 * m33 - m31 * m13) - m10 * (m01 * m33 - m31 * m03) + m30 * (m01 * m13 - m11 * m03);
+    let c23 = -(m00 * (m11 * m23 - m21 * m13) - m10 * (m01 * m23 - m21 * m03) + m20 * (m01 * m13 - m11 * m03));
+
+    let c30 = -(m10 * (m21 * m32 - m31 * m22) - m20 * (m11 * m32 - m31 * m12) + m30 * (m11 * m22 - m21 * m12));
+    let c31 = m00 * (m21 * m32 - m31 * m22) - m20 * (m01 * m32 - m31 * m02) + m30 * (m01 * m22 - m21 * m02);
+    let c32 = -(m00 * (m11 * m32 - m31 * m12) - m10 * (m01 * m32 - m31 * m02) + m30 * (m01 * m12 - m11 * m02));
+    let c33 = m00 * (m11 * m22 - m21 * m12) - m10 * (m01 * m22 - m21 * m02) + m20 * (m01 * m12 - m11 * m02);
+
+    let det = m00 * c00 + m01 * c10 + m02 * c20 + m03 * c30;
+    let invDet = select(0.0, 1.0 / det, abs(det) > 1e-10);
+
+    return mat4x4<f32>(
+        vec4<f32>(c00, c10, c20, c30) * invDet,
+        vec4<f32>(c01, c11, c21, c31) * invDet,
+        vec4<f32>(c02, c12, c22, c32) * invDet,
+        vec4<f32>(c03, c13, c23, c33) * invDet
+    );
+}
+
+@compute @workgroup_size(${WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let eid = gid.x;
+    let count = entityCount[0];
+    if (eid >= count) { return; }
+
+    let shapeId = shapes[eid];
+    let shapeAABB = shapeAABBs[shapeId];
+    let matrix = matrices[eid];
+    let size = sizes[eid].xyz;
+
+    let hasZeroScale = size.x == 0.0 || size.y == 0.0 || size.z == 0.0;
+
+    if (hasZeroScale) {
+        var zeroAABB: InstanceAABB;
+        zeroAABB.minX = 0.0;
+        zeroAABB.minY = 0.0;
+        zeroAABB.minZ = 0.0;
+        zeroAABB._pad0 = 0u;
+        zeroAABB.maxX = 0.0;
+        zeroAABB.maxY = 0.0;
+        zeroAABB.maxZ = 0.0;
+        zeroAABB._pad1 = 0u;
+        instanceAABBs[eid] = zeroAABB;
+        instanceInverses[eid] = mat4x4<f32>();
+        return;
+    }
+
+    let scaledMatrix = scaleColumns(matrix, size);
+
+    let aabbMin = vec3<f32>(shapeAABB.minX, shapeAABB.minY, shapeAABB.minZ);
+    let aabbMax = vec3<f32>(shapeAABB.maxX, shapeAABB.maxY, shapeAABB.maxZ);
+    let worldAABB = transformAABB(aabbMin, aabbMax, scaledMatrix);
+
+    var outAABB: InstanceAABB;
+    outAABB.minX = worldAABB[0].x;
+    outAABB.minY = worldAABB[0].y;
+    outAABB.minZ = worldAABB[0].z;
+    outAABB._pad0 = 0u;
+    outAABB.maxX = worldAABB[1].x;
+    outAABB.maxY = worldAABB[1].y;
+    outAABB.maxZ = worldAABB[1].z;
+    outAABB._pad1 = 0u;
+    instanceAABBs[eid] = outAABB;
+
+    instanceInverses[eid] = inverse4x4(scaledMatrix);
+}
+`;
+
+export interface InstanceConfig {
+    matrices: GPUBuffer;
+    sizes: GPUBuffer;
+    shapes: GPUBuffer;
+    shapeAABBs: GPUBuffer;
+    entityCount: GPUBuffer;
+    instanceAABBs: GPUBuffer;
+    instanceInverses: GPUBuffer;
+    getEntityCount: () => number;
+}
+
+export function createInstanceNode(config: InstanceConfig): ComputeNode {
+    let pipeline: GPUComputePipeline | null = null;
+    let bindGroup: GPUBindGroup | null = null;
+
+    return {
+        id: "instance",
+        inputs: [],
+        outputs: [
+            { id: "instance-aabbs", access: "write" },
+            { id: "instance-inverses", access: "write" },
+        ],
+
+        async prepare(device: GPUDevice) {
+            const module = await device.createShaderModule({ code: shader });
+
+            pipeline = await device.createComputePipelineAsync({
+                layout: "auto",
+                compute: { module, entryPoint: "main" },
+            });
+
+            bindGroup = device.createBindGroup({
+                layout: pipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: config.matrices } },
+                    { binding: 1, resource: { buffer: config.sizes } },
+                    { binding: 2, resource: { buffer: config.shapes } },
+                    { binding: 3, resource: { buffer: config.shapeAABBs } },
+                    { binding: 4, resource: { buffer: config.entityCount } },
+                    { binding: 5, resource: { buffer: config.instanceAABBs } },
+                    { binding: 6, resource: { buffer: config.instanceInverses } },
+                ],
+            });
+        },
+
+        execute(ctx: ExecutionContext) {
+            const workgroups = Math.ceil(config.getEntityCount() / WORKGROUP_SIZE);
+
+            const pass = ctx.encoder.beginComputePass();
+            pass.setPipeline(pipeline!);
+            pass.setBindGroup(0, bindGroup!);
+            pass.dispatchWorkgroups(workgroups);
+            pass.end();
+        },
+    };
+}

package/src/standard/render/intersection.ts

@@ -0,0 +1,72 @@
+const EPSILON = 1e-7;
+
+export interface RayTriangleResult {
+    hit: boolean;
+    t: number;
+    u: number;
+    v: number;
+}
+
+export function intersectRayTriangle(
+    originX: number,
+    originY: number,
+    originZ: number,
+    directionX: number,
+    directionY: number,
+    directionZ: number,
+    v0x: number,
+    v0y: number,
+    v0z: number,
+    v1x: number,
+    v1y: number,
+    v1z: number,
+    v2x: number,
+    v2y: number,
+    v2z: number
+): RayTriangleResult {
+    const e1x = v1x - v0x;
+    const e1y = v1y - v0y;
+    const e1z = v1z - v0z;
+
+    const e2x = v2x - v0x;
+    const e2y = v2y - v0y;
+    const e2z = v2z - v0z;
+
+    const hx = directionY * e2z - directionZ * e2y;
+    const hy = directionZ * e2x - directionX * e2z;
+    const hz = directionX * e2y - directionY * e2x;
+
+    const a = e1x * hx + e1y * hy + e1z * hz;
+
+    if (a > -EPSILON && a < EPSILON) {
+        return { hit: false, t: 0, u: 0, v: 0 };
+    }
+
+    const f = 1 / a;
+
+    const sx = originX - v0x;
+    const sy = originY - v0y;
+    const sz = originZ - v0z;
+
+    const u = f * (sx * hx + sy * hy + sz * hz);
+    if (u < 0 || u > 1) {
+        return { hit: false, t: 0, u: 0, v: 0 };
+    }
+
+    const qx = sy * e1z - sz * e1y;
+    const qy = sz * e1x - sx * e1z;
+    const qz = sx * e1y - sy * e1x;
+
+    const v = f * (directionX * qx + directionY * qy + directionZ * qz);
+    if (v < 0 || u + v > 1) {
+        return { hit: false, t: 0, u: 0, v: 0 };
+    }
+
+    const t = f * (e2x * qx + e2y * qy + e2z * qz);
+
+    if (t > EPSILON) {
+        return { hit: true, t, u, v };
+    }
+
+    return { hit: false, t: 0, u: 0, v: 0 };
+}

package/src/standard/render/light.ts

@@ -21,7 +21,7 @@ export const DirectionalLight = {
 setTraits(DirectionalLight, {
     defaults: () => ({
         color: 0xffffff,
-        intensity: 1.0,
+        intensity: 0.8,
         directionX: -0.6,
         directionY: -1.0,
         directionZ: -0.8,
@@ -49,33 +49,33 @@ export interface DirectionalLightData {
     directionZ: number;
 }
 
+const lightData = new Float32Array(12);
+
 export function packLightUniforms(
     ambient: AmbientLightData,
     directional: DirectionalLightData
 ): Float32Array {
-    const data = new Float32Array(12);
-
     const ambientRgb = unpackColor(ambient.color);
-    data[0] = ambientRgb.r;
-    data[1] = ambientRgb.g;
-    data[2] = ambientRgb.b;
-    data[3] = ambient.intensity;
+    lightData[0] = ambientRgb.r;
+    lightData[1] = ambientRgb.g;
+    lightData[2] = ambientRgb.b;
+    lightData[3] = ambient.intensity;
 
     const [dx, dy, dz] = normalizeDirection(
         directional.directionX,
         directional.directionY,
         directional.directionZ
     );
-    data[4] = dx;
-    data[5] = dy;
-    data[6] = dz;
-    data[7] = 0;
+    lightData[4] = dx;
+    lightData[5] = dy;
+    lightData[6] = dz;
+    lightData[7] = 0;
 
     const sunRgb = unpackColor(directional.color);
-    data[8] = sunRgb.r * directional.intensity;
-    data[9] = sunRgb.g * directional.intensity;
-    data[10] = sunRgb.b * directional.intensity;
-    data[11] = 0;
+    lightData[8] = sunRgb.r * directional.intensity;
+    lightData[9] = sunRgb.g * directional.intensity;
+    lightData[10] = sunRgb.b * directional.intensity;
+    lightData[11] = 0;
 
-    return data;
+    return lightData;
 }

package/src/standard/render/mesh/index.ts

@@ -1,14 +1,16 @@
 import { MAX_ENTITIES } from "../../../core";
 import { setTraits, type FieldAccessor } from "../../../core/component";
 import { createEntityIdBuffer } from "../../compute";
-import { writeIndirect } from "../forward";
+import { writeIndirect } from "../indirect";
 import { createBox } from "./box";
 import { createSphere } from "./sphere";
 import { createPlane } from "./plane";
 
 export const MAX_SURFACES = 16;
 export const MAX_BATCH_SLOTS = 64;
-export const INVALID_SHAPE = 0xffffffff;
+const INVALID_SHAPE = 0xffffffff;
+
+const batchEntityIds = new Uint32Array(MAX_ENTITIES);
 
 export interface MeshData {
     vertices: Float32Array<ArrayBuffer>;
@@ -70,12 +72,14 @@ export const MeshEmission = {
     data: new Float32Array(MAX_ENTITIES * 4),
 };
 
-function initPBRDefaults(): void {
-    for (let i = 0; i < MAX_ENTITIES; i++) {
-        MeshPBR.data[i * 4] = 0.9;
-        MeshPBR.data[i * 4 + 1] = 0.0;
-    }
-}
+export const MeshVolumes = {
+    data: new Uint8Array(MAX_ENTITIES),
+};
+
+export const Volume = {
+    Solid: 0,
+    HalfSpace: 1,
+} as const;
 
 interface ColorProxy extends Array<number>, FieldAccessor {}
 
@@ -95,7 +99,6 @@ function colorProxy(): ColorProxy {
         data[offset] = ((value >> 16) & 0xff) / 255;
         data[offset + 1] = ((value >> 8) & 0xff) / 255;
         data[offset + 2] = (value & 0xff) / 255;
-        data[offset + 3] = 1;
     }
 
     return new Proxy([] as unknown as ColorProxy, {
@@ -277,53 +280,49 @@ export const Mesh: {
     colorR: ColorChannelProxy;
     colorG: ColorChannelProxy;
     colorB: ColorChannelProxy;
+    opacity: ColorChannelProxy;
     sizeX: SizeProxy;
     sizeY: SizeProxy;
     sizeZ: SizeProxy;
     roughness: PBRProxy;
     metallic: PBRProxy;
+    ior: PBRProxy;
     emission: EmissionProxy;
     emissionIntensity: PBRProxy;
+    volume: Uint8Array;
 } = {
     shape: MeshShapes.data,
     color: colorProxy(),
     colorR: colorChannelProxy(0),
     colorG: colorChannelProxy(1),
     colorB: colorChannelProxy(2),
+    opacity: colorChannelProxy(3),
     sizeX: sizeProxy(0),
     sizeY: sizeProxy(1),
     sizeZ: sizeProxy(2),
     roughness: pbrProxy(0, 0.9),
     metallic: pbrProxy(1, 0.0),
+    ior: pbrProxy(2, 1.0),
     emission: emissionProxy(),
     emissionIntensity: emissionIntensityProxy(),
+    volume: MeshVolumes.data,
 };
 
 setTraits(Mesh, {
     defaults: () => ({
         shape: MeshShape.Box,
         color: 0xffffff,
+        opacity: 1.0,
         sizeX: 1,
         sizeY: 1,
         sizeZ: 1,
-        roughness: 0.9,
+        roughness: 1.0,
         metallic: 0.0,
+        ior: 1.0,
         emission: 0x000000,
         emissionIntensity: 0.0,
+        volume: Volume.Solid,
     }),
-    accessors: {
-        color: Mesh.color,
-        colorR: Mesh.colorR,
-        colorG: Mesh.colorG,
-        colorB: Mesh.colorB,
-        sizeX: Mesh.sizeX,
-        sizeY: Mesh.sizeY,
-        sizeZ: Mesh.sizeZ,
-        roughness: Mesh.roughness,
-        metallic: Mesh.metallic,
-        emission: Mesh.emission,
-        emissionIntensity: Mesh.emissionIntensity,
-    },
 });
 
 export interface MeshBuffers {
@@ -350,90 +349,88 @@ export function createMeshBuffers(device: GPUDevice, mesh: MeshData): MeshBuffer
     return { vertex, index, indexCount: mesh.indexCount };
 }
 
-export interface BatchKey {
-    shape: number;
-    surface: number;
-}
+export type BatchEntities = (number[] | null)[];
 
-export function batchKeyString(key: BatchKey): string {
-    return `${key.shape}:${key.surface}`;
-}
-
-export function collectByShapeAndSurface(
+export function collectBatches(
     entities: Iterable<number>,
-    getSurface: (eid: number) => number
-): Map<string, { key: BatchKey; entities: number[] }> {
-    const batches = new Map<string, { key: BatchKey; entities: number[] }>();
+    getSurface: (eid: number) => number,
+    out: BatchEntities
+): void {
+    for (let i = 0; i < MAX_BATCH_SLOTS; i++) {
+        if (out[i]) out[i]!.length = 0;
+    }
     for (const eid of entities) {
         const shape = Mesh.shape[eid];
         const surface = getSurface(eid);
-        const key: BatchKey = { shape, surface };
-        const keyStr = batchKeyString(key);
-        let entry = batches.get(keyStr);
+        const batchIndex = shape * MAX_SURFACES + surface;
+        if (batchIndex >= MAX_BATCH_SLOTS) continue;
+        let entry = out[batchIndex];
         if (!entry) {
-            entry = { key, entities: [] };
-            batches.set(keyStr, entry);
+            entry = [];
+            out[batchIndex] = entry;
         }
-        entry.entities.push(eid);
+        entry.push(eid);
     }
-    return batches;
 }
 
-export interface ShapeBatch {
-    index: number;
-    shape: number;
-    surface: number;
+export interface Batch {
     buffers: MeshBuffers;
     entityIds: GPUBuffer;
     count: number;
 }
 
 export interface BatchState {
-    batches: Map<string, ShapeBatch>;
+    batches: (Batch | null)[];
     buffers: Map<number, MeshBuffers>;
 }
 
 export function updateBatches(
     device: GPUDevice,
-    byShapeAndSurface: Map<string, { key: BatchKey; entities: number[] }>,
+    batchEntities: BatchEntities,
     state: BatchState,
     indirect: GPUBuffer
 ): void {
-    const activeBatches = new Set<string>();
-
-    for (const [keyStr, { key, entities }] of byShapeAndSurface) {
-        activeBatches.add(keyStr);
+    for (let batchIndex = 0; batchIndex < MAX_BATCH_SLOTS; batchIndex++) {
+        const entities = batchEntities[batchIndex];
+        if (!entities || entities.length === 0) {
+            const batch = state.batches[batchIndex];
+            if (batch) {
+                batch.count = 0;
+                writeIndirect(device, indirect, batchIndex, {
+                    indexCount: 0,
+                    instanceCount: 0,
+                    firstIndex: 0,
+                    baseVertex: 0,
+                    firstInstance: 0,
+                });
+            }
+            continue;
+        }
 
-        let batch = state.batches.get(keyStr);
+        let batch = state.batches[batchIndex];
         if (!batch) {
-            const batchIndex = key.shape * MAX_SURFACES + key.surface;
-            if (batchIndex >= MAX_BATCH_SLOTS) {
-                console.warn(
-                    `Batch index ${batchIndex} exceeds limit (${MAX_BATCH_SLOTS}), skipping batch`
-                );
-                continue;
-            }
-            let buffers = state.buffers.get(key.shape);
+            const shape = Math.floor(batchIndex / MAX_SURFACES);
+            let buffers = state.buffers.get(shape);
             if (!buffers) {
-                const data = getMesh(key.shape) ?? getMesh(MeshShape.Box)!;
+                const data = getMesh(shape) ?? getMesh(MeshShape.Box)!;
                 buffers = createMeshBuffers(device, data);
-                state.buffers.set(key.shape, buffers);
+                state.buffers.set(shape, buffers);
             }
             batch = {
-                index: batchIndex,
-                shape: key.shape,
-                surface: key.surface,
                 buffers,
                 entityIds: createEntityIdBuffer(device, MAX_ENTITIES),
                 count: 0,
             };
-            state.batches.set(keyStr, batch);
+            state.batches[batchIndex] = batch;
         }
 
-        device.queue.writeBuffer(batch.entityIds, 0, new Uint32Array(entities));
+        for (let i = 0; i < entities.length; i++) {
+            batchEntityIds[i] = entities[i];
+        }
+        device.queue.writeBuffer(batch.entityIds, 0, batchEntityIds, 0, entities.length);
         batch.count = entities.length;
 
-        writeIndirect(device, indirect, batch.index, {
+        writeIndirect(device, indirect, batchIndex, {
             indexCount: batch.buffers.indexCount,
             instanceCount: entities.length,
             firstIndex: 0,
@@ -441,14 +438,9 @@ export function updateBatches(
             firstInstance: 0,
         });
     }
-
-    for (const keyStr of state.batches.keys()) {
-        if (!activeBatches.has(keyStr)) {
-            state.batches.delete(keyStr);
-        }
-    }
 }
 
 export { createBox } from "./box";
 export { createSphere } from "./sphere";
 export { createPlane } from "./plane";
+export { createShapeAtlas } from "./unified";