@multiplekex/shallot 0.2.5 → 0.3.0

package/src/standard/raster/batch.ts

@@ -0,0 +1,149 @@
+import { MAX_ENTITIES } from "../../core";
+import { MAX_SURFACES, MAX_BATCH_SLOTS, Mesh, getMesh, createMeshBuffers } from "../render/mesh";
+import type { MeshBuffers } from "../render/mesh";
+
+const INVALID_SHAPE = 0xffffffff;
+const SLOT_STRIDE = 4;
+
+export interface Batch {
+    entityIds: GPUBuffer;
+    buffers: Map<number, MeshBuffers>;
+    opaque: Uint32Array;
+    transparent: Uint32Array;
+}
+
+export function createBatch(device: GPUDevice): Batch {
+    return {
+        entityIds: device.createBuffer({
+            label: "raster-entity-ids",
+            size: MAX_ENTITIES * 4,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        }),
+        buffers: new Map(),
+        opaque: new Uint32Array(MAX_BATCH_SLOTS * SLOT_STRIDE),
+        transparent: new Uint32Array(MAX_BATCH_SLOTS * SLOT_STRIDE),
+    };
+}
+
+export function slotInstanceCount(slots: Uint32Array, i: number): number {
+    return slots[i * SLOT_STRIDE + 1];
+}
+
+export function slotIndexCount(slots: Uint32Array, i: number): number {
+    return slots[i * SLOT_STRIDE];
+}
+
+export function slotFirstInstance(slots: Uint32Array, i: number): number {
+    return slots[i * SLOT_STRIDE + 2];
+}
+
+export function slotShapeId(slots: Uint32Array, i: number): number {
+    return slots[i * SLOT_STRIDE + 3];
+}
+
+const entityIdsData = new Uint32Array(MAX_ENTITIES);
+const opaqueCounts = new Uint32Array(MAX_BATCH_SLOTS);
+const transparentCounts = new Uint32Array(MAX_BATCH_SLOTS);
+const opaqueOffsets = new Uint32Array(MAX_BATCH_SLOTS);
+const transparentOffsets = new Uint32Array(MAX_BATCH_SLOTS);
+const opaqueWriteOffsets = new Uint32Array(MAX_BATCH_SLOTS);
+const transparentWriteOffsets = new Uint32Array(MAX_BATCH_SLOTS);
+
+const opaqueEids = new Uint32Array(MAX_ENTITIES);
+const opaqueBatchIds = new Uint32Array(MAX_ENTITIES);
+const transparentEids = new Uint32Array(MAX_ENTITIES);
+const transparentBatchIds = new Uint32Array(MAX_ENTITIES);
+
+export function uploadBatch(
+    device: GPUDevice,
+    entities: Iterable<number>,
+    getSurface: (eid: number) => number,
+    getOpacity: (eid: number) => number,
+    state: Batch
+): void {
+    opaqueCounts.fill(0);
+    transparentCounts.fill(0);
+    let opaqueLen = 0;
+    let transparentLen = 0;
+
+    for (const eid of entities) {
+        const shape = Mesh.shape[eid];
+        if (shape === INVALID_SHAPE) continue;
+
+        const surface = getSurface(eid);
+        const batchIndex = shape * MAX_SURFACES + surface;
+        if (batchIndex >= MAX_BATCH_SLOTS) continue;
+
+        if (getOpacity(eid) < 1.0) {
+            transparentEids[transparentLen] = eid;
+            transparentBatchIds[transparentLen] = batchIndex;
+            transparentLen++;
+            transparentCounts[batchIndex]++;
+        } else {
+            opaqueEids[opaqueLen] = eid;
+            opaqueBatchIds[opaqueLen] = batchIndex;
+            opaqueLen++;
+            opaqueCounts[batchIndex]++;
+        }
+    }
+
+    let offset = 0;
+    for (let i = 0; i < MAX_BATCH_SLOTS; i++) {
+        opaqueOffsets[i] = offset;
+        offset += opaqueCounts[i];
+    }
+    for (let i = 0; i < MAX_BATCH_SLOTS; i++) {
+        transparentOffsets[i] = offset;
+        offset += transparentCounts[i];
+    }
+
+    opaqueWriteOffsets.fill(0);
+    for (let i = 0; i < opaqueLen; i++) {
+        const batchIndex = opaqueBatchIds[i];
+        const idx = opaqueOffsets[batchIndex] + opaqueWriteOffsets[batchIndex];
+        entityIdsData[idx] = opaqueEids[i];
+        opaqueWriteOffsets[batchIndex]++;
+    }
+
+    transparentWriteOffsets.fill(0);
+    for (let i = 0; i < transparentLen; i++) {
+        const batchIndex = transparentBatchIds[i];
+        const idx = transparentOffsets[batchIndex] + transparentWriteOffsets[batchIndex];
+        entityIdsData[idx] = transparentEids[i];
+        transparentWriteOffsets[batchIndex]++;
+    }
+
+    const totalEntities = offset;
+    if (totalEntities > 0) {
+        device.queue.writeBuffer(state.entityIds, 0, entityIdsData, 0, totalEntities);
+    }
+
+    for (let batchIndex = 0; batchIndex < MAX_BATCH_SLOTS; batchIndex++) {
+        const shapeId = Math.floor(batchIndex / MAX_SURFACES);
+        const o = batchIndex * SLOT_STRIDE;
+
+        const opaqueCount = opaqueCounts[batchIndex];
+        const transparentCount = transparentCounts[batchIndex];
+
+        let indexCount = 0;
+        if (opaqueCount > 0 || transparentCount > 0) {
+            const mesh = getMesh(shapeId);
+            if (mesh) {
+                indexCount = mesh.indexCount;
+                if (!state.buffers.has(shapeId)) {
+                    state.buffers.set(shapeId, createMeshBuffers(device, mesh));
+                }
+            }
+        }
+
+        state.opaque[o] = opaqueCount > 0 ? indexCount : 0;
+        state.opaque[o + 1] = opaqueCount;
+        state.opaque[o + 2] = opaqueOffsets[batchIndex];
+        state.opaque[o + 3] = shapeId;
+
+        state.transparent[o] = transparentCount > 0 ? indexCount : 0;
+        state.transparent[o + 1] = transparentCount;
+        state.transparent[o + 2] = transparentOffsets[batchIndex];
+        state.transparent[o + 3] = shapeId;
+    }
+}