@multiplekex/shallot 0.2.5 → 0.3.0

package/src/standard/render/mesh.ts

@@ -0,0 +1,404 @@
+import { MAX_ENTITIES } from "../../core";
+import { setTraits, createFieldProxy, type FieldProxy } from "../../core/component";
+
+export const MAX_SURFACES = 16;
+export const MAX_SHAPES = 256;
+export const MAX_BATCH_SLOTS = MAX_SHAPES * MAX_SURFACES;
+const INVALID_SHAPE = 0xffffffff;
+
+let meshVersion = 0;
+
+export function getMeshVersion(): number {
+    return meshVersion;
+}
+
+export function meshCount(): number {
+    ensureBuiltIns();
+    return meshes.length;
+}
+
+export interface MeshData {
+    vertices: Float32Array<ArrayBuffer>;
+    indices: Uint16Array<ArrayBuffer>;
+    vertexCount: number;
+    indexCount: number;
+}
+
+const meshes: MeshData[] = [];
+const meshNames = new Map<string, number>();
+
+function ensureBuiltIns(): void {
+    if (meshes.length === 0) {
+        meshes.push(createBox());
+        meshes.push(createSphere());
+        meshes.push(createPlane());
+        meshNames.set("box", 0);
+        meshNames.set("sphere", 1);
+        meshNames.set("plane", 2);
+    }
+}
+
+export const MeshShape = {
+    Box: 0,
+    Sphere: 1,
+    Plane: 2,
+} as const;
+
+export function mesh(data: MeshData, name?: string): number {
+    ensureBuiltIns();
+    if (meshes.length >= MAX_SHAPES) throw new Error(`mesh limit reached (${MAX_SHAPES})`);
+    const id = meshes.length;
+    meshes.push(data);
+    if (name) meshNames.set(name, id);
+    meshVersion++;
+    return id;
+}
+
+export function getMeshByName(name: string): number | undefined {
+    ensureBuiltIns();
+    return meshNames.get(name);
+}
+
+export function getMesh(id: number): MeshData | undefined {
+    ensureBuiltIns();
+    return meshes[id];
+}
+
+export function clearMeshes(): void {
+    meshes.length = 0;
+    meshNames.clear();
+    meshVersion++;
+}
+
+export const MeshShapes = {
+    data: new Uint32Array(MAX_ENTITIES).fill(INVALID_SHAPE),
+};
+
+export const MeshColors = {
+    data: new Float32Array(MAX_ENTITIES * 4),
+};
+
+export const MeshSizes = {
+    data: new Float32Array(MAX_ENTITIES * 4),
+};
+
+export const MeshPBR = {
+    data: new Float32Array(MAX_ENTITIES * 4),
+};
+
+export const MeshEmission = {
+    data: new Float32Array(MAX_ENTITIES * 4),
+};
+
+export const MeshVolumes = {
+    data: new Uint8Array(MAX_ENTITIES),
+};
+
+export const Volume = {
+    Solid: 0,
+    HalfSpace: 1,
+} as const;
+
+function hexColorProxy(data: Float32Array): FieldProxy {
+    function getValue(eid: number): number {
+        const offset = eid * 4;
+        const r = Math.round(data[offset] * 255);
+        const g = Math.round(data[offset + 1] * 255);
+        const b = Math.round(data[offset + 2] * 255);
+        return (r << 16) | (g << 8) | b;
+    }
+
+    function setValue(eid: number, value: number): void {
+        const offset = eid * 4;
+        data[offset] = ((value >> 16) & 0xff) / 255;
+        data[offset + 1] = ((value >> 8) & 0xff) / 255;
+        data[offset + 2] = (value & 0xff) / 255;
+    }
+
+    return new Proxy([] as unknown as FieldProxy, {
+        get(_, prop) {
+            if (prop === "get") return getValue;
+            if (prop === "set") return setValue;
+            const eid = Number(prop);
+            if (Number.isNaN(eid)) return undefined;
+            return getValue(eid);
+        },
+        set(_, prop, value) {
+            const eid = Number(prop);
+            if (Number.isNaN(eid)) return false;
+            setValue(eid, value);
+            return true;
+        },
+    });
+}
+
+export const Mesh: {
+    shape: Uint32Array;
+    color: FieldProxy;
+    colorR: FieldProxy;
+    colorG: FieldProxy;
+    colorB: FieldProxy;
+    opacity: FieldProxy;
+    sizeX: FieldProxy;
+    sizeY: FieldProxy;
+    sizeZ: FieldProxy;
+    roughness: FieldProxy;
+    metallic: FieldProxy;
+    ior: FieldProxy;
+    emission: FieldProxy;
+    emissionIntensity: FieldProxy;
+    volume: Uint8Array;
+} = {
+    shape: MeshShapes.data,
+    color: hexColorProxy(MeshColors.data),
+    colorR: createFieldProxy(MeshColors.data, 4, 0),
+    colorG: createFieldProxy(MeshColors.data, 4, 1),
+    colorB: createFieldProxy(MeshColors.data, 4, 2),
+    opacity: createFieldProxy(MeshColors.data, 4, 3),
+    sizeX: createFieldProxy(MeshSizes.data, 4, 0),
+    sizeY: createFieldProxy(MeshSizes.data, 4, 1),
+    sizeZ: createFieldProxy(MeshSizes.data, 4, 2),
+    roughness: createFieldProxy(MeshPBR.data, 4, 0),
+    metallic: createFieldProxy(MeshPBR.data, 4, 1),
+    ior: createFieldProxy(MeshPBR.data, 4, 2),
+    emission: hexColorProxy(MeshEmission.data),
+    emissionIntensity: createFieldProxy(MeshEmission.data, 4, 3),
+    volume: MeshVolumes.data,
+};
+
+setTraits(Mesh, {
+    defaults: () => ({
+        shape: MeshShape.Box,
+        color: 0xffffff,
+        opacity: 1.0,
+        sizeX: 1,
+        sizeY: 1,
+        sizeZ: 1,
+        roughness: 1.0,
+        metallic: 0.0,
+        ior: 1.0,
+        emission: 0x000000,
+        emissionIntensity: 0.0,
+        volume: Volume.Solid,
+    }),
+    parse: { shape: getMeshByName },
+});
+
+export interface MeshBuffers {
+    vertex: GPUBuffer;
+    index: GPUBuffer;
+    indexCount: number;
+}
+
+export function createMeshBuffers(device: GPUDevice, mesh: MeshData): MeshBuffers {
+    const vertex = device.createBuffer({
+        label: "vertex",
+        size: mesh.vertices.byteLength,
+        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(vertex, 0, mesh.vertices);
+
+    const index = device.createBuffer({
+        label: "index",
+        size: mesh.indices.byteLength,
+        usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(index, 0, mesh.indices);
+
+    return { vertex, index, indexCount: mesh.indexCount };
+}
+
+export interface AABB {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+}
+
+export function computeShapeAABB(mesh: MeshData): AABB {
+    const { vertices, vertexCount } = mesh;
+    const stride = 6;
+
+    if (vertexCount === 0) {
+        return { minX: 0, minY: 0, minZ: 0, maxX: 0, maxY: 0, maxZ: 0 };
+    }
+
+    let minX = vertices[0];
+    let minY = vertices[1];
+    let minZ = vertices[2];
+    let maxX = vertices[0];
+    let maxY = vertices[1];
+    let maxZ = vertices[2];
+
+    for (let i = 1; i < vertexCount; i++) {
+        const x = vertices[i * stride];
+        const y = vertices[i * stride + 1];
+        const z = vertices[i * stride + 2];
+        if (x < minX) minX = x;
+        if (y < minY) minY = y;
+        if (z < minZ) minZ = z;
+        if (x > maxX) maxX = x;
+        if (y > maxY) maxY = y;
+        if (z > maxZ) maxZ = z;
+    }
+
+    return { minX, minY, minZ, maxX, maxY, maxZ };
+}
+
+export function createBox(): MeshData {
+    const vertices = new Float32Array([
+        -0.5, -0.5, 0.5, 0, 0, 1, 0.5, -0.5, 0.5, 0, 0, 1, 0.5, 0.5, 0.5, 0, 0, 1, -0.5, 0.5, 0.5,
+        0, 0, 1, 0.5, -0.5, -0.5, 0, 0, -1, -0.5, -0.5, -0.5, 0, 0, -1, -0.5, 0.5, -0.5, 0, 0, -1,
+        0.5, 0.5, -0.5, 0, 0, -1, -0.5, 0.5, 0.5, 0, 1, 0, 0.5, 0.5, 0.5, 0, 1, 0, 0.5, 0.5, -0.5,
+        0, 1, 0, -0.5, 0.5, -0.5, 0, 1, 0, -0.5, -0.5, -0.5, 0, -1, 0, 0.5, -0.5, -0.5, 0, -1, 0,
+        0.5, -0.5, 0.5, 0, -1, 0, -0.5, -0.5, 0.5, 0, -1, 0, 0.5, -0.5, 0.5, 1, 0, 0, 0.5, -0.5,
+        -0.5, 1, 0, 0, 0.5, 0.5, -0.5, 1, 0, 0, 0.5, 0.5, 0.5, 1, 0, 0, -0.5, -0.5, -0.5, -1, 0, 0,
+        -0.5, -0.5, 0.5, -1, 0, 0, -0.5, 0.5, 0.5, -1, 0, 0, -0.5, 0.5, -0.5, -1, 0, 0,
+    ]);
+
+    const indices = new Uint16Array([
+        0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13, 14, 12, 14, 15, 16, 17, 18,
+        16, 18, 19, 20, 21, 22, 20, 22, 23,
+    ]);
+
+    return { vertices, indices, vertexCount: 24, indexCount: 36 };
+}
+
+export function createSphere(segments = 32, rings = 16): MeshData {
+    const vertices: number[] = [];
+    const indices: number[] = [];
+    const radius = 0.5;
+
+    for (let y = 0; y <= rings; y++) {
+        const v = y / rings;
+        const theta = v * Math.PI;
+
+        for (let x = 0; x <= segments; x++) {
+            const u = x / segments;
+            const phi = u * Math.PI * 2;
+
+            const nx = Math.sin(theta) * Math.cos(phi);
+            const ny = Math.cos(theta);
+            const nz = Math.sin(theta) * Math.sin(phi);
+
+            vertices.push(nx * radius, ny * radius, nz * radius, nx, ny, nz);
+        }
+    }
+
+    for (let y = 0; y < rings; y++) {
+        for (let x = 0; x < segments; x++) {
+            const a = y * (segments + 1) + x;
+            const b = a + segments + 1;
+
+            indices.push(a, a + 1, b);
+            indices.push(a + 1, b + 1, b);
+        }
+    }
+
+    return {
+        vertices: new Float32Array(vertices),
+        indices: new Uint16Array(indices),
+        vertexCount: (rings + 1) * (segments + 1),
+        indexCount: rings * segments * 6,
+    };
+}
+
+export function createPlane(): MeshData {
+    const vertices = new Float32Array([
+        -0.5, 0, 0.5, 0, 1, 0, 0.5, 0, 0.5, 0, 1, 0, 0.5, 0, -0.5, 0, 1, 0, -0.5, 0, -0.5, 0, 1, 0,
+    ]);
+
+    const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+
+    return { vertices, indices, vertexCount: 4, indexCount: 6 };
+}
+
+interface ShapeMeta {
+    vertexOffset: number;
+    indexOffset: number;
+    triCount: number;
+}
+
+export interface ShapeAtlas {
+    vertices: GPUBuffer;
+    indices: GPUBuffer;
+    meta: GPUBuffer;
+    shapeCount: number;
+    maxTriangles: number;
+}
+
+export function createShapeAtlas(device: GPUDevice): ShapeAtlas {
+    const allVertices: number[] = [];
+    const allIndices: number[] = [];
+    const shapeMetas: ShapeMeta[] = [];
+
+    let vertexOffset = 0;
+    let indexOffset = 0;
+    let maxTriangles = 0;
+
+    const shapeCount = meshCount();
+    for (let shapeId = 0; shapeId < shapeCount; shapeId++) {
+        const m = getMesh(shapeId);
+        if (!m) {
+            shapeMetas.push({ vertexOffset: 0, indexOffset: 0, triCount: 0 });
+            continue;
+        }
+
+        const triCount = m.indexCount / 3;
+        shapeMetas.push({ vertexOffset, indexOffset, triCount });
+
+        for (let i = 0; i < m.vertices.length; i++) {
+            allVertices.push(m.vertices[i]);
+        }
+
+        for (let i = 0; i < m.indices.length; i++) {
+            allIndices.push(m.indices[i]);
+        }
+
+        vertexOffset += m.vertices.length;
+        indexOffset += m.indices.length;
+        maxTriangles += triCount;
+    }
+
+    const verticesData = new Float32Array(allVertices);
+    const indicesData = new Uint32Array(allIndices);
+    const metaData = new Uint32Array(shapeCount * 4);
+
+    for (let i = 0; i < shapeMetas.length; i++) {
+        metaData[i * 4] = shapeMetas[i].vertexOffset;
+        metaData[i * 4 + 1] = shapeMetas[i].indexOffset;
+        metaData[i * 4 + 2] = shapeMetas[i].triCount;
+        metaData[i * 4 + 3] = 0;
+    }
+
+    const vertices = device.createBuffer({
+        label: "unified-vertices",
+        size: Math.max(verticesData.byteLength, 16),
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(vertices, 0, verticesData);
+
+    const indices = device.createBuffer({
+        label: "unified-indices",
+        size: Math.max(indicesData.byteLength, 16),
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(indices, 0, indicesData);
+
+    const meta = device.createBuffer({
+        label: "unified-meta",
+        size: metaData.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(meta, 0, metaData);
+
+    return {
+        vertices,
+        indices,
+        meta,
+        shapeCount: shapeMetas.filter((m) => m.triCount > 0).length,
+        maxTriangles,
+    };
+}

package/src/standard/render/overlay.ts

@@ -5,14 +5,17 @@ import { Pass, getDrawsByPass, type DrawContext, type SharedPassContext } from "
 
 export { MASK_FORMAT };
 
-export interface OverlayNodeConfig {
+interface OverlayNodeConfig {
     state: State;
 }
 
 export function createOverlayNode(config: OverlayNodeConfig): ComputeNode {
     return {
         id: "overlay",
-        inputs: [{ id: "z", access: "read" }],
+        inputs: [
+            { id: "z", access: "read" },
+            { id: "eid", access: "read" },
+        ],
         outputs: [
             { id: "color", access: "write" },
             { id: "mask", access: "write" },