@woosh/meep-engine 2.33.3 → 2.33.8

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/convertTexture2Sampler2D.js

@@ -1,7 +1,8 @@
 import { WebGLRendererPool } from "../../render/RendererPool.js";
-import ImageFilter, { flipArrayInPlace } from "../../filter/ImageFilter.js";
+import ImageFilter from "../../filter/ImageFilter.js";
 import { Sampler2D } from "./Sampler2D.js";
 import CopyShader from "../../postprocess/threejs/shaders/CopyShader.js";
+import { flipArrayInPlace } from "../../filter/FlipArrayInPlace.js";
 
 
 const DEFAULT_TEXTURE_WIDTH = 512;
@@ -65,7 +66,7 @@ export function convertTexture2Sampler2D(texture, width, height, flipY = true) {
                 value: texture,
                 type: 't'
             },
-            "opacity": { value: 1.0 }
+            opacity: { value: 1.0 }
         }
     });
 

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/engine/graphics/texture/virtual/v2/ShaderUsage.js

@@ -14,27 +14,28 @@ function vertex() {
 function fragment() {
     return `
 uniform vec4 u_mt_tex; // [ width, height, tileSize, id ]
+uniform vec2 u_mt_params; // [ bias, maxLevel, xx, xx ]
+varying vec2 vUv;
+
 float MTCalculateMipLevel( const in vec2 uv, const in float bias ) {
     vec2 dx = dFdx( uv * u_mt_tex.x );
     vec2 dy = dFdy( uv * u_mt_tex.y );
     return log2( max( dot( dx, dx ), dot( dy, dy ) ) ) / 2.0 + bias;
 }
 
-uniform vec2 u_mt_params; // [ bias, maxLevel, xx, xx ]
 vec4 MTCalculateTileKeyRGBA( const in vec2 uv ) {
    float level = clamp( floor( MTCalculateMipLevel( uv, u_mt_params.x ) ), 0.0, u_mt_params.y );
    vec2 texIS = uv.xy * u_mt_tex.xy;                     // [0-1]x[0-1] -> [0-texwidth]x[0-texheight]
    vec2 texLS = texIS / exp2( level );                   // -> [0-levelwidth]x[0-levelheight]
    vec2 texTS = floor( texLS / u_mt_tex.z );             // -> [0->tileswide]x[0-tileshigh]
-   return vec4( u_mt_params.y - level, texTS.xy, u_mt_tex.w ) / 255.0; // [ texId, level, tileX, tileY ] -> RGBA
+   return vec4( u_mt_params.y - level, texTS.xy, u_mt_tex.w ) / 255.0; // [  level, tileX, tileY, texId ] -> RGBA
 }
 
-    varying vec2 vUv;
     
 void main(){
     vec4 tile =  MTCalculateTileKeyRGBA(vUv);
     // gl_FragColor = tile;
-    gl_FragColor = vec4(mix(0.1,1.0,tile.x*255.0), tile.yz*64.0, 1.0);
+    gl_FragColor = vec4(mix(0.1,1.0,tile.x*255.0/u_mt_params.y), tile.yz*64.0, 1.0);
     // gl_FragColor = MTCalculateTileKeyRGBA(vUv);
     // gl_FragColor = vec4(1.0);
 }
@@ -44,4 +45,4 @@ void main(){
 export {
     vertex,
     fragment
-};
+};

package/engine/graphics/texture/virtual/v2/prototype.js

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import { fragment, vertex } from "./ShaderUsage.js";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
 
 let camera, renderer, clock, scene;
 
@@ -22,7 +23,14 @@ function init() {
     const textureLoader = new THREE.TextureLoader();
 
     uniforms = {
-        "u_mt_params": { value: new THREE.Vector2(0.1, 5) },
+        "u_mt_params": { value: new THREE.Vector2(0.1, 6) },
+        /**
+         * Format: VT_WIDTH, VT_HEIGHT, VT_TILE_SIZE, VT_ID
+         *   - VT_WIDTH :       width of the virtual texture
+         *   - VT_HEIGHT :      height of the virtual texture
+         *   - VT_TILE_SIZE :   resolution of a single tile
+         *   - VT_ID :          multiple different virtual textures may be used, this identifies current texture
+         */
         "u_mt_tex": { value: new THREE.Vector4(16384, 16384, 256, 1) }
     };
 
@@ -30,11 +38,11 @@ function init() {
 
     const material = new THREE.ShaderMaterial({
 
-                                                  uniforms: uniforms,
-                                                  vertexShader: vertex(),
-                                                  fragmentShader: fragment()
+        uniforms: uniforms,
+        vertexShader: vertex(),
+        fragmentShader: fragment()
 
-                                              });
+    });
 
     mesh = new THREE.Mesh(new THREE.TorusGeometry(size, 0.3, 30, 30), material);
     mesh.rotation.x = 0.3;
@@ -57,6 +65,8 @@ function init() {
 
     window.addEventListener("resize", onWindowResize);
 
+    new OrbitControls(camera, renderer.domElement);
+
 }
 
 function onWindowResize() {
@@ -88,4 +98,4 @@ function render() {
     renderer.clear();
     renderer.render(scene, camera)
 
-}
+}

package/engine/plugin/EnginePluginManager.d.ts

@@ -0,0 +1,9 @@
+import {Reference} from "../reference/v2/Reference";
+
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
+export class EnginePluginManager {
+    acquire<T>(klass: Type<T>): Promise<Reference<T>>
+}

package/engine/reference/v2/Reference.d.ts

@@ -0,0 +1,7 @@
+export class Reference<T> {
+    getValue(): T | null
+
+    release(): void
+
+    bind(v: T): void
+}

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.3",
+  "version": "2.33.8",
   "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/build/clustering/cluster_mesh_vertices.js

@@ -1,3 +0,0 @@
-export function cluster_mesh_vertices(mesh, max_face_count){
-
-}

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

@@ -1,159 +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[]|Float32Array} frustum_planes
- * @param {number[]} me
- */
-function array_setFromProjectionMatrix(frustum_planes, me) {
-
-    const me0 = me[0], me1 = me[1], me2 = me[2], me3 = me[3];
-    const me4 = me[4], me5 = me[5], me6 = me[6], me7 = me[7];
-    const me8 = me[8], me9 = me[9], me10 = me[10], me11 = me[11];
-    const me12 = me[12], me13 = me[13], me14 = me[14], me15 = me[15];
-
-    frustum_planes[0] = me3 - me0;
-    frustum_planes[1] = me7 - me4;
-    frustum_planes[2] = me11 - me8;
-    frustum_planes[3] = me15 - me12;
-
-    frustum_planes[4] = me3 + me0;
-    frustum_planes[5] = me7 + me4;
-    frustum_planes[6] = me11 + me8;
-    frustum_planes[7] = me15 + me12;
-
-    frustum_planes[8] = me3 + me1;
-    frustum_planes[9] = me7 + me5;
-    frustum_planes[10] = me11 + me9;
-    frustum_planes[11] = me15 + me13;
-
-    frustum_planes[12] = me3 - me1;
-    frustum_planes[13] = me7 - me5;
-    frustum_planes[14] = me11 - me9;
-    frustum_planes[15] = me15 - me13;
-
-    frustum_planes[16] = me3 - me2;
-    frustum_planes[17] = me7 - me6;
-    frustum_planes[18] = me11 - me10;
-    frustum_planes[19] = me15 - me14;
-
-    frustum_planes[20] = me3 + me2;
-    frustum_planes[21] = me7 + me6;
-    frustum_planes[22] = me11 + me10;
-    frustum_planes[23] = me15 + me14;
-
-    // normalize plane
-    array_normalize_plane(frustum_planes, 0);
-    array_normalize_plane(frustum_planes, 4);
-    array_normalize_plane(frustum_planes, 8);
-    array_normalize_plane(frustum_planes, 12);
-    array_normalize_plane(frustum_planes, 16);
-    array_normalize_plane(frustum_planes, 20);
-}
-
-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;
-
-        /**
-         * 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');
-    }
-
-    /**
-     *
-     * @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);
-    }
-}