@woosh/meep-engine 2.33.61 → 2.33.65

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

@@ -7,19 +7,23 @@ struct LightData {
   color : vec3<f32>;
   radius : f32;
 };
-[[block]] struct LightsBuffer {
+
+struct LightsBuffer {
   lights: array<LightData>;
 };
+
 [[group(1), binding(0)]] var<storage, read> lightsBuffer: LightsBuffer;
 
-[[block]] struct Config {
+struct Config {
   numLights : u32;
 };
+
 [[group(1), binding(1)]] var<uniform> config: Config;
 
-[[block]] struct CanvasConstants {
+struct CanvasConstants {
   size: vec2<f32>;
 };
+
 [[group(2), binding(0)]] var<uniform> canvas : CanvasConstants;
 
 [[stage(fragment)]]

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

@@ -2,9 +2,10 @@
 [[group(0), binding(1)]] var gBufferNormal: texture_2d<f32>;
 [[group(0), binding(2)]] var gBufferAlbedo: texture_2d<f32>;
 
-[[block]] struct CanvasConstants {
+struct CanvasConstants {
   size: vec2<f32>;
 };
+
 [[group(1), binding(0)]] var<uniform> canvas : CanvasConstants;
 
 [[stage(fragment)]]
@@ -18,7 +19,7 @@ fn main([[builtin(position)]] coord : vec4<f32>)
       vec2<i32>(floor(coord.xy)),
       0
     );
-  } elseif (c.x < 0.66667) {
+  } else if (c.x < 0.66667) {
     result = textureLoad(
       gBufferNormal,
       vec2<i32>(floor(coord.xy)),
@@ -35,4 +36,4 @@ fn main([[builtin(position)]] coord : vec4<f32>)
     );
   }
   return result;
-}
+}

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

@@ -3,20 +3,22 @@ struct LightData {
   color : vec3<f32>;
   radius : f32;
 };
-[[block]] struct LightsBuffer {
+struct LightsBuffer {
   lights: array<LightData>;
 };
 [[group(0), binding(0)]] var<storage, read_write> lightsBuffer: LightsBuffer;
 
-[[block]] struct Config {
+struct Config {
   numLights : u32;
 };
+
 [[group(0), binding(1)]] var<uniform> config: Config;
 
-[[block]] struct LightExtent {
+struct LightExtent {
   min : vec4<f32>;
   max : vec4<f32>;
 };
+
 [[group(0), binding(2)]] var<uniform> lightExtent: LightExtent;
 
 [[stage(compute), workgroup_size(64, 1, 1)]]
@@ -26,9 +28,14 @@ fn main([[builtin(global_invocation_id)]] GlobalInvocationID : vec3<u32>) {
     return;
   }
 
-  lightsBuffer.lights[index].position.y = lightsBuffer.lights[index].position.y - 0.5 - 0.003 * (f32(index) - 64.0 * floor(f32(index) / 64.0));
+  let light = &lightsBuffer.lights[index];
 
-  if (lightsBuffer.lights[index].position.y < lightExtent.min.y) {
-    lightsBuffer.lights[index].position.y = lightExtent.max.y;
+  (*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;
 }

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

@@ -5,62 +5,95 @@ import fragmentWriteGBuffers from './fragmentWriteGBuffers.wgsl';
 import vertexTextureQuad from './vertexTextureQuad.wgsl';
 import fragmentGBuffersDebugView from './fragmentGBuffersDebugView.wgsl';
 import fragmentDeferredRendering from './fragmentDeferredRendering.wgsl';
-import { GUI } from "dat.gui";
+import dat from "dat.gui";
+import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
+import { noop } from "../../../../../core/function/Functions.js";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshInstance } from "./MeshInstance.js";
 
 const kMaxNumLights = 1024;
 const lightExtentMin = vec3.fromValues(-50, -30, -50);
 const lightExtentMax = vec3.fromValues(50, 50, 50);
-const mesh = [];
+
+/**
+ *
+ * @param {string} path
+ * @return {Promise<THREE.BufferGeometry>}
+ */
+function load_geometry(path) {
+    const loader = new PLYLoader();
+
+    return new Promise((resolve, reject) => {
+
+        loader.load(path, resolve, noop, reject);
+    });
+}
+
+function load_geometry_gltf(path) {
+    const loader = new GLTFLoader();
+
+    return new Promise((resolve, reject) => {
+        loader.load(path, (gltf) => {
+            let r = null;
+
+            gltf.scene.traverse(o => {
+                if (o.isMesh) {
+                    r = o.geometry;
+                }
+            });
+
+            resolve(r);
+
+        }, noop, reject);
+    });
+}
 
 const init = async ({ canvasRef, gui }) => {
+
+    // const mesh = await load_geometry("data/models/stanford/dragon_recon/dragon_vrip.ply");
+    const mesh = await load_geometry_gltf("data/models/stanford/DragonAttenuation.glb");
+
+
     const adapter = await navigator.gpu.requestAdapter();
     const device = await adapter.requestDevice();
-    if (canvasRef.current === null)
+
+    /**
+     *
+     * @type {HTMLCanvasElement}
+     */
+    const canvas = canvasRef.current;
+
+    if (canvas === null) {
         return;
-    const context = canvasRef.current.getContext('webgpu');
+    }
+
+    /**
+     *
+     * @type {GPUCanvasContext}
+     */
+    const context = canvas.getContext('webgpu');
+
     const devicePixelRatio = window.devicePixelRatio || 1;
+
     const presentationSize = [
-        canvasRef.current.clientWidth * devicePixelRatio,
-        canvasRef.current.clientHeight * devicePixelRatio,
+        canvas.clientWidth * devicePixelRatio,
+        canvas.clientHeight * devicePixelRatio,
     ];
+
     const aspect = presentationSize[0] / presentationSize[1];
+
     const presentationFormat = context.getPreferredFormat(adapter);
+
     context.configure({
         device,
         format: presentationFormat,
         size: presentationSize,
     });
-    // Create the model vertex buffer.
-    const kVertexStride = 8;
-    const vertexBuffer = device.createBuffer({
-        // position: vec3, normal: vec3, uv: vec2
-        size: mesh.positions.length * kVertexStride * Float32Array.BYTES_PER_ELEMENT,
-        usage: GPUBufferUsage.VERTEX,
-        mappedAtCreation: true,
-    });
-    {
-        const mapping = new Float32Array(vertexBuffer.getMappedRange());
-        for (let i = 0; i < mesh.positions.length; ++i) {
-            mapping.set(mesh.positions[i], kVertexStride * i);
-            mapping.set(mesh.normals[i], kVertexStride * i + 3);
-            mapping.set(mesh.uvs[i], kVertexStride * i + 6);
-        }
-        vertexBuffer.unmap();
-    }
-    // Create the model index buffer.
-    const indexCount = mesh.triangles.length * 3;
-    const indexBuffer = device.createBuffer({
-        size: indexCount * Uint16Array.BYTES_PER_ELEMENT,
-        usage: GPUBufferUsage.INDEX,
-        mappedAtCreation: true,
-    });
-    {
-        const mapping = new Uint16Array(indexBuffer.getMappedRange());
-        for (let i = 0; i < mesh.triangles.length; ++i) {
-            mapping.set(mesh.triangles[i], 3 * i);
-        }
-        indexBuffer.unmap();
-    }
+
+    const m_instance = new MeshInstance();
+    m_instance.geometry = mesh;
+    m_instance.init(device);
+
     // GBuffer texture render targets
     const gBufferTexture2DFloat = device.createTexture({
         size: [...presentationSize, 3],
@@ -290,7 +323,7 @@ const init = async ({ canvasRef, gui }) => {
     };
     const settings = {
         mode: 'rendering',
-        numLights: 128,
+        numLights:1,
     };
     const configUniformBuffer = (() => {
         const buffer = device.createBuffer({
@@ -486,7 +519,7 @@ const init = async ({ canvasRef, gui }) => {
 
     // Rotates the camera around the origin based on time.
     function getCameraViewProjMatrix() {
-        const eyePosition = vec3.fromValues(0, 50, -100);
+        const eyePosition = vec3.fromValues(0, 50, -10);
         const rad = Math.PI * (Date.now() / 5000);
         vec3.rotateY(eyePosition, eyePosition, origin, rad);
         const viewMatrix = mat4.create();
@@ -497,7 +530,7 @@ const init = async ({ canvasRef, gui }) => {
 
     function frame() {
         // Sample is no longer the active page.
-        if (!canvasRef.current)
+        if (!canvas)
             return;
         const cameraViewProj = getCameraViewProjMatrix();
         device.queue.writeBuffer(cameraUniformBuffer, 0, cameraViewProj.buffer, cameraViewProj.byteOffset, cameraViewProj.byteLength);
@@ -507,9 +540,9 @@ const init = async ({ canvasRef, gui }) => {
             const gBufferPass = commandEncoder.beginRenderPass(writeGBufferPassDescriptor);
             gBufferPass.setPipeline(writeGBuffersPipeline);
             gBufferPass.setBindGroup(0, sceneUniformBindGroup);
-            gBufferPass.setVertexBuffer(0, vertexBuffer);
-            gBufferPass.setIndexBuffer(indexBuffer, 'uint16');
-            gBufferPass.drawIndexed(indexCount);
+
+                m_instance.draw(gBufferPass);
+
             gBufferPass.endPass();
         }
         {
@@ -557,10 +590,15 @@ const init = async ({ canvasRef, gui }) => {
 };
 
 const canvas_el = document.createElement('canvas');
+canvas_el.width = window.innerWidth;
+canvas_el.height = window.innerHeight;
 
+document.body.appendChild(canvas_el);
+
+const gui = new dat.GUI();
 init({
     canvasRef: {
         current: canvas_el,
-        gui: new GUI()
-    }
+    },
+    gui: gui
 });

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

@@ -1,10 +1,12 @@
-[[block]] struct Uniforms {
+struct Uniforms {
   modelMatrix : mat4x4<f32>;
   normalModelMatrix : mat4x4<f32>;
 };
-[[block]] struct Camera {
+
+struct Camera {
   viewProjectionMatrix : mat4x4<f32>;
 };
+
 [[group(0), binding(0)]] var<uniform> uniforms : Uniforms;
 [[group(0), binding(1)]] var<uniform> camera : Camera;
 
@@ -25,4 +27,4 @@ fn main([[location(0)]] position : vec3<f32>,
   output.fragNormal = normalize((uniforms.normalModelMatrix * vec4<f32>(normal, 1.0)).xyz);
   output.fragUV = uv;
   return output;
-}
+}

package/engine/graphics/util/modelHitTest.js

@@ -0,0 +1,63 @@
+import Vector2 from "../../../core/geom/Vector2.js";
+import Mesh from "../ecs/mesh/Mesh.js";
+
+const tempPoint = new Vector2();
+
+/**
+ *
+ * @param {SurfacePoint3} result
+ * @param {Array.<Number>} entities
+ * @param {EntityComponentDataset} ecd
+ * @param {GraphicsEngine} ge
+ * @param {Number} x
+ * @param {Number} y
+ * @returns {Number} entity number or -1 in case of failed test
+ */
+function modelHitTest(result, entities, ecd, ge, x, y) {
+    tempPoint.set(x, y);
+
+    ge.normalizeViewportPoint(tempPoint, tempPoint);
+
+    let i = 0;
+    const l = entities.length;
+
+    for (; i < l; i++) {
+
+        const entity = entities[i];
+
+        const model = ecd.getComponent(entity, Mesh);
+
+        if (model === null) {
+            //entity no longer exists most likely
+            continue;
+        }
+
+        /**
+         *
+         * @type {Intersection[]}
+         */
+        const hits = ge.intersectObjectUnderViewportPoint(tempPoint.x, tempPoint.y, model.mesh, true);
+
+        // get hit
+
+
+        if (hits.length > 0) {
+            /**
+             *
+             * @type {Intersection}
+             */
+            const hit = hits[0];
+
+            result.position.copy(hit.point);
+
+            //TODO extract normal
+
+            return entity;
+        }
+
+    }
+
+    return -1;
+}
+
+export { modelHitTest };

package/engine/grid/systems/GridPosition2TransformSystem.js

@@ -6,8 +6,8 @@ import { Transform } from '../../ecs/transform/Transform.js';
 import GridPosition from '../components/GridPosition.js';
 import { GridPosition2Transform } from '../components/GridPosition2Transform.js';
 import Vector3 from "../../../core/geom/Vector3.js";
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import { GridPosition2TransformFlags } from "../components/GridPosition2TransformFlags.js";
+import { obtainTerrain } from "../../ecs/terrain/util/obtainTerrain.js";
 
 
 export class GridPosition2TransformSystem extends System {

package/engine/grid/systems/ViewportGridProjectionSystem.js

@@ -5,9 +5,9 @@ import { System } from '../../ecs/System.js';
 import GeometryBVH from '../../ecs/components/GeometryBVH.js';
 import GridPosition from '../components/GridPosition.js';
 import ViewportGridProjection from '../components/ViewportGridProjection.js';
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector3 from "../../../core/geom/Vector3.js";
+import { obtainTerrain } from "../../ecs/terrain/util/obtainTerrain.js";
 
 class ViewportGridProjectionSystem extends System {
     constructor(grid, graphicsEngine) {

package/engine/grid/transform2grid/Transform2GridPositionSystem.js

@@ -2,9 +2,9 @@ import { System } from "../../ecs/System.js";
 import { Transform2GridPosition } from "./Transform2GridPosition.js";
 import GridPosition from "../components/GridPosition.js";
 import { Transform } from "../../ecs/transform/Transform.js";
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { Transform2GridPositionMode } from "./Transform2GridPositionMode.js";
+import { obtainTerrain } from "../../ecs/terrain/util/obtainTerrain.js";
 
 const v2 = new Vector2();
 

package/engine/scene/transitionToScene.js

@@ -1,11 +1,11 @@
 import { actionTask, delayTask, wrapTaskIgnoreFailure } from "../../core/process/task/TaskUtils.js";
-import { loadVisibleTerrainTiles } from "../../../model/game/scenes/SceneUtils.js";
 import TaskGroup from "../../core/process/task/TaskGroup.js";
 import Task from "../../core/process/task/Task.js";
 import TaskState from "../../core/process/task/TaskState.js";
 import { noop } from "../../core/function/Functions.js";
 import { compileAllMaterials } from "../graphics/ecs/compileAllMaterials.js";
 import { createTaskWaitForMeshesToLoad } from "../graphics/ecs/mesh/createTaskWaitForMeshesToLoad.js";
+import { loadVisibleTerrainTiles } from "../ecs/terrain/util/loadVisibleTerrainTiles.js";
 
 
 /**

package/generation/grid/actions/ContinuousGridCellActionSetTerrainHeight.js

@@ -2,9 +2,9 @@ import { lerp } from "../../../core/math/lerp.js";
 import { min2 } from "../../../core/math/min2.js";
 import { ContinuousGridCellAction } from "./ContinuousGridCellAction.js";
 import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import { assert } from "../../../core/assert.js";
 import { CellFilterLiteralFloat } from "../../filtering/numeric/CellFilterLiteralFloat.js";
+import { obtainTerrain } from "../../../engine/ecs/terrain/util/obtainTerrain.js";
 
 export class ContinuousGridCellActionSetTerrainHeight extends ContinuousGridCellAction {
     constructor() {

package/generation/markers/actions/placement/MarkerNodeEntityProcessorClingToTerrain.js

@@ -1,7 +1,7 @@
 import { MarkerNodeEntityProcessor } from "./MarkerNodeEntityProcessor.js";
-import { obtainTerrain } from "../../../../../model/game/scenes/SceneUtils.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { alignToVector } from "../../../../engine/ecs/terrain/ecs/ClingToTerrainSystem.js";
+import { obtainTerrain } from "../../../../engine/ecs/terrain/util/obtainTerrain.js";
 
 const p = new SurfacePoint3();
 

package/generation/markers/debug/visualizeMarkers.js

@@ -11,13 +11,13 @@ import {
 import EntityBuilder from "../../../engine/ecs/EntityBuilder.js";
 import Renderable from "../../../engine/ecs/components/Renderable.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
-import { obtainTerrain } from "../../../../model/game/scenes/SceneUtils.js";
 import LabelView from "../../../view/common/LabelView.js";
 import GUIElement from "../../../engine/ecs/gui/GUIElement.js";
 import ViewportPosition from "../../../engine/ecs/gui/position/ViewportPosition.js";
 import HeadsUpDisplay from "../../../engine/ecs/gui/hud/HeadsUpDisplay.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { MarkerNodeMatcherAny } from "../matcher/MarkerNodeMatcherAny.js";
+import { obtainTerrain } from "../../../engine/ecs/terrain/util/obtainTerrain.js";
 
 function formatValue(v) {
 

package/generation/theme/ThemeEngine.js

@@ -1,6 +1,5 @@
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { assert } from "../../core/assert.js";
-import { obtainTerrain } from "../../../model/game/scenes/SceneUtils.js";
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 import { TerrainLayerRuleAggregator } from "./TerrainLayerRuleAggregator.js";
 import { actionTask, countTask, emptyTask, futureTask } from "../../core/process/task/TaskUtils.js";
@@ -17,6 +16,7 @@ import { TerrainLayer } from "../../engine/ecs/terrain/ecs/layers/TerrainLayer.j
 import { TerrainFlags } from "../../engine/ecs/terrain/ecs/TerrainFlags.js";
 import { binarySearchLowIndex } from "../../core/collection/array/binarySearchLowIndex.js";
 import { randomFloatBetween } from "../../core/math/random/randomFloatBetween.js";
+import { obtainTerrain } from "../../engine/ecs/terrain/util/obtainTerrain.js";
 
 /**
  *

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.61",
+  "version": "2.33.65",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/samples/terrain/main.js

@@ -2,11 +2,11 @@ import { EngineConfiguration } from "../../engine/EngineConfiguration.js";
 import { EngineHarness } from "../../engine/EngineHarness.js";
 import { GameAssetType } from "../../engine/asset/GameAssetType.js";
 import { TextureAssetLoader } from "../../engine/asset/loaders/texture/TextureAssetLoader.js";
-import { obtainTerrain } from "../../../model/game/scenes/SceneUtils.js";
 import { ImprovedNoise } from "three/examples/jsm/math/ImprovedNoise.js";
 import { lerp } from "../../core/math/lerp.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import Vector3 from "../../core/geom/Vector3.js";
+import { obtainTerrain } from "../../engine/ecs/terrain/util/obtainTerrain.js";
 
 const eh = new EngineHarness();
 

package/view/minimap/Minimap.js

@@ -19,7 +19,7 @@ import { MinimapWorldGL } from "./gl/MinimapWorldGL.js";
 import { MinimapCameraView } from "./dom/MinimapCameraView.js";
 import { MinimapFogOfWar } from "./gl/MinimapFogOfWar.js";
 import { MinimapTerrainGL } from "./gl/MinimapTerrainGL.js";
-import { obtainTerrain } from "../../../model/game/scenes/SceneUtils.js";
+import { obtainTerrain } from "../../engine/ecs/terrain/util/obtainTerrain.js";
 
 
 class MinimapView extends View {