csyjk 1.1.1 → 1.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/PerformanceModel/lib/RENDER_PASSES.js

@@ -0,0 +1,34 @@
+/**
+ * @private
+ */
+const RENDER_PASSES = {
+
+    // Skipped - suppress rendering
+
+    NOT_RENDERED: 0,
+
+    // Normal rendering - mutually exclusive modes
+
+    COLOR_OPAQUE: 1,
+    COLOR_TRANSPARENT: 2,
+
+    // Emphasis silhouette rendering - mutually exclusive modes
+
+    SILHOUETTE_HIGHLIGHTED: 3,
+    SILHOUETTE_SELECTED: 4,
+    SILHOUETTE_XRAYED: 5,
+
+    // Edges rendering - mutually exclusive modes
+
+    EDGES_COLOR_OPAQUE: 6,
+    EDGES_COLOR_TRANSPARENT: 7,
+    EDGES_HIGHLIGHTED: 8,
+    EDGES_SELECTED: 9,
+    EDGES_XRAYED: 10,
+
+    // Picking
+
+    PICK: 11
+};
+
+export {RENDER_PASSES};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/PerformanceModel/lib/ScratchMemory.js

@@ -0,0 +1,63 @@
+/**
+ * Provides scratch memory for methods like TrianglesBatchingLayer setFlags() and setColors(),
+ * so they don't need to allocate temporary arrays that need garbage collection.
+ *
+ * @private
+ */
+class ScratchMemory {
+
+    constructor() {
+        this._uint8Arrays = {};
+        this._float32Arrays = {};
+    }
+
+    _clear() {
+        this._uint8Arrays = {};
+        this._float32Arrays = {};
+    }
+
+    getUInt8Array(len) {
+        let uint8Array = this._uint8Arrays[len];
+        if (!uint8Array) {
+            uint8Array = new Uint8Array(len);
+            this._uint8Arrays[len] = uint8Array;
+        }
+        return uint8Array;
+    }
+
+    getFloat32Array(len) {
+        let float32Array = this._float32Arrays[len];
+        if (!float32Array) {
+            float32Array = new Float32Array(len);
+            this._float32Arrays[len] = float32Array;
+        }
+        return float32Array;
+    }
+}
+
+const batchingLayerScratchMemory = new ScratchMemory();
+
+let countUsers = 0;
+
+/**
+ * @private
+ */
+function getScratchMemory() {
+    countUsers++;
+    return batchingLayerScratchMemory;
+}
+
+/**
+ * @private
+ */
+function putScratchMemory() {
+    if (countUsers === 0) {
+        return;
+    }
+    countUsers--;
+    if (countUsers === 0) {
+        batchingLayerScratchMemory._clear();
+    }
+}
+
+export {getScratchMemory, putScratchMemory};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/PerformanceModel/lib/compression.js

@@ -0,0 +1,183 @@
+import {math} from "../../math/math.js";
+import {WEBGL_INFO} from "../../webglInfo.js";
+
+const translate = math.mat4();
+const scale = math.mat4();
+
+function quantizePositions(positions, aabb, positionsDecodeMatrix) { // http://cg.postech.ac.kr/research/mesh_comp_mobile/mesh_comp_mobile_conference.pdf
+    const lenPositions = positions.length;
+    const quantizedPositions = new Uint16Array(lenPositions);
+    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 = 2000000;
+    const maxInt = 65525;
+    const xMultiplier = maxInt / xwid;
+    const yMultiplier = maxInt / ywid;
+    const zMultiplier = maxInt / zwid;
+    for (let i = 0; i < lenPositions; i += 3) {
+        quantizedPositions[i + 0] = Math.floor((positions[i + 0] - xmin) * xMultiplier);
+        quantizedPositions[i + 1] = Math.floor((positions[i + 1] - ymin) * yMultiplier);
+        quantizedPositions[i + 2] = Math.floor((positions[i + 2] - zmin) * zMultiplier);
+    }
+    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 quantizedPositions;
+}
+
+function transformAndOctEncodeNormals(worldNormalMatrix, normals, lenNormals, compressedNormals, lenCompressedNormals) {
+    // http://jcgt.org/published/0003/02/01/
+    let oct, dec, best, currentCos, bestCos;
+    let i, ei;
+    let localNormal = new Float32Array([0, 0, 0, 0]);
+    let worldNormal = new Float32Array([0, 0, 0, 0]);
+    for (i = 0; i < lenNormals; i += 3) {
+        localNormal[0] = normals[i];
+        localNormal[1] = normals[i + 1];
+        localNormal[2] = normals[i + 2];
+
+        math.transformVec3(worldNormalMatrix, localNormal, worldNormal);
+        math.normalizeVec3(worldNormal, worldNormal);
+
+        // Test various combinations of ceil and floor to minimize rounding errors
+        best = oct = octEncodeVec3(worldNormal, "floor", "floor");
+        dec = octDecodeVec2(oct);
+        currentCos = bestCos = dot(worldNormal, dec);
+        oct = octEncodeVec3(worldNormal, "ceil", "floor");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(worldNormal, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        oct = octEncodeVec3(worldNormal, "floor", "ceil");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(worldNormal, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        oct = octEncodeVec3(worldNormal, "ceil", "ceil");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(worldNormal, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        compressedNormals[lenCompressedNormals + i + 0] = best[0];
+        compressedNormals[lenCompressedNormals + i + 1] = best[1];
+        compressedNormals[lenCompressedNormals + i + 2] = 0.0; // Unused
+    }
+    lenCompressedNormals += lenNormals;
+    return lenCompressedNormals;
+}
+
+
+function octEncodeNormals(normals) { // http://jcgt.org/published/0003/02/01/
+    const lenNormals = normals.length;
+    const compressedNormals = new Int8Array(lenNormals)
+    let oct, dec, best, currentCos, bestCos;
+    for (let i = 0; i < lenNormals; i += 3) {
+        // Test various combinations of ceil and floor to minimize rounding errors
+        best = oct = octEncodeNormal(normals, i, "floor", "floor");
+        dec = octDecodeVec2(oct);
+        currentCos = bestCos = dot(normals, i, dec);
+        oct = octEncodeNormal(normals, i, "ceil", "floor");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(normals, i, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        oct = octEncodeNormal(normals, i, "floor", "ceil");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(normals, i, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        oct = octEncodeNormal(normals, i, "ceil", "ceil");
+        dec = octDecodeVec2(oct);
+        currentCos = dot(normals, i, dec);
+        if (currentCos > bestCos) {
+            best = oct;
+            bestCos = currentCos;
+        }
+        compressedNormals[i + 0] = best[0];
+        compressedNormals[i + 1] = best[1];
+        compressedNormals[i + 2] = 0.0; // Unused
+    }
+    return new Int8Array(compressedNormals)
+}
+
+function octEncodeVec3(p, xfunc, yfunc) { // Oct-encode single normal vector in 2 bytes
+    let x = p[0] / (Math.abs(p[0]) + Math.abs(p[1]) + Math.abs(p[2]));
+    let y = p[1] / (Math.abs(p[0]) + Math.abs(p[1]) + Math.abs(p[2]));
+    if (p[2] < 0) {
+        let tempx = x;
+        let tempy = y;
+        tempx = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+        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))
+    ]);
+}
+
+/**
+ * @private
+ */
+function octEncodeNormal(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))
+    ]);
+}
+
+function octDecodeVec2(oct) { // Decode an oct-encoded normal
+    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
+    ];
+}
+
+function dot(p, vec3) { // Dot product of a normal in an array against a candidate decoding
+    return p[0] * vec3[0] + p[1] * vec3[1] + p[2] * vec3[2];
+}
+
+export {
+    quantizePositions,
+    octEncodeNormals,
+    transformAndOctEncodeNormals,
+    octEncodeVec3,
+    octDecodeVec2
+
+};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/PerformanceModel/lib/layers/linesBatching/LinesBatchingBuffer.js

@@ -0,0 +1,33 @@
+import {WEBGL_INFO} from "../../../../webglInfo.js";
+
+const bigIndicesSupported = WEBGL_INFO.SUPPORTED_EXTENSIONS["OES_element_index_uint"];
+
+/**
+ * @private
+ */
+class LinesBatchingBuffer {
+
+    constructor(maxGeometryBatchSize = 5000000) {
+
+        if (bigIndicesSupported) {
+            if (maxGeometryBatchSize > 5000000) {
+                maxGeometryBatchSize = 5000000;
+            }
+        } else {
+            if (maxGeometryBatchSize > 65530) {
+                maxGeometryBatchSize = 65530;
+            }
+        }
+
+        this.maxVerts = maxGeometryBatchSize;
+        this.maxIndices = maxGeometryBatchSize * 3; // Rough rule-of-thumb
+        this.positions = [];
+        this.colors = [];
+        this.flags = [];
+        this.flags2 = [];
+        this.offsets = [];
+        this.indices = [];
+    }
+}
+
+export {LinesBatchingBuffer};