Remove Render from classes and separate into own class

src/scripts/AbstractGPURunner.ts

@@ -1,3 +1,4 @@
+import {Texture} from "./webgpu/texture";
 
 export enum RunnerType {
     HTML = 1,
@@ -8,6 +9,7 @@ export enum RunnerType {
 export interface GPURunner {
     getType(): RunnerType;
     getHTML(): string;
+    getRenderInfo(): {textures: Texture[], fragmentShaderFilenames: string[]};
     getCommandBuffer(): GPUCommandBuffer;
     Run(): Promise<void>;
     Init(): Promise<void>;
@@ -27,4 +29,8 @@ export abstract class GPUAbstractRunner implements GPURunner {
     getHTML(): string {
         throw new Error("Method not implemented.");
     }
+
+    getRenderInfo(): { textures: Texture[]; fragmentShaderFilenames: string[] } {
+        throw new Error("Method not implemented.");
+    }
 }

src/scripts/GPURenderRunner.ts

@@ -0,0 +1,45 @@
+import {GPURunner, RunnerType} from "./AbstractGPURunner";
+import {Render} from "./render/render";
+import {Texture} from "./webgpu/texture";
+import {GPU} from "./webgpu/gpu";
+
+export class GPURenderRunner implements GPURunner {
+    runner: GPURunner
+    render: Render
+
+    constructor(runner: GPURunner) {
+        this.runner = runner
+    }
+
+    getHTML(): string {
+        return this.runner.getHTML()
+    }
+
+    getType(): RunnerType {
+        return this.runner.getType()
+    }
+
+    async Destroy() {
+        await this.render.Destroy()
+        await this.runner.Destroy()
+    }
+
+    async Init() {
+        await this.runner.Init()
+        let renderInfo = this.runner.getRenderInfo()
+        this.render = new Render(renderInfo.textures, ...renderInfo.fragmentShaderFilenames)
+        await this.render.Init()
+    }
+
+    async Run() {
+        GPU.device.queue.submit([this.runner.getCommandBuffer(), this.render.getCommandBuffer()])
+    }
+
+    getCommandBuffer(): GPUCommandBuffer {
+        throw new Error("Method not implemented.");
+    }
+
+    getRenderInfo(): { textures: Texture[]; fragmentShaderFilenames: string[] } {
+        throw new Error("Method not implemented.");
+    }
+}

src/scripts/GPURunner.ts → src/scripts/RunGPURunner.ts

@@ -5,7 +5,7 @@ import {Mutex} from "async-mutex";
 
 let stop_immediately = true;
 
-function ListenToError() {
+export function ListenToError() {
     GPU.device.addEventListener("uncapturederror", (event) => {
         let e = event as GPUUncapturedErrorEvent
         console.error("A WebGPU error was not captured", e.error);

src/scripts/diffuse/diffuse.ts

@@ -10,7 +10,6 @@ export class Diffuse extends GPUAbstractRunner {
 
     texturesrc: Texture;
     texturedest: Texture;
-    render: Render;
 
     bind_group_layout: GPUBindGroupLayout
     bind_group_layout_mesh: GPUBindGroupLayout
@@ -52,7 +51,6 @@ export class Diffuse extends GPUAbstractRunner {
     }
 
     override async Destroy() {
-        await this.render.Destroy()
         this.texturesrc.destroy()
         this.texturedest.destroy()
         this.vertexBuffer.destroy()
@@ -157,8 +155,6 @@ export class Diffuse extends GPUAbstractRunner {
         this.texturesrc = GPU.CreateStorageTexture(this.width, this.height, "rgba32float")
         this.texturedest = GPU.CreateStorageTexture(this.width, this.height, "rgba32float")
 
-        this.render = new Render([this.texturedest], "scripts/diffuse/aces-tone-mapping.wgsl")
-        await this.render.Init()
 
         this.stagingBuffer = GPU.CreateUniformBuffer(4 * 4) // must be a multiple of 16 bytes
         this.stagingData = new Float32Array(4)
@@ -278,7 +274,15 @@ export class Diffuse extends GPUAbstractRunner {
     }
 
     override async Run() {
-        GPU.device.queue.submit([this.getCommandBuffer(), this.render.getCommandBuffer()])
+        GPU.device.queue.submit([this.getCommandBuffer()])
         await GPU.device.queue.onSubmittedWorkDone()
     }
+
+    override getRenderInfo(): { textures: Texture[]; fragmentShaderFilenames: string[] } {
+        return {
+            textures: [this.texturedest],
+            fragmentShaderFilenames: ["scripts/diffuse/aces-tone-mapping.wgsl"]
+        }
+    }
+
 }

src/scripts/fluid/render/render.frag.wgsl

@@ -5,24 +5,10 @@ struct VertexOutput {
   @builtin(position) Position : vec4<f32>,
   @location(0) fragUV : vec2<f32>
 };
-/*
-[[stage(fragment)]]
-fn main(data: VertexOutput) -> [[location(0)]] vec4<f32> {
-    return textureSample(myTexture, mySampler, data.fragUV);
-}
-*/
 
 @fragment
 fn main(data: VertexOutput) -> @location(0) vec4<f32> {
     var d: vec2<f32> = vec2<f32>(textureDimensions(myTexture, 0));
     let c = textureLoad(myTexture, vec2<i32>(data.fragUV*d), 0).rgb;
     return vec4<f32>(abs(c), 1.);
-    //return vec4<f32>(c.r, -c.r, 0., 1.);
-}
-
-/*
-[[stage(fragment)]]
-fn main([[location(0)]] fragUV: vec2<f32>) -> [[location(0)]] vec4<f32> {
-    return vec4<f32>(fragUV.x, 0.0, 0.0, 1.0);
 }
-*/

src/scripts/light/light.ts

@@ -12,17 +12,12 @@ import {Texture} from "../webgpu/texture";
 import {Buffer} from "../webgpu/buffer";
 import {GPUAbstractRunner, RunnerType} from "../AbstractGPURunner";
 import {Render} from "../render/render";
-import {Raytrace} from "../raytrace/raytrace";
-import {SDF} from "../sdf/sdf";
 
 export class LightPropagation extends GPUAbstractRunner {
     width: number
     height: number
 
     render: Render
-    sdf: SDF
-    raytrace: Raytrace
-    textureSignedDistance: Texture
 
     textureDest: Texture
     textureSrc: Texture
@@ -48,35 +43,9 @@ export class LightPropagation extends GPUAbstractRunner {
     async Destroy() {
         this.textureDest.destroy()
         this.textureSrc.destroy()
- /*
-        await this.sdf.Destroy()
-        await this.raytrace.Destroy()
- */
     }
 
     async Init() {
-/*
-        this.raytrace = new Raytrace("fbm.wgsl", false)
-        try {
-            await this.raytrace.Init()
-            await this.raytrace.Run()
-        } catch (e) {
-            ShowError("Creation of FBM failed", e as Error)
-            throw e
-        }
-        this.sdf = new SDF(this.raytrace.texturedest)
-        try {
-            await this.sdf.Init()
-            for(let i = 0; i < 256; i++) {
-                await this.sdf.Run()
-            }
-        } catch (e) {
-            ShowError("Creation of SDF failed", e as Error)
-            throw e
-        }
-        //this.textureSignedDistance = await GPU.createTextureFromTexture(this.sdf.texturea, "rgba16float")
-        this.textureSignedDistance = this.sdf.texturea
-*/
         console.log("Create Texture")
         this.textureDest = GPU.CreateStorageTextureArray(this.width, this.height, 3,  "rgba16float")
         this.textureSrc = GPU.CreateStorageTextureArray(this.width, this.height, 3, "rgba16float")

src/scripts/raytrace/raytrace.ts

@@ -5,12 +5,12 @@ import {GPUAbstractRunner, RunnerType} from "../AbstractGPURunner";
 import {Render} from "../render/render";
 
 export class Raytrace extends GPUAbstractRunner {
-    width: number;
-    height: number;
+    width: number
+    height: number
 
-    texturesrc: Texture;
-    texturedest: Texture;
-    render: Render;
+    texturesrc: Texture
+    texturedest: Texture
+    render: Render
 
     bind_group_layout: GPUBindGroupLayout
     bind_group: GPUBindGroup
@@ -20,16 +20,13 @@ export class Raytrace extends GPUAbstractRunner {
     stagingBuffer: Buffer
     stagingData: Float32Array
 
-    filename: string;
+    filename: string
+    fragmentShaderFilename: string
 
-    showOnScreen: boolean;
-    fragmentShaderFilename: string;
+    startTime: number
 
-    startTime: number;
-
-    constructor(filename: string, showOnScreen: boolean, fragmentShaderFilename: string = null) {
+    constructor(filename: string, fragmentShaderFilename: string = null) {
         super();
-        this.showOnScreen = showOnScreen
         this.filename = filename
         this.width = GPU.viewport.width
         this.height = GPU.viewport.height
@@ -41,9 +38,6 @@ export class Raytrace extends GPUAbstractRunner {
     }
 
     override async Destroy() {
-        if (this.showOnScreen) {
-            await this.render.Destroy()
-        }
         this.texturesrc.destroy()
         this.texturedest.destroy()
     }
@@ -53,15 +47,6 @@ export class Raytrace extends GPUAbstractRunner {
         this.texturesrc = GPU.CreateStorageTexture(this.width, this.height, "rgba32float")
         this.texturedest = GPU.CreateStorageTexture(this.width, this.height, "rgba32float")
 
-        if (this.showOnScreen) {
-            if (this.fragmentShaderFilename === null) {
-                this.render = new Render([this.texturedest])
-            } else {
-                this.render = new Render([this.texturedest], "scripts/raytrace/" + this.fragmentShaderFilename)
-            }
-            await this.render.Init()
-        }
-
         this.stagingBuffer = GPU.CreateUniformBuffer(4*3 + 4) // must be a multiple of 16 bytes
         this.stagingData = new Float32Array(4)
 
@@ -112,7 +97,19 @@ export class Raytrace extends GPUAbstractRunner {
         })
 
         this.startTime = new Date().getTime();
+    }
 
+    override getRenderInfo(): { textures: Texture[]; fragmentShaderFilenames: string[] } {
+        if (this.fragmentShaderFilename == null) {
+            return {
+                textures: [this.texturedest],
+                fragmentShaderFilenames: []
+            }
+        }
+        return {
+            textures: [this.texturedest],
+            fragmentShaderFilenames: ["scripts/raytrace/" + this.fragmentShaderFilename]
+        }
     }
 
     previousMouseCoordinatex: number = 0
@@ -145,11 +142,7 @@ export class Raytrace extends GPUAbstractRunner {
     }
 
     override async Run() {
-        if (this.showOnScreen) {
-            GPU.device.queue.submit([this.getCommandBuffer(), this.render.getCommandBuffer()])
-        } else {
-            GPU.device.queue.submit([this.getCommandBuffer()])
-        }
+        GPU.device.queue.submit([this.getCommandBuffer()])
         await GPU.device.queue.onSubmittedWorkDone()
     }
 }

src/scripts/render/render.ts

@@ -3,13 +3,12 @@ import {Texture} from "../webgpu/texture";
 import {GPUAbstractRunner, RunnerType} from "../AbstractGPURunner";
 
 export class Render extends GPUAbstractRunner {
-    bind_group_layout: GPUBindGroupLayout;
-    bind_group: GPUBindGroup;
-    pipeline_layout: GPUPipelineLayout;
-    pipeline: GPURenderPipeline;
-    textures: Texture[];
-
-    fragmentShaderFilenames: string[];
+    bind_group_layout: GPUBindGroupLayout
+    bind_group: GPUBindGroup
+    pipeline_layout: GPUPipelineLayout
+    pipeline: GPURenderPipeline
+    textures: Texture[]
+    fragmentShaderFilenames: string[]
 
     constructor(textures: Texture[], ...fragmentShaderFilenames: string[]) {
         super();
@@ -21,7 +20,6 @@ export class Render extends GPUAbstractRunner {
         return RunnerType.GRAPHIC
     }
 
-
     override async Destroy() {
     }
 
@@ -101,16 +99,16 @@ export class Render extends GPUAbstractRunner {
                 topology: "triangle-strip",
                 stripIndexFormat: "uint32"
             }
-        });
+        })
     }
 
     override getCommandBuffer(): GPUCommandBuffer {
-        const commandEncoder = GPU.device.createCommandEncoder({});
-        const passEncoder = commandEncoder.beginRenderPass(GPU.getRenderPassDescriptor());
-        passEncoder.setPipeline(this.pipeline);
-        passEncoder.setBindGroup(0, this.bind_group);
-        passEncoder.draw(4, 1, 0, 0);
-        passEncoder.end();
+        const commandEncoder = GPU.device.createCommandEncoder({})
+        const passEncoder = commandEncoder.beginRenderPass(GPU.getRenderPassDescriptor())
+        passEncoder.setPipeline(this.pipeline)
+        passEncoder.setBindGroup(0, this.bind_group)
+        passEncoder.draw(4, 1, 0, 0)
+        passEncoder.end()
         return commandEncoder.finish()
     }