@multiplekex/shallot 0.1.12 → 0.2.0

package/src/standard/compute/timing.ts

@@ -1,139 +0,0 @@
-import type { NodeId } from "./graph";
-
-export interface NodeTiming {
-    readonly nodeId: NodeId;
-    readonly cpuMs: number;
-    readonly gpuNs?: number;
-}
-
-export interface FrameTiming {
-    readonly frameIndex: number;
-    readonly nodes: readonly NodeTiming[];
-    readonly totalCpuMs: number;
-    readonly totalGpuNs?: number;
-}
-
-export interface TimingConfig {
-    readonly enabled: boolean;
-    readonly gpuTimestamps: boolean;
-    readonly historySize: number;
-}
-
-export interface TimingState {
-    readonly config: TimingConfig;
-    readonly history: FrameTiming[];
-    readonly querySet?: GPUQuerySet;
-    readonly resolveBuffer?: GPUBuffer;
-    readonly readBuffer?: GPUBuffer;
-}
-
-export function supportsTimestampQuery(device: GPUDevice): boolean {
-    return device.features.has("timestamp-query");
-}
-
-export function createTimingState(
-    device: GPUDevice,
-    maxNodes: number,
-    historySize = 60
-): TimingState {
-    const gpuTimestamps = supportsTimestampQuery(device);
-
-    let querySet: GPUQuerySet | undefined;
-    let resolveBuffer: GPUBuffer | undefined;
-    let readBuffer: GPUBuffer | undefined;
-
-    if (gpuTimestamps) {
-        const queryCount = maxNodes * 2;
-        querySet = device.createQuerySet({
-            label: "timing-queries",
-            type: "timestamp",
-            count: queryCount,
-        });
-
-        resolveBuffer = device.createBuffer({
-            label: "timing-resolve",
-            size: queryCount * 8,
-            usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
-        });
-
-        readBuffer = device.createBuffer({
-            label: "timing-read",
-            size: queryCount * 8,
-            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-        });
-    }
-
-    return {
-        config: { enabled: true, gpuTimestamps, historySize },
-        history: [],
-        querySet,
-        resolveBuffer,
-        readBuffer,
-    };
-}
-
-export async function readTimestamps(
-    device: GPUDevice,
-    timing: TimingState,
-    nodeCount: number
-): Promise<BigUint64Array | null> {
-    if (!timing.querySet || !timing.resolveBuffer || !timing.readBuffer) {
-        return null;
-    }
-
-    const encoder = device.createCommandEncoder();
-    encoder.resolveQuerySet(timing.querySet, 0, nodeCount * 2, timing.resolveBuffer, 0);
-    encoder.copyBufferToBuffer(timing.resolveBuffer, 0, timing.readBuffer, 0, nodeCount * 2 * 8);
-    device.queue.submit([encoder.finish()]);
-
-    await timing.readBuffer.mapAsync(GPUMapMode.READ);
-    const data = new BigUint64Array(timing.readBuffer.getMappedRange().slice(0));
-    timing.readBuffer.unmap();
-
-    return data;
-}
-
-export function disposeTimingState(timing: TimingState): void {
-    timing.querySet?.destroy();
-    timing.resolveBuffer?.destroy();
-    timing.readBuffer?.destroy();
-}
-
-export interface TimingCollector {
-    readonly nodeTimings: Map<NodeId, { start: number; end: number }>;
-    beginNode(nodeId: NodeId): void;
-    endNode(nodeId: NodeId): void;
-    finish(frameIndex: number): FrameTiming;
-}
-
-export function createTimingCollector(): TimingCollector {
-    const nodeTimings = new Map<NodeId, { start: number; end: number }>();
-
-    return {
-        nodeTimings,
-
-        beginNode(nodeId: NodeId): void {
-            nodeTimings.set(nodeId, { start: performance.now(), end: 0 });
-        },
-
-        endNode(nodeId: NodeId): void {
-            const timing = nodeTimings.get(nodeId);
-            if (timing) {
-                timing.end = performance.now();
-            }
-        },
-
-        finish(frameIndex: number): FrameTiming {
-            const nodes: NodeTiming[] = [];
-            let totalCpuMs = 0;
-
-            for (const [nodeId, timing] of nodeTimings) {
-                const cpuMs = timing.end - timing.start;
-                totalCpuMs += cpuMs;
-                nodes.push({ nodeId, cpuMs });
-            }
-
-            return { frameIndex, nodes, totalCpuMs };
-        },
-    };
-}

package/src/standard/render/forward.ts

@@ -1,273 +0,0 @@
-import type { State } from "../../core";
-import type { ComputeNode, ExecutionContext } from "../compute";
-import type { ShapeBatch } from "./mesh";
-import { DEPTH_FORMAT, ENTITY_ID_FORMAT } from "./scene";
-import { getSurface, compileSurface, SurfaceType } from "./surface";
-import { WGSL_STRUCTS } from "./surface/structs";
-import { Pass, getDrawsByPass, type DrawContext } from "./pass";
-
-export const INDIRECT_SIZE = 20;
-
-export interface IndirectArgs {
-    indexCount: number;
-    instanceCount: number;
-    firstIndex: number;
-    baseVertex: number;
-    firstInstance: number;
-}
-
-export function createIndirectBuffer(device: GPUDevice, slotCount: number): GPUBuffer {
-    return device.createBuffer({
-        label: "indirect",
-        size: slotCount * INDIRECT_SIZE,
-        usage:
-            GPUBufferUsage.INDIRECT |
-            GPUBufferUsage.STORAGE |
-            GPUBufferUsage.COPY_DST |
-            GPUBufferUsage.COPY_SRC,
-    });
-}
-
-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);
-
-    device.queue.writeBuffer(buffer, offset, data);
-}
-
-export const litShader = /* wgsl */ `
-${WGSL_STRUCTS}
-
-@vertex
-fn vs(input: VertexInput) -> VertexOutput {
-    let eid = entityIds[input.instance];
-    let world = matrices[eid];
-    let scaledPos = input.position * sizes[eid].xyz;
-    let worldPos = world * vec4<f32>(scaledPos, 1.0);
-    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);
-    _ = shapes[eid]; // Keep binding alive
-
-    var output: VertexOutput;
-    output.position = scene.viewProj * worldPos;
-    output.color = colors[eid];
-    output.worldNormal = worldNormal;
-    output.entityId = eid;
-    output.worldPos = worldPos.xyz;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> FragmentOutput {
-    let eid = input.entityId;
-    let pbrData = pbr[eid];
-    let emissionData = emission[eid];
-    let normal = normalize(input.worldNormal);
-    let NdotL = max(dot(normal, -scene.sunDirection.xyz), 0.0);
-
-    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-    let diffuse = scene.sunColor.rgb * NdotL;
-    let diffuseFactor = 1.0 - pbrData.y * 0.9;
-    let lighting = ambient + diffuse * diffuseFactor;
-
-    var output: FragmentOutput;
-    output.color = vec4<f32>(input.color.rgb * lighting + emissionData.rgb * emissionData.a, input.color.a);
-    output.entityId = input.entityId;
-    return output;
-}
-`;
-
-export function createForwardPipeline(
-    device: GPUDevice,
-    format: GPUTextureFormat,
-    shaderCode: string
-): GPURenderPipeline {
-    const module = device.createShaderModule({ code: shaderCode });
-
-    return device.createRenderPipeline({
-        layout: "auto",
-        vertex: {
-            module,
-            entryPoint: "vs",
-            buffers: [
-                {
-                    arrayStride: 24,
-                    attributes: [
-                        { shaderLocation: 0, offset: 0, format: "float32x3" as const },
-                        { shaderLocation: 1, offset: 12, format: "float32x3" as const },
-                    ],
-                },
-            ],
-        },
-        fragment: {
-            module,
-            entryPoint: "fs",
-            targets: [{ format }, { format: ENTITY_ID_FORMAT, writeMask: 0x1 }],
-        },
-        primitive: {
-            topology: "triangle-list",
-            cullMode: "back",
-        },
-        depthStencil: {
-            format: DEPTH_FORMAT,
-            depthWriteEnabled: true,
-            depthCompare: "less",
-        },
-    });
-}
-
-function getOrCreatePipeline(
-    device: GPUDevice,
-    format: GPUTextureFormat,
-    surfaceId: number,
-    pipelineCache: Map<number, GPURenderPipeline>
-): GPURenderPipeline {
-    let pipeline = pipelineCache.get(surfaceId);
-    if (!pipeline) {
-        const data = getSurface(surfaceId) ?? getSurface(SurfaceType.Default)!;
-        const code = compileSurface(data);
-        pipeline = createForwardPipeline(device, format, code);
-        pipelineCache.set(surfaceId, pipeline);
-    }
-    return pipeline;
-}
-
-export const clearColor = { r: 0.1, g: 0.1, b: 0.1, a: 1 };
-
-export interface ForwardConfig {
-    state: State;
-    scene: GPUBuffer;
-    matrices: GPUBuffer;
-    colors: GPUBuffer;
-    sizes: GPUBuffer;
-    shapes: GPUBuffer;
-    pbr: GPUBuffer;
-    emission: GPUBuffer;
-    indirect: GPUBuffer;
-    batches: Map<string, ShapeBatch>;
-}
-
-export function createForwardNode(config: ForwardConfig): ComputeNode {
-    const pipelineCache = new Map<number, GPURenderPipeline>();
-    const bindGroups = new Map<string, GPUBindGroup>();
-
-    return {
-        id: "forward",
-        pass: Pass.Opaque,
-        inputs: [],
-        outputs: [
-            { id: "scene", access: "write" },
-            { id: "depth", access: "write" },
-            { id: "entityId", access: "write" },
-        ],
-
-        execute(ctx: ExecutionContext) {
-            const { device, encoder, format, context } = ctx;
-            const targetView = ctx.getTextureView("scene") ?? ctx.canvasView;
-            const depthView = ctx.getTextureView("depth")!;
-            const entityIdView = ctx.getTextureView("entityId")!;
-            const maskView = ctx.getTextureView("mask")!;
-
-            const passCtx: DrawContext = {
-                device,
-                encoder,
-                format,
-                width: context.canvas.width,
-                height: context.canvas.height,
-                sceneView: targetView,
-                depthView,
-                entityIdView,
-                maskView,
-                canvasView: ctx.canvasView,
-            };
-
-            const beforeOpaques = getDrawsByPass(config.state, Pass.BeforeOpaque);
-            for (const contributor of beforeOpaques) {
-                contributor.execute(passCtx);
-            }
-
-            const pass = encoder.beginRenderPass({
-                colorAttachments: [
-                    {
-                        view: targetView,
-                        clearValue: clearColor,
-                        loadOp: "clear" as const,
-                        storeOp: "store" as const,
-                    },
-                    {
-                        view: entityIdView,
-                        clearValue: { r: 0, g: 0, b: 0, a: 0 },
-                        loadOp: "clear" as const,
-                        storeOp: "store" as const,
-                    },
-                ],
-                depthStencilAttachment: {
-                    view: depthView,
-                    depthClearValue: 1.0,
-                    depthLoadOp: "clear" as const,
-                    depthStoreOp: "store" as const,
-                },
-            });
-
-            let currentSurfaceId = -1;
-            let currentPipeline: GPURenderPipeline | null = null;
-
-            for (const batch of config.batches.values()) {
-                if (batch.count === 0) continue;
-
-                if (batch.surface !== currentSurfaceId) {
-                    currentSurfaceId = batch.surface;
-                    currentPipeline = getOrCreatePipeline(
-                        device,
-                        format,
-                        currentSurfaceId,
-                        pipelineCache
-                    );
-                    pass.setPipeline(currentPipeline);
-                }
-
-                const bindGroupKey = `${batch.index}:${batch.surface}`;
-                let bindGroup = bindGroups.get(bindGroupKey);
-                if (!bindGroup) {
-                    bindGroup = device.createBindGroup({
-                        layout: currentPipeline!.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 } },
-                        ],
-                    });
-                    bindGroups.set(bindGroupKey, bindGroup);
-                }
-
-                pass.setBindGroup(0, bindGroup);
-                pass.setVertexBuffer(0, batch.buffers.vertex);
-                pass.setIndexBuffer(batch.buffers.index, "uint16");
-                pass.drawIndexedIndirect(config.indirect, batch.index * INDIRECT_SIZE);
-            }
-
-            pass.end();
-
-            const afterOpaques = getDrawsByPass(config.state, Pass.AfterOpaque);
-            for (const contributor of afterOpaques) {
-                contributor.execute(passCtx);
-            }
-        },
-    };
-}