@xeokit/xeokit-sdk 2.2.4 → 2.2.5-beta-2

package/types/plugins/FastNavPlugin/FastNavPlugin.d.ts

@@ -0,0 +1,203 @@
+import { Plugin } from "../../viewer/Plugin";
+import { Viewer } from "../../viewer/Viewer";
+
+export declare type FastNavPluginConfiguration = {
+  /** Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}. */
+  id?: string;
+  /** Whether to temporarily hide physically-based rendering (PBR) whenever we interact with the Viewer. */
+  hidePBR?: boolean;
+  /** Whether to temporarily hide scalable ambient occlusion (SAO) whenever we interact with the Viewer. */
+  hideSAO?: boolean;
+  /** Whether to temporarily hide edges whenever we interact with the Viewer.*/
+  hideEdges?: boolean;
+  /** Whether to temporarily hide transparent objects whenever we interact with the Viewer. */
+  hideTransparentObjects?: boolean;
+  /** Whether to temporarily down-scale the canvas resolution whenever we interact with the Viewer. */
+  scaleCanvasResolution?: number;
+  /** The factor by which we downscale the canvas resolution whenever we interact with the Viewer. */
+  scaleCanvasResolutionFactor?: number;
+  /** Whether to temporarily have a delay before restoring normal rendering after we stop interacting with the Viewer. */
+  delayBeforeRestore?: boolean;
+  /** Delay in seconds before restoring normal rendering after we stop interacting with the Viewer. */
+  delayBeforeRestoreSeconds?: number;
+};
+
+/**
+ * {@link Viewer} plugin that makes interaction smoother with large models, by temporarily switching
+ * the Viewer to faster, lower-quality rendering modes whenever we interact.
+ *
+ */
+export declare class FastNavPlugin extends Plugin {
+    /**
+     * @constructor
+     * @param {Viewer} viewer The Viewer.
+     * @param {FastNavPluginConfiguration} cfg FastNavPlugin configuration.
+     */
+    constructor(viewer: Viewer, cfg?: FastNavPluginConfiguration);
+
+    /**
+     * Sets whether to temporarily hide physically-based rendering (PBR) whenever we interact with the Viewer.
+     *
+     * Default is ````true````.
+     *
+     * @param {Boolean} value ````true```` to hide PBR.
+     */
+    set hidePBR(value: boolean);
+
+    /**
+     * Gets whether to temporarily hide physically-based rendering (PBR) whenever we interact with the Viewer.
+     *
+     * Default is ````true````.
+     *
+     * @return {Boolean} ````true```` if hiding PBR.
+     */
+    get hidePBR(): boolean;
+
+    /**
+     * Sets whether to temporarily hide scalable ambient shadows (SAO) whenever we interact with the Viewer.
+     *
+     * Default is ````true````.
+     *
+     * @param {Boolean} value ````true```` to hide SAO.
+     */
+    set hideSAO(value: boolean);
+
+    /**
+     * Gets whether to temporarily hide scalable ambient shadows (SAO) whenever we interact with the Viewer.
+     *
+     * Default is ````true````.
+     *
+     * @return {Boolean} ````true```` if hiding SAO.
+     */
+    get hideSAO(): boolean;
+
+    /**
+     * Sets whether to temporarily hide edges whenever we interact with the Viewer.
+     *
+     * Default is ````true````.
+     *
+     * @param {Boolean} value ````true```` to hide edges.
+     */
+    set hideEdges(value: boolean);
+
+    /**
+     * Gets whether to temporarily hide edges whenever we interact with the Viewer.
+     *
+     * Default is ````true````.
+     *
+     * @return {Boolean}  ````true```` if hiding edges.
+     */
+    get hideEdges(): boolean;
+
+    /**
+     * Sets whether to temporarily hide transparent objects whenever we interact with the Viewer.
+     *
+     * Does not hide X-rayed, selected, highlighted objects.
+     *
+     * Default is ````false````.
+     *
+     * @param {Boolean} value ````true```` to hide transparent objects.
+     */
+    set hideTransparentObjects(value: boolean);
+
+    /**
+     * Gets whether to temporarily hide transparent objects whenever we interact with the Viewer.
+     *
+     * Does not hide X-rayed, selected, highlighted objects.
+     *
+     * Default is ````false````.
+     *
+     * @return {Boolean} ````true```` if hiding transparent objects.
+     */
+    get hideTransparentObjects(): boolean;
+
+    /**
+     * Sets whether to temporarily scale the canvas resolution whenever we interact with the Viewer.
+     *
+     * Default is ````false````.
+     *
+     * The scaling factor is configured via {@link FastNavPlugin#scaleCanvasResolutionFactor}.
+     *
+     * @param {Boolean} scaleCanvasResolution ````true```` to scale the canvas resolution.
+     */
+    set scaleCanvasResolution(value: boolean);
+
+    /**
+     * Gets whether to temporarily scale the canvas resolution whenever we interact with the Viewer.
+     *
+     * Default is ````false````.
+     *
+     * The scaling factor is configured via {@link FastNavPlugin#scaleCanvasResolutionFactor}.
+     *
+     * @return {Boolean} ````true```` if scaling the canvas resolution.
+     */
+    get scaleCanvasResolution(): boolean;
+
+    /**
+     * Sets the factor by which we temporarily scale the canvas resolution when we interact with the viewer.
+     *
+     * Accepted range is ````[0.0 .. 1.0]````.
+     *
+     * Default is ````0.6````.
+     *
+     * Enable canvas resolution scaling by setting {@link FastNavPlugin#scaleCanvasResolution} ````true````.
+     *
+     * @param {Number} scaleCanvasResolutionFactor Factor by which we scale the canvas resolution.
+     */
+    set scaleCanvasResolutionFactor(value: number);
+
+    /**
+     * Gets the factor by which we temporarily scale the canvas resolution when we interact with the viewer.
+     *
+     * Default is ````0.6````.
+     *
+     * Enable canvas resolution scaling by setting {@link FastNavPlugin#scaleCanvasResolution} ````true````.
+     *
+     * @return {Number} Factor by which we scale the canvas resolution.
+     */
+    get scaleCanvasResolutionFactor(): number;
+
+    /**
+     * Sets whether to have a delay before restoring normal rendering after we stop interacting with the Viewer.
+     *
+     * The delay duration is configured via {@link FastNavPlugin#delayBeforeRestoreSeconds}.
+     *
+     * Default is ````true````.
+     *
+     * @param {Boolean} delayBeforeRestore Whether to have a delay.
+     */
+    set delayBeforeRestore(value: boolean);
+
+    /**
+     * Gets whether to have a delay before restoring normal rendering after we stop interacting with the Viewer.
+     *
+     * The delay duration is configured via {@link FastNavPlugin#delayBeforeRestoreSeconds}.
+     *
+     * Default is ````true````.
+     *
+     * @return {Boolean} Whether to have a delay.
+     */
+    get delayBeforeRestore(): boolean;
+
+    /**
+     * Sets the delay before restoring normal rendering after we stop interacting with the Viewer.
+     *
+     * The delay is enabled when {@link FastNavPlugin#delayBeforeRestore} is ````true````.
+     *
+     * Default is ````0.5```` seconds.
+     *
+     * @param {Number} delayBeforeRestoreSeconds Delay in seconds.
+     */
+    set delayBeforeRestoreSeconds(value: number);
+
+    /**
+     * Gets the delay before restoring normal rendering after we stop interacting with the Viewer.
+     *
+     * The delay is enabled when {@link FastNavPlugin#delayBeforeRestore} is ````true````.
+     *
+     * Default is ````0.5```` seconds.
+     *
+     * @return {Number} Delay in seconds.
+     */
+    get delayBeforeRestoreSeconds(): number;
+}

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

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

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

@@ -0,0 +1,140 @@
+import { Plugin, Viewer, PerformanceModel, IFCObjectDefaults } 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;
+};
+
+/**
+ * {@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 {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}
+   */
+  load(params: LoadGLTFModel): PerformanceModel;
+}

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

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

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

@@ -0,0 +1,146 @@
+import { PerformanceModel, Plugin, 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";
+};
+
+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;
+  /** 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 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(arg: 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(arg: 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(arg: 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";
+  
+  /**
+   * Loads an ````LAS```` model into this LASLoaderPlugin's {@link Viewer}.
+   *
+   * @param {LoadLASModel} params Loading parameters.
+   * @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}.
+   */
+  load(params?: LoadLASModel): PerformanceModel;
+}

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

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

package/types/plugins/NavCubePlugin/NavCubePlugin.d.ts

@@ -0,0 +1,160 @@
+import { Plugin } from "../../viewer/Plugin";
+import { Viewer } from "../../viewer/Viewer";
+
+export declare type NavCubePluginConfiguration = {
+  /** Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}. */
+  id?: string;
+  /** ID of an existing HTML canvas to display the NavCube - either this or canvasElement is mandatory. When both values are given, the element reference is always preferred to the ID. */
+  canvasId?: string;
+  /** Reference of an existing HTML canvas to display the NavCube - either this or canvasId is mandatory. When both values are given, the element reference is always preferred to the ID. */
+  canvasElement?: HTMLCanvasElement;
+  /** Initial visibility. */
+  visible?: boolean;
+  /** Whether the shadow of the cube is visible. */
+  shadowVisible?: boolean;
+  /** Whether the {@link Camera} flies or jumps to each selected axis or diagonal. */
+  cameraFly?: string;
+  /** How much of the field-of-view, in degrees, that the 3D scene should fill the {@link Canvas} when the {@link Camera} moves to an axis or diagonal. */
+  cameraFitFOV?: string;
+  /** When flying the {@link Camera} to each new axis or diagonal, how long, in seconds, that the Camera takes to get there. */
+  cameraFlyDuration?: string;
+  /** Custom uniform color for the faces of the NavCube. */
+  color?: string;
+  /** Custom color for the front face of the NavCube. Overrides ````color````. */
+  frontColor?: string;
+  /** Custom color for the back face of the NavCube. Overrides ````color````. */
+  backColor?: string;
+  /** Custom color for the left face of the NavCube. Overrides ````color````. */
+  leftColor?: string;
+  /** Custom color for the right face of the NavCube. Overrides ````color````. */
+  rightColor?: string;
+  /** Custom color for the top face of the NavCube. Overrides ````color````. */
+  topColor?: string;
+  /** Custom color for the bottom face of the NavCube. Overrides ````color````. */
+  bottomColor?: string;
+  /** Custom color for highlighting regions on the NavCube as we hover the pointer over them. */
+  hoverColor?: string;
+  /** Sets whether the axis, corner and edge-aligned views will fit the view to the entire {@link Scene} or just to visible object-{@link Entity}s. Entitys are visible objects when {@link Entity#isObject} and {@link Entity#visible} are both ````true````. */
+  fitVisible?: boolean;
+  /** Sets whether the NavCube switches between perspective and orthographic projections in synchrony with the {@link Camera}. When ````false````, the NavCube will always be rendered with perspective projection. */
+  synchProjection?: boolean;
+};
+
+/**
+ * {@link Viewer} plugin that lets us look at the entire {@link Scene} from along a chosen axis or diagonal.
+ *
+ */
+export declare class NavCubePlugin extends Plugin {
+    /**
+     * @constructor
+     * @param {Viewer} viewer The Viewer.
+     * @param {NavCubePluginConfiguration} cfg NavCubePlugin configuration.
+     */
+    constructor(viewer: Viewer, cfg?: NavCubePluginConfiguration);
+
+    /**
+     * Sets if the NavCube is visible.
+     *
+     * @param {Boolean} value Whether or not the NavCube is visible.
+     */
+    setVisible(value?: boolean): void;
+
+    /**
+     * Gets if the NavCube is visible.
+     *
+     * @return {Boolean} True when the NavCube is visible.
+     */
+    getVisible(): boolean;
+
+    /**
+     * Sets whether the axis, corner and edge-aligned views will fit the
+     * view to the entire {@link Scene} or just to visible object-{@link Entity}s.
+     *
+     * Entitys are visible objects when {@link Entity#isObject} and {@link Entity#visible} are both ````true````.
+     *
+     * @param {Boolean} value Set ````true```` to fit only visible object-Entitys.
+     */
+    setFitVisible(value: boolean): void;
+
+    /**
+     * Gets whether the axis, corner and edge-aligned views will fit the
+     * view to the entire {@link Scene} or just to visible object-{@link Entity}s.
+     *
+     * Entitys are visible objects when {@link Entity#isObject} and {@link Entity#visible} are both ````true````.
+     *
+     * @return {Boolean} True when fitting only visible object-Entitys.
+     */
+    getFitVisible(): boolean;
+
+    /**
+     * Sets whether the {@link Camera} flies or jumps to each selected axis or diagonal.
+     *
+     * Default is ````true````, to fly.
+     *
+     * @param {Boolean} value Set ````true```` to fly, else ````false```` to jump.
+     */
+    setCameraFly(value: boolean): void;
+
+    /**
+     * Gets whether the {@link Camera} flies or jumps to each selected axis or diagonal.
+     *
+     * Default is ````true````, to fly.
+     *
+     * @returns {Boolean} Returns ````true```` to fly, else ````false```` to jump.
+     */
+    getCameraFly(): boolean;
+
+    /**
+     * Sets how much of the field-of-view, in degrees, that the {@link Scene} should
+     * fill the canvas when flying or jumping the {@link Camera} to each selected axis or diagonal.
+     *
+     * Default value is ````45````.
+     *
+     * @param {Number} value New FOV value.
+     */
+    setCameraFitFOV(value: number): void;
+
+    /**
+     * Gets how much of the field-of-view, in degrees, that the {@link Scene} should
+     * fill the canvas when flying or jumping the {@link Camera} to each selected axis or diagonal.
+     *
+     * Default value is ````45````.
+     *
+     * @returns {Number} Current FOV value.
+     */
+    getCameraFitFOV(): number;
+
+    /**
+     * When flying the {@link Camera} to each new axis or diagonal, sets how long, in seconds, that the Camera takes to get there.
+     *
+     * Default is ````0.5````.
+     *
+     * @param {Boolean} value Camera flight duration in seconds.
+     */
+    setCameraFlyDuration(value: boolean): void;
+
+    /**
+     * When flying the {@link Camera} to each new axis or diagonal, gets how long, in seconds, that the Camera takes to get there.
+     *
+     * Default is ````0.5````.
+     *
+     * @returns {Boolean} Camera flight duration in seconds.
+     */
+    getCameraFlyDuration(): boolean;
+
+    /**
+     * Sets whether the NavCube switches between perspective and orthographic projections in synchrony with
+     * the {@link Camera}. When ````false````, the NavCube will always be rendered with perspective projection.
+     *
+     * @param {Boolean} value Set ````true```` to keep NavCube projection synchronized with {@link Camera#projection}.
+     */
+    setSynchProjection(value: boolean): void;
+
+    /**
+     * Gets whether the NavCube switches between perspective and orthographic projections in synchrony with
+     * the {@link Camera}. When ````false````, the NavCube will always be rendered with perspective projection.
+     *
+     * @return {Boolean} True when NavCube projection is synchronized with {@link Camera#projection}.
+     */
+    getSynchProjection(): boolean;
+}

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

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