@woosh/meep-engine 2.33.5 → 2.33.6

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

@@ -3,13 +3,13 @@
  */
 
 
-import Vector4 from "../../../../core/geom/Vector4.js";
 import { clamp } from "../../../../core/math/clamp.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { mix } from "../../../../core/math/mix.js";
 import { BlendingType } from "./BlendingType.js";
 import { assert } from "../../../../core/assert.js";
+import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
 
 function v2CrossMag(ax, ay, bx, by) {
     return ax * by - ay * bx;
@@ -1319,8 +1319,8 @@ Sampler2D.prototype.fill = function (x, y, width, height, value) {
  * @param {number} value
  */
 Sampler2D.prototype.writeChannel = function (x, y, channel, value) {
-    assert.typeOf(x, "number", "x");
-    assert.typeOf(y, "number", "y");
+    assert.isNumber(x, "x");
+    assert.isNumber(y, "y");
 
     assert.greaterThanOrEqual(x, 0);
     assert.greaterThanOrEqual(y, 0);
@@ -1385,32 +1385,6 @@ Sampler2D.prototype.traverseCircle = function (centerX, centerY, radius, visitor
     }
 };
 
-export function arrayConstructorByInstance(a) {
-    if (a instanceof Int8Array) {
-        return Int8Array;
-    } else if (a instanceof Int16Array) {
-        return Int16Array;
-    } else if (a instanceof Int32Array) {
-        return Int32Array;
-    } else if (a instanceof Uint8Array) {
-        return Uint8Array;
-    } else if (a instanceof Uint8ClampedArray) {
-        return Uint8ClampedArray;
-    } else if (a instanceof Uint16Array) {
-        return Uint16Array;
-    } else if (a instanceof Uint32Array) {
-        return Uint32Array;
-    } else if (a instanceof Float32Array) {
-        return Float32Array;
-    } else if (a instanceof Float64Array) {
-        return Float64Array;
-    } else if (Array.isArray(a)) {
-        return Array;
-    } else {
-        throw new TypeError(`Unsupported array type`);
-    }
-}
-
 /**
  *
  * @param {number} x
@@ -1419,31 +1393,40 @@ export function arrayConstructorByInstance(a) {
  */
 Sampler2D.prototype.resize = function (x, y, preserveData = true) {
 
+    const _w = this.width;
+    const _h = this.height;
+
+    if (_w === x && _h === y) {
+        // size didn't change
+        return;
+    }
+
     const itemSize = this.itemSize;
+
     const length = x * y * itemSize;
 
     const oldData = this.data;
 
-    const Constructor = arrayConstructorByInstance(oldData);
+    const Constructor = typedArrayConstructorByInstance(oldData);
 
     const newData = new Constructor(length);
 
     if (preserveData) {
         //copy old data
-        if (x === this.width) {
+        if (x === _w) {
             // number of columns is preserved, we can just copy the old data across
             newData.set(oldData.subarray(0, Math.min(oldData.length, length)));
         } else {
             //we need to copy new data row-by-row
-            const rowCount = min2(y, this.height);
+            const rowCount = min2(y, _h);
 
-            const columnCount = min2(x, this.width);
+            const columnCount = min2(x, _w);
 
             for (let i = 0; i < rowCount; i++) {
                 for (let j = 0; j < columnCount; j++) {
 
                     const targetItemAddress = (i * x + j) * itemSize;
-                    const sourceItemAddress = (i * this.width + j) * itemSize;
+                    const sourceItemAddress = (i * _w + j) * itemSize;
 
                     for (let k = 0; k < itemSize; k++) {
 
@@ -1457,6 +1440,7 @@ Sampler2D.prototype.resize = function (x, y, preserveData = true) {
 
     this.width = x;
     this.height = y;
+
     this.data = newData;
 };
 
@@ -1563,31 +1547,3 @@ Sampler2D.prototype.traverseOrthogonalNeighbours = function (x, y, visitor, this
     }
 };
 
-/**
- *
- * @param {Sampler2D} sampler0
- * @param {Sampler2D} sampler1
- * @returns {Sampler2D}
- */
-export function differenceSampler(sampler0, sampler1) {
-    let v0 = new Vector4();
-    let v1 = new Vector4();
-    //
-    const width = sampler0.width;
-    const height = sampler0.height;
-    //
-    const difference = new Float32Array(width * height);
-    for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            v0 = sampler0.get(x, y, v0);
-            v1 = sampler1.get(x, y, v1);
-            v0.normalize();
-            v1.normalize();
-            //check distance
-            difference[x + y * width] = 1 - v0.dot(v1);
-        }
-    }
-    //
-    const sampleD = new Sampler2D(difference, 1, width, height);
-    return sampleD;
-}

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

@@ -1,6 +1,7 @@
-import { arrayConstructorByInstance, Sampler2D } from "../Sampler2D.js";
+import { Sampler2D } from "../Sampler2D.js";
 import { scaleSampler2D } from "../scaleSampler2D.js";
 import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
+import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInstance.js";
 
 /**
  *
@@ -14,7 +15,7 @@ export function paintSamplerOnHTML(s, x, y, scale, offset) {
 
     const d = 180;
 
-    const target = new Sampler2D(arrayConstructorByInstance(s.data), s.itemSize, d, d);
+    const target = new Sampler2D(typedArrayConstructorByInstance(s.data), s.itemSize, d, d);
 
     scaleSampler2D(s, target);
 

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

@@ -0,0 +1,31 @@
+import Vector4 from "../../../../core/geom/Vector4.js";
+import { Sampler2D } from "./Sampler2D.js";
+
+/**
+ *
+ * @param {Sampler2D} sampler0
+ * @param {Sampler2D} sampler1
+ * @returns {Sampler2D}
+ */
+export function differenceSampler(sampler0, sampler1) {
+    let v0 = new Vector4();
+    let v1 = new Vector4();
+    //
+    const width = sampler0.width;
+    const height = sampler0.height;
+    //
+    const difference = new Float32Array(width * height);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            v0 = sampler0.get(x, y, v0);
+            v1 = sampler1.get(x, y, v1);
+            v0.normalize();
+            v1.normalize();
+            //check distance
+            difference[x + y * width] = 1 - v0.dot(v1);
+        }
+    }
+    //
+    const sampleD = new Sampler2D(difference, 1, width, height);
+    return sampleD;
+}

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

@@ -0,0 +1,25 @@
+export function typedArrayConstructorByInstance(a) {
+    if (a instanceof Int8Array) {
+        return Int8Array;
+    } else if (a instanceof Int16Array) {
+        return Int16Array;
+    } else if (a instanceof Int32Array) {
+        return Int32Array;
+    } else if (a instanceof Uint8Array) {
+        return Uint8Array;
+    } else if (a instanceof Uint8ClampedArray) {
+        return Uint8ClampedArray;
+    } else if (a instanceof Uint16Array) {
+        return Uint16Array;
+    } else if (a instanceof Uint32Array) {
+        return Uint32Array;
+    } else if (a instanceof Float32Array) {
+        return Float32Array;
+    } else if (a instanceof Float64Array) {
+        return Float64Array;
+    } else if (Array.isArray(a)) {
+        return Array;
+    } else {
+        throw new TypeError(`Unsupported array type`);
+    }
+}

package/engine/graphics/texture/sampler/util/drawSamplerHTML.js

@@ -1,6 +1,7 @@
-import { arrayConstructorByInstance, Sampler2D } from "../Sampler2D.js";
+import { Sampler2D } from "../Sampler2D.js";
 import { scaleSampler2D } from "../scaleSampler2D.js";
 import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
+import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInstance.js";
 
 /**
  *
@@ -15,7 +16,7 @@ import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
 export function drawSamplerHTML(parentNode, sampler, x, y, scale, offset, size) {
 
 
-    const target = new Sampler2D(arrayConstructorByInstance(sampler.data), sampler.itemSize, size, size);
+    const target = new Sampler2D(typedArrayConstructorByInstance(sampler.data), sampler.itemSize, size, size);
 
     scaleSampler2D(sampler, target);
 

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.5",
+  "version": "2.33.6",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",

package/view/minimap/gl/MinimapMarkersGL.js

@@ -1,7 +1,7 @@
 import {
     DataTexture,
-    LinearFilter,
     LinearMipMapLinearFilter,
+    NearestFilter,
     NormalBlending,
     Points,
     RGBAFormat,
@@ -82,7 +82,7 @@ function buildMaterial() {
     dataTexture.flipY = false;
     dataTexture.generateMipmaps = true;
     dataTexture.minFilter = LinearMipMapLinearFilter;
-    dataTexture.magFilter = LinearFilter;
+    dataTexture.magFilter = NearestFilter;
 
     const uniforms = {
         atlas: {

package/engine/graphics/micron/render/RefinementSpec.js

@@ -1,181 +0,0 @@
-import Vector2 from "../../../../core/geom/Vector2.js";
-import { Matrix4 } from "three";
-import { mat4 } from "gl-matrix";
-import { v3_length } from "../../../../core/geom/Vector3.js";
-
-/**
- * Normalize a plane in-place
- * @param {number[]} source
- * @param {number} source_offset
- */
-function array_normalize_plane(source, source_offset) {
-    const _x = source[source_offset];
-    const _y = source[source_offset + 1];
-    const _z = source[source_offset + 2];
-
-    const length = v3_length(_x, _y, _z);
-
-    const inverseNormalLength = 1.0 / length;
-
-    /*
-    By re-using values already in the registers instead of using *= we save a few extra READ ops
-     */
-    source[source_offset] = _x * inverseNormalLength;
-    source[source_offset + 1] = _y * inverseNormalLength;
-    source[source_offset + 2] = _z * inverseNormalLength;
-
-    source[source_offset + 3] *= inverseNormalLength;
-}
-
-/**
- *
- * @param {number[]} destination
- * @param {number} destination_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} w
- */
-function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
-    const length = v3_length(x, y, z);
-
-    const inverseNormalLength = 1.0 / length;
-
-    destination[destination_offset] = x * inverseNormalLength;
-    destination[destination_offset + 1] = y * inverseNormalLength;
-    destination[destination_offset + 2] = z * inverseNormalLength;
-    destination[destination_offset + 3] = w * inverseNormalLength;
-}
-
-/**
- *
- * @param {number[]|Float32Array} frustum_planes
- * @param {number[]} me
- */
-function array_setFromProjectionMatrix(frustum_planes, me) {
-
-    const me0 = me[0];
-    const me3 = me[3];
-
-    const me4 = me[4];
-    const me7 = me[7];
-
-    const me8 = me[8];
-    const me11 = me[11];
-
-    const me12 = me[12];
-    const me15 = me[15];
-
-    array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
-    array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
-
-    const me1 = me[1];
-    const me5 = me[5];
-    const me9 = me[9];
-    const me13 = me[13];
-
-    array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
-    array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
-
-    const me2 = me[2];
-    const me6 = me[6];
-    const me10 = me[10];
-    const me14 = me[14];
-
-    array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
-    array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);
-}
-
-export class RefinementSpec {
-    constructor() {
-
-        /**
-         * Viewport resolution
-         * @type {Vector2}
-         */
-        this.resolution = new Vector2();
-
-        /**
-         * Number of pixels in the viewport
-         * @type {number}
-         */
-        this.viewport_area = 0;
-
-        /**
-         * How much error to accept when deciding to subdivide a cluster
-         * Measured in pixels
-         * Higher value will result in better performance but more visible artifacts
-         * @type {number}
-         */
-        this.error_threshold = 1;
-
-        /**
-         * Error threshold as a fraction of the screen area instead of pixels, derived internally from pixel value
-         * @type {number}
-         */
-        this.error_threshold_normalized = 1;
-
-        /**
-         * Object-space camera frustum
-         * Frustum planes in compact form
-         * @type {Float32Array}
-         */
-        this.frustum_f32 = new Float32Array(24);
-
-        /**
-         * Model world transform
-         * @type {Float32Array|number[]|mat4}
-         */
-        this.transform = new Float32Array(16);
-
-        /**
-         * Contains transformation from camera space to object space
-         * @type {Float32Array|number[]|mat4}
-         */
-        this.projection_matrix = new Float32Array(16);
-
-        /**
-         * FOV in radians
-         * @type {number}
-         */
-        this.focal_length = 0;
-
-        /**
-         * Object-space camera position
-         * @type {Float32Array}
-         */
-        this.view_position = new Float32Array(3);
-    }
-
-    get frustum() {
-        throw new Error('deprecated, use .frustum_f32 instead');
-    }
-
-    setResolution(x, y) {
-        this.resolution.set(x, y);
-
-        this.viewport_area = x * y;
-
-        this.error_threshold_normalized = this.error_threshold / this.viewport_area;
-    }
-
-    /**
-     *
-     * @param {Matrix4} transform world-space object transform
-     * @param {Matrix4} matrix_world_inverse camera's world inverse matrix
-     * @param {Matrix4} matrix_projection camera's projection matrix
-     */
-    build(transform, matrix_world_inverse, matrix_projection) {
-        const _transform = this.transform;
-        _transform.set(transform.elements);
-
-        // build projection matrix
-        const projection_matrix = this.projection_matrix;
-
-        mat4.multiply(projection_matrix, matrix_world_inverse.elements, _transform);
-        mat4.multiply(projection_matrix, matrix_projection.elements, projection_matrix);
-
-        // compute view frustum in model-space
-        array_setFromProjectionMatrix(this.frustum_f32, projection_matrix);
-    }
-}