@xtctwins/tctwins-core 1.0.54 → 1.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xtctwins/tctwins-core",
-	"version": "1.0.54",
+	"version": "1.0.56",
 	"private": false,
 	"description": "Web Programming Toolkit for 3D/2D BIM and CAD",
 	"module": "./dist/tctwins-core.es5.js",

package/types/plugins/BCFViewpointsPlugin/BCFViewpointsPlugin.d.ts

@@ -0,0 +1,148 @@
+import { Plugin, Viewer } from "../../viewer";
+
+export declare type BCFViewpointsPluginConfiguration = {
+	/** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
+	id?: string;
+	/** Identifies the originating system for BCF records. */
+	originatingSystem?: string;
+	/** Identifies the authoring tool for BCF records. */
+	authoringTool?: string;
+};
+
+/**
+ * {@link Viewer} plugin that saves and loads BCF viewpoints as JSON objects.
+ */
+export declare class BCFViewpointsPlugin extends Plugin {
+	/**
+	 * @constructor
+	 * @param {Viewer} viewer The Viewer.
+	 * @param {BCFViewpointsPluginConfiguration} cfg  Plugin configuration.
+	 */
+	constructor(viewer: Viewer, cfg?: BCFViewpointsPluginConfiguration);
+
+	/**
+	 * Identifies the originating system to include in BCF viewpoints saved by this plugin.
+	 * @type {string}
+	 */
+	originatingSystem: string;
+
+	/**
+	 * Identifies the authoring tool to include in BCF viewpoints saved by this plugin.
+	 * @type {string}
+	 */
+	authoringTool: string;
+
+	/**
+	 * Saves viewer state to a BCF viewpoint.
+	 *
+	 * Note that xeokit's {@link Camera.look} is the **point-of-interest**, whereas the BCF ````camera_direction```` is a
+	 * direction vector. Therefore, we save ````camera_direction```` as the vector from {@link Camera.eye} to {@link Camera.look}.
+	 *
+	 * @param {*} [options] Options for getting the viewpoint.
+	 * @param {Boolean} [options.spacesVisible=false] Indicates whether ````IfcSpace```` types should be forced visible in the viewpoint.
+	 * @param {Boolean} [options.openingsVisible=false] Indicates whether ````IfcOpening```` types should be forced visible in the viewpoint.
+	 * @param {Boolean} [options.spaceBoundariesVisible=false] Indicates whether the boundaries of ````IfcSpace```` types should be visible in the viewpoint.
+	 * @param {Boolean} [options.snapshot=true] Indicates whether the snapshot should be included in the viewpoint.
+	 * @param {Boolean} [options.defaultInvisible=false] When ````true````, will save the default visibility of all objects
+	 * as ````false````. This means that when we load the viewpoint again, and there are additional models loaded that
+	 * were not saved in the viewpoint, those models will be hidden when we load the viewpoint, and that only the
+	 * objects in the viewpoint will be visible.
+	 * @param {Boolean} [options.reverseClippingPlanes=false] When ````true````, clipping planes are reversed (https://github.com/buildingSMART/BCF-XML/issues/193)
+	 * @returns {*} BCF JSON viewpoint object
+	 * @example
+	 *
+	 * const viewer = new Viewer();
+	 *
+	 * const bcfPlugin = new BCFPlugin(viewer, {
+	 *     //...
+	 * });
+	 *
+	 * const viewpoint = bcfPlugin.getViewpoint({ // Options - see constructor
+	 *     spacesVisible: false,          // Default
+	 *     spaceBoundariesVisible: false, // Default
+	 *     openingsVisible: false         // Default
+	 * });
+	 *
+	 * // viewpoint will resemble the following:
+	 *
+	 * {
+	 *     perspective_camera: {
+	 *         camera_view_point: {
+	 *             x: 0.0,
+	 *             y: 0.0,
+	 *             z: 0.0
+	 *         },
+	 *         camera_direction: {
+	 *             x: 1.0,
+	 *             y: 1.0,
+	 *             z: 2.0
+	 *         },
+	 *         camera_up_vector: {
+	 *             x: 0.0,
+	 *             y: 0.0,
+	 *             z: 1.0
+	 *         },
+	 *         field_of_view: 90.0
+	 *     },
+	 *     lines: [],
+	 *     clipping_planes: [{
+	 *         location: {
+	 *             x: 0.5,
+	 *             y: 0.5,
+	 *             z: 0.5
+	 *         },
+	 *         direction: {
+	 *             x: 1.0,
+	 *             y: 0.0,
+	 *             z: 0.0
+	 *         }
+	 *     }],
+	 *     bitmaps: [],
+	 *     snapshot: {
+	 *         snapshot_type: png,
+	 *         snapshot_data: "data:image/png;base64,......"
+	 *     },
+	 *     components: {
+	 *         visibility: {
+	 *             default_visibility: false,
+	 *             exceptions: [{
+	 *                 ifc_guid: 4$cshxZO9AJBebsni$z9Yk,
+	 *                 originating_system: xeokit.io,
+	 *                 authoring_tool_id: xeokit/v1.0
+	 *             }]
+	 *        },
+	 *         selection: [{
+	 *            ifc_guid: "4$cshxZO9AJBebsni$z9Yk",
+	 *         }]
+	 *     }
+	 * }
+	 */
+	getViewpoint(options?: any): any;
+
+	/**
+	 * Sets viewer state to the given BCF viewpoint.
+	 *
+	 * Note that xeokit's {@link Camera.look} is the **point-of-interest**, whereas the BCF ````camera_direction```` is a
+	 * direction vector. Therefore, when loading a BCF viewpoint, we set {@link Camera.look} to the absolute position
+	 * obtained by offsetting the BCF ````camera_view_point````  along ````camera_direction````.
+	 *
+	 * When loading a viewpoint, we also have the option to find {@link Camera.look} as the closest point of intersection
+	 * (on the surface of any visible and pickable {@link Entity}) with a 3D ray fired from ````camera_view_point```` in
+	 * the direction of ````camera_direction````.
+	 *
+	 * @param {*} bcfViewpoint  BCF JSON viewpoint object,
+	 * shows default visible entities and restores camera to initial default position.
+	 * @param {*} [options] Options for setting the viewpoint.
+	 * @param {Boolean} [options.rayCast=true] When ````true```` (default), will attempt to set {@link Camera.look} to the closest
+	 * point of surface intersection with a ray fired from the BCF ````camera_view_point```` in the direction of ````camera_direction````.
+	 * @param {Boolean} [options.immediate=true] When ````true```` (default), immediately set camera position.
+	 * @param {Boolean} [options.duration] Flight duration in seconds.  Overrides {@link CameraFlightAnimation.duration}. Only applies when ````immediate```` is ````false````.
+	 * @param {Boolean} [options.reset=true] When ````true```` (default), set {@link Entity.xrayed} and {@link Entity.highlighted} ````false```` on all scene objects.
+	 * @param {Boolean} [options.reverseClippingPlanes=false] When ````true````, clipping planes are reversed (https://github.com/buildingSMART/BCF-XML/issues/193)
+	 * @param {Boolean} [options.updateCompositeObjects=false] When ````true````, then when visibility and selection updates refer to composite objects (eg. an IfcBuildingStorey),
+	 * then this method will apply the updates to objects within those composites.
+	 */
+	setViewpoint(bcfViewpoint: any, options?: any): void;
+
+	getUUID(): string;
+}

package/types/plugins/BCFViewpointsPlugin/index.d.ts

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

package/types/plugins/DistanceMeasurementsPlugin/DistanceMeasurement.d.ts

@@ -80,6 +80,9 @@ export declare class DistanceMeasurement extends Component {
 	 */
 	get targetVisible(): boolean;
 
+	get xLabel(): any;
+	get yLabel(): any;
+	get zLabel(): any;
 	/**
 	 * Sets if the axis-aligned wires between {@link DistanceMeasurement#origin} and {@link DistanceMeasurement#target} are enabled.
 	 *

package/types/plugins/GLTFLoaderPlugin/GLTFLoaderPlugin.d.ts

@@ -0,0 +1,142 @@
+import { Entity, IFCObjectDefaults, Plugin, SceneModel, Viewer } from "../../viewer";
+
+export declare interface IGLTFDefaultDataSource {
+	/**
+	 * Gets metamodel JSON.
+	 *
+	 * @param {String|Number} metaModelSrc Identifies the metamodel JSON asset.
+	 * @param {Function(*)} ok Fired on successful loading of the metamodel JSON asset.
+	 * @param {Function(*)} error Fired on error while loading the metamodel JSON asset.
+	 */
+	getMetaModel(metaModelSrc: string | number, ok: Function, error: Function): void;
+
+	/**
+	 * Gets glTF JSON.
+	 *
+	 * @param {String|Number} glTFSrc Identifies the glTF JSON asset.
+	 * @param {Function} ok Fired on successful loading of the glTF JSON asset.
+	 * @param {Function} error Fired on error while loading the glTF JSON asset.
+	 */
+	getGLTF(glTFSrc: string | number, ok: Function, error: Function): void;
+
+	/**
+	 * Gets glTF binary attachment.
+	 *
+	 * Note that this method requires the source of the glTF JSON asset. This is because the binary attachment
+	 * source could be relative to the glTF source, IE. it may not be a global ID.
+	 *
+	 * @param {String|Number} glTFSrc Identifies the glTF JSON asset.
+	 * @param {String|Number} binarySrc Identifies the glTF binary asset.
+	 * @param {Function} ok Fired on successful loading of the glTF binary asset.
+	 * @param {Function} error Fired on error while loading the glTF binary asset.
+	 */
+	getArrayBuffer(glTFSrc: string | number, binarySrc: string | number, ok: Function, error: Function): void;
+}
+
+export declare type GLTFLoaderPluginConfiguration = {
+	/** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
+	id?: string;
+	/** Map of initial default states for each loaded {@link Entity} that represents an object.  Default value is {@link IFCObjectDefaults}. */
+	objectDefaults?: IFCObjectDefaults;
+	/** A custom data source through which the GLTFLoaderPlugin can load metadata, glTF and binary attachments. Defaults to an instance of {@link GLTFDefaultDataSource}, which loads over HTTP. */
+	dataSource?: IGLTFDefaultDataSource;
+};
+
+export declare type LoadGLTFModel = {
+	/** ID to assign to the root {@link Entity.id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default. */
+	id?: string;
+	/** Path to a glTF file, as an alternative to the ````gltf```` parameter. */
+	src?: string;
+	/** glTF JSON, as an alternative to the ````src```` parameter. */
+	gltf?: any;
+	/** Path to an optional metadata file, as an alternative to the ````metaModelData```` parameter.*/
+	metaModelSrc?: string;
+	/** JSON model metadata, as an alternative to the ````metaModelSrc```` parameter. */
+	metaModelData?: any;
+	/** Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}. */
+	objectDefaults?: object;
+	/** When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject.type} values in this list. */
+	includeTypes?: string[];
+	/** When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject.type} values in this list. */
+	excludeTypes?: string[];
+	/** Whether or not xeokit renders the model with edges emphasized. */
+	edges?: boolean;
+	/** The double-precision World-space origin of the model's coordinates. */
+	origin?: number[];
+	/** The single-precision position, relative to ````origin````. */
+	position?: number[];
+	/** The model's scale. */
+	scale?: number[];
+	/** The model's orientation, as Euler angles given in degrees, for each of the X, Y and Z axis. */
+	rotation?: number[];
+	/** The model's world transform matrix. Overrides the position, scale and rotation parameters. Relative to ````origin````. */
+	matrix?: number[];
+	/** When true, allows visible backfaces, wherever specified in the glTF. When false, ignores backfaces. */
+	backfaces?: number[];
+	/** When xraying, highlighting, selecting or edging, this is the threshold angle between normals of adjacent triangles, below which their shared wireframe edge is not drawn. */
+	edgeThreshold?: number[];
+	/** Set ````false```` to load all the materials and textures provided by the glTF file, otherwise leave ````true```` to load the default high-performance representation optimized for low memory usage and efficient rendering. */
+	performance?: boolean;
+	/** When true, generate a single MetaObject that represents the entire glTF model, and a MetaObject for each entity within it. */
+	autoMetaModel?: boolean;
+};
+
+/**
+ * {@link Viewer} plugin that loads models from [glTF](https://www.khronos.org/gltf/).
+ */
+export declare class GLTFLoaderPlugin extends Plugin {
+	/**
+	 * @constructor
+	 *
+	 * @param {Viewer} viewer The Viewer.
+	 * @param {IGLTFDefaultDataSource} cfg  Plugin configuration.
+	 * @param {String} [cfg.id="GLTFLoader"]
+	 * @param {Object} [cfg.objectDefaults]
+	 * @param {Object} [cfg.dataSource]
+	 */
+	constructor(viewer: Viewer, cfg?: GLTFLoaderPluginConfiguration);
+
+	/**
+	 * Sets a custom data source through which the GLTFLoaderPlugin can load metadata, glTF and binary attachments.
+	 *
+	 * Default value is {@link GLTFDefaultDataSource}, which loads via an XMLHttpRequest.
+	 *
+	 * @type {Object}
+	 */
+	set dataSource(arg: IGLTFDefaultDataSource);
+
+	/**
+	 * Gets the custom data source through which the GLTFLoaderPlugin can load metadata, glTF and binary attachments.
+	 *
+	 * Default value is {@link GLTFDefaultDataSource}, which loads via an XMLHttpRequest.
+	 *
+	 * @type {Object}
+	 */
+	get dataSource(): IGLTFDefaultDataSource;
+
+	/**
+	 * Sets map of initial default states for each loaded {@link Entity} that represents an object.
+	 *
+	 * Default value is {@link IFCObjectDefaults}.
+	 *
+	 * @type {IFCObjectDefaults}
+	 */
+	set objectDefaults(arg: IFCObjectDefaults);
+
+	/**
+	 * Gets map of initial default states for each loaded {@link Entity} that represents an object.
+	 *
+	 * Default value is {@link IFCObjectDefaults}.
+	 *
+	 * @type {IFCObjectDefaults}
+	 */
+	get objectDefaults(): IFCObjectDefaults;
+
+	/**
+	 * Loads a glTF model from a file into this GLTFLoaderPlugin's {@link Viewer}.
+	 *
+	 * @param {LoadGLTFModel} params Loading parameters.
+	 * @returns {SceneModel} SceneModel representing the model, which will have {@link Entity.isModel} set ````true```` and will be registered by {@link Entity.id} in {@link Scene.models}.
+	 */
+	load(params: LoadGLTFModel): SceneModel;
+}

package/types/plugins/GLTFLoaderPlugin/index.d.ts

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

package/types/plugins/LASLoaderPlugin/LASLoaderPlugin.d.ts

@@ -0,0 +1,240 @@
+import { Entity, Plugin, SceneModel, Viewer } from "../../viewer";
+import { ModelStats } from "../index";
+
+export declare interface ILASDefaultDataSource {
+	/**
+	 * Gets the contents of the given LAS file in an arraybuffer.
+	 *
+	 * @param {String|Number} src Path or ID of an LAS file.
+	 * @param {Function} ok Callback fired on success, argument is the LAS file in an arraybuffer.
+	 * @param {Function} error Callback fired on error.
+	 */
+	getLAS(src: string | number, ok: (LAS: ArrayBuffer) => void, error: (e: Error) => void): void;
+}
+
+export declare type LASLoaderPluginConfiguration = {
+	/** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
+	id?: string;
+	/** A custom data source through which the LASLoaderPlugin can load model and metadata files. Defaults to an instance of {@link LASDefaultDataSource}, which loads over HTTP. */
+	dataSource?: ILASDefaultDataSource;
+	/** Configures LASLoaderPlugin to load every **n** points.*/
+	skip?: number;
+	/** Configures if LASLoaderPlugin assumes that LAS positions are stored in 64-bit floats instead of 32-bit. */
+	fp64?: number;
+	/** Configures whether LASLoaderPlugin assumes that LAS colors are encoded using 8 or 16 bits. Accepted values are 8, 16 an "auto". */
+	colorDepth?: 8 | 16 | "auto";
+	/** Whether to center the LAS points. Applied before "rotateX", "rotate" and "transform".  */
+	center?: boolean;
+	/** Whether to rotate the LAS point positions 90 degrees. Applied after "center". */
+	rotateX?: boolean;
+	/** Rotations to apply to the LAS points, given as Euler angles in degrees, for each of the X, Y and Z axis. Rotation is applied after "center" and "rotateX".*/
+	rotate?: number[];
+	/** 4x4 transform matrix to immediately apply to the LAS points. This is applied after "center", "rotateX" and "rotate". Typically used instead of "rotateX" and "rotate". */
+	transform?: number[];
+};
+
+export declare type LoadLASModel = {
+	/** ID to assign to the root {@link Entity.id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default. */
+	id?: string;
+	/** Path to a LAS file, as an alternative to the ````las```` parameter. */
+	src?: string;
+	/** The LAS file data, as an alternative to the ````src```` parameter. */
+	las?: ArrayBuffer;
+	/** Create entity with this id */
+	entityId?: string;
+	/** Creates a MetaModel from json */
+	metaModelJSON?: any;
+	/** Whether to load metadata for the LAS model. */
+	loadMetadata?: boolean;
+	/** The model's World-space double-precision 3D origin. Use this to position the model within xeokit's World coordinate system, using double-precision coordinates. */
+	origin?: number[];
+	/** The model single-precision 3D position, relative to the ````origin```` parameter. */
+	position?: number[];
+	/** The model's scale. */
+	scale?: number[];
+	/** The model's orientation, given as Euler angles in degrees, for each of the X, Y and Z axis. */
+	rotation?: number[];
+	/** The model's world transform matrix. Overrides the position, scale and rotation parameters. Relative to ````origin````. */
+	matrix?: number[];
+	/** Collects model statistics. */
+	stats?: ModelStats;
+};
+
+/**
+ * {@link Viewer} plugin that loads lidar point cloud geometry from LAS files.
+ */
+export declare class LASLoaderPlugin extends Plugin {
+	/**
+	 * @constructor
+	 *
+	 * @param {Viewer} viewer The Viewer.
+	 * @param {LASLoaderPluginConfiguration} cfg  Plugin configuration.
+	 */
+	constructor(viewer: Viewer, cfg?: LASLoaderPluginConfiguration);
+
+	/**
+	 * Sets a custom data source through which the LASLoaderPlugin can load LAS files.
+	 *
+	 * Default value is {@link LASDefaultDataSource}, which loads via HTTP.
+	 *
+	 * @type {ILASDefaultDataSource}
+	 */
+	set dataSource(arg: ILASDefaultDataSource);
+
+	/**
+	 * Gets the custom data source through which the LASLoaderPlugin can load LAS files.
+	 *
+	 * Default value is {@link LASDefaultDataSource}, which loads via HTTP.
+	 *
+	 * @type {ILASDefaultDataSource}
+	 */
+	get dataSource(): ILASDefaultDataSource;
+
+	/**
+	 * Configures LASLoaderPlugin to load every **n** points.
+	 *
+	 * Default value is ````1````.
+	 *
+	 * @param {Number} value The **n**th point that LASLoaderPlugin will read.
+	 */
+	set skip(value: number);
+
+	/**
+	 * When LASLoaderPlugin is configured to load every **n** points, returns the value of **n**.
+	 *
+	 * Default value is ````1````.
+	 *
+	 * @returns {Number} The **n**th point that LASLoaderPlugin will read.
+	 */
+	get skip(): number;
+
+	/**
+	 * Configures if LASLoaderPlugin assumes that LAS positions are stored in 64-bit floats instead of 32-bit.
+	 *
+	 * Default value is ````false````.
+	 *
+	 * @param {Boolean} value True if LASLoaderPlugin assumes that positions are stored in 64-bit floats instead of 32-bit.
+	 */
+	set fp64(value: boolean);
+
+	/**
+	 * Gets if LASLoaderPlugin assumes that LAS positions are stored in 64-bit floats instead of 32-bit.
+	 *
+	 * Default value is ````false````.
+	 *
+	 * @returns {Boolean} True if LASLoaderPlugin assumes that positions are stored in 64-bit floats instead of 32-bit.
+	 */
+	get fp64(): boolean;
+
+	/**
+	 * Configures whether LASLoaderPlugin assumes that LAS colors are encoded using 8 or 16 bits.
+	 *
+	 * Default value is ````8````.
+	 *
+	 * Note: LAS specification recommends 16 bits.
+	 *
+	 * @param {Number|String} value Valid values are 8, 16 and "auto".
+	 */
+	set colorDepth(value: 8 | 16 | "auto");
+
+	/**
+	 * Gets whether LASLoaderPlugin assumes that LAS colors are encoded using 8 or 16 bits.
+	 *
+	 * Default value is ````8````.
+	 *
+	 * Note: LAS specification recommends 16 bits.
+	 *
+	 * @returns {Number|String} Possible returned values are 8, 16 and "auto".
+	 */
+	get colorDepth(): 8 | 16 | "auto";
+
+	/**
+	 * Gets if LASLoaderPlugin immediately centers LAS positions.
+	 *
+	 * If this is ````true```` then centering is the first thing that happens to LAS positions as they are loaded.
+	 *
+	 * Default value is ````false````.
+	 *
+	 * @returns {Boolean} True if LASLoaderPlugin immediately centers LAS positions.
+	 */
+	get center(): number[];
+
+	/**
+	 * Configures if LASLoaderPlugin immediately centers LAS positions.
+	 *
+	 * If this is ````true```` then centering is the first thing that happens to LAS positions as they are loaded.
+	 *
+	 * Default value is ````false````.
+	 *
+	 * @param {Boolean} value True if LASLoaderPlugin immediately centers LAS positions.
+	 */
+	set center(value: number[]);
+
+	/**
+	 * Gets the current transformation to apply to LAS positions as they are loaded.
+	 *
+	 * If this is ````true```` then LAS positions will be transformed right after they are centered.
+	 *
+	 * Default value is null.
+	 *
+	 * @returns {Number[]|null} A 16-element array containing a 4x4 transformation matrix.
+	 */
+	get transform(): number[];
+
+	/**
+	 * Sets the current transformation to apply to LAS positions as they are loaded.
+	 *
+	 * Default value is null.
+	 *
+	 * @param {Number[]|null} transform A 16-element array containing a 4x4 transformation matrix.
+	 */
+	set transform(transform: number[]);
+
+	/**
+	 * Gets the current rotations to apply to LAS positions as they are loaded.
+	 *
+	 * Rotations are an array of three Euler angles in degrees, for each of the X, Y and Z axis, applied in that order.
+	 *
+	 * Default value is null.
+	 *
+	 * @returns {Number[]|null} If defined, an array of three Euler angles in degrees, for each of the X, Y and Z axis. Null if undefined.
+	 */
+	get rotate(): number[];
+
+	/**
+	 * Sets the current rotations to apply to LAS positions as they are loaded.
+	 *
+	 * Rotations are an array of three Euler angles in degrees, for each of the X, Y and Z axis, applied in that order.
+	 *
+	 * Default value is null.
+	 *
+	 * @param {Number[]|null} rotate Array of three Euler angles in degrees, for each of the X, Y and Z axis.
+	 */
+	set rotate(rotate: number[]);
+
+	/**
+	 * Gets if LAS positions are rotated 90 degrees about X as they are loaded.
+	 *
+	 * Default value is ````false````.
+	 *
+	 * @returns {*}
+	 */
+	get rotateX(): boolean;
+
+	/**
+	 * Sets if LAS positions are rotated 90 degrees about X as they are loaded.
+	 *
+	 * Default value is ````false````.
+	 *
+	 * @param rotateX
+	 */
+	set rotateX(rotateX: boolean);
+
+	/**
+	 * Loads an ````LAS```` model into this LASLoaderPlugin's {@link Viewer}.
+	 *
+	 * @param {LoadLASModel} params Loading parameters.
+	 * @returns {SceneModel} SceneModel representing the model, which will have {@link Entity.isModel} set ````true```` and will be registered by {@link Entity.id} in {@link Scene.models}.
+	 */
+	load(params?: LoadLASModel): SceneModel;
+}

package/types/plugins/LASLoaderPlugin/index.d.ts

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

package/types/plugins/ViewCullPlugin/ViewCullPlugin.d.ts

@@ -0,0 +1,34 @@
+import { Plugin, Viewer } from "../../viewer";
+
+export declare type ViewCullPluginConfiguration = {
+  /** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
+  id?: string;
+  /** Maximum depth of the kd-tree. */
+  maxTreeDepth?: number;
+};
+
+/**
+ * {@link Viewer} plugin that performs view frustum culling to accelerate rendering performance.
+ */
+export declare class ViewCullPlugin extends Plugin {
+  /**
+   * @constructor
+   * @param {Viewer} viewer The Viewer.
+   * @param {ViewCullPluginConfiguration} cfg  Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg?: ViewCullPluginConfiguration);
+
+  /**
+   * Sets whether view culling is enabled.
+   *
+   * @param {Boolean} enabled Whether to enable view culling.
+   */
+  set enabled(arg: boolean);
+
+  /**
+   * Gets whether view culling is enabled.
+   *
+   * @retutns {Boolean} Whether view culling is enabled.
+   */
+  get enabled(): boolean;
+}

package/types/plugins/ViewCullPlugin/index.d.ts

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

package/types/plugins/index.d.ts

@@ -1,14 +1,18 @@
 export * from "./AngleMeasurementsPlugin";
 export * from "./AnnotationsPlugin";
+export * from "./BCFViewpointsPlugin";
 export * from "./DistanceMeasurementsPlugin";
 export * from "./FastNavPlugin";
+export * from "./GLTFLoaderPlugin";
 export * from "./NavCubePlugin";
 export * from "./SectionPlanesPlugin";
 export * from "./SkyboxesPlugin";
 export * from "./StoreyViewsPlugin";
 export * from "./TreeViewPlugin";
+export * from "./ViewCullPlugin";
 export * from "./XTCLoaderPlugin";
 export * from "./WebIFCLoaderPlugin";
+export * from "./LASLoaderPlugin";
 
 export declare type ModelStats = {
 	sourceFormat: string;

package/types/viewer/scene/postfx/CrossSections.d.ts

@@ -0,0 +1,42 @@
+import { Component } from "../Component";
+
+/**
+ * @desc Configures cross-section slices for a {@link Scene}.
+ */
+export declare class CrossSections extends Component {
+    /**
+     * Sets the thickness of a slice created by a section.
+     *
+     * Default value is ````0.0````.
+     *
+     * @type {Number}
+     */
+    set sliceThickness(arg: number);
+
+    /**
+     * Gets the thickness of a slice created by a section.
+     *
+     * Default value is ````0.0````.
+     *
+     * @type {Number}
+     */
+    get sliceThickness(): number;
+
+    /**
+     * Sets the color of a slice created by a section.
+     *
+     * Default value is ````[0.0, 0.0, 0.0, 1.0]````.
+     *
+     * @type {Number}
+     */
+    set sliceColor(arg: number[]);
+
+    /**
+     * Gets the color of a slice created by a section.
+     *
+     * Default value is ````[0.0, 0.0, 0.0, 1.0]````.
+     *
+     * @type {Number}
+     */
+    get sliceColor(): number[];
+}