@woosh/meep-engine 2.33.60 → 2.33.64

package/engine/graphics/render/webgpu/sample/MeshInstance.js

@@ -0,0 +1,108 @@
+import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+
+const BIND_GROUP_MATERIAL = 1;
+
+export class MeshInstance {
+    constructor() {
+
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         */
+        this.geometry = null;
+
+        /**
+         *
+         * @type {null}
+         */
+        this.material = null;
+
+        /**
+         *
+         * @type {GPUBuffer|null}
+         */
+        this.vertex_buffer = null;
+
+        /**
+         *
+         * @type {GPUBuffer|null}
+         */
+        this.index_buffer = null;
+    }
+
+    /**
+     *
+     * @param {GPUDevice} device
+     */
+    init(device) {
+        const mesh = this.geometry;
+
+        const kVertexStride = 8;
+        const attribute_position = mesh.getAttribute('position');
+        const vertexBuffer = device.createBuffer({
+            // position: vec3, normal: vec3, uv: vec2
+            size: attribute_position.array.length * kVertexStride * Float32Array.BYTES_PER_ELEMENT,
+            usage: GPUBufferUsage.VERTEX,
+            mappedAtCreation: true,
+        });
+
+        {
+            const mapping = new Float32Array(vertexBuffer.getMappedRange());
+
+            const attribute_normal = mesh.getAttribute('normal');
+            const attribute_uv = mesh.getAttribute('uv');
+
+            const vertex_count = attribute_position.count;
+
+            for (let i = 0; i < vertex_count; ++i) {
+                const address = kVertexStride * i;
+                array_copy(attribute_position.array, i * 3, mapping, address, 3);
+                array_copy(attribute_normal.array, i * 3, mapping, address + 3, 3);
+                array_copy(attribute_uv.array, i * 2, mapping, address + 6, 2);
+            }
+            vertexBuffer.unmap();
+        }
+
+        this.vertex_buffer = vertexBuffer;
+
+        const indexCount = mesh.getIndex().array.length;
+        const indexBuffer = device.createBuffer({
+            size: indexCount * Uint32Array.BYTES_PER_ELEMENT,
+            usage: GPUBufferUsage.INDEX,
+            mappedAtCreation: true,
+        });
+        {
+            const mapping = new Uint32Array(indexBuffer.getMappedRange());
+
+            mapping.set(mesh.getIndex().array);
+
+            indexBuffer.unmap();
+        }
+
+        this.index_buffer = indexBuffer;
+
+    }
+
+    /**
+     *
+     * @param {GPURenderPassEncoder} pass
+     */
+    preparePass(pass) {
+
+    }
+
+    /**
+     *
+     * @param {GPURenderPassEncoder} pass
+     */
+    draw(pass) {
+        // set material bindings
+
+        // pass.setBindGroup(BIND_GROUP_MATERIAL, {});
+
+        pass.setVertexBuffer(0, this.vertex_buffer);
+        pass.setIndexBuffer(this.index_buffer, 'uint32');
+
+        pass.drawIndexed(this.geometry.getIndex().array.length);
+    }
+}

package/engine/graphics/render/webgpu/sample/fragmentDeferredRendering.wgsl

@@ -0,0 +1,71 @@
+[[group(0), binding(0)]] var gBufferPosition: texture_2d<f32>;
+[[group(0), binding(1)]] var gBufferNormal: texture_2d<f32>;
+[[group(0), binding(2)]] var gBufferAlbedo: texture_2d<f32>;
+
+struct LightData {
+  position : vec4<f32>;
+  color : vec3<f32>;
+  radius : f32;
+};
+
+struct LightsBuffer {
+  lights: array<LightData>;
+};
+
+[[group(1), binding(0)]] var<storage, read> lightsBuffer: LightsBuffer;
+
+struct Config {
+  numLights : u32;
+};
+
+[[group(1), binding(1)]] var<uniform> config: Config;
+
+struct CanvasConstants {
+  size: vec2<f32>;
+};
+
+[[group(2), binding(0)]] var<uniform> canvas : CanvasConstants;
+
+[[stage(fragment)]]
+fn main([[builtin(position)]] coord : vec4<f32>)
+     -> [[location(0)]] vec4<f32> {
+  var result = vec3<f32>(0.0, 0.0, 0.0);
+
+  let position = textureLoad(
+    gBufferPosition,
+    vec2<i32>(floor(coord.xy)),
+    0
+  ).xyz;
+
+  if (position.z > 10000.0) {
+    discard;
+  }
+
+  let normal = textureLoad(
+    gBufferNormal,
+    vec2<i32>(floor(coord.xy)),
+    0
+  ).xyz;
+
+  let albedo = textureLoad(
+    gBufferAlbedo,
+    vec2<i32>(floor(coord.xy)),
+    0
+  ).rgb;
+
+  for (var i : u32 = 0u; i < config.numLights; i = i + 1u) {
+    let L = lightsBuffer.lights[i].position.xyz - position;
+    let distance = length(L);
+    if (distance > lightsBuffer.lights[i].radius) {
+        continue;
+    }
+    let lambert = max(dot(normal, normalize(L)), 0.0);
+    result = result + vec3<f32>(
+      lambert * pow(1.0 - distance / lightsBuffer.lights[i].radius, 2.0) * lightsBuffer.lights[i].color * albedo);
+  }
+
+  // some manual ambient
+  result = result + vec3<f32>(0.2, 0.2, 0.2);
+
+  return vec4<f32>(result, 1.0);
+}

package/engine/graphics/render/webgpu/sample/fragmentGBuffersDebugView.wgsl

@@ -0,0 +1,39 @@
+[[group(0), binding(0)]] var gBufferPosition: texture_2d<f32>;
+[[group(0), binding(1)]] var gBufferNormal: texture_2d<f32>;
+[[group(0), binding(2)]] var gBufferAlbedo: texture_2d<f32>;
+
+struct CanvasConstants {
+  size: vec2<f32>;
+};
+
+[[group(1), binding(0)]] var<uniform> canvas : CanvasConstants;
+
+[[stage(fragment)]]
+fn main([[builtin(position)]] coord : vec4<f32>)
+     -> [[location(0)]] vec4<f32> {
+  var result : vec4<f32>;
+  let c = coord.xy / canvas.size;
+  if (c.x < 0.33333) {
+    result = textureLoad(
+      gBufferPosition,
+      vec2<i32>(floor(coord.xy)),
+      0
+    );
+  } else if (c.x < 0.66667) {
+    result = textureLoad(
+      gBufferNormal,
+      vec2<i32>(floor(coord.xy)),
+      0
+    );
+    result.x = (result.x + 1.0) * 0.5;
+    result.y = (result.y + 1.0) * 0.5;
+    result.z = (result.z + 1.0) * 0.5;
+  } else {
+    result = textureLoad(
+      gBufferAlbedo,
+      vec2<i32>(floor(coord.xy)),
+      0
+    );
+  }
+  return result;
+}

package/engine/graphics/render/webgpu/sample/fragmentWriteGBuffers.wgsl

@@ -0,0 +1,21 @@
+struct GBufferOutput {
+  [[location(0)]] position : vec4<f32>;
+  [[location(1)]] normal : vec4<f32>;
+
+  // Textures: diffuse color, specular color, smoothness, emissive etc. could go here
+  [[location(2)]] albedo : vec4<f32>;
+};
+
+[[stage(fragment)]]
+fn main([[location(0)]] fragPosition: vec3<f32>,
+        [[location(1)]] fragNormal: vec3<f32>,
+        [[location(2)]] fragUV : vec2<f32>) -> GBufferOutput {
+    var output : GBufferOutput;
+    output.position = vec4<f32>(fragPosition, 1.0);
+    output.normal = vec4<f32>(fragNormal, 1.0);
+    // faking some kind of checkerboard texture
+    let uv = floor(30.0 * fragUV);
+    let c = 0.2 + 0.5 * ((uv.x + uv.y) - 2.0 * floor((uv.x + uv.y) / 2.0));
+    output.albedo = vec4<f32>(c, c, c, 1.0);
+    return output;
+}

package/engine/graphics/render/webgpu/sample/lightUpdate.wgsl

@@ -0,0 +1,41 @@
+struct LightData {
+  position : vec4<f32>;
+  color : vec3<f32>;
+  radius : f32;
+};
+struct LightsBuffer {
+  lights: array<LightData>;
+};
+[[group(0), binding(0)]] var<storage, read_write> lightsBuffer: LightsBuffer;
+
+struct Config {
+  numLights : u32;
+};
+
+[[group(0), binding(1)]] var<uniform> config: Config;
+
+struct LightExtent {
+  min : vec4<f32>;
+  max : vec4<f32>;
+};
+
+[[group(0), binding(2)]] var<uniform> lightExtent: LightExtent;
+
+[[stage(compute), workgroup_size(64, 1, 1)]]
+fn main([[builtin(global_invocation_id)]] GlobalInvocationID : vec3<u32>) {
+  var index = GlobalInvocationID.x;
+  if (index >= config.numLights) {
+    return;
+  }
+
+  let light = &lightsBuffer.lights[index];
+
+  (*light).position.y = (*light).position.y - 0.001 - 0.003 * (f32(index) - 64.0 * floor(f32(index) / 64.0));
+
+  if ((*light).position.y < lightExtent.min.y) {
+    (*light).position.y = lightExtent.max.y;
+  }
+
+  // write out
+//  lightBuffer.lighs[index] = light;
+}