@woosh/meep-engine 3.41.0 → 3.42.0

package/editor/selection/editor_pick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editor_pick.d.ts","sourceRoot":"","sources":["../../../editor/selection/editor_pick.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;GASG;AACH,qFANoB,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,qDAG5C,MAAM,GACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;GAYG;AACH,4CAPW,MAAM,EAAE,uDAEC,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,UAC5C,UAAU,MAAM,CAAC,GAAC,YAAY,eAC9B,MAAM,GACJ,MAAM,CA6BlB"}
+{"version":3,"file":"editor_pick.d.ts","sourceRoot":"","sources":["../../../editor/selection/editor_pick.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;GASG;AACH,qFANoB,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,qDAG5C,MAAM,GACJ,MAAM,CA+ClB;AAED;;;;;;;;;;;;GAYG;AACH,4CAPW,MAAM,EAAE,uDAEC,UAAU,MAAM,CAAC,QAAE,MAAM,KAAG,OAAO,UAC5C,UAAU,MAAM,CAAC,GAAC,YAAY,eAC9B,MAAM,GACJ,MAAM,CA6BlB"}

package/editor/selection/editor_pick.js

@@ -76,7 +76,8 @@ export function editor_pick_ray(dataset, read_bounds, origin, direction, max_dis
             0, max_distance
         );
 
-        if (distance >= best_distance) {
+        // Include the finite segment endpoint while keeping the first equally near candidate.
+        if (distance === Infinity || distance > best_distance || (distance === best_distance && best_entity !== -1)) {
             return;
         }
 

package/editor/tools/TransformToolV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,MAFU,cAAc,MAAM,CAAC,CAEmB;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAED;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAiCC;IAED;;OAEG;IACH,6BAgFC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAkBvB;CACJ;iBAnZgB,kBAAkB;0BAJT,uCAAuC;kCAK/B,2BAA2B;4BAJjC,+CAA+C"}
+{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,MAFU,cAAc,MAAM,CAAC,CAEmB;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAED;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAkCC;IAED;;OAEG;IACH,6BAgFC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAuBvB;CACJ;iBAzZgB,kBAAkB;0BAJT,uCAAuC;kCAK/B,2BAA2B;4BAJjC,+CAA+C"}

package/editor/tools/TransformToolV2.js

@@ -147,6 +147,7 @@ export class TransformToolV2 extends Tool {
                 start.setTranslation(controls.worldPositionStart.x, controls.worldPositionStart.y, controls.worldPositionStart.z);
                 start.setRotation(controls.worldQuaternionStart.x, controls.worldQuaternionStart.y, controls.worldQuaternionStart.z, controls.worldQuaternionStart.w);
                 start.setScale(controls._worldScaleStart.x, controls._worldScaleStart.y, controls._worldScaleStart.z);
+                start.updateMatrix();
 
                 snapshots.set(entity, start);
             } else {
@@ -405,7 +406,12 @@ export class TransformToolV2 extends Tool {
 
             space.set(space.getValue() === 'world' ? 'local' : 'world');
         } else if (keyCode === KeyCodes.escape) {
-            this.__controls.reset();
+            if (this.__controls.dragging) {
+                this.__controls.reset();
+                this.__handleObjectChange();
+                this.__controls.pointerUp({ button: 0 });
+                this.editor.toolEngine?.end_gesture();
+            }
         }
     }
 }

package/editor/tools/engine/ToolEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolEngine.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/ToolEngine.js"],"names":[],"mappings":";AAYA;IACI,iBAAmB;IACnB,2BAAiC;IACjC,YAAc;IACd,mBAAkB;IAClB,yBAAuB;IACvB,aAAe;IA2Bf;;;OAGG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,cAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,8BAEC;IAED,8BAOC;IAED,mBA8BC;IAED;;;;OAIG;IACH,8CA2EC;IAzEG,eAAoB;IA2ExB;;;;;OAKG;IACH;;;;;OAKG;IACH,gCAUC;IAED,oBAeC;IAED,iBAwBC;;CACJ;iBA7PgB,2CAA2C;0BAElC,0CAA0C;mBADjD,2CAA2C"}
+{"version":3,"file":"ToolEngine.d.ts","sourceRoot":"","sources":["../../../../editor/tools/engine/ToolEngine.js"],"names":[],"mappings":";AAYA;IACI,iBAAmB;IACnB,2BAAiC;IACjC,YAAc;IACd,mBAAkB;IAClB,yBAAuB;IACvB,aAAe;IA2Bf;;;OAGG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,cAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,8BAEC;IAED,8BAOC;IAED,mBA8BC;IAED;;;;OAIG;IACH,8CAqFC;IAnFG,eAAoB;IAqFxB;;;;;OAKG;IACH;;;;;OAKG;IACH,gCAUC;IAED,oBAeC;IAED,iBAwBC;;CACJ;iBAvQgB,2CAA2C;0BAElC,0CAA0C;mBADjD,2CAA2C"}

package/editor/tools/engine/ToolEngine.js

@@ -173,12 +173,22 @@ class ToolEngine {
         // would otherwise stay running until the next release that happened to land inside
         pointer.on.globalUp.add(pointerUp);
 
+        // Cancellation and focus loss end a press without a pointerup.
+        const viewport = graphics.domElement;
+        function endInterruptedGesture() {
+            self.end_gesture();
+        }
+        viewport.addEventListener('pointercancel', endInterruptedGesture);
+        window.addEventListener('blur', endInterruptedGesture);
+
         pointer.start();
 
 
         function cleanup() {
             pointer.on.down.remove(pointerDown);
             pointer.on.globalUp.remove(pointerUp);
+            viewport.removeEventListener('pointercancel', endInterruptedGesture);
+            window.removeEventListener('blur', endInterruptedGesture);
             pointer.stop();
         }
 

package/editor/tools/v2/TransformControls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformControls.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/TransformControls.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAsNI;;;;;OAKG;IACH,sBALW,+BAA6B,cAE7B,WAAW,eACX,OAAO,EAgCjB;IAzPD;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ,6BAA2B;IAE3B;;OAEG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,MAFU,MAAM,GAAC,IAAI,CAET;IAEZ;;OAEG;IACH,MAFU,MAAM,CAEe;IAE/B;;OAEG;IACH,OAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;OAIG;IACH,iBAFU,MAAM,GAAC,IAAI,CAEE;IAEvB;;;;OAIG;IACH,cAFU,MAAM,GAAC,IAAI,CAED;IAEpB;;OAEG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;OAEG;IACH,eAFU,OAAO,CAEa;IAE9B;;OAEG;IACH,iBAFU,UAAU,CAEe;IAEnC;;;;;OAKG;IACH,oBAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,sBAFU,UAAU,CAEoB;IAExC;;OAEG;IACH,kBAFU,OAAO,CAEuB;IAExC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,qBAFU,UAAU,CAEmB;IAEvC;;OAEG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,kBAFU,UAAU,CAEgB;IAEpC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,SAFU,OAAO,CAEO;IAExB;;OAEG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,cAFU,OAAO,CAEY;IAE7B;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,KAFU,OAAO,CAEU;IA+DvB,cAAwB;IACxB,wBAA4B;IAM5B,iBAAwC;IACxC,oBAA8C;IAC9C,qBAAgD;IAChD,oBAA8C;IAC9C,kBAA0C;IAe9C;;OAEG;IACH,yCAIC;IAmGD,iCAYC;IAED,gCAuCC;IAED;;;OAGG;IACH,qBAFW;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,QAIvB;IAED,gCAmQC;IAED,8BAcC;IAED,gBASC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,iBAAiB,CAW7B;IAED;;;OAGG;IACH,oCAIC;IAGD,eAYC;IAED,cAuBC;IAID,kBAIC;IAED,yBAIC;IAED,+CAIC;IAED,yCAIC;IAED,mCAIC;IAED,yBAIC;IAED,2BAIC;;CAEJ;0BAr5ByB,gBAAgB;oBAHtB,mCAAmC;uBADhC,sCAAsC;4BAEjC,kDAAkD"}
+{"version":3,"file":"TransformControls.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/TransformControls.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAsNI;;;;;OAKG;IACH,sBALW,+BAA6B,cAE7B,WAAW,eACX,OAAO,EAgCjB;IAzPD;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ,6BAA2B;IAE3B;;OAEG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,MAFU,MAAM,GAAC,IAAI,CAET;IAEZ;;OAEG;IACH,MAFU,MAAM,CAEe;IAE/B;;OAEG;IACH,OAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;OAIG;IACH,iBAFU,MAAM,GAAC,IAAI,CAEE;IAEvB;;;;OAIG;IACH,cAFU,MAAM,GAAC,IAAI,CAED;IAEpB;;OAEG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;OAEG;IACH,eAFU,OAAO,CAEa;IAE9B;;OAEG;IACH,iBAFU,UAAU,CAEe;IAEnC;;;;;OAKG;IACH,oBAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,sBAFU,UAAU,CAEoB;IAExC;;OAEG;IACH,kBAFU,OAAO,CAEuB;IAExC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,qBAFU,UAAU,CAEmB;IAEvC;;OAEG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,kBAFU,UAAU,CAEgB;IAEpC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,SAFU,OAAO,CAEO;IAExB;;OAEG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,cAFU,OAAO,CAEY;IAE7B;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,KAFU,OAAO,CAEU;IA+DvB,cAAwB;IACxB,wBAA4B;IAM5B,iBAAwC;IACxC,oBAA8C;IAC9C,qBAAgD;IAChD,oBAA8C;IAC9C,kBAA0C;IAe9C;;OAEG;IACH,yCAIC;IAmGD,iCAYC;IAED,gCAuCC;IAED;;;OAGG;IACH,qBAFW;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,QAIvB;IAED,gCAsPC;IAED,8BAcC;IAED,gBASC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,iBAAiB,CAW7B;IAED;;;OAGG;IACH,oCAIC;IAGD,eAYC;IAED,cAuBC;IAID,kBAIC;IAED,yBAIC;IAED,+CAIC;IAED,yCAIC;IAED,mCAIC;IAED,yBAIC;IAED,2BAIC;;CAEJ;0BAx4ByB,gBAAgB;oBAHtB,mCAAmC;uBADhC,sCAAsC;4BAEjC,kDAAkD"}

package/editor/tools/v2/TransformControls.js

@@ -486,7 +486,7 @@ class TransformControls extends GizmoNode {
         gizmo_drag_plane_normal(
             this.#plane_normal,
             this.mode, this.axis, this.space,
-            ot.rotation,
+            scratch_quaternion.set(ot.rotation_x, ot.rotation_y, ot.rotation_z, ot.rotation_w),
             this.eye, this.#camera_forward
         );
 
@@ -654,25 +654,12 @@ class TransformControls extends GizmoNode {
                 scratch_vector.applyQuaternion(this._worldQuaternionInv);
                 scratch_vector_2.applyQuaternion(this._worldQuaternionInv);
 
-                scratch_vector_2.divide(scratch_vector);
-
-                if (axis.search('X') === -1) {
-
-                    scratch_vector_2.x = 1;
-
-                }
-
-                if (axis.search('Y') === -1) {
-
-                    scratch_vector_2.y = 1;
-
-                }
-
-                if (axis.search('Z') === -1) {
-
-                    scratch_vector_2.z = 1;
-
-                }
+                // Untouched axes keep ratio one; their drag-plane coordinates may both be zero.
+                scratch_vector_2.set(
+                    axis.includes('X') ? scratch_vector_2.x / scratch_vector.x : 1,
+                    axis.includes('Y') ? scratch_vector_2.y / scratch_vector.y : 1,
+                    axis.includes('Z') ? scratch_vector_2.z / scratch_vector.z : 1
+                );
 
             }
 

package/editor/tools/v2/handle/gizmo_drag_plane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gizmo_drag_plane.d.ts","sourceRoot":"","sources":["../../../../../editor/tools/v2/handle/gizmo_drag_plane.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gDARW,OAAO,QACP,MAAM,QACN,MAAM,SACN,MAAM,oCAEN,OAAO,kBACP,OAAO,QAqEjB;AAED;;;;;;;;;;GAUG;AACH,8CARW,OAAO,UACP,OAAO,aACP,OAAO,eACP,OAAO,gBACP,OAAO,GACL,OAAO,CAsBnB;oBAhJmB,sCAAsC"}
+{"version":3,"file":"gizmo_drag_plane.d.ts","sourceRoot":"","sources":["../../../../../editor/tools/v2/handle/gizmo_drag_plane.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gDARW,OAAO,QACP,MAAM,QACN,MAAM,SACN,MAAM,oCAEN,OAAO,kBACP,OAAO,QAqEjB;AAED;;;;;;;;;;GAUG;AACH,8CARW,OAAO,UACP,OAAO,aACP,OAAO,eACP,OAAO,gBACP,OAAO,GACL,OAAO,CA0BnB;oBApJmB,sCAAsC"}

package/editor/tools/v2/handle/gizmo_drag_plane.js

@@ -140,6 +140,10 @@ export function gizmo_ray_plane_point(result, origin, direction, plane_point, pl
 
     const t = along.dot(plane_normal) / denominator;
 
+    if (t < 0) {
+        return false;
+    }
+
     result.copy(direction).multiplyScalar(t).add(origin);
 
     return true;

package/editor/view/ecs/EntityEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBAyOC;IAhOG,YAAkB;IAGlB,0BAAoC;IACpC;;OAEG;IACH,eAFU,cAAc,aAAa,CAAC,CAEM;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAsGrC,wBAEE;IAiGF,aAAkB;;CAazB;iBAzQgB,2BAA2B;0BATlB,0CAA0C;8BAEtC,0CAA0C;iBAHvD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}
+{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBA2OC;IAlOG,YAAkB;IAGlB,0BAAoC;IACpC;;OAEG;IACH,eAFU,cAAc,aAAa,CAAC,CAEM;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAwGrC,wBAEE;IAiGF,aAAkB;;CAazB;iBA3QgB,2BAA2B;0BATlB,0CAA0C;8BAEtC,0CAA0C;iBAHvD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}

package/editor/view/ecs/EntityEditor.js

@@ -156,7 +156,9 @@ class EntityEditor extends View {
             if (oldEntity !== undefined && oldEntity !== null) {
                 unwatchEntity(oldEntity);
             }
-            watchEntity(entity);
+            if (entity !== undefined && entity !== null) {
+                watchEntity(entity);
+            }
 
             rebuildComponents();
         });

package/editor/view/node-graph/NodeGraphView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGraphView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeGraphView.js"],"names":[],"mappings":";AA0GA;IA4GI;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gJAyhBC;IAxpBD,mBAAmC;IAEnC;;;;;;;;;OASG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAQ,CAAC,CAET;IAmBtB;;;OAGG;IACH,qBAFmB,yBAAyB,cAE/B;IAEb;;OAEG;IACH,iBA0DE;IAEF;;;;OAIG;IACH,mBAFU,OAAO,CAEA;IAmCb;;;OAGG;IACH,2CAAsC;IAMtC;;;OAGG;IACH,QAFU,eAAe,CAEL;IAEpB;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,WAFU,kBAAkB,CAEF;IA8e9B;;;;;;;;;OASG;IACH,oBAFa,IAAI,CAgBhB;IAED;;;;;;;;OAQG;IACH,gBAFa,IAAI,CAMhB;IAED;;;;;;;;OAQG;IACH,cAFa,OAAO,CAInB;IAgBD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gCAFa,IAAI,CA+NhB;IAED;;;;;;;;OAQG;IACH,0BAHW,KAAK,GACH,MAAM,EAAE,CAwBpB;IAED;;;;;;;;;;;OAWG;IACH,gCAHW,KAAK,GACH,MAAM,EAAE,CAsBpB;IAED;;;;;;;;;;OAUG;IACH,6BAJW,KAAK,SACL,UAAU,GAAC,YAAY,GACrB,IAAI,CAgDhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,aAAW,IAAI,CAiC3B;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,IAAI,gBACX,MAAM,GAAC,IAAI,SACX,UAAU,GAAC,YAAY,QA8CjC;IAGD;;;;;;;OAOG;IACH,wDAFa,OAAO,CAcnB;IAED;;;;;;;;;OASG;IACH,+CAFa,oBAAoB,CAYhC;IAED;;;;;;OAMG;IACH,oBALW,wBAAwB,QACxB,oBAAoB,iCAEpB,OAAO,QA+DjB;IAED;;;;OAIG;IACH,mCAHW,yBAAyB,UACzB,OAAO,QAiBjB;IAeD;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;IAED;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;;CACJ;iBA/7CgB,2BAA2B;yBAInB,eAAe;0CAIE,sEAAsE;gCAChF,mDAAmD;gCACnD,sBAAsB;mCACnB,yBAAyB;kBAS1C,yCAAyC;oBAlBvC,mCAAmC;qCAiBlB,mEAAmE"}
+{"version":3,"file":"NodeGraphView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeGraphView.js"],"names":[],"mappings":";AA0GA;IA4GI;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gJAwiBC;IAvqBD,mBAAmC;IAEnC;;;;;;;;;OASG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAQ,CAAC,CAET;IAmBtB;;;OAGG;IACH,qBAFmB,yBAAyB,cAE/B;IAEb;;OAEG;IACH,iBA0DE;IAEF;;;;OAIG;IACH,mBAFU,OAAO,CAEA;IAmCb;;;OAGG;IACH,2CAAsC;IAMtC;;;OAGG;IACH,QAFU,eAAe,CAEL;IAEpB;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,WAFU,kBAAkB,CAEF;IA6f9B;;;;;;;;;OASG;IACH,oBAFa,IAAI,CAgBhB;IAED;;;;;;;;OAQG;IACH,gBAFa,IAAI,CAMhB;IAED;;;;;;;;OAQG;IACH,cAFa,OAAO,CAInB;IAgBD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gCAFa,IAAI,CAgOhB;IAED;;;;;;;;OAQG;IACH,0BAHW,KAAK,GACH,MAAM,EAAE,CAwBpB;IAED;;;;;;;;;;;OAWG;IACH,gCAHW,KAAK,GACH,MAAM,EAAE,CAsBpB;IAED;;;;;;;;;;OAUG;IACH,6BAJW,KAAK,SACL,UAAU,GAAC,YAAY,GACrB,IAAI,CAgDhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,aAAW,IAAI,CAiC3B;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,IAAI,gBACX,MAAM,GAAC,IAAI,SACX,UAAU,GAAC,YAAY,QA8CjC;IAGD;;;;;;;OAOG;IACH,wDAFa,OAAO,CAcnB;IAED;;;;;;;;;OASG;IACH,+CAFa,oBAAoB,CAYhC;IAED;;;;;;OAMG;IACH,oBALW,wBAAwB,QACxB,oBAAoB,iCAEpB,OAAO,QA+DjB;IAED;;;;OAIG;IACH,mCAHW,yBAAyB,UACzB,OAAO,QAiBjB;IAeD;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;IAED;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;;CACJ;iBA/8CgB,2BAA2B;yBAInB,eAAe;0CAIE,sEAAsE;gCAChF,mDAAmD;gCACnD,sBAAsB;mCACnB,yBAAyB;kBAS1C,yCAAyC;oBAlBvC,mCAAmC;qCAiBlB,mEAAmE"}

package/editor/view/node-graph/NodeGraphView.js

@@ -289,6 +289,7 @@ export class NodeGraphView extends View {
             enabled: false,
             anchor: new Vector2(),
             endpoint: null,
+            pointerId: null,
 
             /**
              * Whether some port has already dealt with the drop that is ending this drag.
@@ -347,12 +348,14 @@ export class NodeGraphView extends View {
                         // what this port carries on this node, where that is not what it declares
                         portView.setDataType(self.portDataType(node.getEndpoint(port.id)));
 
+                        let ownsWireGesture = false;
                         const draggableAspect = new DraggableAspect({
                             el: portView.el,
                             dragStart(p, event) {
-                                if (self.readOnly) {
+                                if (self.readOnly || tempConnection.enabled) {
                                     return;
                                 }
+                                ownsWireGesture = true;
 
                                 // An input holds one wire, so a drag out of a bound one is that
                                 // wire being taken hold of: what is on the end of the gesture is
@@ -371,6 +374,7 @@ export class NodeGraphView extends View {
                                 }
 
                                 tempConnection.enabled = true;
+                                tempConnection.pointerId = event.pointerId;
                                 tempConnection.consumed = false;
                                 tempConnection.detached = held;
                                 tempConnection.endpoint = endpoint;
@@ -383,15 +387,17 @@ export class NodeGraphView extends View {
                                 self.transformPointCanvas2Graph(v2_pointer, tempConnection.anchor);
                             },
                             dragEnd() {
-                                if (!tempConnection.enabled) {
+                                if (!ownsWireGesture) {
                                     return;
                                 }
+                                ownsWireGesture = false;
 
                                 const endpoint = tempConnection.endpoint;
                                 const consumed = tempConnection.consumed;
                                 const detached = tempConnection.detached;
 
                                 tempConnection.enabled = false;
+                                tempConnection.pointerId = null;
                                 tempConnection.detached = null;
 
                                 requestRedraw();
@@ -423,7 +429,16 @@ export class NodeGraphView extends View {
                                     graph_y: anchor.y,
                                 });
                             },
+                            dragCancel() {
+                                if (!ownsWireGesture) return;
+                                ownsWireGesture = false;
+                                tempConnection.enabled = false;
+                                tempConnection.pointerId = null;
+                                tempConnection.detached = null;
+                                requestRedraw();
+                            },
                             drag(p, o, delta, event) {
+                                if (!ownsWireGesture) return;
                                 // the anchor lives in graph space, derive it from the cursor position over this view
                                 readPositionFromMouseEvent(v2_pointer, event, self.el);
 
@@ -433,10 +448,10 @@ export class NodeGraphView extends View {
                             }
                         });
 
-                        draggableAspect.getPointer().on.up.add(() => {
+                        draggableAspect.getPointer().on.up.add((p, event) => {
                             //pointer released above the port
 
-                            if (tempConnection.enabled) {
+                            if (tempConnection.enabled && event.pointerId === tempConnection.pointerId) {
                                 // whatever happens below, the wire has met a port and its fate is
                                 // decided here rather than on open canvas
                                 tempConnection.consumed = true;
@@ -944,8 +959,16 @@ export class NodeGraphView extends View {
             vMarquee.setClass('toggle', event.ctrlKey);
         };
 
+        const abandonGesture = () => {
+            gesture.button = -1;
+            gesture.drag = CanvasDrag.None;
+            gesture.travelled = false;
+            vMarquee.visible = false;
+        };
+
         const draggableAspect = new DraggableAspect({
             el: this.el,
+            dragCancel: abandonGesture,
             dragStart: (position) => {
                 if (gesture.button === MOUSE_BUTTON.LEFT) {
                     gesture.drag = CanvasDrag.Marquee;
@@ -971,6 +994,7 @@ export class NodeGraphView extends View {
                 }
 
                 if (gesture.drag === CanvasDrag.Pan) {
+                    if (!gesture.travelled) return;
                     const d = origin.clone();
 
                     d.sub(position);
@@ -1074,14 +1098,6 @@ export class NodeGraphView extends View {
 
         // A canvas taken off screen mid-gesture never sees the release that would have ended it, and
         // one that came back still believing a button was down would ignore the next press.
-        const abandonGesture = () => {
-            gesture.button = -1;
-            gesture.drag = CanvasDrag.None;
-            gesture.travelled = false;
-
-            vMarquee.visible = false;
-        };
-
         this.on.linked.add(draggableAspect.start, draggableAspect);
         this.on.unlinked.add(draggableAspect.stop, draggableAspect);
         this.on.unlinked.add(abandonGesture);

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.41.0",
+  "version": "3.42.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/samples/engine/first-scene/index.html

@@ -27,6 +27,9 @@
 </head>
 <body>
 <div id="hint">W / S move the lamp &middot; drag with the left button to slide it</div>
-<script type="module" src="./main.js"></script>
+<script type="module">
+    import { main } from "./main.js";
+    main();
+</script>
 </body>
 </html>

package/samples/engine/first-scene/main.js

@@ -16,6 +16,7 @@
 
 import Vector2 from "../../../src/core/geom/Vector2.js";
 import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
+import { t64_announce_change } from "../../../src/engine/ecs/transform/t64_announce_change.js";
 import Entity from "../../../src/engine/ecs/Entity.js";
 import { EngineHarness } from "../../../src/engine/EngineHarness.js";
 import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
@@ -99,7 +100,7 @@ export async function main() {
     const lampTransform = new Transform64();
     lampTransform.setTranslation(0, ROOM_SIZE_METRES * 0.5, 0);
 
-    new Entity().add(lamp).add(lampTransform).build(engine.entityManager.dataset);
+    const lampId = new Entity().add(lamp).add(lampTransform).build(engine.entityManager.dataset);
 
     /**
      * NOTE 3 — **input arrives on the view stack's element, and the engine does not focus it for
@@ -122,17 +123,24 @@ export async function main() {
         const forward = keyboard.keys.w.is_down ? 1 : 0;
         const back = keyboard.keys.s.is_down ? 1 : 0;
 
-        lampTransform.position.setY(
-            ROOM_SIZE_METRES * 0.5 + (forward - back) * 2
-        );
+        const height = ROOM_SIZE_METRES * 0.5 + (forward - back) * 2;
+        if (height === lampTransform.translation_y) return;
+        lampTransform.setTranslation(lampTransform.translation_x, height, lampTransform.translation_z);
+        t64_announce_change(engine.entityManager.dataset, lampId);
     });
 
-    pointer.on.move.add((position, previous, delta) => {
+    pointer.on.move.add((position, event, delta) => {
         if (!pointer.mouseButtonLeft.is_down) {
             return;
         }
 
-        lampTransform.position._add(delta.x * 0.01, 0, delta.y * 0.01);
+        if (delta.x === 0 && delta.y === 0) return;
+        lampTransform.setTranslation(
+            lampTransform.translation_x + delta.x * 0.01,
+            lampTransform.translation_y,
+            lampTransform.translation_z + delta.y * 0.01
+        );
+        t64_announce_change(engine.entityManager.dataset, lampId);
     });
 
     return engine;
@@ -147,6 +155,3 @@ export async function main() {
  * `importScripts` of a same-origin script is blocked and reproduces exactly the same `NetworkError`
  * as the file not being there at all.
  */
-if (typeof document !== "undefined" && document.currentScript !== null) {
-    main();
-}

package/src/core/binary/utf8/utf8_decode.js

@@ -28,11 +28,11 @@ export function utf8_decode(bytes, start = 0, end = bytes.length) {
         if (b0 < 0x80) {
             result += String.fromCharCode(b0);
         } else if (b0 < 0xe0) {
-            result += String.fromCharCode(((b0 & 0x1f) << 6) | (bytes[i++] & 0x3f));
+            result += String.fromCharCode(((b0 & 0x1f) << 6) | (i < end ? bytes[i++] & 0x3f : 0));
         } else if (b0 < 0xf0) {
-            result += String.fromCharCode(((b0 & 0x0f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f));
+            result += String.fromCharCode(((b0 & 0x0f) << 12) | ((i < end ? bytes[i++] & 0x3f : 0) << 6) | (i < end ? bytes[i++] & 0x3f : 0));
         } else {
-            const code_point = ((b0 & 0x07) << 18) | ((bytes[i++] & 0x3f) << 12) | ((bytes[i++] & 0x3f) << 6) | (bytes[i++] & 0x3f);
+            const code_point = ((b0 & 0x07) << 18) | ((i < end ? bytes[i++] & 0x3f : 0) << 12) | ((i < end ? bytes[i++] & 0x3f : 0) << 6) | (i < end ? bytes[i++] & 0x3f : 0);
             const offset = code_point - 0x10000;
 
             result += String.fromCharCode(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff));

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_query_user_data_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/bvh32_query_user_data_ray.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,kDAZW,MAAM,EAAE,iBACR,MAAM,kCAEN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,MAAM,CA8FlB"}
+{"version":3,"file":"bvh32_query_user_data_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/bvh32_query_user_data_ray.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,kDAZW,MAAM,EAAE,iBACR,MAAM,kCAEN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,MAAM,CA6FlB"}

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.js

@@ -1,113 +1,112 @@
-import { assert } from "../../../assert.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_ray_segment_entry_distance } from "../../../geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
-
-const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {BinaryUint32BVH} bvh
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @param {number} max_distance tMax for the ray, can set to Infinity if you don't care.
- * @returns {number}
- */
-export function bvh32_query_user_data_ray(
-    result, result_offset,
-    bvh,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    max_distance,
-) {
-
-    assert.isNumber(max_distance, "max_distance");
-
-    let hit_count = 0;
-
-    const binary_node_count = bvh.binary_node_count;
-
-    if (binary_node_count <= 0) {
-        // this should not happen
-        return 0;
-    }
-
-    /**
-     *
-     * @type {number}
-     */
-    const stack_top = stack.pointer++;
-
-    /**
-     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
-     * @type {number}
-     */
-    stack[stack_top] = 0;
-
-    const last_valid_index = binary_node_count + bvh.leaf_node_count;
-
-    const float32 = bvh.float32;
-    const uint32 = bvh.uint32;
-
-
-    const inv_direction_x = 1 / direction_x;
-    const inv_direction_y = 1 / direction_y;
-    const inv_direction_z = 1 / direction_z;
-
-    do {
-        stack.pointer--;
-
-        // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack[stack.pointer];
-
-        const node_address = bvh.getNodeAddress(node_index);
-
-        const t = aabb3_ray_segment_entry_distance(
-            float32[node_address], float32[node_address + 1], float32[node_address + 2],
-            float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
-            origin_x, origin_y, origin_z,
-            inv_direction_x, inv_direction_y, inv_direction_z,
-            0,
-            max_distance
-        );
-
-        if (t >= max_distance) {
-            continue;
-        }
-
-        const is_intermediate_node = node_index < binary_node_count;
-
-        if (is_intermediate_node) {
-            // is intermediate node
-
-            const left_index = (node_index << 1) + 1;
-            const right_index = left_index + 1;
-
-            // left node ends up on top of the stack, which aligns with the desired access sequence
-            if (right_index < last_valid_index) {
-                stack[stack.pointer++] = right_index;
-                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack[stack.pointer++] = left_index;
-            } else if (left_index < last_valid_index) {
-                stack[stack.pointer++] = left_index;
-            }
-
-
-        } else {
-            // leaf node
-
-            // write to output
-            result[result_offset + hit_count] = uint32[node_address + 6];
-
-            hit_count++;
-        }
-
-    } while (stack.pointer > stack_top)
-
-    return hit_count;
-}
+import { assert } from "../../../assert.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_ray_segment_entry_distance } from "../../../geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} max_distance tMax for the ray, can set to Infinity if you don't care.
+ * @returns {number}
+ */
+export function bvh32_query_user_data_ray(
+    result, result_offset,
+    bvh,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    max_distance,
+) {
+
+    assert.isNumber(max_distance, "max_distance");
+
+    let hit_count = 0;
+
+    const binary_node_count = bvh.binary_node_count;
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[stack_top] = 0;
+
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    const inv_direction_x = 1 / direction_x;
+    const inv_direction_y = 1 / direction_y;
+    const inv_direction_z = 1 / direction_z;
+
+    do {
+        stack.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stack.pointer];
+
+        const node_address = bvh.getNodeAddress(node_index);
+
+        const t = aabb3_ray_segment_entry_distance(
+            float32[node_address], float32[node_address + 1], float32[node_address + 2],
+            float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
+            origin_x, origin_y, origin_z,
+            inv_direction_x, inv_direction_y, inv_direction_z,
+            0,
+            max_distance
+        );
+
+        // Infinity means a miss; finite segment endpoints are included.
+        if (t === Infinity || t > max_distance) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
+            // is intermediate node
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            // left node ends up on top of the stack, which aligns with the desired access sequence
+            if (right_index < last_valid_index) {
+                stack[stack.pointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack[stack.pointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack[stack.pointer++] = left_index;
+            }
+
+        } else {
+            // leaf node
+
+            // write to output
+            result[result_offset + hit_count] = uint32[node_address + 6];
+
+            hit_count++;
+        }
+
+    } while (stack.pointer > stack_top)
+
+    return hit_count;
+}

package/src/core/bvh2/bvh3/ebvh_nodes_sort_sah_local4.js

@@ -19,7 +19,7 @@ export function ebvh_nodes_sort_sah_local4(
     assert.isNonNegativeInteger(offset, 'offset');
     assert.isNonNegativeInteger(count, 'count');
 
-    const swap_pair_limit = Math.floor((count - (distance + 2)) / 2);
+    const swap_pair_limit = Math.floor((count - distance) / 2);
     const end = offset + swap_pair_limit * 2;
 
     let swap_count = 0;
@@ -91,4 +91,4 @@ export function ebvh_nodes_sort_sah_local4(
     }
 
     return swap_count;
-}
+}