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

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

@@ -0,0 +1,162 @@
+import {math} from './math.js';
+
+/**
+ * @private
+ */
+var buildEdgeIndices = (function () {
+
+    const uniquePositions = [];
+    const indicesLookup = [];
+    const indicesReverseLookup = [];
+    const weldedIndices = [];
+
+// TODO: Optimize with caching, but need to cater to both compressed and uncompressed positions
+
+    const faces = [];
+    let numFaces = 0;
+    const compa = new Uint16Array(3);
+    const compb = new Uint16Array(3);
+    const compc = new Uint16Array(3);
+    const a = math.vec3();
+    const b = math.vec3();
+    const c = math.vec3();
+    const cb = math.vec3();
+    const ab = math.vec3();
+    const cross = math.vec3();
+    const normal = math.vec3();
+
+    function weldVertices(positions, indices) {
+        const positionsMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
+        let vx;
+        let vy;
+        let vz;
+        let key;
+        const precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001
+        const precision = Math.pow(10, precisionPoints);
+        let i;
+        let len;
+        let lenUniquePositions = 0;
+        for (i = 0, len = positions.length; i < len; i += 3) {
+            vx = positions[i];
+            vy = positions[i + 1];
+            vz = positions[i + 2];
+            key = Math.round(vx * precision) + '_' + Math.round(vy * precision) + '_' + Math.round(vz * precision);
+            if (positionsMap[key] === undefined) {
+                positionsMap[key] = lenUniquePositions / 3;
+                uniquePositions[lenUniquePositions++] = vx;
+                uniquePositions[lenUniquePositions++] = vy;
+                uniquePositions[lenUniquePositions++] = vz;
+            }
+            indicesLookup[i / 3] = positionsMap[key];
+        }
+        for (i = 0, len = indices.length; i < len; i++) {
+            weldedIndices[i] = indicesLookup[indices[i]];
+            indicesReverseLookup[weldedIndices[i]] = indices[i];
+        }
+    }
+
+    function buildFaces(numIndices, positionsDecodeMatrix) {
+        numFaces = 0;
+        for (let i = 0, len = numIndices; i < len; i += 3) {
+            const ia = ((weldedIndices[i]) * 3);
+            const ib = ((weldedIndices[i + 1]) * 3);
+            const ic = ((weldedIndices[i + 2]) * 3);
+            if (positionsDecodeMatrix) {
+                compa[0] = uniquePositions[ia];
+                compa[1] = uniquePositions[ia + 1];
+                compa[2] = uniquePositions[ia + 2];
+                compb[0] = uniquePositions[ib];
+                compb[1] = uniquePositions[ib + 1];
+                compb[2] = uniquePositions[ib + 2];
+                compc[0] = uniquePositions[ic];
+                compc[1] = uniquePositions[ic + 1];
+                compc[2] = uniquePositions[ic + 2];
+                // Decode
+                math.decompressPosition(compa, positionsDecodeMatrix, a);
+                math.decompressPosition(compb, positionsDecodeMatrix, b);
+                math.decompressPosition(compc, positionsDecodeMatrix, c);
+            } else {
+                a[0] = uniquePositions[ia];
+                a[1] = uniquePositions[ia + 1];
+                a[2] = uniquePositions[ia + 2];
+                b[0] = uniquePositions[ib];
+                b[1] = uniquePositions[ib + 1];
+                b[2] = uniquePositions[ib + 2];
+                c[0] = uniquePositions[ic];
+                c[1] = uniquePositions[ic + 1];
+                c[2] = uniquePositions[ic + 2];
+            }
+            math.subVec3(c, b, cb);
+            math.subVec3(a, b, ab);
+            math.cross3Vec3(cb, ab, cross);
+            math.normalizeVec3(cross, normal);
+            const face = faces[numFaces] || (faces[numFaces] = {normal: math.vec3()});
+            face.normal[0] = normal[0];
+            face.normal[1] = normal[1];
+            face.normal[2] = normal[2];
+            numFaces++;
+        }
+    }
+
+    return function (positions, indices, positionsDecodeMatrix, edgeThreshold) {
+        weldVertices(positions, indices);
+        buildFaces(indices.length, positionsDecodeMatrix);
+        const edgeIndices = [];
+        const thresholdDot = Math.cos(math.DEGTORAD * edgeThreshold);
+        const edges = {};
+        let edge1;
+        let edge2;
+        let index1;
+        let index2;
+        let key;
+        let largeIndex = false;
+        let edge;
+        let normal1;
+        let normal2;
+        let dot;
+        let ia;
+        let ib;
+        for (let i = 0, len = indices.length; i < len; i += 3) {
+            const faceIndex = i / 3;
+            for (let j = 0; j < 3; j++) {
+                edge1 = weldedIndices[i + j];
+                edge2 = weldedIndices[i + ((j + 1) % 3)];
+                index1 = Math.min(edge1, edge2);
+                index2 = Math.max(edge1, edge2);
+                key = index1 + "," + index2;
+                if (edges[key] === undefined) {
+                    edges[key] = {
+                        index1: index1,
+                        index2: index2,
+                        face1: faceIndex,
+                        face2: undefined
+                    };
+                } else {
+                    edges[key].face2 = faceIndex;
+                }
+            }
+        }
+        for (key in edges) {
+            edge = edges[key];
+            // an edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. default = 1 degree.
+            if (edge.face2 !== undefined) {
+                normal1 = faces[edge.face1].normal;
+                normal2 = faces[edge.face2].normal;
+                dot = math.dotVec3(normal1, normal2);
+                if (dot > thresholdDot) {
+                    continue;
+                }
+            }
+            ia = indicesReverseLookup[edge.index1];
+            ib = indicesReverseLookup[edge.index2];
+            if (!largeIndex && ia > 65535 || ib > 65535) {
+                largeIndex = true;
+            }
+            edgeIndices.push(ia);
+            edgeIndices.push(ib);
+        }
+        return (largeIndex) ? new Uint32Array(edgeIndices) : new Uint16Array(edgeIndices);
+    };
+})();
+
+export {buildEdgeIndices};

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

@@ -0,0 +1,365 @@
+/**
+ * Private geometry compression and decompression utilities.
+ */
+
+import {math} from "./math.js";
+
+/**
+ * @private
+ * @param array
+ * @returns {{min: Float32Array, max: Float32Array}}
+ */
+function getPositionsBounds(array) {
+    const min = new Float32Array(3);
+    const max = new Float32Array(3);
+    let i, j;
+    for (i = 0; i < 3; i++) {
+        min[i] = Number.MAX_VALUE;
+        max[i] = -Number.MAX_VALUE;
+    }
+    for (i = 0; i < array.length; i += 3) {
+        for (j = 0; j < 3; j++) {
+            min[j] = Math.min(min[j], array[i + j]);
+            max[j] = Math.max(max[j], array[i + j]);
+        }
+    }
+    return {
+        min: min,
+        max: max
+    };
+}
+
+const createPositionsDecodeMatrix = (function () {
+    const translate = math.mat4();
+    const scale = math.mat4();
+    return function (aabb, positionsDecodeMatrix) {
+        positionsDecodeMatrix = positionsDecodeMatrix || math.mat4();
+        const xmin = aabb[0];
+        const ymin = aabb[1];
+        const zmin = aabb[2];
+        const xwid = aabb[3] - xmin;
+        const ywid = aabb[4] - ymin;
+        const zwid = aabb[5] - zmin;
+        const maxInt = 65535;
+        math.identityMat4(translate);
+        math.translationMat4v(aabb, translate);
+        math.identityMat4(scale);
+        math.scalingMat4v([xwid / maxInt, ywid / maxInt, zwid / maxInt], scale);
+        math.mulMat4(translate, scale, positionsDecodeMatrix);
+        return positionsDecodeMatrix;
+    };
+})();
+
+/**
+ * @private
+ */
+var compressPositions = (function () { // http://cg.postech.ac.kr/research/mesh_comp_mobile/mesh_comp_mobile_conference.pdf
+    const translate = math.mat4();
+    const scale = math.mat4();
+    return function (array, min, max) {
+        const quantized = new Uint16Array(array.length);
+        const multiplier = new Float32Array([
+            max[0] !== min[0] ? 65535 / (max[0] - min[0]) : 0,
+            max[1] !== min[1] ? 65535 / (max[1] - min[1]) : 0,
+            max[2] !== min[2] ? 65535 / (max[2] - min[2]) : 0
+        ]);
+        let i;
+        for (i = 0; i < array.length; i += 3) {
+            quantized[i + 0] = Math.max(0, Math.min(65535, Math.floor((array[i + 0] - min[0]) * multiplier[0])));
+            quantized[i + 1] = Math.max(0, Math.min(65535, Math.floor((array[i + 1] - min[1]) * multiplier[1])));
+            quantized[i + 2] = Math.max(0, Math.min(65535, Math.floor((array[i + 2] - min[2]) * multiplier[2])));
+        }
+        math.identityMat4(translate);
+        math.translationMat4v(min, translate);
+        math.identityMat4(scale);
+        math.scalingMat4v([
+            (max[0] - min[0]) / 65535,
+            (max[1] - min[1]) / 65535,
+            (max[2] - min[2]) / 65535
+        ], scale);
+        const decodeMat = math.mulMat4(translate, scale, math.identityMat4());
+        return {
+            quantized: quantized,
+            decodeMatrix: decodeMat
+        };
+    };
+})();
+
+function compressPosition(p, aabb, q) {
+    const multiplier = new Float32Array([
+        aabb[3] !== aabb[0] ? 65535 / (aabb[3] - aabb[0]) : 0,
+        aabb[4] !== aabb[1] ? 65535 / (aabb[4] - aabb[1]) : 0,
+        aabb[5] !== aabb[2] ? 65535 / (aabb[5] - aabb[2]) : 0
+    ]);
+    q[0] = Math.max(0, Math.min(65535, Math.floor((p[0] - aabb[0]) * multiplier[0])));
+    q[1] = Math.max(0, Math.min(65535, Math.floor((p[1] - aabb[1]) * multiplier[1])));
+    q[2] = Math.max(0, Math.min(65535, Math.floor((p[2] - aabb[2]) * multiplier[2])));
+}
+
+function decompressPosition(position, decodeMatrix, dest) {
+    dest[0] = position[0] * decodeMatrix[0] + decodeMatrix[12];
+    dest[1] = position[1] * decodeMatrix[5] + decodeMatrix[13];
+    dest[2] = position[2] * decodeMatrix[10] + decodeMatrix[14];
+    return dest;
+}
+
+function decompressAABB(aabb, decodeMatrix, dest = aabb) {
+    dest[0] = aabb[0] * decodeMatrix[0] + decodeMatrix[12];
+    dest[1] = aabb[1] * decodeMatrix[5] + decodeMatrix[13];
+    dest[2] = aabb[2] * decodeMatrix[10] + decodeMatrix[14];
+    dest[3] = aabb[3] * decodeMatrix[0] + decodeMatrix[12];
+    dest[4] = aabb[4] * decodeMatrix[5] + decodeMatrix[13];
+    dest[5] = aabb[5] * decodeMatrix[10] + decodeMatrix[14];
+    return dest;
+}
+
+/**
+ * @private
+ */
+function decompressPositions(positions, decodeMatrix, dest = new Float32Array(positions.length)) {
+    for (let i = 0, len = positions.length; i < len; i += 3) {
+        dest[i + 0] = positions[i + 0] * decodeMatrix[0] + decodeMatrix[12];
+        dest[i + 1] = positions[i + 1] * decodeMatrix[5] + decodeMatrix[13];
+        dest[i + 2] = positions[i + 2] * decodeMatrix[10] + decodeMatrix[14];
+    }
+    return dest;
+}
+
+//--------------- UVs --------------------------------------------------------------------------------------------------
+
+/**
+ * @private
+ * @param array
+ * @returns {{min: Float32Array, max: Float32Array}}
+ */
+function getUVBounds(array) {
+    const min = new Float32Array(2);
+    const max = new Float32Array(2);
+    let i, j;
+    for (i = 0; i < 2; i++) {
+        min[i] = Number.MAX_VALUE;
+        max[i] = -Number.MAX_VALUE;
+    }
+    for (i = 0; i < array.length; i += 2) {
+        for (j = 0; j < 2; j++) {
+            min[j] = Math.min(min[j], array[i + j]);
+            max[j] = Math.max(max[j], array[i + j]);
+        }
+    }
+    return {
+        min: min,
+        max: max
+    };
+}
+
+/**
+ * @private
+ */
+var compressUVs = (function () {
+    const translate = math.mat3();
+    const scale = math.mat3();
+    return function (array, min, max) {
+        const quantized = new Uint16Array(array.length);
+        const multiplier = new Float32Array([
+            65535 / (max[0] - min[0]),
+            65535 / (max[1] - min[1])
+        ]);
+        let i;
+        for (i = 0; i < array.length; i += 2) {
+            quantized[i + 0] = Math.max(0, Math.min(65535, Math.floor((array[i + 0] - min[0]) * multiplier[0])));
+            quantized[i + 1] = Math.max(0, Math.min(65535, Math.floor((array[i + 1] - min[1]) * multiplier[1])));
+        }
+        math.identityMat3(translate);
+        math.translationMat3v(min, translate);
+        math.identityMat3(scale);
+        math.scalingMat3v([
+            (max[0] - min[0]) / 65535,
+            (max[1] - min[1]) / 65535
+        ], scale);
+        const decodeMat = math.mulMat3(translate, scale, math.identityMat3());
+        return {
+            quantized: quantized,
+            decodeMatrix: decodeMat
+        };
+    };
+})();
+
+
+//--------------- Normals ----------------------------------------------------------------------------------------------
+
+/**
+ * @private
+ */
+function compressNormals(array) { // http://jcgt.org/published/0003/02/01/
+
+    // Note: three elements for each encoded normal, in which the last element in each triplet is redundant.
+    // This is to work around a mysterious WebGL issue where 2-element normals just wouldn't work in the shader :/
+
+    const encoded = new Int8Array(array.length);
+    let oct, dec, best, currentCos, bestCos;
+    for (let i = 0; i < array.length; i += 3) {
+        // Test various combinations of ceil and floor
+        // to minimize rounding errors
+        best = oct = octEncodeVec3(array, i, "floor", "floor");
+        dec = octDecodeVec2(oct);
+        currentCos = bestCos = dot(array, i, dec);
+        oct = octEncodeVec3(array, i, "ceil", "floor");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(array, i, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        oct = octEncodeVec3(array, i, "floor", "ceil");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(array, i, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        oct = octEncodeVec3(array, i, "ceil", "ceil");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(array, i, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        encoded[i] = best[0];
+        encoded[i + 1] = best[1];
+    }
+    return encoded;
+}
+
+/**
+ * @private
+ */
+function octEncodeVec3(array, i, xfunc, yfunc) { // Oct-encode single normal vector in 2 bytes
+    let x = array[i] / (Math.abs(array[i]) + Math.abs(array[i + 1]) + Math.abs(array[i + 2]));
+    let y = array[i + 1] / (Math.abs(array[i]) + Math.abs(array[i + 1]) + Math.abs(array[i + 2]));
+    if (array[i + 2] < 0) {
+        let tempx = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+        let tempy = (1 - Math.abs(x)) * (y >= 0 ? 1 : -1);
+        x = tempx;
+        y = tempy;
+    }
+    return new Int8Array([
+        Math[xfunc](x * 127.5 + (x < 0 ? -1 : 0)),
+        Math[yfunc](y * 127.5 + (y < 0 ? -1 : 0))
+    ]);
+}
+
+/**
+ * Decode an oct-encoded normal
+ */
+function octDecodeVec2(oct) {
+    let x = oct[0];
+    let y = oct[1];
+    x /= x < 0 ? 127 : 128;
+    y /= y < 0 ? 127 : 128;
+    const z = 1 - Math.abs(x) - Math.abs(y);
+    if (z < 0) {
+        x = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+        y = (1 - Math.abs(x)) * (y >= 0 ? 1 : -1);
+    }
+    const length = Math.sqrt(x * x + y * y + z * z);
+    return [
+        x / length,
+        y / length,
+        z / length
+    ];
+}
+
+/**
+ * Dot product of a normal in an array against a candidate decoding
+ * @private
+ */
+function dot(array, i, vec3) {
+    return array[i] * vec3[0] + array[i + 1] * vec3[1] + array[i + 2] * vec3[2];
+}
+
+/**
+ * @private
+ */
+function decompressUV(uv, decodeMatrix, dest) {
+    dest[0] = uv[0] * decodeMatrix[0] + decodeMatrix[6];
+    dest[1] = uv[1] * decodeMatrix[4] + decodeMatrix[7];
+}
+
+/**
+ * @private
+ */
+function decompressUVs(uvs, decodeMatrix, dest = new Float32Array(uvs.length)) {
+    for (let i = 0, len = uvs.length; i < len; i += 3) {
+        dest[i + 0] = uvs[i + 0] * decodeMatrix[0] + decodeMatrix[6];
+        dest[i + 1] = uvs[i + 1] * decodeMatrix[4] + decodeMatrix[7];
+    }
+    return dest;
+}
+
+/**
+ * @private
+ */
+function decompressNormal(oct, result) {
+    let x = oct[0];
+    let y = oct[1];
+    x = (2 * x + 1) / 255;
+    y = (2 * y + 1) / 255;
+    const z = 1 - Math.abs(x) - Math.abs(y);
+    if (z < 0) {
+        x = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+        y = (1 - Math.abs(x)) * (y >= 0 ? 1 : -1);
+    }
+    const length = Math.sqrt(x * x + y * y + z * z);
+    result[0] = x / length;
+    result[1] = y / length;
+    result[2] = z / length;
+    return result;
+}
+
+/**
+ * @private
+ */
+function decompressNormals(octs, result) {
+    for (let i = 0, j = 0, len = octs.length; i < len; i += 2) {
+        let x = octs[i + 0];
+        let y = octs[i + 1];
+        x = (2 * x + 1) / 255;
+        y = (2 * y + 1) / 255;
+        const z = 1 - Math.abs(x) - Math.abs(y);
+        if (z < 0) {
+            x = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+            y = (1 - Math.abs(x)) * (y >= 0 ? 1 : -1);
+        }
+        const length = Math.sqrt(x * x + y * y + z * z);
+        result[j + 0] = x / length;
+        result[j + 1] = y / length;
+        result[j + 2] = z / length;
+        j += 3;
+    }
+    return result;
+}
+
+/**
+ * @private
+ */
+const geometryCompressionUtils = {
+
+    getPositionsBounds: getPositionsBounds,
+    createPositionsDecodeMatrix: createPositionsDecodeMatrix,
+    compressPositions: compressPositions,
+    compressPosition:compressPosition,
+    decompressPositions: decompressPositions,
+    decompressPosition: decompressPosition,
+    decompressAABB: decompressAABB,
+
+    getUVBounds: getUVBounds,
+    compressUVs: compressUVs,
+    decompressUVs: decompressUVs,
+    decompressUV: decompressUV,
+
+    compressNormals: compressNormals,
+    decompressNormals: decompressNormals,
+    decompressNormal: decompressNormal
+};
+
+export {geometryCompressionUtils};

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

@@ -0,0 +1,3 @@
+export * from "./math.js";
+export * from "./Frustum.js";
+export * from "./rtcCoords.js";