@woosh/meep-engine 2.43.9 → 2.43.11

package/core/binary/url_to_data_url.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {string} url
+ * @returns {string}
+ */
+export async function url_to_data_url(url) {
+    return fetch(url)
+        .then(response => {
+            return response.blob();
+        })
+        .then(blob => {
+            const fr = new FileReader();
+
+            return new Promise((resolve, reject) => {
+
+                fr.onload = () => {
+                    resolve(fr.result);
+                };
+
+                fr.onerror = reject;
+                fr.onabort = reject;
+
+                fr.readAsDataURL(blob);
+
+            });
+
+        });
+}

package/core/collection/queue/Deque.js

@@ -302,7 +302,7 @@ Deque.prototype.peek = Deque.prototype.getFirst;
 Deque.prototype.push = Deque.prototype.addFirst;
 Deque.prototype.pop = Deque.prototype.removeFirst;
 
-/*
-Standard queue method
+/**
+ * Standard queue method
  */
 Deque.prototype.add = Deque.prototype.addLast;

package/editor/ecs/component/editors/ImagePathEditor.js

@@ -5,6 +5,7 @@ import ImageView from "../../../../view/elements/image/ImageView.js";
 import ObservedString from "../../../../core/model/ObservedString.js";
 import { ObservedStringEditor } from "./ObservedStringEditor.js";
 import ButtonView from "../../../../view/elements/button/ButtonView.js";
+import { url_to_data_url } from "../../../../core/binary/url_to_data_url.js";
 
 /**
  *
@@ -19,35 +20,6 @@ function is_data_url(url) {
     return url.startsWith('data:');
 }
 
-/**
- *
- * @param {string} url
- * @returns {string}
- */
-async function url_to_data_url(url) {
-    return fetch(url)
-        .then(response => {
-            return response.blob();
-        })
-        .then(blob => {
-            const fr = new FileReader();
-
-            return new Promise((resolve, reject) => {
-
-                fr.onload = () => {
-                    resolve(fr.result);
-                };
-
-                fr.onerror = reject;
-                fr.onabort = reject;
-
-                fr.readAsDataURL(blob);
-
-            });
-
-        });
-}
-
 export class ImagePathEditor extends TypeEditor {
     inline = true;
 

package/engine/graphics/ecs/path/PathDisplaySystem.js

@@ -11,6 +11,7 @@ import { RibbonPathBuilder } from "./ribbon/RibbonPathBuilder.js";
 import { PathEvents } from "../../../navigation/ecs/components/PathEvents.js";
 import { assert } from "../../../../core/assert.js";
 import { TubePathBuilder } from "./tube/build/TubePathBuilder.js";
+import { Deque } from "../../../../core/collection/queue/Deque.js";
 
 const builders = {
     [PathDisplayType.None]: function (style, path, result) {
@@ -82,6 +83,14 @@ const builders = {
     }
 };
 
+/**
+ * Maximum amount of time allowed per system tick to spend on processing update queue
+ * in milliseconds
+ * @readonly
+ * @type {number}
+ */
+const UPDATE_PROCESSING_BUDGET_MS = 10;
+
 class PathDisplayContext extends SystemEntityContext {
     constructor() {
         super();
@@ -100,6 +109,8 @@ class PathDisplayContext extends SystemEntityContext {
         const ownedEntities = this.__owned_entities;
         ownedEntities.splice(0, ownedEntities.length);
 
+        // todo check that the main entity still exists before we decide to spawn new entities
+
         /**
          * @type {PathDisplay}
          */
@@ -180,6 +191,16 @@ class PathDisplayContext extends SystemEntityContext {
         this.__build();
     }
 
+    request_update() {
+        /**
+         *
+         * @type {PathDisplaySystem}
+         */
+        const system = this.system;
+
+        system.request_entity_update(this.entity);
+    }
+
     link() {
         super.link();
 
@@ -189,8 +210,8 @@ class PathDisplayContext extends SystemEntityContext {
 
         const entity = this.entity;
 
-        ecd.addEntityEventListener(entity, PathEvents.Changed, this.rebuild, this);
-        ecd.addEntityEventListener(entity, PathDisplayEvents.Changed, this.rebuild, this);
+        ecd.addEntityEventListener(entity, PathEvents.Changed, this.request_update, this);
+        ecd.addEntityEventListener(entity, PathDisplayEvents.Changed, this.request_update, this);
     }
 
     unlink() {
@@ -200,8 +221,16 @@ class PathDisplayContext extends SystemEntityContext {
 
         const entity = this.entity;
 
-        ecd.removeEntityEventListener(entity, PathEvents.Changed, this.rebuild, this);
-        ecd.removeEntityEventListener(entity, PathDisplayEvents.Changed, this.rebuild, this);
+        ecd.removeEntityEventListener(entity, PathEvents.Changed, this.request_update, this);
+        ecd.removeEntityEventListener(entity, PathDisplayEvents.Changed, this.request_update, this);
+
+        /**
+         *
+         * @type {PathDisplaySystem}
+         */
+        const system = this.system;
+
+        system.cancel_entity_update(entity);
 
         // destroy existing owned entities
         this.__destroy_existing_entities();
@@ -238,6 +267,35 @@ export class PathDisplaySystem extends AbstractContextSystem {
          * @type {Reference<RibbonXPlugin>}
          */
         this.plugin = null;
+
+        /**
+         * Deferred queue of entities slated to be rebuilt
+         * @type {Deque<number>}
+         * @private
+         */
+        this.__rebuild_queue = new Deque();
+    }
+
+    /**
+     * Request that path displays be rebuilt
+     * @package
+     * @param {number} entity
+     */
+    request_entity_update(entity) {
+        assert.isNonNegativeInteger(entity, 'entity');
+
+        if (!this.__rebuild_queue.has(entity)) {
+            this.__rebuild_queue.add(entity);
+        }
+    }
+
+    /**
+     * Cancel any pending updates
+     * @package
+     * @param {number} entity
+     */
+    cancel_entity_update(entity) {
+        this.__rebuild_queue.remove(entity);
     }
 
     async startup(entityManager, readyCallback, errorCallback) {
@@ -253,4 +311,34 @@ export class PathDisplaySystem extends AbstractContextSystem {
 
         super.shutdown(entityManager, readyCallback, errorCallback);
     }
+
+    update(time_delta) {
+        // process update queue
+
+        const queue = this.__rebuild_queue;
+        if (queue.isEmpty()) {
+            return;
+        }
+
+        const t0 = performance.now();
+
+        do {
+            // note that we don't need to check if the queue is empty here for the first iteration, as we already checked earlier
+            const entity = queue.pop();
+
+            /**
+             *
+             * @type {PathDisplayContext|undefined}
+             */
+            const ctx = this.__getEntityContext(entity);
+
+            // check that entity still exists
+            if (ctx === undefined) {
+                continue;
+            }
+
+            ctx.rebuild();
+
+        } while ((performance.now() - t0) < UPDATE_PROCESSING_BUDGET_MS && !queue.isEmpty());
+    }
 }

package/engine/graphics/ecs/path/tube/build/{GeometryOutput.js → StreamGeometryBuilder.js}

@@ -4,7 +4,7 @@ import { BufferAttribute, BufferGeometry } from "three";
 /**
  * Helper class, allowing us to treat geometry build process as a stream without having to create intermediate arrays and performing unnecessary copying
  */
-export class GeometryOutput {
+export class StreamGeometryBuilder {
     constructor() {
         /**
          *

package/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -1,4 +1,4 @@
-import { BufferGeometry, MeshBasicMaterial, MeshMatcapMaterial, MeshStandardMaterial, Vector3 } from "three";
+import { BufferGeometry, MeshBasicMaterial, MeshMatcapMaterial, MeshStandardMaterial } from "three";
 import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
 import EntityBuilder from "../../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../../ecs/transform/Transform.js";
@@ -129,8 +129,6 @@ export class TubePathBuilder {
         // generate three.js curve from path
         const path_component = this.path;
 
-        const three_points = [];
-
         const pointCount = path_component.getPointCount();
 
         if (pointCount < 2) {
@@ -138,15 +136,6 @@ export class TubePathBuilder {
             return;
         }
 
-        for (let i = 0; i < pointCount; i++) {
-            const v3 = new Vector3();
-
-            path_component.getPosition(i, v3);
-
-            three_points.push(v3);
-        }
-
-
         const material_def = make_material(style, this.assetManager);
 
         material_def.color.set(style.color.toUint());

package/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.spec.js

@@ -0,0 +1,32 @@
+import Path from "../../../../../navigation/ecs/components/Path.js";
+import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { TubePathStyle } from "../TubePathStyle.js";
+import { CapType } from "../CapType.js";
+
+test('very tiny segment of a path', () => {
+    const path = Path.fromJSON({
+        points: [3, 1, 1, 3, 1, 3, 7, 1, 3, 7, 1, 7, 3, 1, 7, 3, 1, 8]
+    });
+
+    const style = new TubePathStyle();
+    style.cap_type = CapType.Flat;
+    style.width = 0.1;
+    style.path_mask = [0, 0.00005900000113712167];
+    style.resolution = 10;
+    style.shape = [1, -2.4492937051703357e-16, 0.9238795042037964, -0.3826834261417389, 0.7071067690849304, -0.7071067690849304, 0.3826834261417389, -0.9238795042037964, -1.8369701465288538e-16, -1, -0.3826834261417389, -0.9238795042037964, -0.7071067690849304, -0.7071067690849304, -0.9238795042037964, -0.3826834261417389, -1, 1.2246468525851679e-16, -0.9238795042037964, 0.3826834261417389, -0.7071067690849304, 0.7071067690849304, -0.3826834261417389, 0.9238795042037964, 6.123234262925839e-17, 1, 0.3826834261417389, 0.9238795042037964, 0.7071067690849304, 0.7071067690849304, 0.9238795042037964, 0.3826834261417389];
+
+    const result = build_geometry_catmullrom(path, style, style.shape, [
+        1.131973639570565e-16, 1, 0.3826834559440613, 0.9238795042037964, 0.7071067690849304, 0.7071067690849304, 0.9238795042037964, 0.3826834559440613, 1, -8.489801965906992e-17, 0.9238795042037964, -0.3826834559440613, 0.7071067690849304, -0.7071067690849304, 0.3826834559440613, -0.9238795042037964, -5.659868197852824e-17, -1, -0.3826834559440613, -0.9238795042037964, -0.7071067690849304, -0.7071067690849304, -0.9238795042037964, -0.3826834559440613, -1, 4.244900982953496e-17, -0.9238795042037964, 0.3826834559440613, -0.7071067690849304, 0.7071067690849304, -0.3826834559440613, 0.9238795042037964
+    ], [
+        0.10000000149011612, 0, 0, -0, 0.10000000149011612, 0, 0, 0, 1
+    ], 0, 0.00005900000113712167);
+
+
+    const attribute_position = result.getAttribute("position");
+    expect(attribute_position).toBeDefined();
+    expect(attribute_position).not.toBeNull();
+
+    for (let i = 0; i < attribute_position.array.length; i++) {
+        expect(attribute_position.array[i]).not.toBeNaN();
+    }
+});

package/engine/graphics/ecs/path/tube/build/computeFrenetFrames.js

@@ -101,8 +101,13 @@ export function computeFrenetFrames(points, closed = false, normal_hint) {
             // no tangent, copy previous one
             if (i > 0) {
                 tangents[i] = tangents[i - 1];
-                continue;
+            } else {
+                // very first tangent is undefined, set something arbitrary
+                // TODO take normal_hint into account
+                tangents[i] = new Vector3(0, 0, 1);
             }
+            continue;
+
         }
 
         tangents[i] = new Vector3(

package/engine/graphics/ecs/path/tube/build/makeTubeGeometry.js

@@ -1,10 +1,10 @@
 import { BufferGeometry, Vector3 } from "three";
-import { GeometryOutput } from "./GeometryOutput.js";
+import { StreamGeometryBuilder } from "./StreamGeometryBuilder.js";
 import { CapType } from "../CapType.js";
 import { make_ring_vertices } from "./make_ring_vertices.js";
 import { assert } from "../../../../../../core/assert.js";
 import { make_ring_faces } from "./make_ring_faces.js";
-import { compute_cap_geometry_size, make_cap } from "./make_cap.js";
+import { append_compute_cap_geometry_size, make_cap } from "./make_cap.js";
 import { v3_angle_cos_between } from "../../../../../../core/geom/v3_angle_between.js";
 
 
@@ -12,6 +12,7 @@ const v4_array = new Float32Array(4);
 
 /**
  * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
+ * @see https://github.com/hofk/THREEg.js/blob/488f1128a25321a76888aa1fa19db64750318444/THREEg.js#L3483
  * @param {Float32Array|number[]} in_positions
  * @param {Vector3[]} in_normals
  * @param {Vector3[]} in_binormals
@@ -34,7 +35,7 @@ export function makeTubeGeometry(
     assert.isNumber(shape_length, 'shape_length');
     assert.isArrayLike(shape, 'shape');
 
-    const out = new GeometryOutput();
+    const out = new StreamGeometryBuilder();
 
     // helper variables
 
@@ -48,7 +49,7 @@ export function makeTubeGeometry(
     };
 
     if (!closed) {
-        compute_cap_geometry_size(2, geometry_size, shape_length, cap_type);
+        append_compute_cap_geometry_size(2, geometry_size, shape_length, cap_type);
     }
 
     out.allocate(
@@ -57,6 +58,7 @@ export function makeTubeGeometry(
     );
 
     // create buffer data
+
     if (!closed) {
         // start cap
         make_cap(

package/engine/graphics/ecs/path/tube/build/make_cap.js

@@ -50,7 +50,7 @@ function compute_shape_radius(shape, shape_length, cx = 0, cy = 0) {
  * @param {Vector3[]} in_normals
  * @param {Vector3[]} in_binormals
  * @param {Vector3[]} in_tangents
- * @param {GeometryOutput} out
+ * @param {StreamGeometryBuilder} out
  * @param {number[]} shape
  * @param {number[]|Float32Array} shape_normal
  * @param {number} shape_length
@@ -106,9 +106,9 @@ function make_cap_round(
 
     for (i = 0; i <= cap_segment_count; i++) {
 
-        const j = direction>0? i:cap_segment_count-i;
+        const j = direction > 0 ? i : cap_segment_count - i;
 
-        const angle_b = j * angular_step_i ;
+        const angle_b = j * angular_step_i;
 
 
         const cos_b = Math.cos(angle_b);
@@ -151,9 +151,9 @@ const v4_no_bend = new Float32Array([0, 1, 0, 0]);
  * @param {Vector3[]} in_normals
  * @param {Vector3[]} in_binormals
  * @param {Vector3[]} in_tangents
- * @param {GeometryOutput} out
+ * @param {StreamGeometryBuilder} out
  * @param {number[]} shape
- * @param {number[]|Float32Array} shape_normals
+ * @param {number[]|Float32Array} shape_normal
  * @param {number} shape_length
  * @param {number[]} shape_transform
  * @param {number} direction
@@ -211,7 +211,7 @@ function make_cap_flat(
  * @param {Float32Array|number[]} in_positions
  * @param {Vector3[]} in_normals
  * @param {Vector3[]} in_binormals
- * @param {GeometryOutput} out
+ * @param {StreamGeometryBuilder} out
  * @param {Vector3[]} in_tangents
  * @param {number[]} shape
  * @param {number[]|Float32Array} shape_normal
@@ -250,13 +250,13 @@ export function make_cap(
 }
 
 /**
- *
+ * Increases target geometry buffers to accommodate a given number of caps
  * @param {number} count how many caps
- * @param {{polygon_count:number, vertex_count:number}} out
- * @param {number} radial_segments
+ * @param {{polygon_count:number, vertex_count:number}} out where to increment
+ * @param {number} radial_segments number of lines that make up profile of the extruded shape
  * @param {CapType} type
  */
-export function compute_cap_geometry_size(count, out, radial_segments, type) {
+export function append_compute_cap_geometry_size(count, out, radial_segments, type) {
 
     if (type === CapType.None) {
         // do nothing

package/engine/graphics/ecs/path/tube/build/make_ring_faces.js

@@ -1,6 +1,6 @@
 /**
  *
- * @param {GeometryOutput} out
+ * @param {StreamGeometryBuilder} out
  * @param {number} index_offset
  * @param {number} path_segments
  * @param {number} profile_segments

package/engine/graphics/ecs/path/tube/build/make_ring_vertices.js

@@ -4,7 +4,7 @@ import { v3_dot } from "../../../../../../core/geom/v3_dot.js";
 
 /**
  *
- * @param {GeometryOutput} out
+ * @param {StreamGeometryBuilder} out
  * @param {number} Px
  * @param {number} Py
  * @param {number} Pz

package/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js

@@ -27,13 +27,28 @@ const shader_vx = `
     out vec3 local_ray_far;
     
     flat out vec2 frame1;
+    flat out vec3 frame1_normal;
     out vec2 uv_frame1;
     out vec2 xy_frame1;
 
+    flat out vec2 frame2;
+    flat out vec3 frame2_normal;
+    out vec2 uv_frame2;
+    out vec2 xy_frame2;
+
+    flat out vec2 frame3;
+    flat out vec3 frame3_normal;
+    out vec2 uv_frame3;
+    out vec2 xy_frame3;
+    
+    out vec4 blend_weights;
+
     uniform mat4 modelViewMatrix;
     uniform mat4 projectionMatrix;
     uniform mat3 normalMatrix;
     uniform mat4 modelMatrix;
+    uniform mat4 viewMatrix;
+    uniform vec3 cameraPosition;
     
     uniform vec3 uOffset;
     uniform float uRadius;
@@ -143,6 +158,16 @@ const shader_vx = `
         return res;
     }
     
+    vec3 projectOnPlaneBasis(vec3 ray, vec3 plane_normal, vec3 plane_x, vec3 plane_y)
+    {
+        //reproject plane normal onto planeXY basos
+        return normalize(vec3(
+        dot(plane_x, ray),
+        dot(plane_y, ray),
+        dot(plane_normal, ray)
+        ));
+    }
+    
     void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
     {
         vec3 up = vec3(0,1,0);
@@ -155,14 +180,56 @@ const shader_vx = `
         plane_y = normalize(cross(plane_x, plane_normal));
     }
    
+    //this function works well in orthogonal projection. It works okeyish with further distances of perspective projection
+    vec2 virtualPlaneUV(vec3 plane_normal, vec3  plane_x, vec3  plane_y, vec3 pivotToCameraRay, vec3 vertexToCameraRay, float size)
+    {
+        plane_normal = normalize(plane_normal);
+        plane_x = normalize(plane_x);
+        plane_y = normalize(plane_y);
+    
+        // plane_normal is normalized but pivotToCameraRay & vertexToCameraRay are NOT
+        // so what are we doing here ?
+        // We are calculating length of pivotToCameraRay projected onto plane_normal
+        // so pivotToCameraRay is vector to camera from CENTER OF object
+        // we are recalculting this distance taking into account new plane normal
+        float projectedNormalRayLength = dot(plane_normal, pivotToCameraRay);
+        // tihs is direction is almost the same as origin, but its to individual vertex
+        // not sure this is correct for perspective projection
+        float projectedVertexRayLength = dot(plane_normal, vertexToCameraRay);
+        // basically its length difference betwen center and vertex - "not precise"
+        // projectedVertexRayLength is bigger than projectedNormalRayLength when vertex is
+        // further than "main front facing billboard"
+        // so offsetLength is getting smaller, otherwise is getting bigger
+        float offsetLength = projectedNormalRayLength/projectedVertexRayLength;
+    
+        // ok so offsetLength is just a length
+        // we want a vector so we multiply it by vertexToCameraRay to get this offset
+        // now what are we REALY doing is calculuating distance difference
+        // se are SUBSTRACTING pivotToCameraRay vector
+        // we would get difference between center of plane and vertex rotated
+        vec3 offsetVector = vertexToCameraRay * offsetLength - pivotToCameraRay;
+    
+        // we got the offset of rotated vertex, but we need to offset it from correct plane axis
+        // so again we projecting length of intersection (offset of rotated vertex) onto plane_x
+        // and plane_y
+        vec2 duv = vec2(
+        dot(plane_x, offsetVector),
+        dot(plane_y, offsetVector)
+        );
+    
+        //we are in space -1 to 1
+        duv /= 2.0 * size;
+        duv += 0.5;
+        return duv;
+    }
     
     void main() {
         vUv = uv;
         
         vec2 framesMinusOne = uFrames - vec2(1.0);
         
-        vec3 cameraPos_WS = (projectionMatrix * vec4(vec3(0), 1.0)).xyz;
-        vec3 cameraPos_OS = (inverse(modelMatrix) * vec4(cameraPos_WS, 1.0)).xyz;
+        vec3 cameraPos_WS = cameraPosition;
+        vec3 cameraPos_OS = (inverse(viewMatrix) * vec4(cameraPos_WS, 1.0)).xyz;
         
         //TODO: check if this is correct. We are using orho projected images, so
         // camera far away
@@ -206,7 +273,7 @@ const shader_vx = `
         //get 2D projection of this vertex in normalized device coordinates
         vec2 pos = gl_Position.xy/gl_Position.w;
        
-        vec3 projected = position;
+        vec3 projected = object_scale*position;
         vec3 vertexToCameraRay = (pivotToCameraRay - (projected));
         vec3 vertexToCameraDir = normalize(vertexToCameraRay);
        
@@ -221,25 +288,44 @@ const shader_vx = `
         //
         vec3 view_direction = normalize(local_ray_near-local_ray_far);
         
-        vec2 octahedral_uv = clamp(VectorToGrid(view_direction)*0.5 + 0.5, 0.0, 1.0);
-        vec2 grid =  octahedral_uv * vec2(uFrames - 1.0);
+        vec2 grid = VectorToGrid(-view_direction);
+        //bias and scale to 0 to 1
+        grid = clamp((grid + 1.0) * 0.5, vec2(0, 0), vec2(1, 1));
+        grid *= framesMinusOne;
+        grid = clamp(grid, vec2(0), vec2(framesMinusOne));
+        vec2 gridFloor = min(floor(grid), framesMinusOne);
+        vec2 gridFract = fract(grid);
         
-        vec2 gridFrac = fract(grid);
-        vec2 gridFloor = floor(grid);
+        blend_weights = TriangleInterpolate( gridFract ); 
         
-        vec4 weights = TriangleInterpolate( gridFrac ); 
+        frame1 = gridFloor;  
+        frame2 = gridFloor + mix(vec2(0,1),vec2(1,0),blend_weights.w);
+        frame3 = gridFloor + vec2(1.0,1.0);
         
-        vec2 frame1 = gridFloor;  
-        vec2 frame2 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
-        vec2 frame3 = gridFloor + vec2(1.0,1.0);
+        vec3 projectedQuadADir = FrameXYToRay(frame1, framesMinusOne);
+        vec3 projectedQuadBDir = FrameXYToRay(frame2, framesMinusOne);
+        vec3 projectedQuadCDir = FrameXYToRay(frame3, framesMinusOne);
+        
+        frame1_normal = (modelViewMatrix *vec4(projectedQuadADir, 0)).xyz;
+        frame2_normal = (modelViewMatrix *vec4(projectedQuadBDir, 0)).xyz;
+        frame3_normal = (modelViewMatrix *vec4(projectedQuadCDir, 0)).xyz;
         
         vec3 plane_x1, plane_y1, plane_x2, plane_y2, plane_x3, plane_y3;
-        vec3 projectedQuadADir = FrameXYToRay(frame1, framesMinusOne);
+        
         calcuateXYbasis(projectedQuadADir, plane_x1, plane_y1);
         
-        uv_frame1 = virtualPlaneUV(projectedQuadADir, plane_x1, plane_y1, pivotToCameraRay, vertexToCameraRay, scale);
+        uv_frame1 = virtualPlaneUV(projectedQuadADir, plane_x1, plane_y1, pivotToCameraRay, vertexToCameraRay, uRadius);
 	    xy_frame1 = projectOnPlaneBasis(-vertexToCameraDir, projectedQuadADir, plane_x1, plane_y1).xy;
+
+        calcuateXYbasis(projectedQuadBDir, plane_x2, plane_y2);
+        uv_frame2 = virtualPlaneUV(projectedQuadBDir, plane_x2, plane_y2, pivotToCameraRay, vertexToCameraRay, uRadius);
+        xy_frame2 = projectOnPlaneBasis(-vertexToCameraDir, projectedQuadBDir, plane_x2, plane_y2).xy;
         
+        calcuateXYbasis(projectedQuadCDir, plane_x3, plane_y3);
+        uv_frame3 = virtualPlaneUV(projectedQuadCDir, plane_x3, plane_y3, pivotToCameraRay, vertexToCameraRay, uRadius);
+        xy_frame3 = projectOnPlaneBasis(-vertexToCameraDir, projectedQuadCDir, plane_x3, plane_y3).xy;
+
+
     }
 `;
 const shader_fg = `
@@ -269,6 +355,23 @@ const shader_fg = `
     in vec3 local_ray_near;
     in vec3 local_ray_far;
     
+    flat in vec2 frame1;
+    flat in vec3 frame1_normal;
+    in vec2 uv_frame1;
+    in vec2 xy_frame1;
+
+    flat in vec2 frame2;
+    flat in vec3 frame2_normal;
+    in vec2 uv_frame2;
+    in vec2 xy_frame2;
+
+    flat in vec2 frame3;
+    flat in vec3 frame3_normal;
+    in vec2 uv_frame3;
+    in vec2 xy_frame3;
+    
+    in vec4 blend_weights;
+    
     struct Material{
         vec3 diffuse;
         vec3 normal;
@@ -394,14 +497,14 @@ const shader_fg = `
         ));
     }
     
-    vec2 recompute_uv(vec2 frame, vec2 frame_uv, sampler2D gBuffer){
+    vec2 recompute_uv(vec2 frame, vec2 frame_uv, vec2 xy_f, sampler2D gBuffer){
         vec2 frame_size = vec2(1.0/ uFrames);
         
         vec2 source_uv = (frame + frame_uv)*frame_size;
         
         float n_depth = texture(gBuffer, source_uv).a;
             
-        vec2 offset = clamp(length(frame_uv*2.0 - 1.0) * vec2(0.5-n_depth ) * depth_scale,0.0, 1.0);
+        vec2 offset = clamp(xy_f * vec2(0.5-n_depth ) * depth_scale,0.0, 1.0);
         
         vec2 uv_f = clamp(frame_uv+offset, 0.0, 1.0);
         
@@ -411,6 +514,21 @@ const shader_fg = `
         // return source_uv;
     }
     
+    vec2 recalculateUV(vec2 uv_f,  vec2 frame, vec2 xy_f, vec2 frame_size, float d_scale, sampler2D depthTexture)
+    {
+        //clamp for parallax sampling
+        uv_f = clamp(uv_f, vec2(0.0), vec2(1.0));
+        vec2 uv_quad = frame_size * (frame + uv_f);
+        //paralax
+        vec4 n_depth = (texture( depthTexture, uv_quad));
+        uv_f = xy_f * (0.5-n_depth.a) * d_scale + uv_f;
+        //clamp parallax offset
+        uv_f = clamp(uv_f, vec2(0.0), vec2(1.0));
+        uv_f =  frame_size * (frame + uv_f);
+        //clamped full UV
+        return clamp(uv_f, vec2(0.0), vec2(1.0));
+    }
+    
     void main(){
         vec3 view_direction = normalize(local_ray_near-local_ray_far);
         
@@ -420,19 +538,17 @@ const shader_fg = `
         vec2 gridFrac = fract(grid);
         vec2 gridFloor = floor(grid);
                 
-        vec4 weights = TriangleInterpolate( gridFrac ); 
+        vec4 weights = blend_weights; 
         
         vec2 frame_uv = vUv;
         
         //3 nearest frames
-        vec2 frame0 = gridFloor;
-        vec2 frame1 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
-        vec2 frame2 = gridFloor + vec2(1.0,1.0);
-        
-        vec2 uv0 = recompute_uv(frame0, frame_uv, tGeometry);
-        vec2 uv1 = recompute_uv(frame1, frame_uv, tGeometry);
-        vec2 uv2 = recompute_uv(frame2, frame_uv, tGeometry);
-        
+        vec2 quad_size = vec2(1.0) / uFrames;
+        vec2 uv_f1 = recalculateUV(uv_frame1, frame1, xy_frame1, quad_size, depth_scale, tGeometry);
+        vec2 uv_f2 = recalculateUV(uv_frame2, frame2, xy_frame2, quad_size, depth_scale, tGeometry);
+        vec2 uv_f3 = recalculateUV(uv_frame3, frame3, xy_frame3, quad_size, depth_scale, tGeometry);
+    
+            
         vec4 ddxy = vec4( dFdx(vUv.xy), dFdy(vUv.xy) );
         
         vec2 frame_size = vec2(1.0/ uFrames);
@@ -440,9 +556,9 @@ const shader_fg = `
         vec4 texel_color = ImposterBlendWeights(
         // vec4 texel_color = ImposterBlendWeightsNearest(
             tBase,
-            uv0,
-            uv1,
-            uv2,
+            uv_f1,
+            uv_f2,
+            uv_f3,
             weights, ddxy
         );
         

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -139,6 +139,10 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
         scratch_mvc.material = sg.material;
         scratch_mvc.spec = micron_geometry.vertex_spec;
+
+        // clear all flags
+        scratch_mvc.flags = 0;
+
         scratch_mvc.writeFlag(MaterialVertexSpecFlags.CastShadow, sg.getFlag(ShadedGeometryFlags.CastShadow));
         scratch_mvc.writeFlag(MaterialVertexSpecFlags.ReceiveShadow, sg.getFlag(ShadedGeometryFlags.ReceiveShadow));
 
@@ -175,6 +179,7 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
         //  clear context
         const material_contexts = this.ctx.contexts_array;
         const contexts_count = material_contexts.length;
+
         for (let i = 0; i < contexts_count; i++) {
             const mc = material_contexts[i];
 

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -32,6 +32,12 @@ const EXPOSED_ATTRIBUTES = [
     "blending"
 ];
 
+/**
+ * Maximum allowed number of particles per emitter, used as a sanity constraint to prevent renderer from crashing
+ * @type {number}
+ */
+const LIMIT_PARTICLE_COUNT = 1000000;
+
 export class ParticleVolume {
 
     constructor() {
@@ -436,8 +442,13 @@ export class ParticleVolume {
         const volume_value = this.__shape.volume;
 
         // total particle count
-        const particle_count = Math.max(1, Math.ceil(volume_value * this.__density));
+        let particle_count = Math.max(1, Math.ceil(volume_value * this.__density));
 
+        if (particle_count > LIMIT_PARTICLE_COUNT) {
+            console.warn(`ParticleVolume exceeds maximum allowed particle count (limit=${LIMIT_PARTICLE_COUNT}, requested=${particle_count}), clamping to limit. Consider reducing density (current = ${this.__density} particles per unit of volume)`);
+
+            particle_count = LIMIT_PARTICLE_COUNT;
+        }
 
         this.__ensure_initialized();
 

package/engine/navigation/ecs/components/Path.spec.js

@@ -158,3 +158,24 @@ test("getPosition on a path with 1 point", () => {
 
     expect(v.toJSON()).toEqual({ x: 1, y: 3, z: 7 });
 });
+
+
+test("sample_catmull_rom with very small offsets",()=>{
+    const path = Path.fromJSON({
+        points:[3, 1, 1, 3, 1, 3, 7, 1, 3, 7, 1, 7, 3, 1, 7, 3, 1, 8]
+    });
+
+    const v = new Vector3();
+
+    path.sample_catmull_rom(v,0);
+
+    expect(v.x).not.toBeNaN();
+    expect(v.y).not.toBeNaN();
+    expect(v.z).not.toBeNaN();
+
+    path.sample_catmull_rom(v,0.00005900000113712167);
+
+    expect(v.x).not.toBeNaN();
+    expect(v.y).not.toBeNaN();
+    expect(v.z).not.toBeNaN();
+});

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

package/samples/terrain/from_image_2.js

@@ -15,6 +15,9 @@ import { TerrainLayer } from "../../engine/ecs/terrain/ecs/layers/TerrainLayer.j
 import Mesh from "../../engine/graphics/ecs/mesh/Mesh.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
 import { MeshSystem } from "../../engine/graphics/ecs/mesh/MeshSystem.js";
+import { downloadAsFile } from "../../core/binary/ByteArrayTools.js";
+import { url_to_data_url } from "../../core/binary/url_to_data_url.js";
+import ButtonView from "../../view/elements/button/ButtonView.js";
 
 const HEIGHT_RANGE = 64;
 
@@ -149,6 +152,36 @@ async function main(engine) {
     load_gltf("moicon/23_Nov_21_Skogplanter/02/model.gltf", engine, transform);
     // load_gltf("moicon/23_Nov_21_Skogplanter/03/model.gltf", engine, transform);
     // load_gltf("moicon/23_Nov_21_Skogplanter/04/model.gltf", engine, transform);
+
+    engine.gui.view.addChild(new ButtonView({
+        name: 'Download',
+        async action() {
+            for (const layer of terrain.layers.layers.data) {
+                // embed textures
+                layer.textureDiffuseURL = await url_to_data_url(layer.textureDiffuseURL);
+            }
+
+            // we wrap the terrain data into "component json" format that meep editor recognizes to make this compatible with the standalone terrain editor
+            const json_payload = {
+                type: "Terrain",
+                data: terrain.toJSON()
+            };
+
+            downloadAsFile(
+                JSON.stringify(json_payload),
+                'terrain.json'
+            );
+        },
+        css: {
+            bottom: '4px',
+            left: '4px',
+            position: 'absolute',
+            background: 'white',
+            border: '1px solid black',
+            padding: '2px',
+            pointerEvents: 'auto'
+        }
+    }));
 }
 
 /**