@multiplekex/shallot 0.2.4 → 0.3.0

package/src/standard/render/index.ts

@@ -3,12 +3,10 @@ import type { Plugin, State, System } from "../../core";
 import { MAX_ENTITIES, resource } from "../../core";
 import { Canvas, Compute, ComputePlugin } from "../compute";
 import { WorldTransform } from "../transforms";
-import { Activity } from "../activity";
 import {
     Camera,
     Tonemap,
     FXAA,
-    Raytracing,
     Vignette,
     Bloom,
     Quantize,
@@ -23,8 +21,36 @@ import {
     Sun,
     Viewport,
     uploadCamera,
+    uploadSky,
 } from "./camera";
 import { AmbientLight, DirectionalLight, packLightUniforms } from "./light";
+
+export interface ShadowSettingsProvider {
+    softness: number[];
+    samples: number[];
+    isActive: (state: State, eid: number) => boolean;
+}
+
+const shadowSettingsProviders: ShadowSettingsProvider[] = [];
+
+export function registerShadowSettings(settings: ShadowSettingsProvider): void {
+    shadowSettingsProviders.push(settings);
+}
+
+export function getShadowSettings(
+    state: State,
+    eid: number
+): { softness: number; samples: number } {
+    for (const provider of shadowSettingsProviders) {
+        if (provider.isActive(state, eid)) {
+            return {
+                softness: provider.softness[eid] ?? 0,
+                samples: Math.max(1, provider.samples[eid] ?? 16),
+            };
+        }
+    }
+    return { softness: 0, samples: 16 };
+}
 import {
     Mesh,
     MeshShapes,
@@ -33,35 +59,21 @@ import {
     MeshPBR,
     MeshEmission,
     MeshVolumes,
-    collectBatches,
-    updateBatches,
-    MAX_BATCH_SLOTS,
-    type Batch,
-    type MeshBuffers,
-    type BatchEntities,
     createShapeAtlas,
+    getMeshVersion,
 } from "./mesh";
-import { Surface, SurfaceIds, SurfaceType, getDefaultAllSurfaces } from "./surface";
-import { createSceneBuffer, ensureTextures } from "./scene";
-import { createIndirectBuffer } from "./indirect";
-import { createForwardNode } from "./forward";
-import { createDepthConvertNode } from "./depth";
+import { Surface, SurfaceIds } from "./surface";
+import { createSceneBuffer, createSkyBuffer, ensureTextures } from "./scene";
 import { createPostProcessNode, type PostProcessUniforms } from "./postprocess";
 import { createOverlayNode } from "./overlay";
 import { Draws } from "./pass";
-import { createBLASAtlas, type BLASAtlas } from "./bvh/blas";
-import { createTLASBuffers, createTLASNode, type TLASBuffers } from "./bvh/tlas";
-import { getMesh } from "./mesh";
-import { createInstanceNode } from "./instance";
 import { createDataNode } from "./data";
 
 export {
     Camera,
     CameraMode,
-    RenderMode,
     Tonemap,
     FXAA,
-    Raytracing,
     Vignette,
     Bloom,
     Quantize,
@@ -75,42 +87,58 @@ export {
     Clouds,
     Sun,
     Viewport,
+    getClearColor,
+    hasSkyComponent,
+    uploadSky,
 } from "./camera";
 export { AmbientLight, DirectionalLight } from "./light";
-export { Mesh, MeshShape, Volume, mesh, getMesh, clearMeshes } from "./mesh";
-export { createBox } from "./mesh/box";
-export { createSphere } from "./mesh/sphere";
-export { createPlane } from "./mesh/plane";
-export type { MeshData } from "./mesh";
+export {
+    Mesh,
+    MeshShape,
+    Volume,
+    mesh,
+    getMesh,
+    getMeshByName,
+    getMeshVersion,
+    meshCount,
+    clearMeshes,
+    computeShapeAABB,
+    createBox,
+    createSphere,
+    createPlane,
+} from "./mesh";
+export type { MeshData, AABB } from "./mesh";
 export { Surface, SurfaceType } from "./surface";
 
-export { surface, compose } from "./surface";
+export { surface, getSurfaceByName, compose } from "./surface";
 export type { SurfaceData } from "./surface";
 
 export { Pass, registerDraw, unregisterDraw, getDrawsByPass, Draws } from "./pass";
 export type { Draw, DrawContext, SharedPassContext } from "./pass";
-export { createForwardNode, compileRasterShader, compileRTShader } from "./forward";
-export type { ForwardConfig, ForwardNode } from "./forward";
-export { createDepthConvertNode } from "./depth";
 export { createPostProcessNode } from "./postprocess";
 export type { PostProcessUniforms } from "./postprocess";
 export { createOverlayNode } from "./overlay";
-
-const EntityIds = {
-    data: new Uint32Array(MAX_ENTITIES),
-};
+export { COLOR_FORMAT } from "./scene";
 
 const countBuffer = new Uint32Array(1);
+const time = new Float32Array(1);
+const ambientData = { color: 0x888888, intensity: 1.0 };
+const directionalData = {
+    color: 0xffffff,
+    intensity: 1.0,
+    directionX: -0.5,
+    directionY: -1.0,
+    directionZ: -0.5,
+};
 
 export interface Render {
     width: number;
     height: number;
     entityCount: number;
+    meshVersion: number;
     scene: GPUBuffer;
+    sky: GPUBuffer;
     matrices: GPUBuffer;
-}
-
-interface RenderState extends Render {
     colors: GPUBuffer;
     sizes: GPUBuffer;
     pbr: GPUBuffer;
@@ -118,34 +146,21 @@ interface RenderState extends Render {
     shapes: GPUBuffer;
     surfaces: GPUBuffer;
     data: GPUBuffer;
-    indirect: GPUBuffer;
-    batches: (Batch | null)[];
-    batchEntities: BatchEntities;
-    buffers: Map<number, MeshBuffers>;
-    postProcess: PostProcessUniforms;
+    entityCountBuffer: GPUBuffer;
     meshVertices: GPUBuffer;
     meshIndices: GPUBuffer;
     meshMeta: GPUBuffer;
-    blasAtlas: BLASAtlas;
-    instanceAABBs: GPUBuffer;
-    instanceInverses: GPUBuffer;
-    entityCountBuffer: GPUBuffer;
-    instanceCount: GPUBuffer;
-    tlas: TLASBuffers;
+    postProcess: PostProcessUniforms;
 }
 
 export const Render = resource<Render>("render");
 
-function getRenderState(state: State): RenderState | undefined {
-    return Render.from(state) as RenderState | undefined;
-}
-
 const RenderSystem: System = {
     group: "draw",
     first: true,
 
     update(state: State) {
-        const render = getRenderState(state);
+        const render = Render.from(state);
         const compute = Compute.from(state);
         const canvas = Canvas.from(state);
         if (!render || !compute || !canvas) return;
@@ -190,14 +205,33 @@ const RenderSystem: System = {
             resources.textureViews
         );
 
+        const currentMeshVersion = getMeshVersion();
+        if (currentMeshVersion !== render.meshVersion) {
+            render.meshVertices.destroy();
+            render.meshIndices.destroy();
+            render.meshMeta.destroy();
+            const shapeAtlas = createShapeAtlas(device);
+            render.meshVertices = shapeAtlas.vertices;
+            render.meshIndices = shapeAtlas.indices;
+            render.meshMeta = shapeAtlas.meta;
+            render.meshVersion = currentMeshVersion;
+        }
+
         render.entityCount = state.maxEid + 1;
         const uploadCount = render.entityCount;
 
         for (const eid of state.query([Camera])) {
             if (Camera.active[eid]) {
                 const hasShadows = state.hasComponent(eid, Shadows);
-                const shadowSoftness = hasShadows ? Shadows.softness[eid] : 0;
-                const shadowSamples = hasShadows ? Math.max(1, Shadows.samples[eid]) : 0;
+
+                let shadowSoftness = 0;
+                let shadowSamples = 0;
+
+                if (hasShadows) {
+                    const shadowSettings = getShadowSettings(state, eid);
+                    shadowSoftness = shadowSettings.softness;
+                    shadowSamples = shadowSettings.samples;
+                }
 
                 const hasReflections = state.hasComponent(eid, Reflections);
                 const reflectionDepth = hasReflections
@@ -212,54 +246,54 @@ const RenderSystem: System = {
                 const hasHaze = state.hasComponent(eid, Haze);
                 const hazeParams = hasHaze
                     ? {
-                        density: Haze.density[eid],
-                        color: Haze.color[eid],
-                    }
+                          density: Haze.density[eid],
+                          color: Haze.color[eid],
+                      }
                     : undefined;
 
                 const hasSky = state.hasComponent(eid, Sky);
                 const skyParams = hasSky
                     ? {
-                        zenith: Sky.zenith[eid],
-                        horizon: Sky.horizon[eid],
-                    }
+                          zenith: Sky.zenith[eid],
+                          horizon: Sky.horizon[eid],
+                      }
                     : undefined;
 
                 const hasMoon = state.hasComponent(eid, Moon);
                 const moonParams = hasMoon
                     ? {
-                        phase: Moon.phase[eid],
-                        glow: Moon.glow[eid],
-                        azimuth: Moon.azimuth[eid],
-                        elevation: Moon.elevation[eid],
-                    }
+                          phase: Moon.phase[eid],
+                          glow: Moon.glow[eid],
+                          azimuth: Moon.azimuth[eid],
+                          elevation: Moon.elevation[eid],
+                      }
                     : undefined;
 
                 const hasStars = state.hasComponent(eid, Stars);
                 const starsParams = hasStars
                     ? {
-                        intensity: Stars.intensity[eid],
-                        amount: Stars.amount[eid],
-                    }
+                          intensity: Stars.intensity[eid],
+                          amount: Stars.amount[eid],
+                      }
                     : undefined;
 
                 const hasClouds = state.hasComponent(eid, Clouds);
                 const cloudsParams = hasClouds
                     ? {
-                        coverage: Clouds.coverage[eid],
-                        density: Clouds.density[eid],
-                        height: Clouds.height[eid],
-                        color: Clouds.color[eid],
-                    }
+                          coverage: Clouds.coverage[eid],
+                          density: Clouds.density[eid],
+                          height: Clouds.height[eid],
+                          color: Clouds.color[eid],
+                      }
                     : undefined;
 
                 const hasSun = state.hasComponent(eid, Sun);
                 const sunParams = hasSun
                     ? {
-                        size: Sun.size[eid],
-                        glow: Sun.glow[eid],
-                        color: Sun.color[eid],
-                    }
+                          size: Sun.size[eid],
+                          glow: Sun.glow[eid],
+                          color: Sun.color[eid],
+                      }
                     : undefined;
 
                 uploadCamera(
@@ -272,7 +306,15 @@ const RenderSystem: System = {
                     shadowSamples,
                     reflectionDepth,
                     refractionDepth,
-                    uploadCount,
+                    uploadCount
+                );
+
+                time[0] = state.time.elapsed;
+                device.queue.writeBuffer(render.scene, 240, time);
+
+                uploadSky(
+                    device,
+                    render.sky,
                     hazeParams,
                     skyParams,
                     moonParams,
@@ -311,31 +353,26 @@ const RenderSystem: System = {
             }
         }
 
-        let ambientData = { color: 0x888888, intensity: 1.0 };
-        let directionalData = {
-            color: 0xffffff,
-            intensity: 1.0,
-            directionX: -0.5,
-            directionY: -1.0,
-            directionZ: -0.5,
-        };
+        ambientData.color = 0x888888;
+        ambientData.intensity = 1.0;
+        directionalData.color = 0xffffff;
+        directionalData.intensity = 1.0;
+        directionalData.directionX = -0.5;
+        directionalData.directionY = -1.0;
+        directionalData.directionZ = -0.5;
 
         for (const eid of state.query([AmbientLight])) {
-            ambientData = {
-                color: AmbientLight.color[eid],
-                intensity: AmbientLight.intensity[eid],
-            };
+            ambientData.color = AmbientLight.color[eid];
+            ambientData.intensity = AmbientLight.intensity[eid];
             break;
         }
 
         for (const eid of state.query([DirectionalLight])) {
-            directionalData = {
-                color: DirectionalLight.color[eid],
-                intensity: DirectionalLight.intensity[eid],
-                directionX: DirectionalLight.directionX[eid],
-                directionY: DirectionalLight.directionY[eid],
-                directionZ: DirectionalLight.directionZ[eid],
-            };
+            directionalData.color = DirectionalLight.color[eid];
+            directionalData.intensity = DirectionalLight.intensity[eid];
+            directionalData.directionX = DirectionalLight.directionX[eid];
+            directionalData.directionY = DirectionalLight.directionY[eid];
+            directionalData.directionZ = DirectionalLight.directionZ[eid];
             break;
         }
 
@@ -350,7 +387,6 @@ const RenderSystem: System = {
             uploadCount * 16
         );
 
-        const meshEntities = state.query([Mesh, WorldTransform]);
         device.queue.writeBuffer(render.colors, 0, MeshColors.data, 0, uploadCount * 4);
         device.queue.writeBuffer(render.sizes, 0, MeshSizes.data, 0, uploadCount * 4);
         device.queue.writeBuffer(render.pbr, 0, MeshPBR.data, 0, uploadCount * 4);
@@ -359,21 +395,6 @@ const RenderSystem: System = {
         countBuffer[0] = uploadCount;
         device.queue.writeBuffer(render.entityCountBuffer, 0, countBuffer);
 
-        let meshCount = 0;
-        for (const eid of meshEntities) {
-            EntityIds.data[meshCount] = eid;
-            meshCount++;
-        }
-        device.queue.writeBuffer(
-            render.tlas.entityIds,
-            0,
-            EntityIds.data,
-            0,
-            Math.max(meshCount, 1)
-        );
-        countBuffer[0] = meshCount;
-        device.queue.writeBuffer(render.instanceCount, 0, countBuffer);
-
         for (const eid of state.query([Surface])) {
             const surfaceType = Surface.type[eid] & 0xff;
             const volume = (MeshVolumes.data[eid] ?? 0) & 0xf;
@@ -381,13 +402,6 @@ const RenderSystem: System = {
             SurfaceIds.data[eid] = surfaceType | (volume << 8) | (shapeId << 16);
         }
         device.queue.writeBuffer(render.surfaces, 0, SurfaceIds.data, 0, uploadCount);
-
-        collectBatches(
-            meshEntities,
-            (eid) => Surface.type[eid] ?? SurfaceType.Default,
-            render.batchEntities
-        );
-        updateBatches(device, render.batchEntities, render, render.indirect);
     },
 };
 
@@ -410,7 +424,6 @@ export const RenderPlugin: Plugin = {
         DirectionalLight,
         Tonemap,
         FXAA,
-        Raytracing,
         Vignette,
         Bloom,
         Quantize,
@@ -441,10 +454,10 @@ export const RenderPlugin: Plugin = {
             });
 
         const shapeAtlas = createShapeAtlas(device);
-        const blasAtlas = createBLASAtlas(device, getMesh);
 
-        const renderState: RenderState = {
+        const renderState: Render = {
             scene: createSceneBuffer(device),
+            sky: createSkyBuffer(device),
             matrices: createPropertyBuffer(MAX_ENTITIES * 64, "matrices"),
             colors: createPropertyBuffer(MAX_ENTITIES * 16, "colors"),
             sizes: createPropertyBuffer(MAX_ENTITIES * 16, "sizes"),
@@ -453,11 +466,8 @@ export const RenderPlugin: Plugin = {
             shapes: createPropertyBuffer(MAX_ENTITIES * 4, "shapes"),
             surfaces: createPropertyBuffer(MAX_ENTITIES * 4, "surfaces"),
             data: createPropertyBuffer(MAX_ENTITIES * 64, "data"),
-            indirect: createIndirectBuffer(device, MAX_BATCH_SLOTS),
-            batches: Array(MAX_BATCH_SLOTS).fill(null),
-            batchEntities: Array(MAX_BATCH_SLOTS).fill(null),
-            buffers: new Map(),
             entityCount: 1,
+            meshVersion: getMeshVersion(),
             postProcess: {
                 tonemap: false,
                 exposure: 1.0,
@@ -473,20 +483,11 @@ export const RenderPlugin: Plugin = {
             meshVertices: shapeAtlas.vertices,
             meshIndices: shapeAtlas.indices,
             meshMeta: shapeAtlas.meta,
-            blasAtlas,
-            instanceAABBs: createPropertyBuffer(MAX_ENTITIES * 32, "instanceAABBs"),
-            instanceInverses: createPropertyBuffer(MAX_ENTITIES * 64, "instanceInverses"),
             entityCountBuffer: device.createBuffer({
                 label: "entityCount",
                 size: 4,
                 usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
             }),
-            instanceCount: device.createBuffer({
-                label: "instanceCount",
-                size: 4,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
-            }),
-            tlas: createTLASBuffers(device),
             width: 0,
             height: 0,
         };
@@ -498,18 +499,6 @@ export const RenderPlugin: Plugin = {
         };
         state.setResource(Draws, drawState);
 
-        const instanceNode = createInstanceNode({
-            matrices: renderState.matrices,
-            sizes: renderState.sizes,
-            shapes: renderState.shapes,
-            shapeAABBs: renderState.blasAtlas.shapeAABBs,
-            entityCount: renderState.entityCountBuffer,
-            instanceAABBs: renderState.instanceAABBs,
-            instanceInverses: renderState.instanceInverses,
-            getEntityCount: () => renderState.entityCount,
-        });
-        compute.graph.add(instanceNode);
-
         const dataNode = createDataNode({
             colors: renderState.colors,
             pbr: renderState.pbr,
@@ -521,79 +510,6 @@ export const RenderPlugin: Plugin = {
         });
         compute.graph.add(dataNode);
 
-        const tlasNode = createTLASNode({
-            instanceAABBs: renderState.instanceAABBs,
-            instanceCount: renderState.instanceCount,
-            tlas: renderState.tlas,
-            getEntityCount: () => renderState.entityCount,
-        });
-        compute.graph.add(tlasNode);
-
-        const getRaytracing = () => {
-            for (const eid of state.query([Camera])) {
-                if (Camera.active[eid]) {
-                    return state.hasComponent(eid, Raytracing);
-                }
-            }
-            return false;
-        };
-
-        const getClearColor = () => {
-            for (const eid of state.query([Camera])) {
-                if (Camera.active[eid]) {
-                    const packed = Camera.clearColor[eid];
-                    return {
-                        r: ((packed >> 16) & 0xff) / 255,
-                        g: ((packed >> 8) & 0xff) / 255,
-                        b: (packed & 0xff) / 255,
-                    };
-                }
-            }
-            return { r: 0, g: 0, b: 0 };
-        };
-
-        const getSky = () => {
-            for (const eid of state.query([Camera])) {
-                if (Camera.active[eid]) {
-                    return state.hasComponent(eid, Sky);
-                }
-            }
-            return false;
-        };
-
-        const forwardNode = createForwardNode({
-            scene: renderState.scene,
-            matrices: renderState.matrices,
-            colors: renderState.colors,
-            sizes: renderState.sizes,
-            pbr: renderState.pbr,
-            emission: renderState.emission,
-            shapes: renderState.shapes,
-            surfaces: renderState.surfaces,
-            data: renderState.data,
-            getSurfaces: getDefaultAllSurfaces,
-            getRaytracing,
-            getClearColor,
-            getSky,
-            acquire: (message) => Activity.from(state)?.acquire(message),
-            batches: () => renderState.batches,
-            tlasNodes: renderState.tlas.bvhNodes,
-            tlasInstanceIds: renderState.tlas.instanceIds,
-            blasNodes: renderState.blasAtlas.nodesBuffer,
-            blasTriIds: renderState.blasAtlas.triIdsBuffer,
-            blasTriangles: renderState.blasAtlas.trianglesBuffer,
-            blasMeta: renderState.blasAtlas.metaBuffer,
-            instanceInverses: renderState.instanceInverses,
-        });
-        compute.graph.add(forwardNode);
-
-        compute.graph.add(
-            createDepthConvertNode({
-                scene: renderState.scene,
-                getRaytracing,
-            })
-        );
-
         compute.graph.add(createOverlayNode({ state }));
 
         compute.graph.add(

package/src/standard/render/indirect.ts

@@ -20,21 +20,20 @@ export function createIndirectBuffer(device: GPUDevice, slotCount: number): GPUB
     });
 }
 
+const indirectData = new ArrayBuffer(INDIRECT_SIZE);
+const indirectView = new DataView(indirectData);
+
 export function writeIndirect(
     device: GPUDevice,
     buffer: GPUBuffer,
     slot: number,
     args: IndirectArgs
 ): void {
-    const offset = slot * INDIRECT_SIZE;
-    const data = new ArrayBuffer(INDIRECT_SIZE);
-    const view = new DataView(data);
-
-    view.setUint32(0, args.indexCount, true);
-    view.setUint32(4, args.instanceCount, true);
-    view.setUint32(8, args.firstIndex, true);
-    view.setInt32(12, args.baseVertex, true);
-    view.setUint32(16, args.firstInstance, true);
+    indirectView.setUint32(0, args.indexCount, true);
+    indirectView.setUint32(4, args.instanceCount, true);
+    indirectView.setUint32(8, args.firstIndex, true);
+    indirectView.setInt32(12, args.baseVertex, true);
+    indirectView.setUint32(16, args.firstInstance, true);
 
-    device.queue.writeBuffer(buffer, offset, data);
+    device.queue.writeBuffer(buffer, slot * INDIRECT_SIZE, indirectData);
 }

package/src/standard/render/light.ts

@@ -36,12 +36,12 @@ export function normalizeDirection(x: number, y: number, z: number): [number, nu
     return [x / len, y / len, z / len];
 }
 
-export interface AmbientLightData {
+interface AmbientLightData {
     color: number;
     intensity: number;
 }
 
-export interface DirectionalLightData {
+interface DirectionalLightData {
     color: number;
     intensity: number;
     directionX: number;