csyjk 1.2.2 → 2.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/math/buildEdgeIndices.js

@@ -1,162 +0,0 @@
-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/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/math/geometryCompressionUtils.js

@@ -1,353 +0,0 @@
-/**
- * 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);
-        var 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.floor((array[i + 0] - min[0]) * multiplier[0]);
-            quantized[i + 1] = Math.floor((array[i + 1] - min[1]) * multiplier[1]);
-            quantized[i + 2] = 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 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.floor((array[i + 0] - min[0]) * multiplier[0]);
-            quantized[i + 1] = 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,
-    decompressPositions: decompressPositions,
-    decompressPosition: decompressPosition,
-    decompressAABB: decompressAABB,
-
-    getUVBounds: getUVBounds,
-    compressUVs: compressUVs,
-    decompressUVs: decompressUVs,
-    decompressUV: decompressUV,
-
-    compressNormals: compressNormals,
-    decompressNormals: decompressNormals,
-    decompressNormal: decompressNormal
-};
-
-export {geometryCompressionUtils};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/math/index.js

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