@xeokit/xeokit-sdk 2.6.87-renderers-refactor-v4 → 2.6.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeokit/xeokit-sdk",
-  "version": "2.6.87-renderers-refactor-v4",
+  "version": "2.6.88",
   "description": "3D BIM IFC Viewer SDK for AEC engineering applications. Open Source JavaScript Toolkit based on pure WebGL for top performance, real-world coordinates and full double precision",
   "module": "./dist/xeokit-sdk.es.js",
   "main": "./dist/xeokit-sdk.cjs.js",
@@ -52,7 +52,6 @@
   },
   "homepage": "https://xeokit.io",
   "dependencies": {
-    "@creooxag/cxconverter": "^0.0.3-alpha",
     "@loaders.gl/core": "^4.3.3",
     "@loaders.gl/gltf": "^4.3.3",
     "@loaders.gl/las": "^4.3.3",

package/src/plugins/CxConverterIFCLoaderPlugin/CxConverterIFCLoaderPlugin.js

@@ -1,6 +1,5 @@
 import { Plugin } from "../../viewer/Plugin.js";
 import { GLTFLoaderPlugin } from "../GLTFLoaderPlugin/GLTFLoaderPlugin.js";
-import { ifc2gltf } from "@creooxag/cxconverter";
 
 /**
  * Fetches a file from the given URL and returns its contents as text.
@@ -51,6 +50,15 @@ class CxConverterIFCLoaderPlugin extends Plugin {
          * @type {GLTFLoaderPlugin}
          */
         this.gltfLoader = new GLTFLoaderPlugin(this.viewer);
+        this.cxConverterModule = null;
+    }
+
+    /**
+     * Sets the CxConverter module to be used by this plugin.
+     * @param {Object} module The CxConverter module.
+     */
+    setCxConverterModule(module) {
+        this.cxConverterModule = module;
     }
 
     /**
@@ -63,11 +71,14 @@ class CxConverterIFCLoaderPlugin extends Plugin {
      * @returns {Promise<SceneModel>} A promise that resolves to the loaded SceneModel.
      */
     async load(params = {}) {
+        if (!this.cxConverterModule) {
+            throw new Error("CxConverter module is not set. Use setCxConverterModule() to set it.");
+        }
         if (!params.src) {
             this.error("load() param expected: src");
         }
         const data = await fetchFile(params.src);
-        const { gltf, metaData } = await ifc2gltf(
+        const { gltf, metaData } = await this.cxConverterModule.ifc2gltf(
             data,
             {
                 remote: true,

package/src/plugins/DotBIMLoaderPlugin/DotBIMLoaderPlugin.js

@@ -432,7 +432,7 @@ export class DotBIMLoaderPlugin extends Plugin {
 
                     parseDBMesh(dbMeshId, element);
 
-                    const meshId = `${objectId}-mesh`;
+                    const meshId = `${objectId}-mesh-${dbMeshId}`;
 
                     let color = element.color ? [element.color.r / 255.0, element.color.g / 255.0, element.color.b / 255.0] : [1, 1, 1];
                     let opacity = element.color ? element.color.a / 255.0 : 1.0;
@@ -505,7 +505,7 @@ export class DotBIMLoaderPlugin extends Plugin {
                             positions: trianglesCoordinates,
                             indices: [...Array(trianglesCoordinates.length / 3).keys()]
                         });
-                        const meshId = `${objectId}-mesh-${faceColor}`;
+                        const meshId = `${objectId}-mesh-${dbMeshId}-${faceColor}`;
                         const faceColorArray = faceColor.split(',').map(Number);
 
                         let color = [faceColorArray[0] / 255.0, faceColorArray[1] / 255.0, faceColorArray[2] / 255.0];

package/src/plugins/NavCubePlugin/NavCubePlugin.js

@@ -295,25 +295,9 @@ class NavCubePlugin extends Plugin {
             lastY = posY;
         }
 
-        function getCoordsWithinElement(event) {
-            var coords = [0, 0];
-            if (!event) {
-                event = window.event;
-                coords[0] = event.x;
-                coords[1] = event.y;
-            } else {
-                var element = event.target;
-                var totalOffsetLeft = 0;
-                var totalOffsetTop = 0;
-                while (element.offsetParent) {
-                    totalOffsetLeft += element.offsetLeft;
-                    totalOffsetTop += element.offsetTop;
-                    element = element.offsetParent;
-                }
-                coords[0] = event.pageX - totalOffsetLeft;
-                coords[1] = event.pageY - totalOffsetTop;
-            }
-            return coords;
+        function getCoordsWithinElement(clientCoords) {
+            const { left, top } = self._navCubeCanvas.getBoundingClientRect();
+            return [clientCoords.clientX - left, clientCoords.clientY - top];
         }
 
         {
@@ -349,7 +333,7 @@ class NavCubePlugin extends Plugin {
                 downY = e.y;
                 lastX = e.clientX;
                 lastY = e.clientY;
-                var canvasPos = getCoordsWithinElement(e);
+                var canvasPos = getCoordsWithinElement({clientX: e.clientX, clientY: e.clientY});
                 var hit = navCubeScene.pick({
                     canvasPos: canvasPos
                 });
@@ -369,7 +353,7 @@ class NavCubePlugin extends Plugin {
                 if (downX === null) {
                     return;
                 }
-                var canvasPos = getCoordsWithinElement(e);
+                var canvasPos = getCoordsWithinElement({clientX: e.clientX, clientY: e.clientY});
                 var hit = navCubeScene.pick({
                     canvasPos: canvasPos,
                     pickSurface: true
@@ -442,7 +426,7 @@ class NavCubePlugin extends Plugin {
                 if (!over) {
                     return;
                 }
-                var canvasPos = getCoordsWithinElement(e);
+                var canvasPos = getCoordsWithinElement({clientX: e.clientX, clientY: e.clientY});
                 var hit = navCubeScene.pick({
                     canvasPos: canvasPos,
                     pickSurface: true
@@ -472,6 +456,55 @@ class NavCubePlugin extends Plugin {
                     }
                 }
             });
+            
+            self._navCubeCanvas.addEventListener("touchstart", self._onTouchStart = function (e) {
+                if (e.touches.length > 0) {
+                    downX = e.touches[0].clientX;
+                    downY = e.touches[0].clientY;
+                    lastX = e.touches[0].clientX;
+                    lastY = e.touches[0].clientY;
+                    var canvasPos = getCoordsWithinElement({clientX: e.touches[0].clientX, clientY: e.touches[0].clientY});
+                    var hit = navCubeScene.pick({
+                        canvasPos: canvasPos
+                    });
+                    if (hit) {
+                        down = true;
+                    } else {
+                        down = false;
+                    }
+                }
+            }, 
+            {
+                passive: false
+            });
+
+            self._navCubeCanvas.addEventListener("touchmove", self._onTouchMove = function (e) {
+                e.preventDefault();
+                var touch = e.touches[0];
+                var posX = touch.clientX;
+                var posY = touch.clientY;
+
+                var currentElement = document.elementFromPoint(posX, posY);
+                over = (self._navCubeCanvas === currentElement);
+
+                if (!over) {
+                    return;
+                }
+                if (down) {
+                    actionMove(posX, posY);
+                    return;
+                }
+            }, 
+            {
+                passive: false
+            });
+
+            self._navCubeCanvas.addEventListener("touchend", self._onTouchEnd = function (e) {
+                down = false;
+                if (downX === null) {
+                    return;
+                } 
+            });
 
             var flyTo = (function () {
                 var center = math.vec3();
@@ -730,6 +763,10 @@ class NavCubePlugin extends Plugin {
             this._navCubeCanvas.removeEventListener("mousemove", this._onMouseMove);
             this._navCubeCanvas.removeEventListener("mouseup", this._onMouseUp);
 
+            this._navCubeCanvas.removeEventListener("touchstart", this._onTouchStart);
+            this._navCubeCanvas.removeEventListener("touchmove", this._onTouchMove);
+            this._navCubeCanvas.removeEventListener("touchend", this._onTouchEnd);
+
             this._navCubeCanvas = null;
             this._cubeTextureCanvas.destroy();
             this._cubeTextureCanvas = null;
@@ -739,6 +776,10 @@ class NavCubePlugin extends Plugin {
             this._onMouseDown = null;
             this._onMouseMove = null;
             this._onMouseUp = null;
+
+            this._onTouchStart = null;
+            this._onTouchMove = null;
+            this._onTouchEnd = null;
         }
 
         this._navCubeScene.destroy();

package/src/plugins/SectionPlanesPlugin/SectionPlanesPlugin.js

@@ -329,7 +329,8 @@ class SectionPlanesPlugin extends Plugin {
                                      })(),
                                      setQuaternion: q => { rootNode.quaternion = q; },
                                      setScale: s => { rootNode.scale = s; },
-                                     setVisible: v => { rootNode.visible = v; }
+                                     setVisible: v => { rootNode.visible = v; },
+                                     destroy: () => { rootNode.destroy() }
                                  };
                              })();
                              let unbindSectionPlane = () => { };
@@ -348,6 +349,7 @@ class SectionPlanesPlugin extends Plugin {
                                  _destroy: () => {
                                      unbindSectionPlane();
                                      ctrl.destroy();
+                                     planeRoot.destroy();
                                  },
                                  setCulled:  c => { culled = c;  updateVisible(); },
                                  setVisible: v => { visible = v; updateVisible(); },

package/src/viewer/Viewer.js

@@ -311,55 +311,11 @@ class Viewer {
      * Exit snapshot mode using {@link Viewer#endSnapshot}.
      */
     beginSnapshot() {
-        if (! this._snapshotBegun) {
-            this.scene._renderer.snapshot.beginSnapshot();
-            this._snapshotBegun = true;
-        }
-    }
-
-    _renderSnapshotToCanvas(params) {
-        const resize = (params.width !== undefined && params.height !== undefined);
-        const canvas = this.scene.canvas.canvas;
-        const saveWidth  = canvas.clientWidth;
-        const saveHeight = canvas.clientHeight;
-        const excludeGizmos = !params.includeGizmos;
-
-        if (resize) {
-            canvas.width  = params.width  ? Math.floor(params.width)  : canvas.width;
-            canvas.height = params.height ? Math.floor(params.height) : canvas.height;
-        }
-
-        this.beginSnapshot();
-
-        if (excludeGizmos) {
-            this.sendToPlugins("snapshotStarting"); // Tells plugins to hide things that shouldn't be in snapshot
-        }
-
-        const snapshotCanvas = this.scene._renderer.snapshot.renderSnapshotToCanvas();
-
-        if (resize) {
-            canvas.width = saveWidth;
-            canvas.height = saveHeight;
-            this.scene.glRedraw();
+        if (this._snapshotBegun) {
+            return;
         }
-
-        return {
-            canvas:    snapshotCanvas,
-            toDataURL: () => {
-                if (excludeGizmos) {
-                    this.sendToPlugins("snapshotFinished");
-                }
-
-                this.endSnapshot();
-
-                let format = params.format || "png";
-                if (format !== "jpeg" && format !== "png" && format !== "bmp") {
-                    console.error("Unsupported image format: '" + format + "' - supported types are 'jpeg', 'bmp' and 'png' - defaulting to 'png'");
-                    format = "png";
-                }
-                return snapshotCanvas.toDataURL(`image/${format}`);
-            }
-        };
+        this.scene._renderer.beginSnapshot();
+        this._snapshotBegun = true;
     }
 
     /**
@@ -382,9 +338,54 @@ class Viewer {
      * @returns {String} String-encoded image data URI.
      */
     getSnapshot(params = {}) {
+
+        const needFinishSnapshot = (!this._snapshotBegun);
+        const resize = (params.width !== undefined && params.height !== undefined);
+        const canvas = this.scene.canvas.canvas;
+        const saveWidth = canvas.clientWidth;
+        const saveHeight = canvas.clientHeight;
+        const width = params.width ? Math.floor(params.width) : canvas.width;
+        const height = params.height ? Math.floor(params.height) : canvas.height;
+
+        if (resize) {
+            canvas.width = width;
+            canvas.height = height;
+        }
+
+        if (!this._snapshotBegun) {
+            this.beginSnapshot({
+                width,
+                height
+            });
+        }
+
+        if (!params.includeGizmos) {
+            this.sendToPlugins("snapshotStarting"); // Tells plugins to hide things that shouldn't be in snapshot
+        }
+
         // firing "rendering" is necessary to trigger DTX{Lines,Triangles}Layer::_uploadDeferredFlags
         this.scene.fire("rendering", { }, true);
-        return this._renderSnapshotToCanvas(params).toDataURL();
+
+        this.scene._renderer.renderSnapshot();
+
+        const imageDataURI = this.scene._renderer.readSnapshot(params);
+
+        if (resize) {
+            canvas.width = saveWidth;
+            canvas.height = saveHeight;
+
+            this.scene.glRedraw();
+        }
+
+        if (!params.includeGizmos) {
+            this.sendToPlugins("snapshotFinished");
+        }
+
+        if (needFinishSnapshot) {
+            this.endSnapshot();
+        }
+
+        return imageDataURI;
     }
 
     /**
@@ -427,7 +428,36 @@ class Viewer {
         // right amount of pixels, for a sharper image.
 
 
-        const snapshotResult = this._renderSnapshotToCanvas(params);
+        const needFinishSnapshot = (!this._snapshotBegun);
+        const resize = (params.width !== undefined && params.height !== undefined);
+        const canvas = this.scene.canvas.canvas;
+        const saveWidth = canvas.clientWidth;
+        const saveHeight = canvas.clientHeight;
+        const snapshotWidth = params.width ? Math.floor(params.width) : canvas.width;
+        const snapshotHeight = params.height ? Math.floor(params.height) : canvas.height;
+
+        if (resize) {
+            canvas.width = snapshotWidth;
+            canvas.height = snapshotHeight;
+        }
+
+        if (!this._snapshotBegun) {
+            this.beginSnapshot();
+        }
+
+        if (!params.includeGizmos) {
+            this.sendToPlugins("snapshotStarting"); // Tells plugins to hide things that shouldn't be in snapshot
+        }
+
+        this.scene._renderer.renderSnapshot();
+
+        const snapshotCanvas = this.scene._renderer.readSnapshotAsCanvas();
+
+        if (resize) {
+            canvas.width = saveWidth;
+            canvas.height = saveHeight;
+            this.scene.glRedraw();
+        }
 
         const pluginToCapture = {};
         const pluginContainerElements = [];
@@ -451,7 +481,6 @@ class Viewer {
         document.head.appendChild(style);
         style.sheet?.insertRule('body > div:last-child img { display: inline-block; }');
 
-        const snapshotCanvas = snapshotResult.canvas;
         for (let i = 0, len = pluginContainerElements.length; i < len; i++) {
             const containerElement = pluginContainerElements[i];
             await html2canvas(containerElement, {
@@ -467,7 +496,24 @@ class Viewer {
 
         style.remove();
 
-        return snapshotResult.toDataURL();
+        if (!params.includeGizmos) {
+            this.sendToPlugins("snapshotFinished");
+        }
+        if (needFinishSnapshot) {
+            this.endSnapshot();
+        }
+        let format = params.format || "png";
+        if (format !== "jpeg" && format !== "png" && format !== "bmp") {
+            console.error("Unsupported image format: '" + format + "' - supported types are 'jpeg', 'bmp' and 'png' - defaulting to 'png'");
+            format = "png";
+        }
+        if (!params.includeGizmos) {
+            this.sendToPlugins("snapshotFinished");
+        }
+        if (needFinishSnapshot) {
+            this.endSnapshot();
+        }
+        return snapshotCanvas.toDataURL(`image/${format}`);
     }
 
     /**
@@ -477,10 +523,12 @@ class Viewer {
      *
      */
     endSnapshot() {
-        if (this._snapshotBegun) {
-            this.scene._renderer.snapshot.endSnapshot();
-            this._snapshotBegun = false;
+        if (!this._snapshotBegun) {
+            return;
         }
+        this.scene._renderer.endSnapshot();
+        this.scene._renderer.render({force: true});
+        this._snapshotBegun = false;
     }
 
     /** Destroys this Viewer.

package/src/viewer/scene/canvas/Canvas.js

@@ -118,8 +118,38 @@ class Canvas extends Component {
 
         this._initWebGL(cfg);
 
+        // Bind context loss and recovery handlers
+
         const self = this;
 
+        this.canvas.addEventListener("webglcontextlost", this._webglcontextlostListener = function (event) {
+                console.time("webglcontextrestored");
+                self.scene._webglContextLost();
+                /**
+                 * Fired whenever the WebGL context has been lost
+                 * @event webglcontextlost
+                 */
+                self.fire("webglcontextlost");
+                event.preventDefault();
+            },
+            false);
+
+        this.canvas.addEventListener("webglcontextrestored", this._webglcontextrestoredListener = function (event) {
+                self._initWebGL();
+                if (self.gl) {
+                    self.scene._webglContextRestored(self.gl);
+                    /**
+                     * Fired whenever the WebGL context has been restored again after having previously being lost
+                     * @event webglContextRestored
+                     * @param value The WebGL context object
+                     */
+                    self.fire("webglcontextrestored", self.gl);
+                    event.preventDefault();
+                }
+                console.timeEnd("webglcontextrestored");
+            },
+            false);
+
         // Attach to resize events on the canvas
         let dirtyBoundary = true; // make sure we publish the 1st boundary event
 
@@ -418,9 +448,12 @@ class Canvas extends Component {
      *
      * ````JavaScript
      *
+     * // Ignore transparent pixels (default is false)
+     * var opaqueOnly = true;
+     *
      * var colors = new Float32Array(8);
      *
-     * viewer.scene.canvas.readPixels([ 100, 22, 12, 33 ], colors, 2);
+     * viewer.scene.canvas.readPixels([ 100, 22, 12, 33 ], colors, 2, opaqueOnly);
      * ````
      *
      * Then the r,g,b components of the colors will be set to the colors at those pixels.
@@ -428,9 +461,10 @@ class Canvas extends Component {
      * @param {Number[]} pixels
      * @param {Number[]} colors
      * @param {Number} size
+     * @param {Boolean} opaqueOnly
      */
-    readPixels(pixels, colors, size) {
-        return this.scene._renderer.snapshot.readPixels(pixels, colors, size);
+    readPixels(pixels, colors, size, opaqueOnly) {
+        return this.scene._renderer.readPixels(pixels, colors, size, opaqueOnly);
     }
 
     /**
@@ -445,7 +479,13 @@ class Canvas extends Component {
     destroy() {
         this.scene.off(this._tick);
         this._spinner._destroy();
+        // Memory leak avoidance
+        this.canvas.removeEventListener("webglcontextlost", this._webglcontextlostListener);
+        this.canvas.removeEventListener("webglcontextrestored", this._webglcontextrestoredListener);
+        
+        // this.gl.getExtension("WEBGL_lose_context").loseContext(); // disabled because of XCD-306 and XEOK-295
         this.gl = null;
+        
         super.destroy();
     }
 }

package/src/viewer/scene/geometry/ReadableGeometry.js

@@ -224,6 +224,12 @@ class ReadableGeometry extends Geometry {
 
         memoryStats.meshes++;
 
+        this._buildVBOs();
+    }
+
+    _buildVBOs() {
+        const state = this._state;
+        const gl = this.scene.canvas.gl;
         if (state.indices) {
             state.indicesBuf = new ArrayBuf(gl, gl.ELEMENT_ARRAY_BUFFER, state.indices, state.indices.length, 1, gl.STATIC_DRAW);
             memoryStats.indices += state.indicesBuf.numItems;
@@ -332,6 +338,25 @@ class ReadableGeometry extends Geometry {
         // memoryStats.colors += this._pickVertexColorsBuf.numItems;
     }
 
+    _webglContextLost() {
+        if (this._sceneVertexBufs) {
+            this._sceneVertexBufs.webglContextLost();
+        }
+    }
+
+    _webglContextRestored() {
+        if (this._sceneVertexBufs) {
+            this._sceneVertexBufs.webglContextRestored();
+        }
+        this._buildVBOs();
+        this._edgeIndicesBuf = null;
+        this._pickVertexPositionsBuf = null;
+        this._pickTrianglePositionsBuf = null;
+        this._pickTriangleColorsBuf = null;
+        this._pickVertexPositionsBuf = null;
+        this._pickVertexColorsBuf = null;
+    }
+
     /**
      * Gets the Geometry's primitive type.
 

package/src/viewer/scene/lights/CubeTexture.js

@@ -89,6 +89,19 @@ class CubeTexture extends Component {
         return value;
     }
 
+    _webglContextRestored() {
+        const gl = this.scene.canvas.gl;
+        this._state.texture = null;
+        // if (this._images.length > 0) {
+        //     this._state.texture = new xeokit.renderer.Texture2D(gl, gl.TEXTURE_CUBE_MAP);
+        //     this._state.texture.setImage(this._images, this._state);
+        //     this._state.texture.setProps(this._state);
+        // } else
+        if (this._src) {
+            this._loadSrc(this._src);
+        }
+    }
+
     _loadSrc(src) {
         const self = this;
         const gl = this.scene.canvas.gl;

package/src/viewer/scene/lights/DirLight.js

@@ -177,8 +177,7 @@ class DirLight extends Light {
 
             getShadowRenderBuf: () => {
                 if (!this._shadowRenderBuf) {
-                    this._shadowRenderBuf = new RenderBuffer(this.scene.canvas.gl); // Super old mobile devices have a limit of 1024x1024 textures
-                    this._shadowRenderBuf.setSize([1024, 1024]);
+                    this._shadowRenderBuf = new RenderBuffer(this.scene.canvas.canvas, this.scene.canvas.gl, {size: [1024, 1024]}); // Super old mobile devices have a limit of 1024x1024 textures
                 }
                 return this._shadowRenderBuf;
             }

package/src/viewer/scene/lights/PointLight.js

@@ -181,8 +181,7 @@ class PointLight extends Light {
 
             getShadowRenderBuf: () => {
                 if (!self._shadowRenderBuf) {
-                    self._shadowRenderBuf = new RenderBuffer(self.scene.canvas.gl); // Super old mobile devices have a limit of 1024x1024 textures
-                    self._shadowRenderBuf.setSize([1024, 1024]);
+                    self._shadowRenderBuf = new RenderBuffer(self.scene.canvas.canvas, self.scene.canvas.gl, {size: [1024, 1024]}); // Super old mobile devices have a limit of 1024x1024 textures
                 }
                 return self._shadowRenderBuf;
             }

package/src/viewer/scene/materials/Texture.js

@@ -212,6 +212,15 @@ class Texture extends Component {
         return value;
     }
 
+    _webglContextRestored() {
+        this._state.texture = new Texture2D({gl: this.scene.canvas.gl});
+        if (this._image) {
+            this.image = this._image;
+        } else if (this._src) {
+            this.src = this._src;
+        }
+    }
+
     _update() {
         const state = this._state;
         if (this._matrixDirty) {

package/src/viewer/scene/math/rtcCoords.js

@@ -1,6 +1,7 @@
 import {math} from './math.js';
 
 const tempVec3a = math.vec3();
+const tempVec4  = math.vec4();
 
 /**
  * Given a view matrix and a relative-to-center (RTC) coordinate origin, returns a view matrix
@@ -103,4 +104,40 @@ function worldToRTCPositions(worldPositions, rtcPositions, rtcCenter, cellSize =
     return rtcNeeded;
 }
 
-export {createRTCViewMat, worldToRTCPos, worldToRTCPositions};
+/**
+ * Converts an RTC 3D position to World-space.
+ *
+ * @private
+ * @param {Float64Array} rtcCenter Double-precision relative-to-center (RTC) center pos.
+ * @param {Float32Array} rtcPos Single-precision offset fom that center.
+ * @param {Float64Array} worldPos The World-space position.
+ */
+function rtcToWorldPos(rtcCenter, rtcPos, worldPos) {
+    worldPos[0] = rtcCenter[0] + rtcPos[0];
+    worldPos[1] = rtcCenter[1] + rtcPos[1];
+    worldPos[2] = rtcCenter[2] + rtcPos[2];
+    return worldPos;
+}
+
+/**
+ * Given a 3D plane defined by distance from origin and direction, and an RTC center position,
+ * return a plane position that is relative to the RTC center.
+ *
+ * @private
+ * @param dist
+ * @param dir
+ * @param rtcCenter
+ * @param rtcPlanePos
+ * @returns {*}
+ */
+function getPlaneRTCPos(dist, dir, rtcOrigin, rtcPlanePos, originMatrix) {
+    const rtcCenter = (originMatrix
+                       ? (tempVec4.set(rtcOrigin, 0), tempVec4[3] = 1, math.mulMat4v4(originMatrix, tempVec4, tempVec4))
+                       : rtcOrigin);
+    const rtcCenterToPlaneDist = math.dotVec3(dir, rtcCenter) + dist;
+    const dirNormalized = math.normalizeVec3(dir, tempVec3a);
+    math.mulVec3Scalar(dirNormalized, -rtcCenterToPlaneDist, rtcPlanePos);
+    return rtcPlanePos;
+}
+
+export {createRTCViewMat, worldToRTCPos, worldToRTCPositions, rtcToWorldPos, getPlaneRTCPos};