@footgun/cobalt 0.8.0 → 0.8.1

package/src/light/{lights-renderer.ts → lights-renderer.js}

@@ -1,57 +1,27 @@
-/// <reference types="@webgpu/types"/>
-
-import * as wgpuMatrix from "wgpu-matrix";
-import { LightsBuffer } from "./lights-buffer";
-import { LightsTexture, type LightsTextureProperties } from "./texture/lights-texture";
-import { type LightObstacleSegment } from "./texture/lights-texture-mask";
-
-type TextureSamplable = {
-    readonly view: GPUTextureView;
-    readonly sampler: GPUSampler;
-};
-
-type TextureRenderable = {
-    readonly format: GPUTextureFormat;
-};
-
-type Parameters = {
-    readonly device: GPUDevice;
-    readonly albedo: TextureSamplable;
-    readonly targetTexture: TextureRenderable;
-    readonly lightsBuffer: LightsBuffer;
-    readonly lightsTextureProperties: LightsTextureProperties;
-};
+import { LightsBuffer } from "./lights-buffer.js";
+import { LightsTexture } from "./texture/lights-texture.js";
 
 class LightsRenderer {
-    private readonly device: GPUDevice;
-
-    private ambientLight: [number, number, number] = [0.2, 0.2, 0.2];
-
-    private readonly targetTexture: TextureRenderable;
-
-    private readonly renderPipeline: GPURenderPipeline;
-    private readonly uniformsBufferGpu: GPUBuffer;
-    private readonly bindgroup0: GPUBindGroup;
-    private bindgroup1: GPUBindGroup;
-    private renderBundle: GPURenderBundle;
-
-    private readonly lightsBuffer: LightsBuffer;
-    private readonly lightsTexture: LightsTexture;
-
-    public constructor(params: Parameters) {
+    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: `
@@ -154,7 +124,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
 }
             `,
         });
-
         this.renderPipeline = params.device.createRenderPipeline({
             label: "LightsRenderer renderpipeline",
             layout: "auto",
@@ -166,17 +135,15 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 module: shaderModule,
                 entryPoint: "main_fragment",
                 targets: [{
-                    format: this.targetTexture.format,
-                }],
+                        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,
@@ -205,44 +172,34 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 },
             ]
         });
-
         this.bindgroup1 = this.buildBindgroup1(params.albedo);
         this.renderBundle = this.buildRenderBundle();
     }
-
-    public computeLightsTexture(commandEncoder: GPUCommandEncoder): void {
+    computeLightsTexture(commandEncoder) {
         this.lightsTexture.update(commandEncoder);
     }
-
-    public render(renderpassEncoder: GPURenderPassEncoder, invertVpMatrix: wgpuMatrix.Mat4Arg): void {
+    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]);
     }
-
-    public setAlbedo(albedo: TextureSamplable): void {
+    setAlbedo(albedo) {
         this.bindgroup1 = this.buildBindgroup1(albedo);
         this.renderBundle = this.buildRenderBundle();
     }
-
-    public setAmbientLight(color: [number, number, number]): void {
+    setAmbientLight(color) {
         this.ambientLight = [...color];
     }
-
-    public setObstacles(segments: ReadonlyArray<LightObstacleSegment>): void {
+    setObstacles(segments) {
         this.lightsTexture.setObstacles(segments);
     }
-
-    public destroy(): void {
+    destroy() {
         this.uniformsBufferGpu.destroy();
-
         this.lightsTexture.destroy();
     }
-
-    private buildBindgroup1(albedo: TextureSamplable): GPUBindGroup {
+    buildBindgroup1(albedo) {
         return this.device.createBindGroup({
             label: "LightsRenderer bindgroup 1",
             layout: this.renderPipeline.getBindGroupLayout(1),
@@ -258,8 +215,7 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
             ]
         });
     }
-
-    private buildRenderBundle(): GPURenderBundle {
+    buildRenderBundle() {
         const renderBundleEncoder = this.device.createRenderBundleEncoder({
             label: "LightsRenderer renderbundle encoder",
             colorFormats: [this.targetTexture.format],
@@ -271,8 +227,4 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
         return renderBundleEncoder.finish({ label: "LightsRenderer renderbundle" });
     }
 }
-
-export {
-    LightsRenderer
-};
-
+export { LightsRenderer };

package/src/light/texture/{lights-texture-initializer.ts → lights-texture-initializer.js}

@@ -1,19 +1,12 @@
-/// <reference types="@webgpu/types"/>
-
-import { LightsBuffer } from "../lights-buffer";
-import { type ILightsTexture } from "./lights-texture";
+import { LightsBuffer } from "../lights-buffer.js";
 
 class LightsTextureInitializer {
-    private readonly lightsBuffer: LightsBuffer;
-
-    private readonly renderPipeline: GPURenderPipeline;
-    private readonly bindgroup: GPUBindGroup;
-
-    private readonly renderBundle: GPURenderBundle;
-
-    public constructor(device: GPUDevice, lightsBuffer: LightsBuffer, lightsTexture: ILightsTexture, maxLightSize: number) {
+    lightsBuffer;
+    renderPipeline;
+    bindgroup;
+    renderBundle;
+    constructor(device, lightsBuffer, lightsTexture, maxLightSize) {
         this.lightsBuffer = lightsBuffer;
-
         const shaderModule = device.createShaderModule({
             label: "LightsTextureInitializer shader module",
             code: `
@@ -130,7 +123,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
 }
             `,
         });
-
         this.renderPipeline = device.createRenderPipeline({
             label: "LightsTextureInitializer renderpipeline",
             layout: "auto",
@@ -142,8 +134,8 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 module: shaderModule,
                 entryPoint: "main_fragment",
                 targets: [{
-                    format: lightsTexture.format,
-                }],
+                        format: lightsTexture.format,
+                    }],
             },
             primitive: {
                 cullMode: "none",
@@ -153,7 +145,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 count: lightsTexture.sampleCount,
             },
         });
-
         this.bindgroup = device.createBindGroup({
             label: "LightsTextureInitializer bindgroup 0",
             layout: this.renderPipeline.getBindGroupLayout(0),
@@ -164,7 +155,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 },
             ]
         });
-
         const renderBundleEncoder = device.createRenderBundleEncoder({
             label: "LightsTextureInitializer renderbundle encoder",
             colorFormats: [lightsTexture.format],
@@ -175,17 +165,11 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
         renderBundleEncoder.draw(4);
         this.renderBundle = renderBundleEncoder.finish({ label: "LightsTextureInitializer renderbundle" });
     }
-
-    public getRenderBundle(): GPURenderBundle {
+    getRenderBundle() {
         return this.renderBundle;
     }
-
-    public destroy(): void {
+    destroy() {
         // nothing to do
     }
 }
-
-export {
-    LightsTextureInitializer
-};
-
+export { LightsTextureInitializer };

package/src/light/texture/{lights-texture-mask.ts → lights-texture-mask.js}

@@ -1,37 +1,17 @@
-/// <reference types="@webgpu/types"/>
-
-import { LightsBuffer } from "../lights-buffer";
-import { type Point } from "../types";
-import { type ILightsTexture } from "./lights-texture";
-
-type LightObstacleSegment = [Point, Point];
+import { LightsBuffer } from "../lights-buffer.js";
 
 class LightsTextureMask {
-    private readonly device: GPUDevice;
-
-    private readonly renderPipeline: GPURenderPipeline;
-
-    private readonly renderBundleEncoderDescriptor: GPURenderBundleEncoderDescriptor;
-    private renderBundle: GPURenderBundle;
-
-    private readonly lightsBuffer: LightsBuffer;
-
-    private readonly indirectDrawing: {
-        readonly bufferCpu: ArrayBuffer;
-        readonly bufferGpu: GPUBuffer;
-    };
-
-    private obstacles: {
-        readonly positionsBufferGpu: GPUBuffer;
-        readonly indexBufferGpu: GPUBuffer;
-    } | null = null;
-
-    public constructor(device: GPUDevice, lightsBuffer: LightsBuffer, lightsTexture: ILightsTexture, uniformLightSize: number) {
+    device;
+    renderPipeline;
+    renderBundleEncoderDescriptor;
+    renderBundle;
+    lightsBuffer;
+    indirectDrawing;
+    obstacles = null;
+    constructor(device, lightsBuffer, lightsTexture, uniformLightSize) {
         this.device = device;
         this.lightsBuffer = lightsBuffer;
-
-        const obstaclesAreTwoWay = true as boolean;
-
+        const obstaclesAreTwoWay = true;
         const shaderModule = device.createShaderModule({
             label: "LightsTextureMask shader module",
             code: `
@@ -94,7 +74,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
 }
             `,
         });
-
         this.renderPipeline = device.createRenderPipeline({
             label: "LightsTextureMask renderpipeline",
             layout: "auto",
@@ -135,20 +114,20 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 module: shaderModule,
                 entryPoint: "main_fragment",
                 targets: [{
-                    format: lightsTexture.format,
-                    blend: {
-                        color: {
-                            operation: "min",
-                            srcFactor: "one",
-                            dstFactor: "one",
-                        },
-                        alpha: {
-                            operation: "min",
-                            srcFactor: "one",
-                            dstFactor: "one",
+                        format: lightsTexture.format,
+                        blend: {
+                            color: {
+                                operation: "min",
+                                srcFactor: "one",
+                                dstFactor: "one",
+                            },
+                            alpha: {
+                                operation: "min",
+                                srcFactor: "one",
+                                dstFactor: "one",
+                            },
                         },
-                    },
-                }],
+                    }],
             },
             primitive: {
                 cullMode: obstaclesAreTwoWay ? "none" : "back",
@@ -158,7 +137,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
                 count: lightsTexture.sampleCount,
             },
         });
-
         this.indirectDrawing = {
             bufferCpu: new ArrayBuffer(20),
             bufferGpu: device.createBuffer({
@@ -168,7 +146,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
             }),
         };
         this.uploadIndirectDrawingBuffer();
-
         this.renderBundleEncoderDescriptor = {
             label: "LightsTextureMask renderbundle encoder",
             colorFormats: [lightsTexture.format],
@@ -176,32 +153,18 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
         };
         this.renderBundle = this.buildRenderBundle();
     }
-
-    public getRenderBundle(): GPURenderBundle {
+    getRenderBundle() {
         return this.renderBundle;
     }
-
-    public setObstacles(segments: ReadonlyArray<LightObstacleSegment>): void {
-        const positions: number[] = [];
-        const indices: number[] = [];
+    setObstacles(segments) {
+        const positions = [];
+        const indices = [];
         for (const segment of segments) {
             const firstQuadIndex = positions.length / 3;
-
-            positions.push(
-                ...segment[0], 0,
-                ...segment[1], 0,
-                ...segment[0], 1,
-                ...segment[1], 1,
-            );
-
-            indices.push(
-                firstQuadIndex + 0, firstQuadIndex + 1, firstQuadIndex + 3,
-                firstQuadIndex + 0, firstQuadIndex + 3, firstQuadIndex + 2,
-            );
+            positions.push(...segment[0], 0, ...segment[1], 0, ...segment[0], 1, ...segment[1], 1);
+            indices.push(firstQuadIndex + 0, firstQuadIndex + 1, firstQuadIndex + 3, firstQuadIndex + 0, firstQuadIndex + 3, firstQuadIndex + 2);
         }
-
         let gpuBuffersChanged = false;
-
         const positionsArray = new Float32Array(positions);
         let positionsBufferGpu = this.obstacles?.positionsBufferGpu;
         if (!positionsBufferGpu || positionsBufferGpu.size < positionsArray.byteLength) {
@@ -214,7 +177,6 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
             gpuBuffersChanged = true;
         }
         this.device.queue.writeBuffer(positionsBufferGpu, 0, positionsArray);
-
         const indicesArray = new Uint16Array(indices);
         let indexBufferGpu = this.obstacles?.indexBufferGpu;
         if (!indexBufferGpu || indexBufferGpu.size < indicesArray.byteLength) {
@@ -227,43 +189,35 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
             gpuBuffersChanged = true;
         }
         this.device.queue.writeBuffer(indexBufferGpu, 0, indicesArray);
-
         this.obstacles = { positionsBufferGpu, indexBufferGpu };
-
         this.setIndirectIndexCount(indices.length);
-
         if (gpuBuffersChanged) {
             this.renderBundle = this.buildRenderBundle();
         }
     }
-
-    public setLightsCount(count: number): void {
+    setLightsCount(count) {
         this.setIndirectInstanceCount(count);
     }
-
-    public destroy(): void {
+    destroy() {
         this.indirectDrawing.bufferGpu.destroy();
         this.obstacles?.positionsBufferGpu.destroy();
         this.obstacles?.indexBufferGpu.destroy();
     }
-
-    private setIndirectIndexCount(indexCount: number): void {
+    setIndirectIndexCount(indexCount) {
         const drawIndexedIndirectParameters = new Uint32Array(this.indirectDrawing.bufferCpu);
         if (drawIndexedIndirectParameters[0] !== indexCount) {
             drawIndexedIndirectParameters[0] = indexCount;
             this.uploadIndirectDrawingBuffer();
         }
     }
-
-    private setIndirectInstanceCount(instanceCount: number): void {
+    setIndirectInstanceCount(instanceCount) {
         const drawIndexedIndirectParameters = new Uint32Array(this.indirectDrawing.bufferCpu);
         if (drawIndexedIndirectParameters[1] !== instanceCount) {
             drawIndexedIndirectParameters[1] = instanceCount;
             this.uploadIndirectDrawingBuffer();
         }
     }
-
-    private buildRenderBundle(): GPURenderBundle {
+    buildRenderBundle() {
         const renderBundleEncoder = this.device.createRenderBundleEncoder(this.renderBundleEncoderDescriptor);
         if (this.obstacles) {
             renderBundleEncoder.setPipeline(this.renderPipeline);
@@ -274,13 +228,8 @@ fn main_fragment(in: VertexOut) -> FragmentOut {
         }
         return renderBundleEncoder.finish({ label: "LightsTextureMask renderbundle" });
     }
-
-    private uploadIndirectDrawingBuffer(): void {
+    uploadIndirectDrawingBuffer() {
         this.device.queue.writeBuffer(this.indirectDrawing.bufferGpu, 0, this.indirectDrawing.bufferCpu);
     }
 }
-
-export {
-    LightsTextureMask, type LightObstacleSegment
-};
-
+export { LightsTextureMask };

package/src/light/texture/{lights-texture.ts → lights-texture.js}

@@ -1,37 +1,16 @@
-/// <reference types="@webgpu/types"/>
-
-import { type LightsBuffer } from "../lights-buffer";
-import { LightsTextureInitializer } from "./lights-texture-initializer";
-import { type LightObstacleSegment, LightsTextureMask } from "./lights-texture-mask";
-
-type ILightsTexture = {
-    readonly gridSize: { readonly x: number, readonly y: number };
-    readonly format: GPUTextureFormat;
-    readonly sampleCount: number;
-};
-
-type LightsTextureProperties = {
-    readonly resolutionPerLight: number;
-    readonly maxLightSize: number;
-    readonly antialiased: boolean;
-    readonly filtering: GPUFilterMode;
-};
+import { LightsTextureInitializer } from "./lights-texture-initializer.js";
+import { LightsTextureMask } from "./lights-texture-mask.js";
 
 class LightsTexture {
-    private readonly lightsBuffer: LightsBuffer;
-
-    public readonly texture: GPUTexture;
-    public readonly gridSize: { readonly x: number, readonly y: number };
-
-    private readonly textureMultisampled: GPUTexture | null = null;
-    private readonly textureRenderpassDescriptor: GPURenderPassDescriptor;
-
-    private readonly textureInitializer: LightsTextureInitializer;
-    private readonly textureMask: LightsTextureMask;
-
-    public constructor(device: GPUDevice, lightsBuffer: LightsBuffer, lightsTextureProperties: LightsTextureProperties) {
+    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)),
@@ -39,12 +18,10 @@ class LightsTexture {
         };
         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",
@@ -52,7 +29,6 @@ class LightsTexture {
             format,
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
         });
-
         if (lightsTextureProperties.antialiased) {
             this.textureMultisampled = device.createTexture({
                 label: "LightsTextureMask texture multisampled",
@@ -62,10 +38,8 @@ class LightsTexture {
                 sampleCount: 4,
             });
         }
-
         const textureToRenderTo = this.textureMultisampled ?? this.texture;
-
-        const textureRenderpassColorAttachment: GPURenderPassColorAttachment = {
+        const textureRenderpassColorAttachment = {
             view: textureToRenderTo.createView(),
             clearValue: [0, 0, 0, 1],
             loadOp: "load",
@@ -78,8 +52,7 @@ class LightsTexture {
             label: "lights-renderer render to texture renderpass",
             colorAttachments: [textureRenderpassColorAttachment],
         };
-
-        const lightsTexture: ILightsTexture = {
+        const lightsTexture = {
             gridSize,
             format,
             sampleCount: this.textureMultisampled?.sampleCount ?? 1,
@@ -87,10 +60,8 @@ class LightsTexture {
         this.textureInitializer = new LightsTextureInitializer(device, lightsBuffer, lightsTexture, lightsTextureProperties.maxLightSize);
         this.textureMask = new LightsTextureMask(device, lightsBuffer, lightsTexture, lightsTextureProperties.maxLightSize);
     }
-
-    public update(commandEncoder: GPUCommandEncoder): void {
+    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);
@@ -101,21 +72,14 @@ class LightsTexture {
         ]);
         renderpassEncoder.end();
     }
-
-    public setObstacles(segments: ReadonlyArray<LightObstacleSegment>): void {
+    setObstacles(segments) {
         this.textureMask.setObstacles(segments);
     }
-
-    public destroy(): void {
+    destroy() {
         this.texture.destroy();
         this.textureMultisampled?.destroy();
-
         this.textureInitializer.destroy();
         this.textureMask.destroy();
     }
 }
-
-export {
-    LightsTexture, type ILightsTexture, type LightsTextureProperties
-};
-
+export { LightsTexture };

package/src/light/{viewport.ts → viewport.js}

@@ -1,54 +1,35 @@
 import * as wgpuMatrix from "wgpu-matrix";
-import { type Point } from "./types";
-
-type Parameters = {
-    readonly viewportSize: {
-        width: number;
-        height: number;
-    };
-    readonly center?: Point;
-    readonly zoom?: number;
-};
 
 class Viewport {
-    private readonly invViewProjectionMatrix: wgpuMatrix.Mat4Arg = wgpuMatrix.mat4.identity();
-
-    private readonly viewportSize = { width: 1, height: 1 };
-    private readonly topLeft: Point = [0, 0];
-    private zoom: number = 1;
-
-    public constructor(params: Parameters) {
+    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);
     }
-
-    public get invertViewProjectionMatrix(): wgpuMatrix.Mat4Arg {
+    get invertViewProjectionMatrix() {
         return this.invViewProjectionMatrix;
     }
-
-    public setViewportSize(width: number, height: number): void {
+    setViewportSize(width, height) {
         this.viewportSize.width = width;
         this.viewportSize.height = height;
         this.updateMatrices();
     }
-
-    public setTopLeft(x: number, y: number): void {
+    setTopLeft(x, y) {
         this.topLeft[0] = x;
         this.topLeft[1] = y;
         this.updateMatrices();
     }
-
-    public setZoom(zoom: number): void {
+    setZoom(zoom) {
         this.zoom = zoom;
         this.updateMatrices();
     }
-
-    private updateMatrices(): void {
+    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);
@@ -56,8 +37,4 @@ class Viewport {
         wgpuMatrix.mat4.multiply(wgpuMatrix.mat4.translation([this.topLeft[0], this.topLeft[1], 0]), this.invViewProjectionMatrix, this.invViewProjectionMatrix);
     }
 }
-
-export {
-    Viewport
-};
-
+export { Viewport };