@footgun/cobalt 0.9.0 → 0.10.0

package/src/spritesheet/spritesheet.js

@@ -6,7 +6,6 @@ import readSpriteSheet from './read-spritesheet.js'
 
 export default {
     type: 'cobalt:spritesheet',
-    refs: [],
 
     // @params Object cobalt renderer world object
     // @params Object options optional data passed when initing this node

package/src/tile-hdr/atlas.js

@@ -9,7 +9,6 @@ const _buf = new Float32Array(8) //(136)  // tile instance data stored in a UBO
 // shared tile atlas resource, used by each tile render node
 export default {
     type: 'cobalt:tileAtlas',
-    refs: [],
 
     // @params Object cobalt renderer world object
     // @params Object options optional data passed when initing this node

package/src/tile-hdr/tile.js

@@ -15,12 +15,13 @@ Because this processing can happen completely in the fragment shader, there's no
 Inspired by/ported from https://blog.tojicode.com/2012/07/sprite-tile-maps-on-gpu.html
 */
 
+/**
+ * Refs:
+ *   tileAtlas (textureView, rgba8unorm, read) - tile atlas texture
+ *   out (textureView, rgba16float, write) - render target
+ */
 export default {
     type: 'cobalt:tileHDR',
-    refs: [
-        { name: 'tileAtlas', type: 'textureView', format: 'rgba8unorm', access: 'read' },
-        { name: 'hdr', type: 'textureView', format: 'rgba16float', access: 'write' },
-    ],
 
     // @params Object cobalt renderer world object
     // @params Object options optional data passed when initing this node
@@ -174,8 +175,8 @@ function draw(cobalt, nodeData, commandEncoder) {
         label: 'tile',
         colorAttachments: [
             {
-                //    hdr is passsed as a node     ||  FRAME_TEXTURE_VIEW
-                view: nodeData.refs.hdr.data?.view || nodeData.refs.hdr,
+                //    out is passsed as a node     ||  FRAME_TEXTURE_VIEW
+                view: nodeData.refs.out.data?.view || nodeData.refs.out,
                 clearValue: cobalt.clearValue,
                 loadOp,
                 storeOp: 'store',

package/src/light/lights-renderer.js

@@ -1,230 +0,0 @@
-import { LightsBuffer } from "./lights-buffer.js";
-import { LightsTexture } from "./texture/lights-texture.js";
-
-class LightsRenderer {
-    device;
-    ambientLight = [0.2, 0.2, 0.2];
-    targetTexture;
-    renderPipeline;
-    uniformsBufferGpu;
-    bindgroup0;
-    bindgroup1;
-    renderBundle;
-    lightsBuffer;
-    lightsTexture;
-    constructor(params) {
-        this.device = params.device;
-        this.targetTexture = params.targetTexture;
-        this.lightsBuffer = params.lightsBuffer;
-        this.lightsTexture = new LightsTexture(params.device, params.lightsBuffer, params.lightsTextureProperties);
-        this.uniformsBufferGpu = params.device.createBuffer({
-            label: "LightsRenderer uniforms buffer",
-            size: 80,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-        });
-        const shaderModule = params.device.createShaderModule({
-            label: "LightsRenderer shader module",
-            code: `
-struct Uniforms {                  //            align(16) size(80)
-    invertViewMatrix: mat4x4<f32>, // offset(0)  align(16) size(64)
-    ambientLight: vec3<f32>,       // offset(64) align(16) size(12)
-};
-
-${LightsBuffer.structs.definition}
-
-@group(0) @binding(0) var<uniform> uniforms: Uniforms;
-@group(0) @binding(1) var<storage,read> lightsBuffer: LightsBuffer;
-@group(0) @binding(2) var lightsTexture: texture_2d<f32>;
-@group(0) @binding(3) var lightsTextureSampler: sampler;
-
-@group(1) @binding(0) var albedoTexture: texture_2d<f32>;
-@group(1) @binding(1) var albedoSampler: sampler;
-
-struct VertexIn {
-    @builtin(vertex_index) vertexIndex: u32,
-};
-
-struct VertexOut {
-    @builtin(position) position: vec4<f32>,
-    @location(0) worldPosition: vec2<f32>,
-    @location(1) uv: vec2<f32>,
-};
-
-@vertex
-fn main_vertex(in: VertexIn) -> VertexOut {
-    const corners = array<vec2<f32>, 4>(
-        vec2<f32>(-1, -1),
-        vec2<f32>(1, -1),
-        vec2<f32>(-1, 1),
-        vec2<f32>(1, 1),
-    );
-    let screenPosition = corners[in.vertexIndex];
-
-    var out: VertexOut;
-    out.position = vec4<f32>(screenPosition, 0.0, 1.0);
-    out.worldPosition = (uniforms.invertViewMatrix * out.position).xy;
-    out.uv = 0.5 + 0.5 * screenPosition * vec2<f32>(1.0, -1.0);
-    return out;
-}
-
-struct FragmentOut {
-    @location(0) color: vec4<f32>,
-};
-
-const cellsGridSizeU = vec2<u32>(${this.lightsTexture.gridSize.x}, ${this.lightsTexture.gridSize.y});
-const cellsGridSizeF = vec2<f32>(${this.lightsTexture.gridSize.x}, ${this.lightsTexture.gridSize.y});
-
-fn sampleLightBaseIntensity(lightId: u32, localUv: vec2<f32>) -> f32 {
-    let cellIndex = lightId / 4u;
-    let indexInCell = lightId % 4u;
-
-    let cellIdU = vec2<u32>(
-        cellIndex % cellsGridSizeU.x,
-        cellIndex / cellsGridSizeU.x,
-    );
-    let cellIdF = vec2<f32>(cellIdU);
-    let uv = (cellIdF + localUv) / cellsGridSizeF;
-    let uvYInverted = vec2<f32>(uv.x, 1.0 - uv.y);
-    let sample = textureSampleLevel(lightsTexture, lightsTextureSampler, uvYInverted, 0.0);
-    let channel = vec4<f32>(
-        vec4<u32>(indexInCell) == vec4<u32>(0u, 1u, 2u, 3u),
-    );
-    return dot(sample, channel);
-}
-    
-fn compute_lights(worldPosition: vec2<f32>) -> vec3<f32> {
-    var color = vec3<f32>(uniforms.ambientLight);
-
-    const maxUvDistance = f32(${1 - 2 / params.lightsTextureProperties.resolutionPerLight});
-
-    let lightsCount = lightsBuffer.count;
-    for (var iLight = 0u; iLight < lightsCount; iLight++) {
-        let light = lightsBuffer.lights[iLight];
-        let lightSize = f32(${params.lightsTextureProperties.resolutionPerLight});
-        let relativePosition = (worldPosition - light.position) / lightSize;
-        if (max(abs(relativePosition.x), abs(relativePosition.y)) < maxUvDistance) {
-            let localUv = 0.5 + 0.5 * relativePosition;    
-            let lightIntensity = light.intensity * sampleLightBaseIntensity(iLight, localUv);
-            color += lightIntensity * light.color;
-        }
-    }
-
-    return color;
-}
-
-@fragment
-fn main_fragment(in: VertexOut) -> FragmentOut {
-    let light = compute_lights(in.worldPosition);
-    let albedo = textureSample(albedoTexture, albedoSampler, in.uv);
-    let color = albedo.rgb * light;
-
-    var out: FragmentOut;
-    out.color = vec4<f32>(color, 1.0);
-    return out;
-}
-            `,
-        });
-        this.renderPipeline = params.device.createRenderPipeline({
-            label: "LightsRenderer renderpipeline",
-            layout: "auto",
-            vertex: {
-                module: shaderModule,
-                entryPoint: "main_vertex",
-            },
-            fragment: {
-                module: shaderModule,
-                entryPoint: "main_fragment",
-                targets: [{
-                        format: this.targetTexture.format,
-                    }],
-            },
-            primitive: {
-                cullMode: "none",
-                topology: "triangle-strip",
-            },
-        });
-        const bindgroupLayout = this.renderPipeline.getBindGroupLayout(0);
-        this.bindgroup0 = params.device.createBindGroup({
-            label: "LightsRenderer bindgroup 0",
-            layout: bindgroupLayout,
-            entries: [
-                {
-                    binding: 0,
-                    resource: { buffer: this.uniformsBufferGpu },
-                },
-                {
-                    binding: 1,
-                    resource: { buffer: this.lightsBuffer.gpuBuffer },
-                },
-                {
-                    binding: 2,
-                    resource: this.lightsTexture.texture.createView({ label: "LightsRenderer lightsTexture view" }),
-                },
-                {
-                    binding: 3,
-                    resource: params.device.createSampler({
-                        label: "LightsRenderer sampler",
-                        addressModeU: "clamp-to-edge",
-                        addressModeV: "clamp-to-edge",
-                        magFilter: params.lightsTextureProperties.filtering,
-                        minFilter: params.lightsTextureProperties.filtering,
-                    }),
-                },
-            ]
-        });
-        this.bindgroup1 = this.buildBindgroup1(params.albedo);
-        this.renderBundle = this.buildRenderBundle();
-    }
-    computeLightsTexture(commandEncoder) {
-        this.lightsTexture.update(commandEncoder);
-    }
-    render(renderpassEncoder, invertVpMatrix) {
-        const uniformsBufferCpu = new ArrayBuffer(80);
-        new Float32Array(uniformsBufferCpu, 0, 16).set(invertVpMatrix);
-        new Float32Array(uniformsBufferCpu, 64, 3).set(this.ambientLight);
-        this.device.queue.writeBuffer(this.uniformsBufferGpu, 0, uniformsBufferCpu);
-        renderpassEncoder.executeBundles([this.renderBundle]);
-    }
-    setAlbedo(albedo) {
-        this.bindgroup1 = this.buildBindgroup1(albedo);
-        this.renderBundle = this.buildRenderBundle();
-    }
-    setAmbientLight(color) {
-        this.ambientLight = [...color];
-    }
-    setObstacles(segments) {
-        this.lightsTexture.setObstacles(segments);
-    }
-    destroy() {
-        this.uniformsBufferGpu.destroy();
-        this.lightsTexture.destroy();
-    }
-    buildBindgroup1(albedo) {
-        return this.device.createBindGroup({
-            label: "LightsRenderer bindgroup 1",
-            layout: this.renderPipeline.getBindGroupLayout(1),
-            entries: [
-                {
-                    binding: 0,
-                    resource: albedo.view,
-                },
-                {
-                    binding: 1,
-                    resource: albedo.sampler,
-                },
-            ]
-        });
-    }
-    buildRenderBundle() {
-        const renderBundleEncoder = this.device.createRenderBundleEncoder({
-            label: "LightsRenderer renderbundle encoder",
-            colorFormats: [this.targetTexture.format],
-        });
-        renderBundleEncoder.setPipeline(this.renderPipeline);
-        renderBundleEncoder.setBindGroup(0, this.bindgroup0);
-        renderBundleEncoder.setBindGroup(1, this.bindgroup1);
-        renderBundleEncoder.draw(4);
-        return renderBundleEncoder.finish({ label: "LightsRenderer renderbundle" });
-    }
-}
-export { LightsRenderer };

package/src/light/texture/lights-texture-initializer.js

@@ -1,175 +0,0 @@
-import { LightsBuffer } from "../lights-buffer.js";
-
-class LightsTextureInitializer {
-    lightsBuffer;
-    renderPipeline;
-    bindgroup;
-    renderBundle;
-    constructor(device, lightsBuffer, lightsTexture, maxLightSize) {
-        this.lightsBuffer = lightsBuffer;
-        const shaderModule = device.createShaderModule({
-            label: "LightsTextureInitializer shader module",
-            code: `
-${LightsBuffer.structs.definition}
-
-@group(0) @binding(0) var<storage,read> lightsBuffer: LightsBuffer;
-
-struct VertexIn {
-    @builtin(vertex_index) vertexIndex: u32,
-};
-
-struct VertexOut {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-};
-
-const cellsGridSizeU = vec2<u32>(${lightsTexture.gridSize.x}, ${lightsTexture.gridSize.y});
-const cellsGridSizeF = vec2<f32>(${lightsTexture.gridSize.x}, ${lightsTexture.gridSize.y});
-
-@vertex
-fn main_vertex(in: VertexIn) -> VertexOut {
-    const corners = array<vec2<f32>, 4>(
-        vec2<f32>(-1, -1),
-        vec2<f32>(1, -1),
-        vec2<f32>(-1, 1),
-        vec2<f32>(1, 1),
-    );
-    let screenPosition = corners[in.vertexIndex];
-
-    var out: VertexOut;
-    out.position = vec4<f32>(screenPosition, 0.0, 1.0);
-    out.uv = (0.5 + 0.5 * screenPosition) * cellsGridSizeF;
-    return out;
-}
-
-struct FragmentOut {
-    @location(0) color: vec4<f32>,
-};
-
-struct LightProperties {
-    radius: f32,
-    intensity: f32,
-    attenuationLinear: f32,
-    attenuationExp: f32,
-};
-
-fn get_light_properties(lightId: u32) -> LightProperties {
-    var lightProperties: LightProperties;
-    if (lightId < lightsBuffer.count) {
-        let light = lightsBuffer.lights[lightId];
-        lightProperties.radius = light.radius;
-        lightProperties.intensity = 1.0;
-        lightProperties.attenuationLinear = light.attenuationLinear;
-        lightProperties.attenuationExp = light.attenuationExp;
-    } else {
-        lightProperties.radius = 0.0;
-        lightProperties.intensity = 0.0;
-        lightProperties.attenuationLinear = 0.0;
-        lightProperties.attenuationExp = 0.0;
-    }
-    return lightProperties;
-}
-
-@fragment
-fn main_fragment(in: VertexOut) -> FragmentOut {
-    let cellId = vec2<u32>(in.uv);
-
-    let lightIdFrom = 4u * (cellId.x + cellId.y * cellsGridSizeU.x);
-    let lightProperties = array<LightProperties, 4>(
-        get_light_properties(lightIdFrom + 0u),
-        get_light_properties(lightIdFrom + 1u),
-        get_light_properties(lightIdFrom + 2u),
-        get_light_properties(lightIdFrom + 3u),
-    );
-
-    let sizes = vec4<f32>(
-        lightProperties[0].radius,
-        lightProperties[1].radius,
-        lightProperties[2].radius,
-        lightProperties[3].radius,
-    );
-
-    let localUv = fract(in.uv);
-    let fromCenter = 2.0 * localUv - 1.0;
-    let uvDistanceFromCenter = distance(vec2<f32>(0,0), fromCenter);
-    let distancesFromCenter = vec4<f32>(uvDistanceFromCenter / sizes * f32(${maxLightSize}));
-
-    let intensities = vec4<f32>(
-        lightProperties[0].intensity * (1.0 + 1.0 * step(uvDistanceFromCenter, 0.01)),
-        lightProperties[1].intensity * (1.0 + 1.0 * step(uvDistanceFromCenter, 0.01)),
-        lightProperties[2].intensity * (1.0 + 1.0 * step(uvDistanceFromCenter, 0.01)),
-        lightProperties[3].intensity * (1.0 + 1.0 * step(uvDistanceFromCenter, 0.01)),
-    );
-    let attenuationsLinear = vec4<f32>(
-        lightProperties[0].attenuationLinear,
-        lightProperties[1].attenuationLinear,
-        lightProperties[2].attenuationLinear,
-        lightProperties[3].attenuationLinear,
-    );
-    let attenuationsExp = vec4<f32>(
-        lightProperties[0].attenuationExp,
-        lightProperties[1].attenuationExp,
-        lightProperties[2].attenuationExp,
-        lightProperties[3].attenuationExp,
-    );
-
-    var lightIntensities = intensities / (1.0 + distancesFromCenter * (attenuationsLinear + distancesFromCenter * attenuationsExp)); // base intensity equation
-    lightIntensities *= cos(distancesFromCenter * ${Math.PI / 2}); // soft limit;
-    lightIntensities *= step(distancesFromCenter, vec4<f32>(1.0)); // hard limit
-
-    var out: FragmentOut;
-    out.color = lightIntensities;
-    return out;
-}
-            `,
-        });
-        this.renderPipeline = device.createRenderPipeline({
-            label: "LightsTextureInitializer renderpipeline",
-            layout: "auto",
-            vertex: {
-                module: shaderModule,
-                entryPoint: "main_vertex",
-            },
-            fragment: {
-                module: shaderModule,
-                entryPoint: "main_fragment",
-                targets: [{
-                        format: lightsTexture.format,
-                    }],
-            },
-            primitive: {
-                cullMode: "none",
-                topology: "triangle-strip",
-            },
-            multisample: {
-                count: lightsTexture.sampleCount,
-            },
-        });
-        this.bindgroup = device.createBindGroup({
-            label: "LightsTextureInitializer bindgroup 0",
-            layout: this.renderPipeline.getBindGroupLayout(0),
-            entries: [
-                {
-                    binding: 0,
-                    resource: { buffer: this.lightsBuffer.gpuBuffer },
-                },
-            ]
-        });
-        const renderBundleEncoder = device.createRenderBundleEncoder({
-            label: "LightsTextureInitializer renderbundle encoder",
-            colorFormats: [lightsTexture.format],
-            sampleCount: lightsTexture.sampleCount,
-        });
-        renderBundleEncoder.setPipeline(this.renderPipeline);
-        renderBundleEncoder.setBindGroup(0, this.bindgroup);
-        renderBundleEncoder.draw(4);
-        this.renderBundle = renderBundleEncoder.finish({ label: "LightsTextureInitializer renderbundle" });
-    }
-    getRenderBundle() {
-        return this.renderBundle;
-    }
-    destroy() {
-        // nothing to do
-    }
-}
-export { LightsTextureInitializer };

package/src/light/texture/lights-texture.js

@@ -1,85 +0,0 @@
-import { LightsTextureInitializer } from "./lights-texture-initializer.js";
-import { LightsTextureMask } from "./lights-texture-mask.js";
-
-class LightsTexture {
-    lightsBuffer;
-    texture;
-    gridSize;
-    textureMultisampled = null;
-    textureRenderpassDescriptor;
-    textureInitializer;
-    textureMask;
-    constructor(device, lightsBuffer, lightsTextureProperties) {
-        this.lightsBuffer = lightsBuffer;
-        const cellsCount = this.lightsBuffer.maxLightsCount / 4;
-        const gridSize = {
-            x: Math.ceil(Math.sqrt(cellsCount)),
-            y: 0,
-        };
-        gridSize.y = Math.ceil(cellsCount / gridSize.x);
-        this.gridSize = gridSize;
-        const lightTextureSize = {
-            width: gridSize.x * lightsTextureProperties.resolutionPerLight,
-            height: gridSize.y * lightsTextureProperties.resolutionPerLight,
-        };
-        const format = lightsTextureProperties.textureFormat;
-        this.texture = device.createTexture({
-            label: "LightsTextureMask texture",
-            size: [lightTextureSize.width, lightTextureSize.height],
-            format,
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
-        });
-        if (lightsTextureProperties.antialiased) {
-            this.textureMultisampled = device.createTexture({
-                label: "LightsTextureMask texture multisampled",
-                size: [lightTextureSize.width, lightTextureSize.height],
-                format,
-                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
-                sampleCount: 4,
-            });
-        }
-        const textureToRenderTo = this.textureMultisampled ?? this.texture;
-        const textureRenderpassColorAttachment = {
-            view: textureToRenderTo.createView(),
-            clearValue: [0, 0, 0, 1],
-            loadOp: "load",
-            storeOp: "store",
-        };
-        if (lightsTextureProperties.antialiased) {
-            textureRenderpassColorAttachment.resolveTarget = this.texture.createView();
-        }
-        this.textureRenderpassDescriptor = {
-            label: "lights-renderer render to texture renderpass",
-            colorAttachments: [textureRenderpassColorAttachment],
-        };
-        const lightsTexture = {
-            gridSize,
-            format,
-            sampleCount: this.textureMultisampled?.sampleCount ?? 1,
-        };
-        this.textureInitializer = new LightsTextureInitializer(device, lightsBuffer, lightsTexture, lightsTextureProperties.maxLightSize);
-        this.textureMask = new LightsTextureMask(device, lightsBuffer, lightsTexture, lightsTextureProperties.maxLightSize);
-    }
-    update(commandEncoder) {
-        this.textureMask.setLightsCount(this.lightsBuffer.lightsCount);
-        const renderpassEncoder = commandEncoder.beginRenderPass(this.textureRenderpassDescriptor);
-        const [textureWidth, textureHeight] = [this.texture.width, this.texture.height];
-        renderpassEncoder.setViewport(0, 0, textureWidth, textureHeight, 0, 1);
-        renderpassEncoder.setScissorRect(0, 0, textureWidth, textureHeight);
-        renderpassEncoder.executeBundles([
-            this.textureInitializer.getRenderBundle(),
-            this.textureMask.getRenderBundle(),
-        ]);
-        renderpassEncoder.end();
-    }
-    setObstacles(segments) {
-        this.textureMask.setObstacles(segments);
-    }
-    destroy() {
-        this.texture.destroy();
-        this.textureMultisampled?.destroy();
-        this.textureInitializer.destroy();
-        this.textureMask.destroy();
-    }
-}
-export { LightsTexture };

package/src/light/viewport.js

@@ -1,40 +0,0 @@
-import * as wgpuMatrix from "wgpu-matrix";
-
-class Viewport {
-    invViewProjectionMatrix = wgpuMatrix.mat4.identity();
-    viewportSize = { width: 1, height: 1 };
-    topLeft = [0, 0];
-    zoom = 1;
-    constructor(params) {
-        this.setViewportSize(params.viewportSize.width, params.viewportSize.height);
-        const initialTopLeft = params.center ?? this.topLeft;
-        this.setTopLeft(...initialTopLeft);
-        const initialZoom = params.zoom ?? 1;
-        this.setZoom(initialZoom);
-    }
-    get invertViewProjectionMatrix() {
-        return this.invViewProjectionMatrix;
-    }
-    setViewportSize(width, height) {
-        this.viewportSize.width = width;
-        this.viewportSize.height = height;
-        this.updateMatrices();
-    }
-    setTopLeft(x, y) {
-        this.topLeft[0] = x;
-        this.topLeft[1] = y;
-        this.updateMatrices();
-    }
-    setZoom(zoom) {
-        this.zoom = zoom;
-        this.updateMatrices();
-    }
-    updateMatrices() {
-        wgpuMatrix.mat4.identity(this.invViewProjectionMatrix);
-        wgpuMatrix.mat4.multiply(wgpuMatrix.mat4.scaling([1, -1, 0]), this.invViewProjectionMatrix, this.invViewProjectionMatrix);
-        wgpuMatrix.mat4.multiply(wgpuMatrix.mat4.translation([1, 1, 0]), this.invViewProjectionMatrix, this.invViewProjectionMatrix);
-        wgpuMatrix.mat4.multiply(wgpuMatrix.mat4.scaling([0.5 * this.viewportSize.width / this.zoom, 0.5 * this.viewportSize.height / this.zoom, 0]), this.invViewProjectionMatrix, this.invViewProjectionMatrix);
-        wgpuMatrix.mat4.multiply(wgpuMatrix.mat4.translation([this.topLeft[0], this.topLeft[1], 0]), this.invViewProjectionMatrix, this.invViewProjectionMatrix);
-    }
-}
-export { Viewport };