@multiplekex/shallot 0.2.5 → 0.3.0

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

@@ -1,315 +0,0 @@
-import { MAX_ENTITIES } from "../../../core";
-import { setTraits, createFieldProxy, type FieldProxy } from "../../../core/component";
-import { createEntityIdBuffer } from "../../compute";
-import { writeIndirect } from "../indirect";
-import { createBox } from "./box";
-import { createSphere } from "./sphere";
-import { createPlane } from "./plane";
-
-export const MAX_SURFACES = 16;
-export const MAX_BATCH_SLOTS = 256;
-const INVALID_SHAPE = 0xffffffff;
-
-const batchEntityIds = new Uint32Array(MAX_ENTITIES);
-
-export interface MeshData {
-    vertices: Float32Array<ArrayBuffer>;
-    indices: Uint16Array<ArrayBuffer>;
-    vertexCount: number;
-    indexCount: number;
-}
-
-const meshes: MeshData[] = [];
-
-function initBuiltIns(): void {
-    if (meshes.length === 0) {
-        meshes.push(createBox());
-        meshes.push(createSphere());
-        meshes.push(createPlane());
-    }
-}
-
-initBuiltIns();
-
-export const MeshShape = {
-    Box: 0,
-    Sphere: 1,
-    Plane: 2,
-} as const;
-
-export function mesh(data: MeshData): number {
-    const id = meshes.length;
-    meshes.push(data);
-    return id;
-}
-
-export function getMesh(id: number): MeshData | undefined {
-    return meshes[id];
-}
-
-export function clearMeshes(): void {
-    meshes.length = 0;
-    initBuiltIns();
-}
-
-export const MeshShapes = {
-    data: new Uint32Array(MAX_ENTITIES).fill(INVALID_SHAPE),
-};
-
-export const MeshColors = {
-    data: new Float32Array(MAX_ENTITIES * 4),
-};
-
-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),
-};
-
-export const MeshVolumes = {
-    data: new Uint8Array(MAX_ENTITIES),
-};
-
-export const Volume = {
-    Solid: 0,
-    HalfSpace: 1,
-} as const;
-
-function hexColorProxy(data: Float32Array): FieldProxy {
-    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 FieldProxy, {
-        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 roughnessProxy(): FieldProxy {
-    const data = MeshPBR.data;
-
-    function getValue(eid: number): number {
-        const val = data[eid * 4];
-        return val === 0 ? 0.9 : val;
-    }
-
-    function setValue(eid: number, value: number): void {
-        data[eid * 4] = value;
-    }
-
-    return new Proxy([] as unknown as FieldProxy, {
-        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: Uint32Array;
-    color: FieldProxy;
-    colorR: FieldProxy;
-    colorG: FieldProxy;
-    colorB: FieldProxy;
-    opacity: FieldProxy;
-    sizeX: FieldProxy;
-    sizeY: FieldProxy;
-    sizeZ: FieldProxy;
-    roughness: FieldProxy;
-    metallic: FieldProxy;
-    ior: FieldProxy;
-    emission: FieldProxy;
-    emissionIntensity: FieldProxy;
-    volume: Uint8Array;
-} = {
-    shape: MeshShapes.data,
-    color: hexColorProxy(MeshColors.data),
-    colorR: createFieldProxy(MeshColors.data, 4, 0),
-    colorG: createFieldProxy(MeshColors.data, 4, 1),
-    colorB: createFieldProxy(MeshColors.data, 4, 2),
-    opacity: createFieldProxy(MeshColors.data, 4, 3),
-    sizeX: createFieldProxy(MeshSizes.data, 4, 0),
-    sizeY: createFieldProxy(MeshSizes.data, 4, 1),
-    sizeZ: createFieldProxy(MeshSizes.data, 4, 2),
-    roughness: roughnessProxy(),
-    metallic: createFieldProxy(MeshPBR.data, 4, 1),
-    ior: createFieldProxy(MeshPBR.data, 4, 2),
-    emission: hexColorProxy(MeshEmission.data),
-    emissionIntensity: createFieldProxy(MeshEmission.data, 4, 3),
-    volume: MeshVolumes.data,
-};
-
-setTraits(Mesh, {
-    defaults: () => ({
-        shape: MeshShape.Box,
-        color: 0xffffff,
-        opacity: 1.0,
-        sizeX: 1,
-        sizeY: 1,
-        sizeZ: 1,
-        roughness: 1.0,
-        metallic: 0.0,
-        ior: 1.0,
-        emission: 0x000000,
-        emissionIntensity: 0.0,
-        volume: Volume.Solid,
-    }),
-});
-
-export interface MeshBuffers {
-    vertex: GPUBuffer;
-    index: GPUBuffer;
-    indexCount: number;
-}
-
-export function createMeshBuffers(device: GPUDevice, mesh: MeshData): MeshBuffers {
-    const vertex = device.createBuffer({
-        label: "vertex",
-        size: mesh.vertices.byteLength,
-        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(vertex, 0, mesh.vertices);
-
-    const index = device.createBuffer({
-        label: "index",
-        size: mesh.indices.byteLength,
-        usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(index, 0, mesh.indices);
-
-    return { vertex, index, indexCount: mesh.indexCount };
-}
-
-export type BatchEntities = (number[] | null)[];
-
-export function collectBatches(
-    entities: Iterable<number>,
-    getSurface: (eid: number) => number,
-    out: BatchEntities
-): void {
-    for (let i = 0; i < MAX_BATCH_SLOTS; i++) {
-        if (out[i]) out[i]!.length = 0;
-    }
-    for (const eid of entities) {
-        const shape = Mesh.shape[eid];
-        const surface = getSurface(eid);
-        const batchIndex = shape * MAX_SURFACES + surface;
-        if (batchIndex >= MAX_BATCH_SLOTS) continue;
-        let entry = out[batchIndex];
-        if (!entry) {
-            entry = [];
-            out[batchIndex] = entry;
-        }
-        entry.push(eid);
-    }
-}
-
-export interface Batch {
-    buffers: MeshBuffers;
-    entityIds: GPUBuffer;
-    count: number;
-}
-
-export interface BatchState {
-    batches: (Batch | null)[];
-    buffers: Map<number, MeshBuffers>;
-}
-
-export function updateBatches(
-    device: GPUDevice,
-    batchEntities: BatchEntities,
-    state: BatchState,
-    indirect: GPUBuffer
-): void {
-    for (let batchIndex = 0; batchIndex < MAX_BATCH_SLOTS; batchIndex++) {
-        const entities = batchEntities[batchIndex];
-        if (!entities || entities.length === 0) {
-            const batch = state.batches[batchIndex];
-            if (batch) {
-                batch.count = 0;
-                writeIndirect(device, indirect, batchIndex, {
-                    indexCount: 0,
-                    instanceCount: 0,
-                    firstIndex: 0,
-                    baseVertex: 0,
-                    firstInstance: 0,
-                });
-            }
-            continue;
-        }
-
-        let batch = state.batches[batchIndex];
-        if (!batch) {
-            const shape = Math.floor(batchIndex / MAX_SURFACES);
-            let buffers = state.buffers.get(shape);
-            if (!buffers) {
-                const data = getMesh(shape) ?? getMesh(MeshShape.Box)!;
-                buffers = createMeshBuffers(device, data);
-                state.buffers.set(shape, buffers);
-            }
-            batch = {
-                buffers,
-                entityIds: createEntityIdBuffer(device, MAX_ENTITIES),
-                count: 0,
-            };
-            state.batches[batchIndex] = batch;
-        }
-
-        for (let i = 0; i < entities.length; i++) {
-            batchEntityIds[i] = entities[i];
-        }
-        device.queue.writeBuffer(batch.entityIds, 0, batchEntityIds, 0, entities.length);
-        batch.count = entities.length;
-
-        writeIndirect(device, indirect, batchIndex, {
-            indexCount: batch.buffers.indexCount,
-            instanceCount: entities.length,
-            firstIndex: 0,
-            baseVertex: 0,
-            firstInstance: 0,
-        });
-    }
-}
-
-export { createBox } from "./box";
-export { createSphere } from "./sphere";
-export { createPlane } from "./plane";
-export { createShapeAtlas } from "./unified";

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

@@ -1,11 +0,0 @@
-import type { MeshData } from "./index";
-
-export function createPlane(): MeshData {
-    const vertices = new Float32Array([
-        -0.5, 0, 0.5, 0, 1, 0, 0.5, 0, 0.5, 0, 1, 0, 0.5, 0, -0.5, 0, 1, 0, -0.5, 0, -0.5, 0, 1, 0,
-    ]);
-
-    const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
-
-    return { vertices, indices, vertexCount: 4, indexCount: 6 };
-}

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

@@ -1,40 +0,0 @@
-import type { MeshData } from "./index";
-
-export function createSphere(segments = 32, rings = 16): MeshData {
-    const vertices: number[] = [];
-    const indices: number[] = [];
-    const radius = 0.5;
-
-    for (let y = 0; y <= rings; y++) {
-        const v = y / rings;
-        const theta = v * Math.PI;
-
-        for (let x = 0; x <= segments; x++) {
-            const u = x / segments;
-            const phi = u * Math.PI * 2;
-
-            const nx = Math.sin(theta) * Math.cos(phi);
-            const ny = Math.cos(theta);
-            const nz = Math.sin(theta) * Math.sin(phi);
-
-            vertices.push(nx * radius, ny * radius, nz * radius, nx, ny, nz);
-        }
-    }
-
-    for (let y = 0; y < rings; y++) {
-        for (let x = 0; x < segments; x++) {
-            const a = y * (segments + 1) + x;
-            const b = a + segments + 1;
-
-            indices.push(a, a + 1, b);
-            indices.push(a + 1, b + 1, b);
-        }
-    }
-
-    return {
-        vertices: new Float32Array(vertices),
-        indices: new Uint16Array(indices),
-        vertexCount: (rings + 1) * (segments + 1),
-        indexCount: rings * segments * 6,
-    };
-}

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

@@ -1,96 +0,0 @@
-import { getMesh } from ".";
-
-export interface ShapeMeta {
-    vertexOffset: number;
-    indexOffset: number;
-    triCount: number;
-    _pad: number;
-}
-
-export interface ShapeAtlas {
-    vertices: GPUBuffer;
-    indices: GPUBuffer;
-    meta: GPUBuffer;
-    shapeCount: number;
-    maxTriangles: number;
-}
-
-const MAX_SHAPES = 16;
-
-export function createShapeAtlas(device: GPUDevice): ShapeAtlas {
-    const allVertices: number[] = [];
-    const allIndices: number[] = [];
-    const shapeMetas: ShapeMeta[] = [];
-
-    let vertexOffset = 0;
-    let indexOffset = 0;
-    let maxTriangles = 0;
-
-    for (let shapeId = 0; shapeId < MAX_SHAPES; shapeId++) {
-        const mesh = getMesh(shapeId);
-        if (!mesh) {
-            shapeMetas.push({ vertexOffset: 0, indexOffset: 0, triCount: 0, _pad: 0 });
-            continue;
-        }
-
-        const triCount = mesh.indexCount / 3;
-        shapeMetas.push({
-            vertexOffset,
-            indexOffset,
-            triCount,
-            _pad: 0,
-        });
-
-        for (let i = 0; i < mesh.vertices.length; i++) {
-            allVertices.push(mesh.vertices[i]);
-        }
-
-        for (let i = 0; i < mesh.indices.length; i++) {
-            allIndices.push(mesh.indices[i]);
-        }
-
-        vertexOffset += mesh.vertices.length;
-        indexOffset += mesh.indices.length;
-        maxTriangles += triCount;
-    }
-
-    const verticesData = new Float32Array(allVertices);
-    const indicesData = new Uint32Array(allIndices);
-    const metaData = new Uint32Array(MAX_SHAPES * 4);
-
-    for (let i = 0; i < shapeMetas.length; i++) {
-        metaData[i * 4] = shapeMetas[i].vertexOffset;
-        metaData[i * 4 + 1] = shapeMetas[i].indexOffset;
-        metaData[i * 4 + 2] = shapeMetas[i].triCount;
-        metaData[i * 4 + 3] = 0;
-    }
-
-    const vertices = device.createBuffer({
-        label: "unified-vertices",
-        size: Math.max(verticesData.byteLength, 16),
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(vertices, 0, verticesData);
-
-    const indices = device.createBuffer({
-        label: "unified-indices",
-        size: Math.max(indicesData.byteLength, 16),
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(indices, 0, indicesData);
-
-    const meta = device.createBuffer({
-        label: "unified-meta",
-        size: metaData.byteLength,
-        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(meta, 0, metaData);
-
-    return {
-        vertices,
-        indices,
-        meta,
-        shapeCount: shapeMetas.filter((m) => m.triCount > 0).length,
-        maxTriangles,
-    };
-}

package/src/standard/render/surface/compile.ts

@@ -1,65 +0,0 @@
-import { WGSL_STRUCTS } from "./structs";
-import type { SurfaceData } from "./index";
-import { compileVertexBody, WGSL_LIGHTING_CALC } from "./shaders";
-
-export function compileSurface(data: SurfaceData): string {
-    const vertexTransform = compileVertexBody(data.vertex);
-
-    const fragmentBody = data.fragment ?? "";
-
-    return /* wgsl */ `
-${WGSL_STRUCTS}
-
-fn userVertexTransform(worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    ${vertexTransform}
-}
-
-fn userFragment(surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    ${fragmentBody}
-}
-
-@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 finalWorldPos = userVertexTransform(baseWorldPos, worldNormal, eid);
-
-    var output: VertexOutput;
-    output.position = scene.viewProj * vec4<f32>(finalWorldPos, 1.0);
-    output.color = data[eid].baseColor;
-    output.worldNormal = worldNormal;
-    output.entityId = eid;
-    output.worldPos = finalWorldPos;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> FragmentOutput {
-    let eid = input.entityId;
-    let d = data[eid];
-
-    var surface: SurfaceData;
-    surface.baseColor = input.color.rgb;
-    surface.roughness = d.pbr.x;
-    surface.metallic = d.pbr.y;
-    surface.emission = d.emission.rgb * d.emission.a;
-    surface.normal = normalize(input.worldNormal);
-    surface.worldPos = input.worldPos;
-
-    userFragment(&surface, input.position);
-
-    var output: FragmentOutput;
-${
-    data.lit === false
-        ? `    output.color = vec4<f32>(surface.baseColor, input.color.a);`
-        : `    ${WGSL_LIGHTING_CALC}
-    output.color = vec4<f32>(surface.baseColor * lighting + surface.emission, input.color.a);`
-}
-    output.entityId = input.entityId;
-    return output;
-}
-`;
-}

package/src/standard/render/surface/noise.ts

@@ -1,58 +0,0 @@
-export const NOISE_WGSL = /* wgsl */ `
-fn hash2(p: vec2<f32>) -> f32 {
-    var p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
-    p3 += dot(p3, p3.yzx + 33.33);
-    return fract((p3.x + p3.y) * p3.z);
-}
-
-fn value2d(p: vec2f, seed: vec2f) -> f32 {
-    let i = floor(p);
-    let f = fract(p);
-    let u = f * f * (3.0 - 2.0 * f);
-    return mix(
-        mix(fract(sin(dot(i, seed)) * 43758.5) * 2.0 - 1.0,
-            fract(sin(dot(i + vec2(1.0, 0.0), seed)) * 43758.5) * 2.0 - 1.0, u.x),
-        mix(fract(sin(dot(i + vec2(0.0, 1.0), seed)) * 43758.5) * 2.0 - 1.0,
-            fract(sin(dot(i + vec2(1.0, 1.0), seed)) * 43758.5) * 2.0 - 1.0, u.x), u.y);
-}
-
-fn simplex2(p: vec2<f32>) -> f32 {
-    let K1 = 0.366025404;
-    let K2 = 0.211324865;
-
-    let i = floor(p + (p.x + p.y) * K1);
-    let a = p - i + (i.x + i.y) * K2;
-
-    let o = select(vec2(0.0, 1.0), vec2(1.0, 0.0), a.x > a.y);
-    let b = a - o + K2;
-    let c = a - 1.0 + 2.0 * K2;
-
-    let h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), vec3(0.0));
-    let h4 = h * h * h * h;
-
-    let n = vec3(
-        dot(a, vec2(hash2(i) * 2.0 - 1.0, hash2(i + vec2(0.0, 1.0)) * 2.0 - 1.0)),
-        dot(b, vec2(hash2(i + o) * 2.0 - 1.0, hash2(i + o + vec2(0.0, 1.0)) * 2.0 - 1.0)),
-        dot(c, vec2(hash2(i + 1.0) * 2.0 - 1.0, hash2(i + vec2(1.0, 2.0)) * 2.0 - 1.0))
-    );
-
-    return dot(h4, n) * 70.0;
-}
-
-const FBM2_OCTAVES = 5;
-
-fn fbm2(p: vec2<f32>) -> f32 {
-    var value = 0.0;
-    var amplitude = 0.5;
-    var frequency = 1.0;
-    var pos = p;
-
-    for (var i = 0; i < FBM2_OCTAVES; i++) {
-        value += amplitude * simplex2(pos * frequency);
-        amplitude *= 0.5;
-        frequency *= 2.0;
-    }
-
-    return value;
-}
-`;