@woosh/meep-engine 2.33.62 → 2.33.67

package/engine/graphics/texture/sampler/debug/paintSamplerOnHTML.js

@@ -10,20 +10,23 @@ import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInsta
  * @param {number} y
  * @param scale
  * @param offset
+ * @param {number} resolution
  */
-export function paintSamplerOnHTML(s, x, y, scale, offset) {
+export function paintSamplerOnHTML(s, x, y, scale, offset, resolution=256) {
 
-    const d = 180;
+    const d = resolution;
 
-    const target = new Sampler2D(typedArrayConstructorByInstance(s.data), s.itemSize, d, d);
+    const TA = typedArrayConstructorByInstance(s.data);
+
+    const target = new Sampler2D(new TA(d * d * s.itemSize), s.itemSize, d, d);
 
     scaleSampler2D(s, target);
 
     const c = convertSampler2D2Canvas(target, scale, offset);
     c.style.zIndex = 1000;
     c.style.position = "absolute";
-    c.style.left = `${x * d}px`;
-    c.style.top = `${y * d}px`;
+    c.style.left = `${x}px`;
+    c.style.top = `${y}px`;
 
     document.body.appendChild(c);
 }

package/engine/graphics/texture/sampler/sampler2DToFloat32Texture.js

@@ -1,5 +1,8 @@
-import { ClampToEdgeWrapping, DataTexture, FloatType, LinearFilter, NearestFilter, RedFormat } from "three";
+import { ClampToEdgeWrapping, DataTexture, FloatType, LinearFilter, NearestFilter } from "three";
 import { assert } from "../../../../core/assert.js";
+import { channelCountToThreeTextureFormat } from "../channelCountToThreeTextureFormat.js";
+import { computeThreeTextureInternalFormatFromDataType } from "../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
+import { DataType } from "../../../../core/collection/table/DataType.js";
 
 /**
  *
@@ -12,7 +15,7 @@ export function sampler2DtoFloat32Texture(sampler) {
     const width = sampler.width;
     const height = sampler.height;
 
-    const texture = new DataTexture(sampler.data, width, height, RedFormat, FloatType);
+    const texture = new DataTexture(sampler.data, width, height);
 
     texture.wrapS = ClampToEdgeWrapping;
     texture.wrapT = ClampToEdgeWrapping;
@@ -24,7 +27,11 @@ export function sampler2DtoFloat32Texture(sampler) {
 
     texture.flipY = false;
 
-    texture.internalFormat = 'R32F';
+    texture.type = FloatType;
+    texture.format = channelCountToThreeTextureFormat(sampler.itemSize);
+    texture.internalFormat = computeThreeTextureInternalFormatFromDataType(DataType.Float32, sampler.itemSize);
+
+    texture.needsUpdate = true;
 
     return texture;
 }

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/generation/example/filters/SampleGroundMoistureFilter.js

@@ -24,7 +24,8 @@ export const SampleGroundMoistureFilter = CellFilterAdd.from(
                 CellFilterStep.from(CellFilterLiteralFloat.from(0), fReadHeight)
             ),
             7,
-            7
+            7,
+            1
         ),
         CellFilterLiteralFloat.from(0.6)
     )

package/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -1,9 +1,23 @@
 import { CellFilter } from "../../CellFilter.js";
 import { gaussian } from "../../../../core/math/gaussian.js";
-
+import { max2 } from "../../../../core/math/max2.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} samplesX
+ * @param {number} samplesY
+ * @param {number} sigma_x
+ * @param {number} sigma_y
+ * @return {number}
+ */
 function buildKernel(result, samplesX, samplesY, sigma_x, sigma_y) {
-    const half_samples_x = (samplesX / 2);
-    const half_samples_y = (samplesY / 2);
+    assert.isNonNegativeInteger(samplesX, 'samplesX');
+    assert.isNonNegativeInteger(samplesY, 'samplesY');
+
+    const half_samples_x = samplesX * 0.5;
+    const half_samples_y = samplesY * 0.5;
 
     let powerTotal = 0;
     let ix, iy;
@@ -70,6 +84,8 @@ export class CellFilterGaussianBlur extends CellFilter {
         if (!this.source.initialized) {
             this.source.initialize(grid, seed);
 
+            this.__kernel = new Float32Array(this.samples_x * this.samples_y);
+
             // initialize kernel
             this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
         }
@@ -84,13 +100,13 @@ export class CellFilterGaussianBlur extends CellFilter {
      * @param {number} quality
      * @returns {CellFilterGaussianBlur}
      */
-    static from(source, x, y, quality = 5) {
+    static from(source, x, y, quality = 3) {
         const r = new CellFilterGaussianBlur();
 
         r.source = source;
 
-        r.samples_x = quality * x;
-        r.samples_y = quality * y;
+        r.samples_x = max2(2, Math.round(quality * x));
+        r.samples_y = max2(2, Math.round(quality * y));
 
         r.size_x = x;
         r.size_y = y;
@@ -102,24 +118,24 @@ export class CellFilterGaussianBlur extends CellFilter {
         const samplesX = this.samples_x;
         const samplesY = this.samples_y;
 
-        const half_samples_x = (samplesX / 2);
-        const half_samples_y = (samplesY / 2);
+        const half_samples_x = (samplesX - 1) * 0.5;
+        const half_samples_y = (samplesY - 1) * 0.5;
 
         const sizeX = this.size_x;
         const sizeY = this.size_y;
 
-        const local_u_scale = 1 / samplesX;
-        const local_v_scale = 1 / samplesY;
+        const local_u_scale = 1 / (samplesX - 1);
+        const local_v_scale = 1 / (samplesY - 1);
 
         let sum = 0;
-        let ix, iy;
+        let ix, iy = 0;
 
         const source = this.source;
         const kernel = this.__kernel;
 
-        const i_samples_x = samplesX|0;
+        const i_samples_x = samplesX | 0;
 
-        for (iy = 0; iy < samplesY; iy++) {
+        for (; iy < samplesY; iy++) {
             const local_y = iy - half_samples_y;
 
             const ny = local_y * local_v_scale;

package/generation/grid/GridData.js

@@ -2,6 +2,7 @@ import { assert } from "../../core/assert.js";
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { OffsetScaleTransform2D } from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D.js";
 import { MarkerMatchCounter } from "./MarkerMatchCounter.js";
+import { max2 } from "../../core/math/max2.js";
 
 const scratch_match_counter = new MarkerMatchCounter();
 
@@ -167,8 +168,14 @@ export class GridData {
      * @param {number} height
      */
     resize(width, height) {
-        assert.typeOf(width, 'number', 'width');
-        assert.typeOf(height, 'number', 'height');
+        assert.isNumber(width, 'width');
+        assert.isNumber(height, 'height');
+
+        assert.isNonNegativeInteger(width,'width');
+        assert.isNonNegativeInteger(height,'height');
+
+        assert.isFiniteNumber(width, 'width');
+        assert.isFiniteNumber(height, 'width');
 
         if (width === this.width && height === this.height) {
             //no need, already the right size
@@ -187,6 +194,14 @@ export class GridData {
 
             layer.resize(width, height);
         }
+
+        // resize the quad tree pre-emptively, to avoid expensive re-balancing operations later on
+        this.markers.resize(
+            -max2(1, width * 0.5),
+            -max2(1, height * 0.5),
+            max2(width + 1, width * 1.5),
+            max2(height + 1, height * 1.5)
+        );
     }
 
     /**

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.62",
+  "version": "2.33.67",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",