@woosh/meep-engine 2.33.4 → 2.33.9

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/network/convertPathToURL.js

@@ -34,6 +34,12 @@ export function convertPathToURL(path) {
             scope = window;
         } else if (ENVIRONMENT_IS_WORKER) {
             scope = self;
+        } else if (ENVIRONMENT_IS_NODE) {
+            scope = {
+                location: new URL(import.meta.url)
+            };
+        } else {
+            throw new Error('Unknown environment');
         }
 
         const location = scope.location;

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.4",
+  "version": "2.33.9",
   "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,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);
-    }
-}