@multiplekex/shallot 0.2.4 → 0.3.0

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

@@ -1,446 +0,0 @@
-import { MAX_ENTITIES } from "../../../core";
-import { setTraits, type FieldAccessor } from "../../../core/component";
-import { createEntityIdBuffer } from "../../compute";
-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;
-const INVALID_SHAPE = 0xffffffff;
-
-const batchEntityIds = new Uint32Array(MAX_ENTITIES);
-
-export interface MeshData {
-    vertices: Float32Array<ArrayBuffer>;
-    indices: Uint16Array<ArrayBuffer>;
-    vertexCount: number;
-    indexCount: number;
-}
-
-const meshes: MeshData[] = [];
-
-function initBuiltIns(): void {
-    if (meshes.length === 0) {
-        meshes.push(createBox());
-        meshes.push(createSphere());
-        meshes.push(createPlane());
-    }
-}
-
-initBuiltIns();
-
-export const MeshShape = {
-    Box: 0,
-    Sphere: 1,
-    Plane: 2,
-} as const;
-
-export function mesh(data: MeshData): number {
-    const id = meshes.length;
-    meshes.push(data);
-    return id;
-}
-
-export function getMesh(id: number): MeshData | undefined {
-    return meshes[id];
-}
-
-export function clearMeshes(): void {
-    meshes.length = 0;
-    initBuiltIns();
-}
-
-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;
-
-interface ColorProxy extends Array<number>, FieldAccessor {}
-
-function colorProxy(): ColorProxy {
-    const data = MeshColors.data;
-
-    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 ColorProxy, {
-        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;
-        },
-    });
-}
-
-interface ColorChannelProxy extends Array<number>, FieldAccessor {}
-
-function colorChannelProxy(channelIndex: number): ColorChannelProxy {
-    const data = MeshColors.data;
-
-    function getValue(eid: number): number {
-        return data[eid * 4 + channelIndex];
-    }
-
-    function setValue(eid: number, value: number): void {
-        data[eid * 4 + channelIndex] = value;
-    }
-
-    return new Proxy([] as unknown as ColorChannelProxy, {
-        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;
-        },
-    });
-}
-
-interface SizeProxy extends Array<number>, FieldAccessor {}
-
-function sizeProxy(component: number): SizeProxy {
-    const data = MeshSizes.data;
-
-    function getValue(eid: number): number {
-        return data[eid * 4 + component];
-    }
-
-    function setValue(eid: number, value: number): void {
-        data[eid * 4 + component] = value;
-    }
-
-    return new Proxy([] as unknown as SizeProxy, {
-        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;
-        },
-    });
-}
-
-interface PBRProxy extends Array<number>, FieldAccessor {}
-
-function pbrProxy(component: number, defaultValue: number): PBRProxy {
-    const data = MeshPBR.data;
-
-    function getValue(eid: number): number {
-        const val = data[eid * 4 + component];
-        return val === 0 && component === 0 ? defaultValue : val;
-    }
-
-    function setValue(eid: number, value: number): void {
-        data[eid * 4 + component] = value;
-    }
-
-    return new Proxy([] as unknown as PBRProxy, {
-        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;
-        },
-    });
-}
-
-interface EmissionProxy extends Array<number>, FieldAccessor {}
-
-function emissionProxy(): EmissionProxy {
-    const data = MeshEmission.data;
-
-    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 EmissionProxy, {
-        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;
-        },
-    });
-}
-
-function emissionIntensityProxy(): PBRProxy {
-    const data = MeshEmission.data;
-
-    function getValue(eid: number): number {
-        return data[eid * 4 + 3];
-    }
-
-    function setValue(eid: number, value: number): void {
-        data[eid * 4 + 3] = value;
-    }
-
-    return new Proxy([] as unknown as PBRProxy, {
-        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: ColorProxy;
-    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: 1.0,
-        metallic: 0.0,
-        ior: 1.0,
-        emission: 0x000000,
-        emissionIntensity: 0.0,
-        volume: Volume.Solid,
-    }),
-});
-
-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 type BatchEntities = (number[] | null)[];
-
-export function collectBatches(
-    entities: Iterable<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 batchIndex = shape * MAX_SURFACES + surface;
-        if (batchIndex >= MAX_BATCH_SLOTS) continue;
-        let entry = out[batchIndex];
-        if (!entry) {
-            entry = [];
-            out[batchIndex] = entry;
-        }
-        entry.push(eid);
-    }
-}
-
-export interface Batch {
-    buffers: MeshBuffers;
-    entityIds: GPUBuffer;
-    count: number;
-}
-
-export interface BatchState {
-    batches: (Batch | null)[];
-    buffers: Map<number, MeshBuffers>;
-}
-
-export function updateBatches(
-    device: GPUDevice,
-    batchEntities: BatchEntities,
-    state: BatchState,
-    indirect: GPUBuffer
-): void {
-    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[batchIndex];
-        if (!batch) {
-            const shape = Math.floor(batchIndex / MAX_SURFACES);
-            let buffers = state.buffers.get(shape);
-            if (!buffers) {
-                const data = getMesh(shape) ?? getMesh(MeshShape.Box)!;
-                buffers = createMeshBuffers(device, data);
-                state.buffers.set(shape, buffers);
-            }
-            batch = {
-                buffers,
-                entityIds: createEntityIdBuffer(device, MAX_ENTITIES),
-                count: 0,
-            };
-            state.batches[batchIndex] = batch;
-        }
-
-        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, batchIndex, {
-            indexCount: batch.buffers.indexCount,
-            instanceCount: entities.length,
-            firstIndex: 0,
-            baseVertex: 0,
-            firstInstance: 0,
-        });
-    }
-}
-
-export { createBox } from "./box";
-export { createSphere } from "./sphere";
-export { createPlane } from "./plane";
-export { createShapeAtlas } from "./unified";

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

@@ -1,11 +0,0 @@
-import type { MeshData } from "./index";
-
-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 };
-}

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

@@ -1,40 +0,0 @@
-import type { MeshData } from "./index";
-
-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,
-    };
-}

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

@@ -1,96 +0,0 @@
-import { getMesh } from ".";
-
-export interface ShapeMeta {
-    vertexOffset: number;
-    indexOffset: number;
-    triCount: number;
-    _pad: number;
-}
-
-export interface ShapeAtlas {
-    vertices: GPUBuffer;
-    indices: GPUBuffer;
-    meta: GPUBuffer;
-    shapeCount: number;
-    maxTriangles: number;
-}
-
-const MAX_SHAPES = 16;
-
-export function createShapeAtlas(device: GPUDevice): ShapeAtlas {
-    const allVertices: number[] = [];
-    const allIndices: number[] = [];
-    const shapeMetas: ShapeMeta[] = [];
-
-    let vertexOffset = 0;
-    let indexOffset = 0;
-    let maxTriangles = 0;
-
-    for (let shapeId = 0; shapeId < MAX_SHAPES; shapeId++) {
-        const mesh = getMesh(shapeId);
-        if (!mesh) {
-            shapeMetas.push({ vertexOffset: 0, indexOffset: 0, triCount: 0, _pad: 0 });
-            continue;
-        }
-
-        const triCount = mesh.indexCount / 3;
-        shapeMetas.push({
-            vertexOffset,
-            indexOffset,
-            triCount,
-            _pad: 0,
-        });
-
-        for (let i = 0; i < mesh.vertices.length; i++) {
-            allVertices.push(mesh.vertices[i]);
-        }
-
-        for (let i = 0; i < mesh.indices.length; i++) {
-            allIndices.push(mesh.indices[i]);
-        }
-
-        vertexOffset += mesh.vertices.length;
-        indexOffset += mesh.indices.length;
-        maxTriangles += triCount;
-    }
-
-    const verticesData = new Float32Array(allVertices);
-    const indicesData = new Uint32Array(allIndices);
-    const metaData = new Uint32Array(MAX_SHAPES * 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,
-    };
-}