@woosh/meep-engine 2.33.59 → 2.33.63

package/engine/graphics/render/frame_graph/UsageModeType.js

@@ -0,0 +1,5 @@
+export const UsageModeType = {
+    Read: 1,
+    Write: 2,
+    Create: 4
+}

package/engine/graphics/render/frame_graph/sample/deferred/GBufferDrawPass.js

@@ -0,0 +1,27 @@
+import { RenderPass } from "../../RenderPass.js";
+import { TextureDescriptor } from "../../TextureDescriptor.js";
+
+export class GBufferDrawPass extends RenderPass {
+    setup(builder, inputs) {
+        // ignore inputs
+
+        const out_albedo = new TextureDescriptor();
+        const res_albedo = builder.createTexture(out_albedo);
+
+        const out_normal = new TextureDescriptor();
+        const res_normal = builder.createTexture(out_normal);
+
+        const out_depth = new TextureDescriptor();
+        const res_depth = builder.createTexture(out_depth);
+
+        return {
+            albedo: res_albedo,
+            normal: res_normal,
+            depth: res_depth
+        };
+    }
+
+    execute(resources, render_context) {
+
+    }
+}

package/engine/graphics/render/frame_graph/sample/deferred/PresentPass.js

@@ -0,0 +1,17 @@
+import { RenderPass } from "../../RenderPass.js";
+
+export class PresentPass extends RenderPass {
+    /**
+     *
+     * @param builder
+     * @param {Resource} data
+     * @return {{data: ResourceReference}}
+     */
+    setup(builder, { data }) {
+        const input_ref = builder.read(data, 0);
+
+        return {
+            data: input_ref
+        };
+    }
+}

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -8,7 +8,6 @@ import PathFollowingSystem from "../../../../navigation/ecs/path_following/PathF
 import SteeringSystem from "../../../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../../../ecs/sockets/AttachmentSocketsSystem.js";
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
 import { SoundEmitterSystem } from "../../../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../../../sound/ecs/SoundControllerSystem.js";
@@ -97,7 +96,6 @@ function makeConfig(engine) {
         new SteeringSystem(),
         new MotionSystem(),
         new TagSystem(),
-        new AttachmentSocketsSystem(),
         new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),

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

@@ -0,0 +1,99 @@
+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
+     */
+    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;
+}