csyjk 1.2.2 → 2.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/plugins/XKTLoaderPlugin/parsers/ParserV8.js

@@ -1,479 +0,0 @@
-/*
-
- Parser for .XKT Format V8
-
- */
-
-import {utils} from "../../../viewer/scene/utils.js";
-import * as p from "./lib/pako.js";
-import {math} from "../../../viewer/scene/math/math.js";
-import {geometryCompressionUtils} from "../../../viewer/scene/math/geometryCompressionUtils.js";
-
-let pako = window.pako || p;
-if (!pako.inflate) {  // See https://github.com/nodeca/pako/issues/97
-    pako = pako.default;
-}
-
-function extract(elements) {
-
-    return {
-
-        // Vertex attributes
-
-        types: elements[0],
-        eachMetaObjectId: elements[1],
-        eachMetaObjectType: elements[2],
-        eachMetaObjectName: elements[3],
-        eachMetaObjectParent: elements[4],
-
-        positions: elements[5],
-        normals: elements[6],
-        colors: elements[7],
-        indices: elements[8],
-        edgeIndices: elements[9],
-
-        // Transform matrices
-
-        matrices: elements[10],
-        reusedGeometriesDecodeMatrix: elements[11],
-
-        // Geometries
-
-        eachGeometryPrimitiveType: elements[12],
-        eachGeometryPositionsPortion: elements[13],
-        eachGeometryNormalsPortion: elements[14],
-        eachGeometryColorsPortion: elements[15],
-        eachGeometryIndicesPortion: elements[16],
-        eachGeometryEdgeIndicesPortion: elements[17],
-
-        // Meshes are grouped in runs that are shared by the same entities
-
-        eachMeshGeometriesPortion: elements[18],
-        eachMeshMatricesPortion: elements[19],
-        eachMeshMaterial: elements[20],
-
-        // Entity elements in the following arrays are grouped in runs that are shared by the same tiles
-
-        eachEntityMetaObject: elements[21],
-        eachEntityMeshesPortion: elements[22],
-
-        eachTileAABB: elements[23],
-        eachTileEntitiesPortion: elements[24]
-    };
-}
-
-function inflate(deflatedData) {
-
-    function inflate(array, options) {
-        return (array.length === 0) ? [] : pako.inflate(array, options).buffer;
-    }
-
-    return {
-
-        types: pako.inflate(deflatedData.types, {to: 'string'}),
-        eachMetaObjectId: pako.inflate(deflatedData.eachMetaObjectId, {to: 'string'}),
-        eachMetaObjectType: new Uint32Array(inflate(deflatedData.eachMetaObjectType)),
-        eachMetaObjectName: pako.inflate(deflatedData.eachMetaObjectName, {to: 'string'}),
-        eachMetaObjectParent: new Uint32Array(inflate(deflatedData.eachMetaObjectParent)),
-
-        positions: new Uint16Array(inflate(deflatedData.positions)),
-        normals: new Int8Array(inflate(deflatedData.normals)),
-        colors: new Uint8Array(inflate(deflatedData.colors)),
-        indices: new Uint32Array(inflate(deflatedData.indices)),
-        edgeIndices: new Uint32Array(inflate(deflatedData.edgeIndices)),
-
-        matrices: new Float32Array(inflate(deflatedData.matrices)),
-        reusedGeometriesDecodeMatrix: new Float32Array(inflate(deflatedData.reusedGeometriesDecodeMatrix)),
-
-        eachGeometryPrimitiveType: new Uint8Array(inflate(deflatedData.eachGeometryPrimitiveType)),
-        eachGeometryPositionsPortion: new Uint32Array(inflate(deflatedData.eachGeometryPositionsPortion)),
-        eachGeometryNormalsPortion: new Uint32Array(inflate(deflatedData.eachGeometryNormalsPortion)),
-        eachGeometryColorsPortion: new Uint32Array(inflate(deflatedData.eachGeometryColorsPortion)),
-        eachGeometryIndicesPortion: new Uint32Array(inflate(deflatedData.eachGeometryIndicesPortion)),
-        eachGeometryEdgeIndicesPortion: new Uint32Array(inflate(deflatedData.eachGeometryEdgeIndicesPortion)),
-
-        eachMeshGeometriesPortion: new Uint32Array(inflate(deflatedData.eachMeshGeometriesPortion)),
-        eachMeshMatricesPortion: new Uint32Array(inflate(deflatedData.eachMeshMatricesPortion)),
-        eachMeshMaterial: new Uint8Array(inflate(deflatedData.eachMeshMaterial)),
-
-        eachEntityMetaObject: new Uint32Array(inflate(deflatedData.eachEntityMetaObject)),
-        eachEntityMeshesPortion: new Uint32Array(inflate(deflatedData.eachEntityMeshesPortion)),
-
-        eachTileAABB: new Float64Array(inflate(deflatedData.eachTileAABB)),
-        eachTileEntitiesPortion: new Uint32Array(inflate(deflatedData.eachTileEntitiesPortion)),
-    };
-}
-
-const decompressColor = (function () {
-    const floatColor = new Float32Array(3);
-    return function (intColor) {
-        floatColor[0] = intColor[0] / 255.0;
-        floatColor[1] = intColor[1] / 255.0;
-        floatColor[2] = intColor[2] / 255.0;
-        return floatColor;
-    };
-})();
-
-function load(viewer, options, inflatedData, performanceModel) {
-
-    const types = JSON.parse(inflatedData.types);
-    const eachMetaObjectId = JSON.parse(inflatedData.eachMetaObjectId);
-    const eachMetaObjectType = inflatedData.eachMetaObjectType;
-    const eachMetaObjectName = JSON.parse(inflatedData.eachMetaObjectName);
-    const eachMetaObjectParent = inflatedData.eachMetaObjectParent;
-
-    const positions = inflatedData.positions;
-    const normals = inflatedData.normals;
-    const colors = inflatedData.colors;
-    const indices = inflatedData.indices;
-    const edgeIndices = inflatedData.edgeIndices;
-
-    const matrices = inflatedData.matrices;
-    const reusedGeometriesDecodeMatrix = inflatedData.reusedGeometriesDecodeMatrix;
-
-    const eachGeometryPrimitiveType = inflatedData.eachGeometryPrimitiveType;
-    const eachGeometryPositionsPortion = inflatedData.eachGeometryPositionsPortion;
-    const eachGeometryNormalsPortion = inflatedData.eachGeometryNormalsPortion;
-    const eachGeometryColorsPortion = inflatedData.eachGeometryColorsPortion;
-    const eachGeometryIndicesPortion = inflatedData.eachGeometryIndicesPortion;
-    const eachGeometryEdgeIndicesPortion = inflatedData.eachGeometryEdgeIndicesPortion;
-
-    const eachMeshGeometriesPortion = inflatedData.eachMeshGeometriesPortion;
-    const eachMeshMatricesPortion = inflatedData.eachMeshMatricesPortion;
-    const eachMeshMaterial = inflatedData.eachMeshMaterial;
-
-    const eachEntityMetaObject = inflatedData.eachEntityMetaObject;
-    const eachEntityMeshesPortion = inflatedData.eachEntityMeshesPortion;
-
-    const eachTileAABB = inflatedData.eachTileAABB;
-    const eachTileEntitiesPortion = inflatedData.eachTileEntitiesPortion;
-
-    const numMetaObjects = eachMetaObjectId.length;
-    const numGeometries = eachGeometryPositionsPortion.length;
-    const numMeshes = eachMeshGeometriesPortion.length;
-    const numEntities = eachEntityMetaObject.length;
-    const numTiles = eachTileEntitiesPortion.length;
-
-    let nextMeshId = 0;
-
-    // Create metamodel, unless already loaded from JSON by XKTLoaderPlugin
-
-    const metaModelId = performanceModel.id;
-
-    if (!viewer.metaScene.metaModels[metaModelId]) {
-
-        const metaModelData = {
-            metaObjects: []
-        };
-
-        for (let metaObjectIndex = 0; metaObjectIndex < numMetaObjects; metaObjectIndex++) {
-
-            const metaObjectId = eachMetaObjectId[metaObjectIndex];
-            const typeIndex = eachMetaObjectType[metaObjectIndex];
-            const metaObjectType = types[typeIndex] || "default";
-            const metaObjectName = eachMetaObjectName[metaObjectIndex];
-            const metaObjectParentIndex = eachMetaObjectParent[metaObjectIndex];
-            const metaObjectParentId = (metaObjectParentIndex !== metaObjectIndex) ? eachMetaObjectId[metaObjectParentIndex] : null;
-
-            metaModelData.metaObjects.push({
-                id: metaObjectId,
-                type: metaObjectType,
-                name: metaObjectName,
-                parent: metaObjectParentId
-            });
-        }
-
-        viewer.metaScene.createMetaModel(metaModelId, metaModelData, {
-            includeTypes: options.includeTypes,
-            excludeTypes: options.excludeTypes,
-            globalizeObjectIds: options.globalizeObjectIds
-        });
-
-        performanceModel.once("destroyed", () => {
-            viewer.metaScene.destroyMetaModel(metaModelId);
-        });
-    }
-
-    // Count instances of each geometry
-
-    const geometryReuseCounts = new Uint32Array(numGeometries);
-
-    for (let meshIndex = 0; meshIndex < numMeshes; meshIndex++) {
-        const geometryIndex = eachMeshGeometriesPortion[meshIndex];
-        if (geometryReuseCounts[geometryIndex] !== undefined) {
-            geometryReuseCounts[geometryIndex]++;
-        } else {
-            geometryReuseCounts[geometryIndex] = 1;
-        }
-    }
-
-    // Iterate over tiles
-
-    const tileCenter = math.vec3();
-    const rtcAABB = math.AABB3();
-
-    for (let tileIndex = 0; tileIndex < numTiles; tileIndex++) {
-
-        const lastTileIndex = (numTiles - 1);
-
-        const atLastTile = (tileIndex === lastTileIndex);
-
-        const firstTileEntityIndex = eachTileEntitiesPortion [tileIndex];
-        const lastTileEntityIndex = atLastTile ? numEntities : eachTileEntitiesPortion[tileIndex + 1];
-
-        const tileAABBIndex = tileIndex * 6;
-        const tileAABB = eachTileAABB.subarray(tileAABBIndex, tileAABBIndex + 6);
-
-        math.getAABB3Center(tileAABB, tileCenter);
-
-        rtcAABB[0] = tileAABB[0] - tileCenter[0];
-        rtcAABB[1] = tileAABB[1] - tileCenter[1];
-        rtcAABB[2] = tileAABB[2] - tileCenter[2];
-        rtcAABB[3] = tileAABB[3] - tileCenter[0];
-        rtcAABB[4] = tileAABB[4] - tileCenter[1];
-        rtcAABB[5] = tileAABB[5] - tileCenter[2];
-
-        const tileDecodeMatrix = geometryCompressionUtils.createPositionsDecodeMatrix(rtcAABB);
-
-        const geometryCreated = {};
-
-        // Iterate over each tile's entities
-
-        for (let tileEntityIndex = firstTileEntityIndex; tileEntityIndex < lastTileEntityIndex; tileEntityIndex++) {
-
-            const xktMetaObjectIndex = eachEntityMetaObject[tileEntityIndex];
-            const xktMetaObjectId = eachMetaObjectId[xktMetaObjectIndex];
-            const xktEntityId = xktMetaObjectId;
-
-            const entityId = options.globalizeObjectIds ? math.globalizeObjectId(performanceModel.id, xktEntityId) : xktEntityId;
-
-            const lastTileEntityIndex = (numEntities - 1);
-            const atLastTileEntity = (tileEntityIndex === lastTileEntityIndex);
-            const firstMeshIndex = eachEntityMeshesPortion [tileEntityIndex];
-            const lastMeshIndex = atLastTileEntity ? eachMeshGeometriesPortion.length : eachEntityMeshesPortion[tileEntityIndex + 1];
-
-            const meshIds = [];
-
-            const metaObject = viewer.metaScene.metaObjects[entityId];
-            const entityDefaults = {};
-            const meshDefaults = {};
-
-            if (metaObject) {
-
-                // Mask loading of object types
-
-                if (options.excludeTypesMap && metaObject.type && options.excludeTypesMap[metaObject.type]) {
-                    continue;
-                }
-
-                if (options.includeTypesMap && metaObject.type && (!options.includeTypesMap[metaObject.type])) {
-                    continue;
-                }
-
-                // Get initial property values for object types
-
-                const props = options.objectDefaults ? options.objectDefaults[metaObject.type] || options.objectDefaults["DEFAULT"] : null;
-
-                if (props) {
-                    if (props.visible === false) {
-                        entityDefaults.visible = false;
-                    }
-                    if (props.pickable === false) {
-                        entityDefaults.pickable = false;
-                    }
-                    if (props.colorize) {
-                        meshDefaults.color = props.colorize;
-                    }
-                    if (props.opacity !== undefined && props.opacity !== null) {
-                        meshDefaults.opacity = props.opacity;
-                    }
-                    if (props.metallic !== undefined && props.metallic !== null) {
-                        meshDefaults.metallic = props.metallic;
-                    }
-                    if (props.roughness !== undefined && props.roughness !== null) {
-                        meshDefaults.roughness = props.roughness;
-                    }
-                }
-
-            } else {
-                if (options.excludeUnclassifiedObjects) {
-                    continue;
-                }
-            }
-
-            // Iterate each entity's meshes
-
-            for (let meshIndex = firstMeshIndex; meshIndex < lastMeshIndex; meshIndex++) {
-
-                const geometryIndex = eachMeshGeometriesPortion[meshIndex];
-                const geometryReuseCount = geometryReuseCounts[geometryIndex];
-                const isReusedGeometry = (geometryReuseCount > 1);
-
-                const atLastGeometry = (geometryIndex === (numGeometries - 1));
-
-                const meshColor = decompressColor(eachMeshMaterial.subarray((meshIndex * 6), (meshIndex * 6) + 3));
-                const meshOpacity = eachMeshMaterial[(meshIndex * 6) + 3] / 255.0;
-                const meshMetallic = eachMeshMaterial[(meshIndex * 6) + 4] / 255.0;
-                const meshRoughness = eachMeshMaterial[(meshIndex * 6) + 5] / 255.0;
-
-                const meshId = nextMeshId++;
-
-                if (isReusedGeometry) {
-
-                    // Create mesh for multi-use geometry - create (or reuse) geometry, create mesh using that geometry
-
-                    const meshMatrixIndex = eachMeshMatricesPortion[meshIndex];
-                    const meshMatrix = matrices.slice(meshMatrixIndex, meshMatrixIndex + 16);
-
-                    const geometryId = "geometry." + tileIndex + "." + geometryIndex; // These IDs are local to the PerformanceModel
-
-                    if (!geometryCreated[geometryId]) {
-
-                        const primitiveType = eachGeometryPrimitiveType[geometryIndex];
-
-                        let primitiveName;
-                        let geometryPositions;
-                        let geometryNormals;
-                        let geometryColors;
-                        let geometryIndices;
-                        let geometryEdgeIndices;
-
-                        switch (primitiveType) {
-                            case 0:
-                                primitiveName = "solid";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                                break;
-                            case 1:
-                                primitiveName = "surface";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                                break;
-                            case 2:
-                                primitiveName = "points";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryColors = colors.subarray(eachGeometryColorsPortion [geometryIndex], atLastGeometry ? colors.length : eachGeometryColorsPortion [geometryIndex + 1]);
-                                break;
-                            case 3:
-                                primitiveName = "lines";
-                                geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                                geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                                break;
-                            default:
-                                continue;
-                        }
-
-                        performanceModel.createGeometry({
-                            id: geometryId,
-                            rtcCenter: tileCenter,
-                            primitive: primitiveName,
-                            positions: geometryPositions,
-                            normals: geometryNormals,
-                            colors: geometryColors,
-                            indices: geometryIndices,
-                            edgeIndices: geometryEdgeIndices,
-                            positionsDecodeMatrix: reusedGeometriesDecodeMatrix
-                        });
-
-                        geometryCreated[geometryId] = true;
-                    }
-
-                    performanceModel.createMesh(utils.apply(meshDefaults, {
-                        id: meshId,
-                        geometryId: geometryId,
-                        matrix: meshMatrix,
-                        color: meshColor,
-                        metallic: meshMetallic,
-                        roughness: meshRoughness,
-                        opacity: meshOpacity
-                    }));
-
-                    meshIds.push(meshId);
-
-                } else {
-
-                    const primitiveType = eachGeometryPrimitiveType[geometryIndex];
-
-                    let primitiveName;
-                    let geometryPositions;
-                    let geometryNormals;
-                    let geometryColors;
-                    let geometryIndices;
-                    let geometryEdgeIndices;
-
-                    switch (primitiveType) {
-                        case 0:
-                            primitiveName = "solid";
-                            geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                            geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                            geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                            geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                            break;
-                        case 1:
-                            primitiveName = "surface";
-                            geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                            geometryNormals = normals.subarray(eachGeometryNormalsPortion [geometryIndex], atLastGeometry ? normals.length : eachGeometryNormalsPortion [geometryIndex + 1]);
-                            geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                            geometryEdgeIndices = edgeIndices.subarray(eachGeometryEdgeIndicesPortion [geometryIndex], atLastGeometry ? edgeIndices.length : eachGeometryEdgeIndicesPortion [geometryIndex + 1]);
-                            break;
-                        case 2:
-                            primitiveName = "points";
-                            geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                            geometryColors = colors.subarray(eachGeometryColorsPortion [geometryIndex], atLastGeometry ? colors.length : eachGeometryColorsPortion [geometryIndex + 1]);
-                            break;
-                        case 3:
-                            primitiveName = "lines";
-                            geometryPositions = positions.subarray(eachGeometryPositionsPortion [geometryIndex], atLastGeometry ? positions.length : eachGeometryPositionsPortion [geometryIndex + 1]);
-                            geometryIndices = indices.subarray(eachGeometryIndicesPortion [geometryIndex], atLastGeometry ? indices.length : eachGeometryIndicesPortion [geometryIndex + 1]);
-                            break;
-                        default:
-                            continue;
-                    }
-
-                    performanceModel.createMesh(utils.apply(meshDefaults, {
-                        id: meshId,
-                        rtcCenter: tileCenter,
-                        primitive: primitiveName,
-                        positions: geometryPositions,
-                        normals: geometryNormals,
-                        colors: geometryColors,
-                        indices: geometryIndices,
-                        edgeIndices: geometryEdgeIndices,
-                        positionsDecodeMatrix: tileDecodeMatrix,
-                        color: meshColor,
-                        metallic: meshMetallic,
-                        roughness: meshRoughness,
-                        opacity: meshOpacity
-                    }));
-
-                    meshIds.push(meshId);
-                }
-            }
-
-            if (meshIds.length > 0) {
-
-                performanceModel.createEntity(utils.apply(entityDefaults, {
-                    id: entityId,
-                    isObject: true,
-                    meshIds: meshIds
-                }));
-            }
-        }
-    }
-}
-
-/** @private */
-const ParserV8 = {
-    version: 8,
-    parse: function (viewer, options, elements, performanceModel) {
-        const deflatedData = extract(elements);
-        const inflatedData = inflate(deflatedData);
-        load(viewer, options, inflatedData, performanceModel);
-    }
-};
-
-export {ParserV8};