@multiplekex/shallot 0.2.4 → 0.3.0

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

@@ -1,259 +0,0 @@
-import type { ComputeNode, ExecutionContext } from "../../compute";
-import type { SurfaceData } from "../surface";
-import type { Batch } from "../mesh";
-import { COLOR_FORMAT } from "../scene";
-import { compileUberShader } from "../shaders";
-import { createRasterPipeline, createSkyPipeline } from "./raster";
-
-export interface ForwardConfig {
-    scene: GPUBuffer;
-    matrices: GPUBuffer;
-    colors: GPUBuffer;
-    sizes: GPUBuffer;
-    pbr: GPUBuffer;
-    emission: GPUBuffer;
-    shapes: GPUBuffer;
-    surfaces: GPUBuffer;
-    data: GPUBuffer;
-    getSurfaces: () => SurfaceData[];
-    getRaytracing: () => boolean;
-    getClearColor: () => { r: number; g: number; b: number };
-    getSky: () => boolean;
-    acquire?: (message?: string) => (() => void) | undefined;
-    batches: () => (Batch | null)[];
-    tlasNodes: GPUBuffer;
-    tlasInstanceIds: GPUBuffer;
-    blasNodes: GPUBuffer;
-    blasTriIds: GPUBuffer;
-    blasTriangles: GPUBuffer;
-    blasMeta: GPUBuffer;
-    instanceInverses: GPUBuffer;
-}
-
-export type ForwardNode = ComputeNode;
-
-export function createForwardNode(config: ForwardConfig): ForwardNode {
-    let rasterPipeline: GPURenderPipeline | null = null;
-    let rtPipeline: GPUComputePipeline | null = null;
-    let rtCompiling = false;
-    let skyPipeline: GPURenderPipeline | null = null;
-
-    function executeRT(ctx: ExecutionContext): void {
-        const { device, encoder } = ctx;
-
-        const colorView = ctx.getTextureView("color");
-        const linearDepthView = ctx.getTextureView("linear-depth");
-        const eidView = ctx.getTextureView("eid");
-
-        if (!colorView || !linearDepthView || !eidView || !rtPipeline) {
-            return;
-        }
-
-        const bindGroup0 = device.createBindGroup({
-            layout: rtPipeline.getBindGroupLayout(0),
-            entries: [
-                { binding: 0, resource: { buffer: config.scene } },
-                { binding: 1, resource: { buffer: config.data } },
-                { binding: 2, resource: colorView },
-                { binding: 3, resource: linearDepthView },
-                { binding: 4, resource: eidView },
-            ],
-        });
-
-        const bindGroup1 = device.createBindGroup({
-            layout: rtPipeline.getBindGroupLayout(1),
-            entries: [
-                { binding: 0, resource: { buffer: config.tlasNodes } },
-                { binding: 1, resource: { buffer: config.tlasInstanceIds } },
-                { binding: 2, resource: { buffer: config.blasNodes } },
-                { binding: 3, resource: { buffer: config.blasTriIds } },
-                { binding: 4, resource: { buffer: config.blasTriangles } },
-                { binding: 5, resource: { buffer: config.blasMeta } },
-                { binding: 6, resource: { buffer: config.instanceInverses } },
-            ],
-        });
-
-        const colorTexture = ctx.getTexture("color");
-        if (!colorTexture) return;
-
-        const width = colorTexture.width;
-        const height = colorTexture.height;
-
-        const pass = encoder.beginComputePass();
-        pass.setPipeline(rtPipeline);
-        pass.setBindGroup(0, bindGroup0);
-        pass.setBindGroup(1, bindGroup1);
-        pass.dispatchWorkgroups(Math.ceil(width / 8), Math.ceil(height / 8));
-        pass.end();
-    }
-
-    function executeRaster(ctx: ExecutionContext): void {
-        const { device, encoder } = ctx;
-
-        const colorView = ctx.getTextureView("color");
-        const eidView = ctx.getTextureView("eid");
-        const depthView = ctx.getTextureView("depth");
-
-        if (!colorView || !eidView || !depthView || !rasterPipeline) {
-            return;
-        }
-
-        const batches = config.batches();
-        const colorTexture = ctx.getTexture("color");
-        if (!colorTexture) return;
-
-        const clearColor = config.getClearColor();
-        const hasSky = config.getSky() && skyPipeline;
-
-        if (hasSky) {
-            const skyPass = encoder.beginRenderPass({
-                colorAttachments: [
-                    {
-                        view: colorView as GPUTextureView,
-                        clearValue: { r: clearColor.r, g: clearColor.g, b: clearColor.b, a: 1 },
-                        loadOp: "clear" as const,
-                        storeOp: "store" as const,
-                    },
-                ],
-                depthStencilAttachment: {
-                    view: depthView as GPUTextureView,
-                    depthClearValue: 1.0,
-                    depthLoadOp: "clear" as const,
-                    depthStoreOp: "store" as const,
-                },
-            });
-
-            const skyBindGroup = device.createBindGroup({
-                layout: skyPipeline!.getBindGroupLayout(0),
-                entries: [{ binding: 0, resource: { buffer: config.scene } }],
-            });
-
-            skyPass.setPipeline(skyPipeline!);
-            skyPass.setBindGroup(0, skyBindGroup);
-            skyPass.draw(3);
-            skyPass.end();
-        }
-
-        const pass = encoder.beginRenderPass({
-            colorAttachments: [
-                {
-                    view: colorView as GPUTextureView,
-                    clearValue: { r: clearColor.r, g: clearColor.g, b: clearColor.b, a: 1 },
-                    loadOp: hasSky ? ("load" as const) : ("clear" as const),
-                    storeOp: "store" as const,
-                },
-                {
-                    view: eidView as GPUTextureView,
-                    clearValue: { r: 0, g: 0, b: 0, a: 0 },
-                    loadOp: "clear" as const,
-                    storeOp: "store" as const,
-                },
-            ],
-            depthStencilAttachment: {
-                view: depthView as GPUTextureView,
-                depthClearValue: 1.0,
-                depthLoadOp: hasSky ? ("load" as const) : ("clear" as const),
-                depthStoreOp: "store" as const,
-            },
-        });
-
-        pass.setPipeline(rasterPipeline);
-
-        for (const batch of batches) {
-            if (!batch || batch.count === 0) continue;
-
-            const batchBindGroup = device.createBindGroup({
-                layout: rasterPipeline.getBindGroupLayout(0),
-                entries: [
-                    { binding: 0, resource: { buffer: config.scene } },
-                    { binding: 1, resource: { buffer: batch.entityIds } },
-                    { binding: 2, resource: { buffer: config.matrices } },
-                    { binding: 3, resource: { buffer: config.colors } },
-                    { binding: 4, resource: { buffer: config.sizes } },
-                    { binding: 5, resource: { buffer: config.pbr } },
-                    { binding: 6, resource: { buffer: config.emission } },
-                    { binding: 7, resource: { buffer: config.shapes } },
-                    { binding: 8, resource: { buffer: config.surfaces } },
-                ],
-            });
-
-            pass.setBindGroup(0, batchBindGroup);
-            pass.setVertexBuffer(0, batch.buffers.vertex);
-            pass.setIndexBuffer(batch.buffers.index, "uint16");
-            pass.drawIndexed(batch.buffers.indexCount, batch.count);
-        }
-
-        pass.end();
-    }
-
-    return {
-        id: "forward",
-        inputs: [{ id: "tlas-bvh-nodes", access: "read" as const }],
-        outputs: [
-            { id: "color", access: "write" },
-            { id: "linear-depth", access: "write" },
-            { id: "eid", access: "write" },
-        ],
-
-        async prepare(device: GPUDevice) {
-            const surfaces = config.getSurfaces();
-            rasterPipeline = await createRasterPipeline(device, surfaces, COLOR_FORMAT);
-            skyPipeline = await createSkyPipeline(device, COLOR_FORMAT);
-
-            if (config.getRaytracing()) {
-                rtCompiling = true;
-                const release = config.acquire?.("compiling shaders");
-                createRTPipeline(device, surfaces)
-                    .then((p) => {
-                        rtPipeline = p;
-                    })
-                    .finally(() => {
-                        rtCompiling = false;
-                        release?.();
-                    });
-            }
-        },
-
-        execute(ctx: ExecutionContext) {
-            const wantRT = config.getRaytracing();
-
-            if (wantRT && !rtPipeline && !rtCompiling) {
-                rtCompiling = true;
-                const release = config.acquire?.("compiling shaders");
-                const surfaces = config.getSurfaces();
-                createRTPipeline(ctx.device, surfaces)
-                    .then((p) => {
-                        rtPipeline = p;
-                    })
-                    .finally(() => {
-                        rtCompiling = false;
-                        release?.();
-                    });
-            }
-
-            if (wantRT && rtPipeline) {
-                executeRT(ctx);
-            } else {
-                executeRaster(ctx);
-            }
-        },
-    };
-}
-
-export function compileRTShader(surfaces: SurfaceData[]): string {
-    return compileUberShader(surfaces);
-}
-
-export async function createRTPipeline(
-    device: GPUDevice,
-    surfaces: SurfaceData[]
-): Promise<GPUComputePipeline> {
-    const code = compileRTShader(surfaces);
-    const module = device.createShaderModule({ code });
-    return device.createComputePipelineAsync({
-        layout: "auto",
-        compute: { module, entryPoint: "main" },
-    });
-}
-
-export { createRasterPipeline, compileRasterShader } from "./raster";

package/src/standard/render/forward/raster.ts

@@ -1,228 +0,0 @@
-import type { SurfaceData } from "../surface";
-import { SCENE_STRUCT_WGSL, WGSL_STRUCTS } from "../surface/structs";
-import { compileVertexBody, WGSL_LIGHTING_CALC, SKY_WGSL, SKY_DIR_WGSL } from "../surface/wgsl";
-
-function compileSurfaceVariant(id: number, data: SurfaceData): string {
-    const vertexBody = compileVertexBody(data.vertex);
-    const fragmentBody = data.fragment ?? "";
-    const lit = data.lit !== false;
-
-    return `
-fn userVertexTransform_${id}(worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    ${vertexBody}
-}
-
-fn userFragment_${id}(surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    ${fragmentBody}
-}
-
-fn applyLighting_${id}(surface: SurfaceData) -> vec3<f32> {
-    ${
-        lit
-            ? `${WGSL_LIGHTING_CALC}
-    return surface.baseColor * lighting + surface.emission;`
-            : "return surface.baseColor;"
-    }
-}
-`;
-}
-
-function compileDispatchFunctions(surfaceCount: number): string {
-    const vertexCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { return userVertexTransform_${i}(worldPos, normal, eid); }`
-    ).join("\n");
-
-    const fragmentCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { userFragment_${i}(surface, position); }`
-    ).join("\n");
-
-    const lightingCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { return applyLighting_${i}(surface); }`
-    ).join("\n");
-
-    return `
-fn dispatchVertexTransform(surfaceId: u32, worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    switch surfaceId {
-${vertexCases}
-        default: { return userVertexTransform_0(worldPos, normal, eid); }
-    }
-}
-
-fn dispatchFragment(surfaceId: u32, surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    switch surfaceId {
-${fragmentCases}
-        default: { userFragment_0(surface, position); }
-    }
-}
-
-fn dispatchLighting(surfaceId: u32, surface: SurfaceData) -> vec3<f32> {
-    switch surfaceId {
-${lightingCases}
-        default: { return applyLighting_0(surface); }
-    }
-}
-`;
-}
-
-export function compileRasterShader(surfaces: SurfaceData[]): string {
-    const surfaceVariants = surfaces.map((s, i) => compileSurfaceVariant(i, s)).join("\n");
-    const dispatchFunctions = compileDispatchFunctions(surfaces.length);
-
-    return /* wgsl */ `
-${WGSL_STRUCTS}
-
-@group(0) @binding(8) var<storage, read> surfaceIds: array<u32>;
-
-${surfaceVariants}
-${dispatchFunctions}
-
-@vertex
-fn vs(input: VertexInput) -> VertexOutput {
-    let eid = entityIds[input.instance];
-    let world = matrices[eid];
-    let scaledPos = input.position * sizes[eid].xyz;
-    let baseWorldPos = (world * vec4<f32>(scaledPos, 1.0)).xyz;
-    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);
-    let surfaceId = surfaceIds[eid] & 0xFFu;
-    let finalWorldPos = dispatchVertexTransform(surfaceId, baseWorldPos, worldNormal, eid);
-    _ = shapes[eid];
-
-    var output: VertexOutput;
-    output.position = scene.viewProj * vec4<f32>(finalWorldPos, 1.0);
-    output.color = colors[eid];
-    output.worldNormal = worldNormal;
-    output.entityId = eid;
-    output.worldPos = finalWorldPos;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> FragmentOutput {
-    let eid = input.entityId;
-    let pbrData = pbr[eid];
-    let emissionData = emission[eid];
-    let surfaceId = surfaceIds[eid] & 0xFFu;
-
-    var surface: SurfaceData;
-    surface.baseColor = input.color.rgb;
-    surface.roughness = pbrData.x;
-    surface.metallic = pbrData.y;
-    surface.emission = emissionData.rgb * emissionData.a;
-    surface.normal = normalize(input.worldNormal);
-    surface.worldPos = input.worldPos;
-
-    dispatchFragment(surfaceId, &surface, input.position);
-
-    let litColor = dispatchLighting(surfaceId, surface);
-
-    var output: FragmentOutput;
-    output.color = vec4<f32>(litColor, input.color.a);
-    output.entityId = input.entityId;
-    return output;
-}
-`;
-}
-
-export async function createRasterPipeline(
-    device: GPUDevice,
-    surfaces: SurfaceData[],
-    colorFormat: GPUTextureFormat
-): Promise<GPURenderPipeline> {
-    const code = compileRasterShader(surfaces);
-    const module = device.createShaderModule({ code });
-
-    return device.createRenderPipelineAsync({
-        layout: "auto",
-        vertex: {
-            module,
-            entryPoint: "vs",
-            buffers: [
-                {
-                    arrayStride: 24,
-                    attributes: [
-                        { shaderLocation: 0, offset: 0, format: "float32x3" },
-                        { shaderLocation: 1, offset: 12, format: "float32x3" },
-                    ],
-                },
-            ],
-        },
-        fragment: {
-            module,
-            entryPoint: "fs",
-            targets: [{ format: colorFormat }, { format: "r32uint" }],
-        },
-        depthStencil: {
-            format: "depth24plus",
-            depthWriteEnabled: true,
-            depthCompare: "less",
-        },
-        primitive: {
-            topology: "triangle-list",
-            cullMode: "back",
-        },
-    });
-}
-
-export function compileSkyShader(): string {
-    return /* wgsl */ `
-${SCENE_STRUCT_WGSL}
-
-@group(0) @binding(0) var<uniform> scene: Scene;
-
-${SKY_DIR_WGSL}
-${SKY_WGSL}
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-}
-
-@vertex
-fn vs(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
-    var positions = array<vec2<f32>, 3>(
-        vec2(-1.0, -1.0),
-        vec2(3.0, -1.0),
-        vec2(-1.0, 3.0)
-    );
-    var output: VertexOutput;
-    output.position = vec4(positions[vertexIndex], 0.0, 1.0);
-    output.uv = (positions[vertexIndex] + 1.0) * 0.5;
-    output.uv.y = 1.0 - output.uv.y;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> @location(0) vec4<f32> {
-    let dir = computeSkyDir(input.uv.x, input.uv.y);
-    let color = sampleSky(dir);
-    return vec4(color, 1.0);
-}
-`;
-}
-
-export async function createSkyPipeline(
-    device: GPUDevice,
-    colorFormat: GPUTextureFormat
-): Promise<GPURenderPipeline> {
-    const code = compileSkyShader();
-    const module = device.createShaderModule({ code });
-
-    return device.createRenderPipelineAsync({
-        layout: "auto",
-        vertex: { module, entryPoint: "vs" },
-        fragment: {
-            module,
-            entryPoint: "fs",
-            targets: [{ format: colorFormat }],
-        },
-        depthStencil: {
-            format: "depth24plus",
-            depthWriteEnabled: false,
-            depthCompare: "always",
-        },
-        primitive: { topology: "triangle-list" },
-    });
-}

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

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