@xeokit/xeokit-sdk 2.5.2-beta-10 → 2.5.2-beta-11

package/src/src/viewer/scene/model/SceneModelTransform.js

@@ -0,0 +1,404 @@
+import {math} from "../math/index.js";
+
+const angleAxis = math.vec4(4);
+const q1 = math.vec4();
+const q2 = math.vec4();
+const xAxis = math.vec3([1, 0, 0]);
+const yAxis = math.vec3([0, 1, 0]);
+const zAxis = math.vec3([0, 0, 1]);
+
+const veca = math.vec3(3);
+const vecb = math.vec3(3);
+
+const identityMat = math.identityMat4();
+
+/**
+ * A dynamically-updatable transform within a {@link SceneModel}.
+ *
+ * * Can be composed into hierarchies
+ * * Shared by multiple {@link SceneModelMesh}es
+ * * Created with {@link SceneModel#createTransform}
+ * * Stored by ID in {@link SceneModel#transforms}
+ * * Referenced by {@link SceneModelMesh#transform}
+ */
+export class SceneModelTransform {
+
+    /**
+     * @private
+     */
+    constructor(cfg) {
+        this._model = cfg.model;
+
+        /**
+         * Unique ID of this SceneModelTransform.
+         *
+         * The SceneModelTransform is registered against this ID in {@link SceneModel#transforms}.
+         */
+        this.id = cfg.id;
+
+        this._parentTransform = cfg.parent;
+        this._childTransforms = [];
+        this._meshes = [];
+        this._scale = new Float32Array([1,1,1]);
+        this._quaternion = math.identityQuaternion(new Float32Array(4));
+        this._rotation = new Float32Array(3);
+        this._position = new Float32Array(3);
+        this._localMatrix = math.identityMat4(new Float32Array(16));
+        this._worldMatrix = math.identityMat4(new Float32Array(16));
+        this._localMatrixDirty = true;
+        this._worldMatrixDirty = true;
+
+        if (cfg.matrix) {
+            this.matrix = cfg.matrix;
+        } else {
+            this.scale = cfg.scale;
+            this.position = cfg.position;
+            if (cfg.quaternion) {
+            } else {
+                this.rotation = cfg.rotation;
+            }
+        }
+        if (cfg.parent) {
+            cfg.parent._addChildTransform(this);
+        }
+    }
+
+    _addChildTransform(childTransform) {
+        this._childTransforms.push(childTransform);
+        childTransform._parentTransform = this;
+        childTransform._setWorldMatrixDirty();
+        childTransform._setAABBDirty();
+    }
+
+    _addMesh(mesh) {
+        this._meshes.push(mesh);
+        mesh.transform = this;
+        // childTransform._setWorldMatrixDirty();
+        // childTransform._setAABBDirty();
+    }
+
+    /**
+     * The optional parent SceneModelTransform.
+     *
+     * @type {SceneModelTransform}
+     */
+    get parentTransform() {
+        return this._parentTransform;
+    }
+
+    /**
+     * The {@link SceneModelMesh}es transformed by this SceneModelTransform.
+     *
+     * @returns {[]}
+     */
+    get meshes() {
+        return this._meshes;
+    }
+
+    /**
+     * Sets the SceneModelTransform's local translation.
+     *
+     * Default value is ````[0,0,0]````.
+     *
+     * @type {Number[]}
+     */
+    set position(value) {
+        this._position.set(value || [0, 0, 0]);
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+    }
+
+    /**
+     * Gets the SceneModelTransform's translation.
+     *
+     * Default value is ````[0,0,0]````.
+     *
+     * @type {Number[]}
+     */
+    get position() {
+        return this._position;
+    }
+
+    /**
+     * Sets the SceneModelTransform's rotation, as Euler angles given in degrees, for each of the X, Y and Z axis.
+     *
+     * Default value is ````[0,0,0]````.
+     *
+     * @type {Number[]}
+     */
+    set rotation(value) {
+        this._rotation.set(value || [0, 0, 0]);
+        math.eulerToQuaternion(this._rotation, "XYZ", this._quaternion);
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+    }
+
+    /**
+     * Gets the SceneModelTransform's rotation, as Euler angles given in degrees, for each of the X, Y and Z axis.
+     *
+     * Default value is ````[0,0,0]````.
+     *
+     * @type {Number[]}
+     */
+    get rotation() {
+        return this._rotation;
+    }
+
+    /**
+     * Sets the SceneModelTransform's rotation quaternion.
+     *
+     * Default value is ````[0,0,0,1]````.
+     *
+     * @type {Number[]}
+     */
+    set quaternion(value) {
+        this._quaternion.set(value || [0, 0, 0, 1]);
+        math.quaternionToEuler(this._quaternion, "XYZ", this._rotation);
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+    }
+
+    /**
+     * Gets the SceneModelTransform's rotation quaternion.
+     *
+     * Default value is ````[0,0,0,1]````.
+     *
+     * @type {Number[]}
+     */
+    get quaternion() {
+        return this._quaternion;
+    }
+
+    /**
+     * Sets the SceneModelTransform's scale.
+     *
+     * Default value is ````[1,1,1]````.
+     *
+     * @type {Number[]}
+     */
+    set scale(value) {
+        this._scale.set(value || [1, 1, 1]);
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+    }
+
+    /**
+     * Gets the SceneModelTransform's scale.
+     *
+     * Default value is ````[1,1,1]````.
+     *
+     * @type {Number[]}
+     */
+    get scale() {
+        return this._scale;
+    }
+
+    /**
+     * Sets the SceneModelTransform's transform matrix.
+     *
+     * Default value is ````[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]````.
+     *
+     * @type {Number[]}
+     */
+    set matrix(value) {
+        if (!this._localMatrix) {
+            this._localMatrix = math.identityMat4();
+        }
+        this._localMatrix.set(value || identityMat);
+        math.decomposeMat4(this._localMatrix, this._position, this._quaternion, this._scale);
+        this._localMatrixDirty = false;
+        this._transformDirty();
+        this._model.glRedraw();
+    }
+
+    /**
+     * Gets the SceneModelTransform's transform matrix.
+     *
+     * Default value is ````[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]````.
+     *
+     * @type {Number[]}
+     */
+    get matrix() {
+        if (this._localMatrixDirty) {
+            if (!this._localMatrix) {
+                this._localMatrix = math.identityMat4();
+            }
+            math.composeMat4(this._position, this._quaternion, this._scale, this._localMatrix);
+            this._localMatrixDirty = false;
+        }
+        return this._localMatrix;
+    }
+
+    /**
+     * Gets the SceneModelTransform's World matrix.
+     *
+     * @property worldMatrix
+     * @type {Number[]}
+     */
+    get worldMatrix() {
+        if (this._worldMatrixDirty) {
+            this._buildWorldMatrix();
+        }
+        return this._worldMatrix;
+    }
+
+    /**
+     * Rotates the SceneModelTransform about the given axis by the given increment.
+     *
+     * @param {Number[]} axis Local axis about which to rotate.
+     * @param {Number} angle Angle increment in degrees.
+     */
+    rotate(axis, angle) {
+        angleAxis[0] = axis[0];
+        angleAxis[1] = axis[1];
+        angleAxis[2] = axis[2];
+        angleAxis[3] = angle * math.DEGTORAD;
+        math.angleAxisToQuaternion(angleAxis, q1);
+        math.mulQuaternions(this.quaternion, q1, q2);
+        this.quaternion = q2;
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+        return this;
+    }
+
+    /**
+     * Rotates the SceneModelTransform about the given World-space axis by the given increment.
+     *
+     * @param {Number[]} axis Local axis about which to rotate.
+     * @param {Number} angle Angle increment in degrees.
+     */
+    rotateOnWorldAxis(axis, angle) {
+        angleAxis[0] = axis[0];
+        angleAxis[1] = axis[1];
+        angleAxis[2] = axis[2];
+        angleAxis[3] = angle * math.DEGTORAD;
+        math.angleAxisToQuaternion(angleAxis, q1);
+        math.mulQuaternions(q1, this.quaternion, q1);
+        //this.quaternion.premultiply(q1);
+        return this;
+    }
+
+    /**
+     * Rotates the SceneModelTransform about the local X-axis by the given increment.
+     *
+     * @param {Number} angle Angle increment in degrees.
+     */
+    rotateX(angle) {
+        return this.rotate(xAxis, angle);
+    }
+
+    /**
+     * Rotates the SceneModelTransform about the local Y-axis by the given increment.
+     *
+     * @param {Number} angle Angle increment in degrees.
+     */
+    rotateY(angle) {
+        return this.rotate(yAxis, angle);
+    }
+
+    /**
+     * Rotates the SceneModelTransform about the local Z-axis by the given increment.
+     *
+     * @param {Number} angle Angle increment in degrees.
+     */
+    rotateZ(angle) {
+        return this.rotate(zAxis, angle);
+    }
+
+    /**
+     * Translates the SceneModelTransform along the local axis by the given increment.
+     *
+     * @param {Number[]} axis Normalized local space 3D vector along which to translate.
+     * @param {Number} distance Distance to translate along  the vector.
+     */
+    translate(axis) {
+        this._position[0] += axis[0];
+        this._position[1] += axis[1];
+        this._position[2] += axis[2];
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+        return this;
+    }
+
+    /**
+     * Translates the SceneModelTransform along the local X-axis by the given increment.
+     *
+     * @param {Number} distance Distance to translate along  the X-axis.
+     */
+    translateX(distance) {
+        this._position[0] += distance;
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+        return this;
+    }
+
+    /**
+     * Translates the SceneModelTransform along the local Y-axis by the given increment.
+     *
+     * @param {Number} distance Distance to translate along  the Y-axis.
+     */
+    translateY(distance) {
+        this._position[1] += distance;
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+        return this;
+    }
+
+    /**
+     * Translates the SceneModelTransform along the local Z-axis by the given increment.
+     *
+     * @param {Number} distance Distance to translate along  the Z-axis.
+     */
+    translateZ(distance) {
+        this._position[2] += distance;
+        this._setLocalMatrixDirty();
+        this._model.glRedraw();
+        return this;
+    }
+
+    _setLocalMatrixDirty() {
+        this._localMatrixDirty = true;
+        this._transformDirty();
+    }
+
+    _transformDirty() {
+        this._worldMatrixDirty = true;
+        for (let i = 0, len = this._childTransforms.length; i < len; i++) {
+            const childTransform = this._childTransforms[i];
+            childTransform._transformDirty();
+            if (childTransform._meshes && childTransform._meshes.length > 0) {
+               const meshes = childTransform._meshes;
+               for (let j =0, lenj = meshes.length; j < lenj; j++) {
+                 meshes[j]._transformDirty();
+               }
+            }
+        }
+        if (this._meshes && this._meshes.length > 0) {
+            const meshes = this._meshes;
+            for (let j =0, lenj = meshes.length; j < lenj; j++) {
+                meshes[j]._transformDirty();
+            }
+        }
+    }
+
+    _buildWorldMatrix() {
+        const localMatrix = this.matrix;
+        if (!this._parentTransform) {
+            for (let i = 0, len = localMatrix.length; i < len; i++) {
+                this._worldMatrix[i] = localMatrix[i];
+            }
+        } else {
+            math.mulMat4(this._parentTransform.worldMatrix, localMatrix, this._worldMatrix);
+        }
+        this._worldMatrixDirty = false;
+    }
+
+    _setSubtreeAABBsDirty(sceneTransform) {
+        sceneTransform._aabbDirty = true;
+        if (sceneTransform._childTransforms) {
+            for (let i = 0, len = sceneTransform._childTransforms.length; i < len; i++) {
+                this._setSubtreeAABBsDirty(sceneTransform._childTransforms[i]);
+            }
+        }
+    }
+}

package/src/src/viewer/scene/model/VBOSceneModel.js

@@ -0,0 +1,26 @@
+import {SceneModel} from "./SceneModel.js";
+
+/**
+ * @desc A high-performance model representation for efficient rendering and low memory usage.
+ *
+ * * VBOSceneModel was replaced with {@link SceneModel} in ````xeokit-sdk v2.4````.
+ * * VBOSceneModel currently extends {@link SceneModel}, in order to maintain backward-compatibility until we remove VBOSceneModel.
+ * * See {@link SceneModel} for API details.
+ *
+ * @deprecated
+ * @implements {Drawable}
+ * @implements {Entity}
+ * @extends {SceneModel}
+ */
+export class VBOSceneModel extends SceneModel {
+
+    /**
+     * See {@link VBOSceneModel} for details.
+     *
+     * @param owner
+     * @param cfg
+     */
+    constructor(owner, cfg = {}) {
+        super(owner, cfg);
+    }
+}

package/src/src/viewer/scene/model/calculateUniquePositions.js

@@ -0,0 +1,126 @@
+/**
+ * @author https://github.com/tmarti, with support from https://tribia.com/
+ * @license MIT
+ *
+ * This file takes a geometry given by { positionsCompressed, indices }, and returns
+ * equivalent { positionsCompressed, indices } arrays but which only contain unique
+ * positionsCompressed.
+ *
+ * The time is O(N logN) with the number of positionsCompressed due to a pre-sorting
+ * step, but is much more GC-friendly and actually faster than the classic O(N)
+ * approach based in keeping a hash-based LUT to identify unique positionsCompressed.
+ */
+let comparePositions = null;
+
+function compareVertex(a, b) {
+    let res;
+    for (let i = 0; i < 3; i++) {
+        if (0 !== (res = comparePositions[a * 3 + i] - comparePositions[b * 3 + i])) {
+            return res;
+        }
+    }
+    return 0;
+}
+
+let seqInit = null;
+
+function setMaxNumberOfPositions(maxPositions) {
+    if (seqInit !== null && seqInit.length >= maxPositions) {
+        return;
+    }
+    seqInit = new Uint32Array(maxPositions);
+    for (let i = 0; i < maxPositions; i++) {
+        seqInit[i] = i;
+    }
+}
+
+/**
+ * This function obtains unique positionsCompressed in the provided object
+ * .positionsCompressed array and calculates an index mapping, which is then
+ * applied to the provided object .indices and .edgeindices.
+ *
+ * The input object items are not modified, and instead new set
+ * of positionsCompressed, indices and edgeIndices with the applied optimization
+ * are returned.
+ *
+ * The algorithm, instead of being based in a hash-like LUT for
+ * identifying unique positionsCompressed, is based in pre-sorting the input
+ * positionsCompressed...
+ *
+ * (it's possible to define a _"consistent ordering"_ for the positionsCompressed
+ *  as positionsCompressed are quantized and thus not suffer from float number
+ *  comparison artifacts)
+ *
+ * ... so same positionsCompressed are adjacent in the sorted array, and then
+ * it's easy to scan linearly the sorted array. During the linear run,
+ * we will know that we found a different position because the comparison
+ * function will return != 0 between current and previous element.
+ *
+ * During this linear traversal of the array, a `unique counter` is used
+ * in order to calculate the mapping between original indices and unique
+ * indices.
+ *
+ * @param {{positionsCompressed: number[],indices: number[], edgeIndices: number[]}} mesh The input mesh to process, with `positionsCompressed`, `indices` and `edgeIndices` keys.
+ *
+ * @returns {[Uint16Array, Uint32Array, Uint32Array]} An array with 3 elements: 0 => the uniquified positionsCompressed; 1 and 2 => the remapped edges and edgeIndices arrays
+ */
+export function uniquifyPositions(mesh) {
+    const _positions = mesh.positionsCompressed;
+    const _indices = mesh.indices;
+    const _edgeIndices = mesh.edgeIndices;
+
+    setMaxNumberOfPositions(_positions.length / 3);
+
+    const seq = seqInit.slice(0, _positions.length / 3);
+    const remappings = seqInit.slice(0, _positions.length / 3);
+
+    comparePositions = _positions;
+
+    seq.sort(compareVertex);
+
+    let uniqueIdx = 0
+
+    remappings[seq[0]] = 0;
+
+    for (let i = 1, len = seq.length; i < len; i++) {
+        if (0 !== compareVertex(seq[i], seq[i - 1])) {
+            uniqueIdx++;
+        }
+        remappings[seq[i]] = uniqueIdx;
+    }
+
+    const numUniquePositions = uniqueIdx + 1;
+    const newPositions = new Uint16Array(numUniquePositions * 3);
+
+    uniqueIdx = 0
+
+    newPositions [uniqueIdx * 3 + 0] = _positions [seq[0] * 3 + 0];
+    newPositions [uniqueIdx * 3 + 1] = _positions [seq[0] * 3 + 1];
+    newPositions [uniqueIdx * 3 + 2] = _positions [seq[0] * 3 + 2];
+
+    for (let i = 1, len = seq.length; i < len; i++) {
+        if (0 !== compareVertex(seq[i], seq[i - 1])) {
+            uniqueIdx++;
+            newPositions [uniqueIdx * 3 + 0] = _positions [seq[i] * 3 + 0];
+            newPositions [uniqueIdx * 3 + 1] = _positions [seq[i] * 3 + 1];
+            newPositions [uniqueIdx * 3 + 2] = _positions [seq[i] * 3 + 2];
+        }
+        remappings[seq[i]] = uniqueIdx;
+    }
+
+    comparePositions = null;
+
+    const newIndices = new Uint32Array(_indices.length);
+
+    for (let i = 0, len = _indices.length; i < len; i++) {
+        newIndices[i] = remappings [_indices[i]];
+    }
+
+    const newEdgeIndices = new Uint32Array(_edgeIndices.length);
+
+    for (let i = 0, len = _edgeIndices.length; i < len; i++) {
+        newEdgeIndices[i] = remappings [_edgeIndices[i]];
+    }
+
+    return [newPositions, newIndices, newEdgeIndices];
+}