src/plugins/XKTLoaderPlugin/XKTLoaderPlugin.js
import {utils} from "../../viewer/scene/utils.js"
import {PerformanceModel} from "../../viewer/scene/PerformanceModel/PerformanceModel.js";
import {Plugin} from "../../viewer/Plugin.js";
import {XKTDefaultDataSource} from "./XKTDefaultDataSource.js";
import {IFCObjectDefaults} from "../../viewer/metadata/IFCObjectDefaults.js";
import * as p from "./lib/pako.js";
let pako = window.pako || p;
if(!pako.inflate) {
// See https://github.com/nodeca/pako/issues/97
pako = pako.default;
}
const XKT_VERSION = 2; // XKT format version supported by this XKTLoaderPlugin
const decompressColor = (function () {
const color2 = new Float32Array(3);
return function (color) {
color2[0] = color[0] / 255.0;
color2[1] = color[1] / 255.0;
color2[2] = color[2] / 255.0;
return color2;
};
})();
/**
* {@link Viewer} plugin that loads models from xeokit's optimized *````.xkt````* format.
*
* <a href="https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_OTCConferenceCenter"><img src="http://xeokit.io/img/docs/XKTLoaderPlugin/XKTLoaderPlugin.png"></a>
*
* [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_OTCConferenceCenter)]
*
* ## Overview
*
* * XKTLoaderPlugin is the most efficient way to load high-detail models into xeokit.
* * An *````.xkt````* file is a single BLOB containing a model, compressed using geometry quantization
* and [pako](https://nodeca.github.io/pako/).
* * Set the position, scale and rotation of each model as you load it.
* * Filter which IFC types get loaded.
* * Configure initial default appearances for IFC types.
* * Set a custom data source for *````.xkt````* and IFC metadata files.
* * Does not support textures or physically-based materials.
*
* ## Credits
*
* XKTLoaderPlugin and the ````xeokit-gltf-to-xkt```` tool (see below) are based on prototypes
* by [Toni Marti](https://github.com/tmarti) at [uniZite](https://www.unizite.com/login).
*
* ## Creating *````.xkt````* files
*
* Use the node.js-based [xeokit-gltf-to-xkt](https://github.com/xeokit/xeokit-gltf-to-xkt) tool to
* convert your ````glTF```` IFC files to *````.xkt````* format.
*
* ## Scene representation
*
* When loading a model, XKTLoaderPlugin creates an {@link Entity} that represents the model, which
* will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id}
* in {@link Scene#models}. The XKTLoaderPlugin also creates an {@link Entity} for each object within the
* model. Those Entities will have {@link Entity#isObject} set ````true```` and will be registered
* by {@link Entity#id} in {@link Scene#objects}.
*
* ## Metadata
*
* XKTLoaderPlugin can also load an accompanying JSON metadata file with each model, which creates a {@link MetaModel} corresponding
* to the model {@link Entity} and a {@link MetaObject} corresponding to each object {@link Entity}.
*
* Each {@link MetaObject} has a {@link MetaObject#type}, which indicates the classification of its corresponding {@link Entity}. When loading
* metadata, we can also configure XKTLoaderPlugin with a custom lookup table of initial values to set on the properties of each type of {@link Entity}. By default, XKTLoaderPlugin
* uses its own map of default colors and visibilities for IFC element types.
*
* ## Usage
*
* In the example below we'll load the Schependomlaan model from a [.xkt file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/models/xkt/schependomlaan), along
* with an accompanying JSON [IFC metadata file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/metaModels/schependomlaan).
*
* This will create a bunch of {@link Entity}s that represents the model and its objects, along with a {@link MetaModel} and {@link MetaObject}s
* that hold their metadata.
*
* Since this model contains IFC types, the XKTLoaderPlugin will set the initial appearance of each object {@link Entity} according to its IFC type in {@link XKTLoaderPlugin#objectDefaults}.
*
* Read more about this example in the user guide on [Viewing BIM Models Offline](https://github.com/xeokit/xeokit-sdk/wiki/Viewing-BIM-Models-Offline).
*
* [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#BIMOffline_XKT_metadata_Schependomlaan)]
*
* ````javascript
* import {Viewer} from "../src/viewer/Viewer.js";
* import {XKTLoaderPlugin} from "../src/plugins/XKTLoaderPlugin/XKTLoaderPlugin.js";
*
* //------------------------------------------------------------------------------------------------------------------
* // 1. Create a Viewer,
* // 2. Arrange the camera
* //------------------------------------------------------------------------------------------------------------------
*
* // 1
* const viewer = new Viewer({
* canvasId: "myCanvas",
* transparent: true
* });
*
* // 2
* viewer.camera.eye = [-2.56, 8.38, 8.27];
* viewer.camera.look = [13.44, 3.31, -14.83];
* viewer.camera.up = [0.10, 0.98, -0.14];
*
* //------------------------------------------------------------------------------------------------------------------
* // 1. Create a XKTLoaderPlugin,
* // 2. Load a building model and JSON IFC metadata
* //------------------------------------------------------------------------------------------------------------------
*
* // 1
* const xktLoader = new XKTLoaderPlugin(viewer);
*
* // 2
* const model = xktLoader.load({ // Returns an Entity that represents the model
* id: "myModel",
* src: "./models/xkt/schependomlaan/schependomlaan.xkt",
* metaModelSrc: "./metaModels/schependomlaan/metaModel.json", // Creates a MetaModel (see below)
* edges: true
* });
*
* model.on("loaded", () => {
*
* //--------------------------------------------------------------------------------------------------------------
* // 1. Find metadata on the third storey
* // 2. Select all the objects in the building's third storey
* // 3. Fit the camera to all the objects on the third storey
* //--------------------------------------------------------------------------------------------------------------
*
* // 1
* const metaModel = viewer.metaScene.metaModels["myModel"]; // MetaModel with ID "myModel"
* const metaObject
* = viewer.metaScene.metaObjects["0u4wgLe6n0ABVaiXyikbkA"]; // MetaObject with ID "0u4wgLe6n0ABVaiXyikbkA"
*
* const name = metaObject.name; // "01 eerste verdieping"
* const type = metaObject.type; // "IfcBuildingStorey"
* const parent = metaObject.parent; // MetaObject with type "IfcBuilding"
* const children = metaObject.children; // Array of child MetaObjects
* const objectId = metaObject.id; // "0u4wgLe6n0ABVaiXyikbkA"
* const objectIds = viewer.metaScene.getObjectIDsInSubtree(objectId); // IDs of leaf sub-objects
* const aabb = viewer.scene.getAABB(objectIds); // Axis-aligned boundary of the leaf sub-objects
*
* // 2
* viewer.scene.setObjectsSelected(objectIds, true);
*
* // 3
* viewer.cameraFlight.flyTo(aabb);
* });
*
* // Find the model Entity by ID
* model = viewer.scene.models["myModel"];
*
* // Destroy the model
* model.destroy();
* ````
*
* ## Transforming
*
* We have the option to rotate, scale and translate each *````.xkt````* model as we load it.
*
* This lets us load multiple models, or even multiple copies of the same model, and position them apart from each other.
*
* In the example below, we'll scale our model to half its size, rotate it 90 degrees about its local X-axis, then
* translate it 100 units along its X axis.
*
* [[Run example](https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_Duplex_transform)]
*
* ````javascript
* xktLoader.load({
* src: "./models/xkt/duplex/duplex.xkt",
* metaModelSrc: "./metaModels/duplex/metaModel.json",
* rotation: [90,0,0],
* scale: [0.5, 0.5, 0.5],
* position: [100, 0, 0]
* });
* ````
*
* ## Including and excluding IFC types
*
* We can also load only those objects that have the specified IFC types.
*
* In the example below, we'll load only the objects that represent walls.
*
* [[Run example](https://xeokit.github.io/xeokit-sdk/examples/#BIMOffline_XKT_includeTypes)]
*
* ````javascript
* const model2 = xktLoader.load({
* id: "myModel2",
* src: "./models/xkt/OTCConferenceCenter/OTCConferenceCenter.xkt",
* metaModelSrc: "./metaModels/OTCConferenceCenter/metaModel.json",
* includeTypes: ["IfcWallStandardCase"]
* });
* ````
*
* We can also load only those objects that **don't** have the specified IFC types.
*
* In the example below, we'll load only the objects that do not represent empty space.
*
* [[Run example](https://xeokit.github.io/xeokit-sdk/examples/#BIMOffline_XKT_excludeTypes)]
*
* ````javascript
* const model3 = xktLoader.load({
* id: "myModel3",
* src: "./models/xkt/OTCConferenceCenter/OTCConferenceCenter.xkt",
* metaModelSrc: "./metaModels/OTCConferenceCenter/metaModel.json",
* excludeTypes: ["IfcSpace"]
* });
* ````
*
* ## Configuring initial IFC object appearances
*
* We can specify the initial appearance of loaded objects according to their IFC types.
*
* This is useful for things like:
*
* * setting the colors to our objects according to their IFC types,
* * automatically hiding ````IfcSpace```` objects, and
* * ensuring that ````IfcWindow```` objects are always transparent.
*
* <br>
* [[Run example](https://xeokit.github.io/xeokit-sdk/examples/#BIMOffline_XKT_objectDefaults)]
*
* ````javascript
* const myObjectDefaults = {
*
* IfcSpace: {
* visible: false
* },
* IfcWindow: {
* colorize: [0.337255, 0.303922, 0.870588], // Blue
* opacity: 0.3
* },
*
* //...
*
* DEFAULT: {
* colorize: [0.5, 0.5, 0.5]
* }
* };
*
* const model4 = xktLoader.load({
* id: "myModel4",
* src: "./models/xkt/duplex/duplex.xkt",
* metaModelSrc: "./metaModels/duplex/metaModel.json", // Creates a MetaObject instances in scene.metaScene.metaObjects
* objectDefaults: myObjectDefaults // Use our custom initial default states for object Entities
* });
* ````
*
* ## Configuring a custom data source
*
* By default, XKTLoaderPlugin will load *````.xkt````* files and metadata JSON over HTTP.
*
* As shown below, we can customize the way XKTLoaderPlugin loads the files by configuring it with our own data source
* object. For simplicity, our custom data source example also uses HTTP, using a couple of xeokit utility functions.
*
* [[Run example](https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_dataSource)]
*
* ````javascript
* import {utils} from "./../src/viewer/scene/utils.js";
*
* class MyDataSource {
*
* constructor() {
* }
*
* // Gets metamodel JSON
* getMetaModel(metaModelSrc, ok, error) {
* console.log("MyDataSource#getMetaModel(" + metaModelSrc + ", ... )");
* utils.loadJSON(metaModelSrc,
* (json) => {
* ok(json);
* },
* function (errMsg) {
* error(errMsg);
* });
* }
*
* // Gets the contents of the given .xkt file in an arraybuffer
* getXKT(src, ok, error) {
* console.log("MyDataSource#getXKT(" + xKTSrc + ", ... )");
* utils.loadArraybuffer(src,
* (arraybuffer) => {
* ok(arraybuffer);
* },
* function (errMsg) {
* error(errMsg);
* });
* }
* }
*
* const xktLoader2 = new XKTLoaderPlugin(viewer, {
* dataSource: new MyDataSource()
* });
*
* const model5 = xktLoader2.load({
* id: "myModel5",
* src: "./models/xkt/duplex/duplex.xkt",
* metaModelSrc: "./metaModels/duplex/metaModel.json" // Creates a MetaObject instances in scene.metaScene.metaObjects
* });
* ````
* @class XKTLoaderPlugin
*/
class XKTLoaderPlugin extends Plugin {
/**
* @constructor
*
* @param {Viewer} viewer The Viewer.
* @param {Object} cfg Plugin configuration.
* @param {String} [cfg.id="XKTLoader"] Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}.
* @param {Object} [cfg.objectDefaults] Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}.
* @param {Object} [cfg.dataSource] A custom data source through which the XKTLoaderPlugin can load model and metadata files. Defaults to an instance of {@link XKTDefaultDataSource}, which loads uover HTTP.
* @param {String[]} [cfg.includeTypes] When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
* @param {String[]} [cfg.excludeTypes] When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
* @param {Boolean} [cfg.excludeUnclassifiedObjects=false] When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link StructureTreeViewPlugin}.
*/
constructor(viewer, cfg = {}) {
super("XKTLoader", viewer, cfg);
this.dataSource = cfg.dataSource;
this.objectDefaults = cfg.objectDefaults;
this.includeTypes = cfg.includeTypes;
this.excludeTypes = cfg.excludeTypes;
this.excludeUnclassifiedObjects = cfg.excludeUnclassifiedObjects;
}
/**
* The *````.xkt````* format version supported by this XKTLoaderPlugin.
*
* @type {Number}
*/
static get XKTVersion() {
return XKT_VERSION;
}
/**
* Sets a custom data source through which the XKTLoaderPlugin can load models and metadata.
*
* Default value is {@link XKTDefaultDataSource}, which loads via HTTP.
*
* @type {Object}
*/
set dataSource(value) {
this._dataSource = value || new XKTDefaultDataSource();
}
/**
* Gets the custom data source through which the XKTLoaderPlugin can load models and metadata.
*
* Default value is {@link XKTDefaultDataSource}, which loads via HTTP.
*
* @type {Object}
*/
get dataSource() {
return this._dataSource;
}
/**
* Sets map of initial default states for each loaded {@link Entity} that represents an object.
*
* Default value is {@link IFCObjectDefaults}.
*
* @type {{String: Object}}
*/
set objectDefaults(value) {
this._objectDefaults = value || IFCObjectDefaults;
}
/**
* Gets map of initial default states for each loaded {@link Entity} that represents an object.
*
* Default value is {@link IFCObjectDefaults}.
*
* @type {{String: Object}}
*/
get objectDefaults() {
return this._objectDefaults;
}
/**
* Sets the whitelist of the IFC types loaded by this XKTLoaderPlugin.
*
* When loading models with metadata, causes this XKTLoaderPlugin to only load objects whose types are in this
* list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
*
* Default value is ````undefined````.
*
* @type {String[]}
*/
set includeTypes(value) {
this._includeTypes = value;
}
/**
* Gets the whitelist of the IFC types loaded by this XKTLoaderPlugin.
*
* When loading models with metadata, causes this XKTLoaderPlugin to only load objects whose types are in this
* list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
*
* Default value is ````undefined````.
*
* @type {String[]}
*/
get includeTypes() {
return this._includeTypes;
}
/**
* Sets the blacklist of IFC types that are never loaded by this XKTLoaderPlugin.
*
* When loading models with metadata, causes this XKTLoaderPlugin to **not** load objects whose types are in this
* list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
*
* Default value is ````undefined````.
*
* @type {String[]}
*/
set excludeTypes(value) {
this._excludeTypes = value;
}
/**
* Gets the blacklist of IFC types that are never loaded by this XKTLoaderPlugin.
*
* When loading models with metadata, causes this XKTLoaderPlugin to **not** load objects whose types are in this
* list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
*
* Default value is ````undefined````.
*
* @type {String[]}
*/
get excludeTypes() {
return this._excludeTypes;
}
/**
* Sets whether we load objects that don't have IFC types.
*
* When loading models with metadata and this is ````true````, XKTLoaderPlugin will not load objects
* that don't have IFC types.
*
* Default value is ````false````.
*
* @type {Boolean}
*/
set excludeUnclassifiedObjects(value) {
this._excludeUnclassifiedObjects = !!value;
}
/**
* Gets whether we load objects that don't have IFC types.
*
* When loading models with metadata and this is ````true````, XKTLoaderPlugin will not load objects
* that don't have IFC types.
*
* Default value is ````false````.
*
* @type {Boolean}
*/
get excludeUnclassifiedObjects() {
return this._excludeUnclassifiedObjects;
}
/**
* Loads a .xkt model into this XKTLoaderPlugin's {@link Viewer}.
*
* @param {*} params Loading parameters.
* @param {String} [params.id] ID to assign to the root {@link Entity#id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default.
* @param {String} [params.src] Path to a *````.xkt````* file, as an alternative to the ````xkt```` parameter.
* @param {ArrayBuffer} [params.xkt] The *````.xkt````* file data, as an alternative to the ````src```` parameter.
* @param {String} [params.metaModelSrc] Path to an optional metadata file, as an alternative to the ````metaModelData```` parameter (see user guide: [Model Metadata](https://github.com/xeolabs/xeokit.io/wiki/Model-Metadata)).
* @param {*} [params.metaModelData] JSON model metadata, as an alternative to the ````metaModelSrc```` parameter (see user guide: [Model Metadata](https://github.com/xeolabs/xeokit.io/wiki/Model-Metadata)).
* @param {{String:Object}} [params.objectDefaults] Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}.
* @param {String[]} [params.includeTypes] When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
* @param {String[]} [params.excludeTypes] When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list.
* @param {Boolean} [params.edges=false] Whether or not xeokit renders the model with edges emphasized.
* @param {Number[]} [params.position=[0,0,0]] The model World-space 3D position.
* @param {Number[]} [params.scale=[1,1,1]] The model's World-space scale.
* @param {Number[]} [params.rotation=[0,0,0]] The model's World-space rotation, as Euler angles given in degrees, for each of the X, Y and Z axis.
* @param {Number[]} [params.matrix=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]] The model's world transform matrix. Overrides the position, scale and rotation parameters.
* @param {Boolean} [params.edges=false] Indicates if the model's edges are initially emphasized.
* @returns {Entity} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}.
* @param {Boolean} [params.excludeUnclassifiedObjects=false] When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link StructureTreeViewPlugin}.
*/
load(params = {}) {
if (params.id && this.viewer.scene.components[params.id]) {
this.error("Component with this ID already exists in viewer: " + params.id + " - will autogenerate this ID");
delete params.id;
}
const performanceModel = new PerformanceModel(this.viewer.scene, utils.apply(params, {
isModel: true,
preCompressed: true
}));
const modelId = performanceModel.id; // In case ID was auto-generated
if (!params.src && !params.xkt) {
this.error("load() param expected: src or xkt");
return performanceModel; // Return new empty model
}
const options = {};
if (params.metaModelSrc || params.metaModelData) {
const includeTypes = params.includeTypes || this._includeTypes;
const excludeTypes = params.excludeTypes || this._excludeTypes;
const objectDefaults = params.objectDefaults || this._objectDefaults;
if (includeTypes) {
options.includeTypesMap = {};
for (let i = 0, len = includeTypes.length; i < len; i++) {
options.includeTypesMap[includeTypes[i]] = true;
}
}
if (excludeTypes) {
options.excludeTypesMap = {};
for (let i = 0, len = excludeTypes.length; i < len; i++) {
options.excludeTypesMap[excludeTypes[i]] = true;
}
}
if (objectDefaults) {
options.objectDefaults = objectDefaults;
}
options.excludeUnclassifiedObjects = (params.excludeUnclassifiedObjects !== undefined) ? (!!params.excludeUnclassifiedObjects) : this._excludeUnclassifiedObjects;
const processMetaModelData = (metaModelData) => {
this.viewer.metaScene.createMetaModel(modelId, metaModelData, {
includeTypes: includeTypes,
excludeTypes: excludeTypes
});
this.viewer.scene.canvas.spinner.processes--;
if (params.src) {
this._loadModel(params.src, params, options, performanceModel);
} else {
this._parseModel(params.xkt, params, options, performanceModel);
}
};
if (params.metaModelSrc) {
const metaModelSrc = params.metaModelSrc;
this.viewer.scene.canvas.spinner.processes++;
this._dataSource.getMetaModel(metaModelSrc, (metaModelData) => {
this.viewer.scene.canvas.spinner.processes--;
processMetaModelData(metaModelData);
}, (errMsg) => {
this.error(`load(): Failed to load model metadata for model '${modelId} from '${metaModelSrc}' - ${errMsg}`);
this.viewer.scene.canvas.spinner.processes--;
});
} else if (params.metaModelData) {
processMetaModelData(params.metaModelData);
}
} else {
if (params.src) {
this._loadModel(params.src, params, options, performanceModel);
} else {
this._parseModel(params.xkt, params, options, performanceModel);
}
}
performanceModel.once("destroyed", () => {
this.viewer.metaScene.destroyMetaModel(modelId);
});
return performanceModel;
}
_loadModel(src, params, options, performanceModel) {
const spinner = this.viewer.scene.canvas.spinner;
spinner.processes++;
this._dataSource.getXKT(params.src, (arrayBuffer) => {
this._parseModel(arrayBuffer, params, options, performanceModel);
spinner.processes--;
},
(errMsg) => {
spinner.processes--;
this.error(errMsg);
performanceModel.fire("error", errMsg);
});
}
_parseModel(arrayBuffer, params, options, performanceModel) {
const deflatedData = this._extractData(arrayBuffer);
if (!deflatedData) { // Error
return;
}
const inflatedData = this._inflateData(deflatedData);
this._loadDataIntoModel(inflatedData, options, performanceModel);
}
_extractData(arrayBuffer) {
const dataView = new DataView(arrayBuffer);
const dataArray = new Uint8Array(arrayBuffer);
const xktVersion = dataView.getUint32(0, true);
if (xktVersion > XKT_VERSION) {
this.error("Incompatible .XKT file version; this XKTLoaderPlugin supports versions <= V" + XKT_VERSION);
return;
}
const numElements = dataView.getUint32(4, true);
const elements = [];
let byteOffset = (numElements + 2) * 4;
for (let i = 0; i < numElements; i++) {
const elementSize = dataView.getUint32((i + 2) * 4, true);
elements.push(dataArray.subarray(byteOffset, byteOffset + elementSize));
byteOffset += elementSize;
}
if (xktVersion >= 2) {
return {
xktVersion: xktVersion,
positions: elements[0],
normals: elements[1],
indices: elements[2],
edgeIndices: elements[3],
meshPositions: elements[4],
meshIndices: elements[5],
meshEdgesIndices: elements[6],
meshColors: elements[7],
entityIDs: elements[8],
entityMeshes: elements[9],
entityIsObjects: elements[10],
positionsDecodeMatrix: elements[11],
entityMeshIds: elements[12],
entityMatrices: elements[13],
entityUsesInstancing: elements[14],
};
}
return { // XKT version < 2
xktVersion: xktVersion,
positions: elements[0],
normals: elements[1],
indices: elements[2],
edgeIndices: elements[3],
meshPositions: elements[4],
meshIndices: elements[5],
meshEdgesIndices: elements[6],
meshColors: elements[7],
entityIDs: elements[8],
entityMeshes: elements[9],
entityIsObjects: elements[10],
positionsDecodeMatrix: elements[11]
};
}
_inflateData(deflatedData) {
if (deflatedData.xktVersion >= 2) {
return {
xktVersion: deflatedData.xktVersion,
positions: new Uint16Array(pako.inflate(deflatedData.positions).buffer),
normals: new Int8Array(pako.inflate(deflatedData.normals).buffer),
indices: new Uint32Array(pako.inflate(deflatedData.indices).buffer),
edgeIndices: new Uint32Array(pako.inflate(deflatedData.edgeIndices).buffer),
meshPositions: new Uint32Array(pako.inflate(deflatedData.meshPositions).buffer),
meshIndices: new Uint32Array(pako.inflate(deflatedData.meshIndices).buffer),
meshEdgesIndices: new Uint32Array(pako.inflate(deflatedData.meshEdgesIndices).buffer),
meshColors: new Uint8Array(pako.inflate(deflatedData.meshColors).buffer),
entityIDs: pako.inflate(deflatedData.entityIDs, {to: 'string'}),
entityMeshes: new Uint32Array(pako.inflate(deflatedData.entityMeshes).buffer),
entityIsObjects: new Uint8Array(pako.inflate(deflatedData.entityIsObjects).buffer),
positionsDecodeMatrix: new Float32Array(pako.inflate(deflatedData.positionsDecodeMatrix).buffer),
entityMeshIds: new Uint32Array(pako.inflate(deflatedData.entityMeshIds).buffer),
entityMatrices: new Float32Array(pako.inflate(deflatedData.entityMatrices).buffer),
entityUsesInstancing: new Uint8Array(pako.inflate(deflatedData.entityUsesInstancing).buffer),
};
}
return { // XKT version < 2
xktVersion: deflatedData.xktVersion,
positions: new Uint16Array(pako.inflate(deflatedData.positions).buffer),
normals: new Int8Array(pako.inflate(deflatedData.normals).buffer),
indices: new Uint32Array(pako.inflate(deflatedData.indices).buffer),
edgeIndices: new Uint32Array(pako.inflate(deflatedData.edgeIndices).buffer),
meshPositions: new Uint32Array(pako.inflate(deflatedData.meshPositions).buffer),
meshIndices: new Uint32Array(pako.inflate(deflatedData.meshIndices).buffer),
meshEdgesIndices: new Uint32Array(pako.inflate(deflatedData.meshEdgesIndices).buffer),
meshColors: new Uint8Array(pako.inflate(deflatedData.meshColors).buffer),
entityIDs: pako.inflate(deflatedData.entityIDs, {to: 'string'}),
entityMeshes: new Uint32Array(pako.inflate(deflatedData.entityMeshes).buffer),
entityIsObjects: new Uint8Array(pako.inflate(deflatedData.entityIsObjects).buffer),
positionsDecodeMatrix: new Float32Array(pako.inflate(deflatedData.positionsDecodeMatrix).buffer)
};
}
_loadDataIntoModel(inflatedData, options, performanceModel) {
if (inflatedData.xktVersion >= 2) {
const positions = inflatedData.positions;
const normals = inflatedData.normals;
const indices = inflatedData.indices;
const edgeIndices = inflatedData.edgeIndices;
const meshPositions = inflatedData.meshPositions;
const meshIndices = inflatedData.meshIndices;
const meshEdgesIndices = inflatedData.meshEdgesIndices;
const meshColors = inflatedData.meshColors;
const entityIDs = JSON.parse(inflatedData.entityIDs);
const entityMeshes = inflatedData.entityMeshes;
const entityIsObjects = inflatedData.entityIsObjects;
const entityMeshIds = inflatedData.entityMeshIds;
const entityMatrices = inflatedData.entityMatrices;
const entityUsesInstancing = inflatedData.entityUsesInstancing;
const numMeshes = meshPositions.length;
const numEntities = entityMeshes.length;
const _alreadyCreatedGeometries = {};
for (let i = 0; i < numEntities; i++) {
const entityId = entityIDs [i];
const metaObject = this.viewer.metaScene.metaObjects[entityId];
const entityDefaults = {};
const meshDefaults = {};
const entityMatrix = entityMatrices.subarray((i * 16), (i * 16) + 16);
if (metaObject) {
if (options.excludeTypesMap && metaObject.type && options.excludeTypesMap[metaObject.type]) {
continue;
}
if (options.includeTypesMap && metaObject.type && (!options.includeTypesMap[metaObject.type])) {
continue;
}
const props = options.objectDefaults ? options.objectDefaults[metaObject.type || "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;
}
}
} else {
if (options.excludeUnclassifiedObjects) {
continue;
}
}
const lastEntity = (i === numEntities - 1);
const meshIds = [];
for (let j = entityMeshes [i], jlen = lastEntity ? entityMeshIds.length : entityMeshes [i + 1]; j < jlen; j++) {
var jj = entityMeshIds [j];
const lastMesh = (jj === (numMeshes - 1));
const meshId = entityId + ".mesh." + jj;
const color = decompressColor(meshColors.subarray((jj * 4), (jj * 4) + 3));
const opacity = meshColors[(jj * 4) + 3] / 255.0;
var tmpPositions = positions.subarray(meshPositions [jj], lastMesh ? positions.length : meshPositions [jj + 1]);
var tmpNormals = normals.subarray(meshPositions [jj], lastMesh ? positions.length : meshPositions [jj + 1]);
var tmpIndices = indices.subarray(meshIndices [jj], lastMesh ? indices.length : meshIndices [jj + 1]);
var tmpEdgeIndices = edgeIndices.subarray(meshEdgesIndices [jj], lastMesh ? edgeIndices.length : meshEdgesIndices [jj + 1]);
if (entityUsesInstancing [i] === 1) {
var geometryId = "geometry." + jj;
if (!(geometryId in _alreadyCreatedGeometries)) {
performanceModel.createGeometry({
id: geometryId,
positions: tmpPositions,
normals: tmpNormals,
indices: tmpIndices,
edgeIndices: tmpEdgeIndices,
primitive: "triangles",
positionsDecodeMatrix: inflatedData.positionsDecodeMatrix,
});
_alreadyCreatedGeometries [geometryId] = true;
}
performanceModel.createMesh(utils.apply(meshDefaults,{
id: meshId,
color: color,
opacity: opacity,
matrix: entityMatrix,
geometryId: geometryId,
}));
meshIds.push(meshId);
} else {
performanceModel.createMesh(utils.apply(meshDefaults, {
id: meshId,
primitive: "triangles",
positions: tmpPositions,
normals: tmpNormals,
indices: tmpIndices,
edgeIndices: tmpEdgeIndices,
positionsDecodeMatrix: inflatedData.positionsDecodeMatrix,
color: color,
opacity: opacity
}));
meshIds.push(meshId);
}
}
if (meshIds.length) {
performanceModel.createEntity(utils.apply(entityDefaults, {
id: entityId,
isObject: (entityIsObjects [i] === 1),
meshIds: meshIds
}));
}
}
} else { // XKT version <= 2
const positions = inflatedData.positions;
const normals = inflatedData.normals;
const indices = inflatedData.indices;
const edgeIndices = inflatedData.edgeIndices;
const meshPositions = inflatedData.meshPositions;
const meshIndices = inflatedData.meshIndices;
const meshEdgesIndices = inflatedData.meshEdgesIndices;
const meshColors = inflatedData.meshColors;
const entityIDs = JSON.parse(inflatedData.entityIDs);
const entityMeshes = inflatedData.entityMeshes;
const entityIsObjects = inflatedData.entityIsObjects;
const numMeshes = meshPositions.length;
const numEntities = entityMeshes.length;
for (let i = 0; i < numEntities; i++) {
const entityId = entityIDs [i];
const metaObject = this.viewer.metaScene.metaObjects[entityId];
const entityDefaults = {};
const meshDefaults = {};
if (metaObject) {
if (options.excludeTypesMap && metaObject.type && options.excludeTypesMap[metaObject.type]) {
continue;
}
if (options.includeTypesMap && metaObject.type && (!options.includeTypesMap[metaObject.type])) {
continue;
}
const props = options.objectDefaults ? options.objectDefaults[metaObject.type || "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;
}
}
} else {
if (options.excludeUnclassifiedObjects) {
continue;
}
}
const lastEntity = (i === numEntities - 1);
const meshIds = [];
for (let j = entityMeshes [i], jlen = lastEntity ? entityMeshes.length : entityMeshes [i + 1]; j < jlen; j++) {
const lastMesh = (j === (numMeshes - 1));
const meshId = entityId + ".mesh." + j;
const color = decompressColor(meshColors.subarray((j * 4), (j * 4) + 3));
const opacity = meshColors[(j * 4) + 3] / 255.0;
performanceModel.createMesh(utils.apply(meshDefaults, {
id: meshId,
primitive: "triangles",
positions: positions.subarray(meshPositions [j], lastMesh ? positions.length : meshPositions [j + 1]),
normals: normals.subarray(meshPositions [j], lastMesh ? positions.length : meshPositions [j + 1]),
indices: indices.subarray(meshIndices [j], lastMesh ? indices.length : meshIndices [j + 1]),
edgeIndices: edgeIndices.subarray(meshEdgesIndices [j], lastMesh ? edgeIndices.length : meshEdgesIndices [j + 1]),
positionsDecodeMatrix: inflatedData.positionsDecodeMatrix,
color: color,
opacity: opacity
}));
meshIds.push(meshId);
}
performanceModel.createEntity(utils.apply(entityDefaults, {
id: entityId,
isObject: (entityIsObjects [i] === 1),
meshIds: meshIds
}));
}
}
performanceModel.finalize();
performanceModel.scene.once("tick", () => {
performanceModel.scene.fire("modelLoaded", performanceModel.id); // FIXME: Assumes listeners know order of these two events
performanceModel.fire("loaded", true, true);
});
}
}
export {XKTLoaderPlugin}
