thing added

Author: geant04

README.md

@@ -17,11 +17,7 @@ WebGL Forward+ and Clustered Deferred Shading
 
 ### (TODO: Your README)
 
-*DO NOT* leave the README to the last minute! It is a crucial part of the
-project, and we will not be able to grade you without a good README.
-
-This assignment has a considerable amount of performance analysis compared
-to implementation work. Complete the implementation early to leave time!
+hi gamers
 
 ### Credits
 

src/main.ts

@@ -50,7 +50,7 @@ function setRenderer(mode: string) {
 }
 
 const renderModes = { naive: 'naive', forwardPlus: 'forward+', clusteredDeferred: 'clustered deferred' };
-let renderModeController = gui.add({ mode: renderModes.clusteredDeferred }, 'mode', renderModes);
+let renderModeController = gui.add({ mode: renderModes.forwardPlus }, 'mode', renderModes);
 renderModeController.onChange(setRenderer);
 
 setRenderer(renderModeController.getValue());

src/renderer.ts

@@ -127,7 +127,7 @@ export abstract class Renderer {
     protected abstract draw(): void;
 
     // CHECKITOUT: this is the main rendering loop
-    private onFrame(time: number) {
+    private async onFrame(time: number) {
         if (this.prevTime == 0) {
             this.prevTime = time;
         }
@@ -139,6 +139,11 @@ export abstract class Renderer {
         this.stats.begin();
 
         this.draw();
+        
+        if (true)
+        {
+            await device.queue.onSubmittedWorkDone();
+        }
 
         this.stats.end();
 

src/renderers/clustered_deferred.ts

@@ -1,6 +1,5 @@
 import * as renderer from '../renderer';
 import * as shaders from '../shaders/shaders';
-import * as lights from '../stage/lights';
 
 import { Stage } from '../stage/stage';
 

src/shaders/clustered_deferred.fs.wgsl

@@ -26,8 +26,15 @@ fn main(in: FragmentInput) -> FragmentOutput
 {
     var output: FragmentOutput;
 
-    output.normal = vec4f(in.nor, 1f);
-    output.albedo = textureSample(diffuseTex, diffuseTexSampler, in.uv);
+    let sampledAlbedo = textureSample(diffuseTex, diffuseTexSampler, in.uv);
 
+    if (sampledAlbedo.a < 0.5f)
+    {
+        discard;
+    }
+
+    output.normal = vec4f(in.nor, 1f);
+    output.albedo= sampledAlbedo;
+
     return output;
 }

src/shaders/clustered_deferred_fullscreen.fs.wgsl

@@ -34,12 +34,9 @@ fn main(@builtin(position) fragPos : vec4f) -> @location(0) vec4f {
 
     let clusterID = clusterX + (clusterY * clusterSet.numClustersX) + (clusterZ * (clusterSet.numClustersX * clusterSet.numClustersY));
 
-    let cluster: Cluster = clusterSet.clusters[clusterID];
-    let numLights: u32 = cluster.numLights;
-
     var totalLightContrib = vec3f(0, 0, 0);
-    for (var clusterLightIdx = 0u; clusterLightIdx < numLights; clusterLightIdx++) {
-        let lightIdx = cluster.lightIndices[clusterLightIdx];
+    for (var clusterLightIdx = 0u; clusterLightIdx < clusterSet.clusters[clusterID].numLights; clusterLightIdx++) {
+        let lightIdx = clusterSet.clusters[clusterID].lightIndices[clusterLightIdx];
         let light = lightSet.lights[lightIdx];
         totalLightContrib += calculateLightContrib(light, position, normalize(normal));
     }

src/shaders/clustered_deferred_fullscreen.vs.wgsl

@@ -4,6 +4,7 @@
 
 @vertex
 fn main( @builtin(vertex_index) VertexIndex : u32 ) -> @builtin(position) vec4f {
+  // https://webgpu.github.io/webgpu-samples/?sample=deferredRendering#fragmentDeferredRendering.wgsl
   const pos = array(
     vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),
     vec2(-1.0, 1.0), vec2(1.0, -1.0), vec2(1.0, 1.0),

src/shaders/clustering.cs.wgsl

@@ -49,20 +49,25 @@ fn lineIntersectionToZPlane(a: vec3f, b: vec3f, distance: f32) -> vec3f {
 
 
 @compute
-@workgroup_size(1, 1, 1)
-fn getClusterBounds(@builtin(global_invocation_id) globalIdx: vec3u) {
+@workgroup_size(${clusterLightsWorkgroupX}, ${clusterLightsWorkgroupY}, ${clusterLightsWorkgroupZ})
+fn getClusterBounds(@builtin(global_invocation_id) globalIdx: vec3u){
     let numClustersX = clusterSet.numClustersX;
     let numClustersY = clusterSet.numClustersY;
     let numClustersZ = clusterSet.numClustersZ;
     let numClusters = numClustersX * numClustersY * numClustersZ;
 
-    let clusterID = globalIdx.x + (globalIdx.y * numClustersX) + (globalIdx.z * (numClustersX * numClustersY));
+    let clusterX = globalIdx.x;
+    let clusterY = globalIdx.y;
+    let clusterZ = globalIdx.z;
 
-    if (clusterID >= numClusters)
+    if ( (clusterX >= numClustersX) || (clusterY >= numClustersY) || (clusterZ >= numClustersZ) ) 
     {
         return;
     }
 
+    let clusterID = (clusterX) + (clusterY * numClustersX) + (clusterZ * (numClustersX * numClustersY));
+
+
     let uniformSliceLength: f32 = ${sliceLength};
     var minZ: f32 = -uniformSliceLength * f32(globalIdx.z);
     var maxZ: f32 = -uniformSliceLength * f32(globalIdx.z + 1);
@@ -87,14 +92,14 @@ fn getClusterBounds(@builtin(global_invocation_id) globalIdx: vec3u) {
     var clusterLightArrayIdx: u32 = 0;
     let maxLightsPerCluster: u32 = ${maxLightsPerCluster};
 
-    for (var lightIdx = 0u; lightIdx < lightSet.numLights; lightIdx++) {
+    for (var lightIdx = 0u; lightIdx < lightSet.numLights && clusterLightArrayIdx < maxLightsPerCluster; lightIdx++) {
         let light = lightSet.lights[lightIdx];
 
         // Need to transform lightZ to the view Z to match the cluster's Z sapce
         var viewLightPos: vec4f = cameraUniforms.viewMat * vec4f(light.pos, 1f);
 
         var isIntersected: bool = testAABBSphereIntersection(minPointAABB, maxPointAABB, viewLightPos.xyz, ${lightRadius});
-        if (isIntersected && clusterLightArrayIdx < maxLightsPerCluster)
+        if (isIntersected)
         {
             // Is there a way to use references for this assignment?
             clusterSet.clusters[clusterID].lightIndices[clusterLightArrayIdx] = lightIdx;

src/shaders/forward_plus.fs.wgsl

@@ -17,6 +17,9 @@ struct FragmentInput
 fn main(in: FragmentInput) -> @location(0) vec4f
 {
     let diffuseColor = textureSample(diffuseTex, diffuseTexSampler, in.uv);
+    if (diffuseColor.a < 0.5f) {
+        discard;
+    }
 
     // Copy the light logic from naive, but just use the light indices from the accessed cluster for that
     let fragPos: vec4f = in.fragPos;
@@ -31,12 +34,9 @@ fn main(in: FragmentInput) -> @location(0) vec4f
 
     let clusterID = clusterX + (clusterY * clusterSet.numClustersX) + (clusterZ * (clusterSet.numClustersX * clusterSet.numClustersY));
 
-    let cluster: Cluster = clusterSet.clusters[clusterID];
-    let numLights: u32 = cluster.numLights;
-
     var totalLightContrib = vec3f(0, 0, 0);
-    for (var clusterLightIdx = 0u; clusterLightIdx < numLights; clusterLightIdx++) {
-        let lightIdx = cluster.lightIndices[clusterLightIdx];
+    for (var clusterLightIdx = 0u; clusterLightIdx < clusterSet.clusters[clusterID].numLights; clusterLightIdx++) {
+        let lightIdx = clusterSet.clusters[clusterID].lightIndices[clusterLightIdx];
         let light = lightSet.lights[lightIdx];
         totalLightContrib += calculateLightContrib(light, in.pos, normalize(in.nor));
     }

src/shaders/shaders.ts

@@ -29,10 +29,14 @@ export const constants = {
     bindGroup_material: 2,
     moveLightsWorkgroupSize: 128,
 
+    clusterLightsWorkgroupX: 16,
+    clusterLightsWorkgroupY: 16,
+    clusterLightsWorkgroupZ: 1,
+
     numSlices: 32,
     sliceLength: 1,
-    tileSize: 128,
-    maxLightsPerCluster: 128,
+    tileSize: 64,
+    maxLightsPerCluster: 256,
 
     near: 0.1,
     far: 5000,