@multiplekex/shallot 0.1.9 → 0.1.10

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

@@ -6,6 +6,10 @@ 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;
+
 export interface MeshData {
     vertices: Float32Array<ArrayBuffer>;
     indices: Uint16Array<ArrayBuffer>;
@@ -46,6 +50,10 @@ export function clearMeshes(): void {
     initBuiltIns();
 }
 
+export const MeshShapes = {
+    data: new Uint32Array(MAX_ENTITIES).fill(INVALID_SHAPE),
+};
+
 export const MeshColors = {
     data: new Float32Array(MAX_ENTITIES * 4),
 };
@@ -54,6 +62,21 @@ 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),
+};
+
+function initPBRDefaults(): void {
+    for (let i = 0; i < MAX_ENTITIES; i++) {
+        MeshPBR.data[i * 4] = 0.9;
+        MeshPBR.data[i * 4 + 1] = 0.0;
+    }
+}
+
 interface ColorProxy extends Array<number>, FieldAccessor {}
 
 function colorProxy(): ColorProxy {
@@ -152,8 +175,104 @@ function sizeProxy(component: number): SizeProxy {
     });
 }
 
+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: number[];
+    shape: Uint32Array;
     color: ColorProxy;
     colorR: ColorChannelProxy;
     colorG: ColorChannelProxy;
@@ -161,8 +280,12 @@ export const Mesh: {
     sizeX: SizeProxy;
     sizeY: SizeProxy;
     sizeZ: SizeProxy;
+    roughness: PBRProxy;
+    metallic: PBRProxy;
+    emission: EmissionProxy;
+    emissionIntensity: PBRProxy;
 } = {
-    shape: [],
+    shape: MeshShapes.data,
     color: colorProxy(),
     colorR: colorChannelProxy(0),
     colorG: colorChannelProxy(1),
@@ -170,6 +293,10 @@ export const Mesh: {
     sizeX: sizeProxy(0),
     sizeY: sizeProxy(1),
     sizeZ: sizeProxy(2),
+    roughness: pbrProxy(0, 0.9),
+    metallic: pbrProxy(1, 0.0),
+    emission: emissionProxy(),
+    emissionIntensity: emissionIntensityProxy(),
 };
 
 setTraits(Mesh, {
@@ -179,6 +306,10 @@ setTraits(Mesh, {
         sizeX: 1,
         sizeY: 1,
         sizeZ: 1,
+        roughness: 0.9,
+        metallic: 0.0,
+        emission: 0x000000,
+        emissionIntensity: 0.0,
     }),
     accessors: {
         color: Mesh.color,
@@ -188,6 +319,10 @@ setTraits(Mesh, {
         sizeX: Mesh.sizeX,
         sizeY: Mesh.sizeY,
         sizeZ: Mesh.sizeZ,
+        roughness: Mesh.roughness,
+        metallic: Mesh.metallic,
+        emission: Mesh.emission,
+        emissionIntensity: Mesh.emissionIntensity,
     },
 });
 
@@ -215,54 +350,84 @@ export function createMeshBuffers(device: GPUDevice, mesh: MeshData): MeshBuffer
     return { vertex, index, indexCount: mesh.indexCount };
 }
 
-export function collectByShape(entities: Iterable<number>): Map<number, number[]> {
-    const byShape = new Map<number, number[]>();
+export interface BatchKey {
+    shape: number;
+    surface: number;
+}
+
+export function batchKeyString(key: BatchKey): string {
+    return `${key.shape}:${key.surface}`;
+}
+
+export function collectByShapeAndSurface(
+    entities: Iterable<number>,
+    getSurface: (eid: number) => number
+): Map<string, { key: BatchKey; entities: number[] }> {
+    const batches = new Map<string, { key: BatchKey; entities: number[] }>();
     for (const eid of entities) {
         const shape = Mesh.shape[eid];
-        let list = byShape.get(shape);
-        if (!list) {
-            list = [];
-            byShape.set(shape, list);
+        const surface = getSurface(eid);
+        const key: BatchKey = { shape, surface };
+        const keyStr = batchKeyString(key);
+        let entry = batches.get(keyStr);
+        if (!entry) {
+            entry = { key, entities: [] };
+            batches.set(keyStr, entry);
         }
-        list.push(eid);
+        entry.entities.push(eid);
     }
-    return byShape;
+    return batches;
 }
 
 export interface ShapeBatch {
     index: number;
+    shape: number;
+    surface: number;
     buffers: MeshBuffers;
     entityIds: GPUBuffer;
     count: number;
 }
 
 export interface BatchState {
-    batches: Map<number, ShapeBatch>;
+    batches: Map<string, ShapeBatch>;
     buffers: Map<number, MeshBuffers>;
 }
 
 export function updateBatches(
     device: GPUDevice,
-    byShape: Map<number, number[]>,
+    byShapeAndSurface: Map<string, { key: BatchKey; entities: number[] }>,
     state: BatchState,
     indirect: GPUBuffer
 ): void {
-    for (const [shape, entities] of byShape) {
-        let batch = state.batches.get(shape);
+    const activeBatches = new Set<string>();
+
+    for (const [keyStr, { key, entities }] of byShapeAndSurface) {
+        activeBatches.add(keyStr);
+
+        let batch = state.batches.get(keyStr);
         if (!batch) {
-            let buffers = state.buffers.get(shape);
+            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);
             if (!buffers) {
-                const data = getMesh(shape) ?? getMesh(MeshShape.Box)!;
+                const data = getMesh(key.shape) ?? getMesh(MeshShape.Box)!;
                 buffers = createMeshBuffers(device, data);
-                state.buffers.set(shape, buffers);
+                state.buffers.set(key.shape, buffers);
             }
             batch = {
-                index: state.batches.size,
+                index: batchIndex,
+                shape: key.shape,
+                surface: key.surface,
                 buffers,
                 entityIds: createEntityIdBuffer(device, MAX_ENTITIES),
                 count: 0,
             };
-            state.batches.set(shape, batch);
+            state.batches.set(keyStr, batch);
         }
 
         device.queue.writeBuffer(batch.entityIds, 0, new Uint32Array(entities));
@@ -276,6 +441,12 @@ export function updateBatches(
             firstInstance: 0,
         });
     }
+
+    for (const keyStr of state.batches.keys()) {
+        if (!activeBatches.has(keyStr)) {
+            state.batches.delete(keyStr);
+        }
+    }
 }
 
 export { createBox } from "./box";

package/src/standard/render/pass.ts

@@ -0,0 +1,63 @@
+import { resource, type State } from "../../core";
+import { Pass } from "../compute/pass";
+
+export { Pass };
+
+export interface DrawContext {
+    readonly device: GPUDevice;
+    readonly encoder: GPUCommandEncoder;
+    readonly format: GPUTextureFormat;
+    readonly width: number;
+    readonly height: number;
+
+    readonly sceneView: GPUTextureView;
+    readonly depthView: GPUTextureView;
+    readonly entityIdView: GPUTextureView;
+    readonly maskView: GPUTextureView;
+    readonly canvasView: GPUTextureView;
+
+    readonly inputView?: GPUTextureView;
+    readonly outputView?: GPUTextureView;
+}
+
+export interface SharedPassContext {
+    readonly device: GPUDevice;
+    readonly format: GPUTextureFormat;
+    readonly maskFormat: GPUTextureFormat;
+}
+
+export interface Draw {
+    readonly id: string;
+    readonly pass: Pass;
+    readonly order: number;
+    execute(ctx: DrawContext): void;
+    draw?(pass: GPURenderPassEncoder, ctx: SharedPassContext): void;
+}
+
+export interface DrawState {
+    draws: Map<string, Draw>;
+}
+
+export const Draws = resource<DrawState>("draws");
+
+export function registerDraw(state: State, draw: Draw): void {
+    const draws = Draws.from(state);
+    if (draws) {
+        draws.draws.set(draw.id, draw);
+    }
+}
+
+export function unregisterDraw(state: State, id: string): void {
+    const draws = Draws.from(state);
+    if (draws) {
+        draws.draws.delete(id);
+    }
+}
+
+export function getDrawsByPass(state: State, pass: Pass): Draw[] {
+    const draws = Draws.from(state);
+    if (!draws) return [];
+    return Array.from(draws.draws.values())
+        .filter((d) => d.pass === pass)
+        .sort((a, b) => a.order - b.order);
+}