@xeokit/xeokit-sdk 2.6.26 → 2.6.27

package/dist/xeokit-sdk.cjs.js

@@ -6194,54 +6194,49 @@ const math = {
      @static
      @param {Number[]} viewMatrix View matrix
      @param {Number[]} projMatrix Projection matrix
+     @param {String} projection Projection type (e.g. "ortho")
      @param {Number[]} canvasPos The Canvas-space position.
      @param {Number[]} worldRayOrigin The World-space ray origin.
      @param {Number[]} worldRayDir The World-space ray direction.
      */
     canvasPosToWorldRay: ((() => {
 
-        const tempMat4b = new FloatArrayType(16);
-        const tempMat4c = new FloatArrayType(16);
-        const tempVec4a = new FloatArrayType(4);
-        const tempVec4b = new FloatArrayType(4);
-        const tempVec4c = new FloatArrayType(4);
-        const tempVec4d = new FloatArrayType(4);
+        const pvMatInv = new FloatArrayType(16);
+        const vec4Near = new FloatArrayType(4);
+        const vec4Far  = new FloatArrayType(4);
 
-        return (canvas, viewMatrix, projMatrix, canvasPos, worldRayOrigin, worldRayDir) => {
+        const clipToWorld = (clipX, clipY, clipZ, isOrtho, outVec4) => {
+            outVec4[0] = clipX;
+            outVec4[1] = clipY;
+            outVec4[2] = clipZ;
+            outVec4[3] = 1;
 
-            const pvMat = math.mulMat4(projMatrix, viewMatrix, tempMat4b);
-            const pvMatInverse = math.inverseMat4(pvMat, tempMat4c);
-
-            // Calculate clip space coordinates, which will be in range
-            // of x=[-1..1] and y=[-1..1], with y=(+1) at top
+            math.transformVec4(pvMatInv, outVec4, outVec4);
+            if (! isOrtho)
+                math.mulVec4Scalar(outVec4, 1 / outVec4[3]);
+        };
 
-            const canvasWidth = canvas.width;
-            const canvasHeight = canvas.height;
+        return (canvas, viewMatrix, projMatrix, projection, canvasPos, worldRayOrigin, worldRayDir) => {
+            const isOrtho = projection === "ortho";
 
-            const clipX = (canvasPos[0] - canvasWidth / 2) / (canvasWidth / 2);  // Calculate clip space coordinates
-            const clipY = -(canvasPos[1] - canvasHeight / 2) / (canvasHeight / 2);
+            math.mulMat4(projMatrix, viewMatrix, pvMatInv);
+            math.inverseMat4(pvMatInv, pvMatInv);
 
-            tempVec4a[0] = clipX;
-            tempVec4a[1] = clipY;
-            tempVec4a[2] = -1;
-            tempVec4a[3] = 1;
+            // Calculate clip space coordinates, which will be in range
+            // of x=[-1..1] and y=[-1..1], with y=(+1) at top
 
-            math.transformVec4(pvMatInverse, tempVec4a, tempVec4b);
-            math.mulVec4Scalar(tempVec4b, 1 / tempVec4b[3]);
+            const clipX =     2 * canvasPos[0] / canvas.width - 1;  // Calculate clip space coordinates
+            const clipY = 1 - 2 * canvasPos[1] / canvas.height;
 
-            tempVec4c[0] = clipX;
-            tempVec4c[1] = clipY;
-            tempVec4c[2] = 1;
-            tempVec4c[3] = 1;
+            clipToWorld(clipX, clipY, -1, isOrtho, vec4Near);
 
-            math.transformVec4(pvMatInverse, tempVec4c, tempVec4d);
-            math.mulVec4Scalar(tempVec4d, 1 / tempVec4d[3]);
+            clipToWorld(clipX, clipY,  1, isOrtho, vec4Far);
 
-            worldRayOrigin[0] = tempVec4d[0];
-            worldRayOrigin[1] = tempVec4d[1];
-            worldRayOrigin[2] = tempVec4d[2];
+            worldRayOrigin[0] = vec4Near[0];
+            worldRayOrigin[1] = vec4Near[1];
+            worldRayOrigin[2] = vec4Near[2];
 
-            math.subVec3(tempVec4d, tempVec4b, worldRayDir);
+            math.subVec3(vec4Far, vec4Near, worldRayDir);
 
             math.normalizeVec3(worldRayDir);
         };
@@ -6265,8 +6260,8 @@ const math = {
         const worldRayOrigin = new FloatArrayType(3);
         const worldRayDir = new FloatArrayType(3);
 
-        return (canvas, viewMatrix, projMatrix, worldMatrix, canvasPos, localRayOrigin, localRayDir) => {
-            math.canvasPosToWorldRay(canvas, viewMatrix, projMatrix, canvasPos, worldRayOrigin, worldRayDir);
+        return (canvas, viewMatrix, projMatrix, projection, worldMatrix, canvasPos, localRayOrigin, localRayDir) => {
+            math.canvasPosToWorldRay(canvas, viewMatrix, projMatrix, projection, canvasPos, worldRayOrigin, worldRayDir);
             math.worldRayToLocalRay(worldMatrix, worldRayOrigin, worldRayDir, localRayOrigin, localRayDir);
         };
     }))(),
@@ -11121,7 +11116,7 @@ function activateDraggableDot(dot, cfg) {
     const pickWorldPos = canvasPos => {
         const origin = math.vec3();
         const direction = math.vec3();
-        math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, canvasPos, origin, direction);
+        math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, canvasPos, origin, direction);
         return ray2WorldPos(origin, direction, canvasPos);
     };
 
@@ -20014,6 +20009,7 @@ const Renderer$1 = function (scene, options) {
             let look;
             let pickViewMatrix = null;
             let pickProjMatrix = null;
+            let projection = null;
 
             pickResult.pickSurface = params.pickSurface;
 
@@ -20024,6 +20020,7 @@ const Renderer$1 = function (scene, options) {
 
                 pickViewMatrix = scene.camera.viewMatrix;
                 pickProjMatrix = scene.camera.projMatrix;
+                projection     = scene.camera.projection;
 
                 pickResult.canvasPos = params.canvasPos;
 
@@ -20036,6 +20033,7 @@ const Renderer$1 = function (scene, options) {
 
                     pickViewMatrix = params.matrix;
                     pickProjMatrix = scene.camera.projMatrix;
+                    projection     = scene.camera.projection;
 
                 } else {
 
@@ -20054,6 +20052,7 @@ const Renderer$1 = function (scene, options) {
                     pickViewMatrix = math.lookAtMat4v(worldRayOrigin, look, up, tempMat4b);
                     //    pickProjMatrix = scene.camera.projMatrix;
                     pickProjMatrix = scene.camera.ortho.matrix;
+                    projection     = "ortho";
 
                     pickResult.origin = worldRayOrigin;
                     pickResult.direction = worldRayDir;
@@ -20101,7 +20100,7 @@ const Renderer$1 = function (scene, options) {
 
                     gpuPickTriangle(pickBuffer, pickable, canvasPos, pickViewMatrix, pickProjMatrix, pickResult);
 
-                    pickable.pickTriangleSurface(pickViewMatrix, pickProjMatrix, pickResult);
+                    pickable.pickTriangleSurface(pickViewMatrix, pickProjMatrix, projection, pickResult);
 
                     pickResult.pickSurfacePrecision = false;
 
@@ -20374,7 +20373,9 @@ const Renderer$1 = function (scene, options) {
 
         const _pickResult = new PickResult();
 
-        return function (canvasPos, snapRadiusInPixels, snapToVertex, snapToEdge, pickResult = _pickResult) {
+        return function (params, pickResult = _pickResult) {
+
+            const {canvasPos, origin, direction, snapRadius, snapToVertex, snapToEdge} = params;
 
             if (!snapToVertex && !snapToEdge) {
                 return this.pick({canvasPos, pickSurface: true});
@@ -20388,7 +20389,7 @@ const Renderer$1 = function (scene, options) {
             frameCtx.pickZNear = scene.camera.project.near;
             frameCtx.pickZFar = scene.camera.project.far;
 
-            snapRadiusInPixels = snapRadiusInPixels || 30;
+            const snapRadiusInPixels = snapRadius || 30;
 
             const vertexPickBuffer = renderBufferManager.getRenderBuffer("uniquePickColors-aabs", {
                 depthTexture: true,
@@ -20399,8 +20400,8 @@ const Renderer$1 = function (scene, options) {
             });
 
             frameCtx.snapVectorA = [
-                getClipPosX(canvasPos[0] * resolutionScale, gl.drawingBufferWidth),
-                getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight),
+                canvasPos ? getClipPosX(canvasPos[0] * resolutionScale, gl.drawingBufferWidth) : 0,
+                canvasPos ? getClipPosY(canvasPos[1] * resolutionScale, gl.drawingBufferHeight) : 0,
             ];
 
             frameCtx.snapInvVectorAB = [
@@ -20427,7 +20428,14 @@ const Renderer$1 = function (scene, options) {
             // Set view and proj mats for VBO renderers
             ///////////////////////////////////////
 
-            const pickViewMatrix = scene.camera.viewMatrix;
+            frameCtx.pickViewMatrix = (canvasPos
+                                       ? scene.camera.viewMatrix
+                                       : math.lookAtMat4v(
+                                           origin,
+                                           math.addVec3(origin, direction, math.vec3()),
+                                           math.vec3([0, 1, 0]),
+                                           math.mat4()));
+
             const pickProjMatrix = scene.camera.projMatrix;
 
             for (let type in drawableTypeInfo) {
@@ -20436,7 +20444,7 @@ const Renderer$1 = function (scene, options) {
                     for (let i = 0, len = drawableList.length; i < len; i++) {
                         const drawable = drawableList[i];
                         if (drawable.setPickMatrices) { // Eg. SceneModel, which needs pre-loading into texture
-                            drawable.setPickMatrices(pickViewMatrix, pickProjMatrix);
+                            drawable.setPickMatrices(frameCtx.pickViewMatrix, pickProjMatrix);
                         }
                     }
                 }
@@ -20613,7 +20621,7 @@ const Renderer$1 = function (scene, options) {
             pickResult.worldPos = snappedWorldPos;
             pickResult.worldNormal = snappedWorldNormal;
             pickResult.entity = snappedEntity;
-            pickResult.canvasPos = canvasPos;
+            pickResult.canvasPos = canvasPos || scene.camera.projectWorldPos(worldPos || snappedWorldPos);
             pickResult.snappedCanvasPos = snappedCanvasPos || canvasPos;
 
             return pickResult;
@@ -32019,11 +32027,6 @@ class Scene extends Component {
             return null;
         }
 
-        if ((params.snapToVertex || params.snapToEdge) && !params.canvasPos) {
-            this.error("Scene.snapPick() `canvasPos` parameter expected for `snapToVertex:true` or `snapToEdge:true`");
-            return;
-        }
-
         params = params || {};
 
         params.pickSurface = params.pickSurface || params.rayPick; // Backwards compatibility
@@ -32049,13 +32052,7 @@ class Scene extends Component {
         }
 
         if (params.snapToEdge || params.snapToVertex) {
-            pickResult = this._renderer.snapPick(
-                params.canvasPos,
-                params.snapRadius || 30,
-                params.snapToVertex,
-                params.snapToEdge,
-                pickResult
-            );
+            pickResult = this._renderer.snapPick(params, pickResult);
         } else {
             pickResult = this._renderer.pick(params, pickResult);
         }
@@ -32086,12 +32083,7 @@ class Scene extends Component {
             this.error("Scene.snapPick() canvasPos parameter expected");
             return;
         }
-        return this._renderer.snapPick(
-            params.canvasPos,
-            params.snapRadius || 30,
-            params.snapToVertex,
-            params.snapToEdge,
-        );
+        return this._renderer.snapPick(params);
     }
 
     /**
@@ -39829,8 +39821,8 @@ class Mesh extends Component {
     }
 
     /** @private */
-    pickTriangleSurface(pickViewMatrix, pickProjMatrix, pickResult) {
-        pickTriangleSurface(this, pickViewMatrix, pickProjMatrix, pickResult);
+    pickTriangleSurface(pickViewMatrix, pickProjMatrix, projection, pickResult) {
+        pickTriangleSurface(this, pickViewMatrix, pickProjMatrix, projection, pickResult);
     }
 
     /** @private  */
@@ -39922,7 +39914,7 @@ const pickTriangleSurface = (function () {
     const tempVec3j = math.vec3();
     const tempVec3k = math.vec3();
 
-    return function (mesh, pickViewMatrix, pickProjMatrix, pickResult) {
+    return function (mesh, pickViewMatrix, pickProjMatrix, projection, pickResult) {
 
         var primIndex = pickResult.primIndex;
 
@@ -40001,7 +39993,7 @@ const pickTriangleSurface = (function () {
                 // Attempt to ray-pick the triangle in local space
 
                 if (pickResult.canvasPos) {
-                    math.canvasPosToLocalRay(canvas.canvas, mesh.origin ? createRTCViewMat(pickViewMatrix, mesh.origin) : pickViewMatrix, pickProjMatrix, mesh.worldMatrix, pickResult.canvasPos, localRayOrigin, localRayDir);
+                    math.canvasPosToLocalRay(canvas.canvas, mesh.origin ? createRTCViewMat(pickViewMatrix, mesh.origin) : pickViewMatrix, pickProjMatrix, projection, mesh.worldMatrix, pickResult.canvasPos, localRayOrigin, localRayDir);
 
                 } else if (pickResult.origin && pickResult.direction) {
                     math.worldRayToLocalRay(mesh.worldMatrix, pickResult.origin, pickResult.direction, localRayOrigin, localRayDir);
@@ -87576,7 +87568,7 @@ class DistanceMeasurement extends Component {
                 }
 
                 if (!this._zAxisLabelCulled) {
-                    if(this._measurementOrientation === 'Vertical') {
+                    if(this._measurementOrientation === 'Vertical' && this.useRotationAdjustment) {
                         this._zAxisLabel.setPrefix("");
                         this._zAxisLabel.setText(tilde + Math.abs(math.lenVec3(math.subVec3(this._targetWorld, [this._originWorld[0], this._targetWorld[1], this._originWorld[2]], distVec3)) * scale).toFixed(2) + unitAbbrev);
                     }
@@ -88614,27 +88606,27 @@ class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
         if (!this._active) {
             return;
         }
-
+        
         this.fire("activated", false);
 
         if (this.pointerLens) {
             this.pointerLens.visible = false;
         }
-        if (this._markerDiv) {
-            this._destroyMarkerDiv();
-        }
-        this.reset();
+        // if (this._markerDiv) {
+        //     this._destroyMarkerDiv()
+        // }
+        // this.reset();
         const canvas = this.scene.canvas.canvas;
         canvas.removeEventListener("mousedown", this._onMouseDown);
         canvas.removeEventListener("mouseup", this._onMouseUp);
         const cameraControl = this.distanceMeasurementsPlugin.viewer.cameraControl;
         cameraControl.off(this._onCameraControlHoverSnapOrSurface);
         cameraControl.off(this._onCameraControlHoverSnapOrSurfaceOff);
-        if (this._currentDistanceMeasurement) {
-            this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
-            this._currentDistanceMeasurement.destroy();
-            this._currentDistanceMeasurement = null;
-        }
+        // if (this._currentDistanceMeasurement) {
+        //     this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
+        //     this._currentDistanceMeasurement.destroy();
+        //     this._currentDistanceMeasurement = null;
+        // }
         this._active = false;
     }
 
@@ -89169,7 +89161,7 @@ class DistanceMeasurementsPlugin extends Plugin {
       axisVisible: params.axisVisible !== false && this.defaultAxisVisible !== false,
       xAxisVisible: params.xAxisVisible !== false && this.defaultXAxisVisible !== false,
       yAxisVisible: params.yAxisVisible !== false && this.defaultYAxisVisible !== false,
-      zAxisVisibld: params.zAxisVisible !== false && this.defaultZAxisVisible !== false,
+      zAxisVisible: params.zAxisVisible !== false && this.defaultZAxisVisible !== false,
       xLabelEnabled: params.xLabelEnabled !== false && this.defaultXLabelEnabled !== false,
       yLabelEnabled: params.yLabelEnabled !== false && this.defaultYLabelEnabled !== false,
       zLabelEnabled: params.zLabelEnabled !== false && this.defaultZLabelEnabled !== false,
@@ -96962,8 +96954,7 @@ class MousePickHandler {
                 {
                     const origin = math.vec3();
                     const direction = math.vec3();
-                    // The origin from math.canvasPosToWorldRay is incorrect for a perspective camera, should be the same as scene.camera.eye
-                    math.canvasPosToWorldRay(scene.canvas.canvas, scene.camera.viewMatrix, scene.camera.projMatrix, states.pointerCanvasPos, origin, direction);
+                    math.canvasPosToWorldRay(scene.canvas.canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, states.pointerCanvasPos, origin, direction);
                     cameraControl.fire("rayMove", { canvasPos: states.pointerCanvasPos, ray: { origin: origin, direction: direction, canvasPos: states.pointerCanvasPos } }, true);
                 }
 
@@ -139071,7 +139062,7 @@ const mousePointSelector = function(viewer, ray2WorldPos) {
         const pickWorldPos = canvasPos => {
             const origin = math.vec3();
             const direction = math.vec3();
-            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, canvasPos, origin, direction);
+            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, canvasPos, origin, direction);
             return ray2WorldPos(origin, direction);
         };
 
@@ -139146,7 +139137,7 @@ const touchPointSelector = function(viewer, pointerCircle, ray2WorldPos) {
         const pickWorldPos = canvasPos => {
             const origin = math.vec3();
             const direction = math.vec3();
-            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, canvasPos, origin, direction);
+            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, canvasPos, origin, direction);
             return ray2WorldPos(origin, direction);
         };
 
@@ -140366,7 +140357,7 @@ class ZoneTranslateControl extends Component {
         const pickWorldPos = canvasPos => {
             const origin = math.vec3();
             const direction = math.vec3();
-            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, canvasPos, origin, direction);
+            math.canvasPosToWorldRay(canvas, scene.camera.viewMatrix, scene.camera.projMatrix, scene.camera.projection, canvasPos, origin, direction);
             return ray2WorldPos(origin, direction);
         };