@xeokit/xeokit-sdk 2.5.2-beta-13 → 2.5.2-beta-16

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

@@ -1,404 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,126 +0,0 @@
-/**
- * @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];
-}