@combeenation/3d-viewer 0.0.1

package/dist/types/api/classes/variant.d.ts

@@ -0,0 +1,253 @@
+import { DottedPath } from './dottedPath';
+import { Element } from './element';
+import { ParameterObservable } from './parameterObservable';
+import { Parameterizable } from './parameterizable';
+import { VariantParameterizable } from './variantParameterizable';
+import { Viewer } from './viewer';
+import { ViewerLight } from './viewerLight';
+import { Light } from '@babylonjs/core/Lights/light';
+import '@babylonjs/core/Loading/Plugins/babylonFileLoader';
+import { Material } from '@babylonjs/core/Materials/material';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { AssetContainer } from '@babylonjs/core/assetContainer';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_draco_mesh_compression';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_clearcoat';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_ior';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_sheen';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_specular';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_translucency';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_transmission';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_unlit';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_variants';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_texture_basisu';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_texture_transform';
+import '@babylonjs/loaders/glTF/2.0/glTFLoader';
+/**
+ * A concrete "Variant". Most of these are handled by either the {@link Viewer} or {@link VariantInstance}.
+ */
+export declare class Variant extends Parameterizable {
+    protected readonly _variantInstance: VariantInstance | null;
+    readonly name: string;
+    protected readonly _structureJson: StructureJson;
+    readonly viewer: Viewer;
+    readonly parent?: Variant | undefined;
+    assetContainer: AssetContainer;
+    readonly elements: Element[];
+    readonly viewerLights: ViewerLight[];
+    structureJson: StructureJson;
+    protected _dottedNodes: Map<DottedPath, TransformNode> | undefined;
+    protected readonly _children: Map<string, Variant>;
+    protected readonly _parameterObservers: Map<string, ParameterObserver[]>;
+    /**
+     * @internal
+     */
+    private parametersInitialized;
+    /**
+     * Constructor.
+     */
+    protected constructor(_variantInstance: VariantInstance | null, name: string, _structureJson: StructureJson, viewer: Viewer, parent?: Variant | undefined);
+    /**
+     * Creates the root {@link Variant}.
+     */
+    static createRoot(structureJson: StructureJson, viewer: Viewer): Promise<Variant>;
+    /**
+     * Creates a {@link Variant} based on given parameters.
+     *
+     * @throws Error if "gltf" property is provided without a filename
+     */
+    static create(variantInstance: VariantInstance | null, name: string, structureJson: StructureJson, viewer: Viewer, parent?: Variant): Promise<Variant>;
+    /**
+     * The ancestor {@link Variant}s ordered from top to bottom in the built tree.
+     */
+    get ancestors(): Variant[];
+    /**
+     * The root {@link Variant}.
+     */
+    get root(): Variant;
+    /**
+     * The {@link DottedPath} in the built tree of {@link Variant}s.
+     * E.g. "_.top-1.sub-2.sub-sub-3"
+     */
+    get dottedPath(): DottedPath;
+    /**
+     * Gets the {@link VariantInstance} this variant was created for. There are variants without an instance (the "ghost"
+     * ones used for bootstrapping instances). The usage of {@link Variant}s without an instance is an absolute edge-case
+     * when deeply using the viewer api and working abroad best practices.
+     */
+    get variantInstance(): VariantInstance | null;
+    /**
+     * The id representing a {@link DottedPath}.
+     */
+    get id(): string;
+    /**
+     * The defined glTF Asset.
+     */
+    get glTF(): Asset | undefined;
+    /**
+     * The defined glTF URI.
+     */
+    get glTFUri(): string | undefined;
+    /**
+     * The inherited defined glTF URI.
+     */
+    get inheritedGlTFUri(): string | undefined;
+    /**
+     * The TransformNodes of the {@link Variant}.
+     */
+    get nodes(): TransformNode[];
+    /**
+     * The {@link ViewerLight}s of the {@link Variant}.
+     */
+    get lights(): Light[];
+    /**
+     * All TransformNodes of the {@link Variant} mapped flat with a {@link DottedPath}.
+     */
+    get dottedNodes(): Map<DottedPath, TransformNode>;
+    /**
+     * The Materials of the {@link Variant}.
+     */
+    get materials(): Material[];
+    /**
+     * The cloned TransformNodes of all {@link Element}s created for this {@link Variant}.
+     */
+    get elementNodes(): TransformNode[];
+    /**
+     * The cloned TransformNodes of all {@link Element}s created for this {@link Variant} flattened.
+     */
+    get elementNodesFlat(): TransformNode[];
+    /**
+     * All {@link Element}s from this {@link Variant}'s parents.
+     */
+    get inheritedElements(): Element[];
+    /**
+     * All {@link ViewerLight}s inherited from this {@link Variant}'s parents.
+     */
+    get inheritedViewerLights(): ViewerLight[];
+    /**
+     * All TransformNodes inherited from this {@link Variant}'s parents.
+     */
+    get inheritedNodes(): TransformNode[];
+    /**
+     * All TransformNodes inherited from this {@link Variant}'s parents mapped flat with a {@link DottedPath}.
+     */
+    get inheritedDottedNodes(): Map<DottedPath, TransformNode>;
+    /**
+     * All Lights inherited from this {@link Variant}'s parents.
+     */
+    get inheritedLights(): Light[];
+    /**
+     * The {@link ParameterDeclarations} inherited from this {@link Variant}'s parents.
+     */
+    get inheritedParameterDeclaration(): ParameterDeclarations;
+    /**
+     * The {@link ParameterBag} inherited from this {@link Variant}'s parents.
+     */
+    get inheritedParameters(): ParameterBag;
+    /**
+     * All Materials from this {@link Variant}'s parents.
+     */
+    get inheritedMaterials(): Material[];
+    /**
+     * Gets the direct children of the current {@link Variant}.
+     */
+    getChildren(): Promise<Variant[]>;
+    /**
+     *  Gets a descendant {@link Variant} of the current {@link Variant} relative to its {@link DottedPath}.
+     *  If you have the dotted path `_.product_x.variant_blue.with_yellow_highlight` in a tree and you operate on the
+     *  `product_x`, you can call `this.getDescendant('variant_blue.with_yellow_highlight')` to get the lowermost
+     *  {@link Variant}.
+     */
+    getDescendant(dottedPath: DottedPathArgument): Promise<Variant>;
+    /**
+     * Gets the desired {@link Element} of the current {@link Variant} relative to its {@link DottedPath}.
+     * Uses the mechanism of {@link getDescendant} to resolve the appropriate variant in tree.
+     */
+    getElement(dottedPath: DottedPathArgument): Promise<Element>;
+    /**
+     * Gets the desired {@link ViewerLight} of the current {@link Variant} relative to its {@link DottedPath}.
+     * Uses the mechanism of {@link getDescendant} to resolve the appropriate variant in tree.
+     */
+    getViewerLight(dottedPath: DottedPathArgument): Promise<ViewerLight>;
+    /**
+     * A proxy for directly getting a Node from an {@link Element} by its {@link DottedPath}s.
+     */
+    getNode(elementDottedPath: DottedPathArgument, nodeDottedPath: DottedPathArgument): Promise<TransformNode>;
+    /**
+     * A proxy for directly getting a Mesh from an {@link Element} by its {@link DottedPath}s.
+     */
+    getMesh(elementDottedPath: DottedPathArgument, meshDottedPath: DottedPathArgument): Promise<Mesh | null>;
+    /**
+     * Creates a living clone of this {@link Variant}. Will clone all parent {@link Variant}s in tree.
+     *
+     * @emit {@link Event.VARIANT_CREATED}
+     * @ignore
+     */
+    createLiving(variantInstance: VariantInstance, parameters?: ParameterBag): Promise<Variant>;
+    /**
+     * Destroys this {@link Variant}, all parents and destroy the {@link Element}s.
+     */
+    destroy(): Variant;
+    /**
+     * Places the given {@link ParameterBag} in the {@link Variant}'s parameters, replaces all patterns in the
+     * {@link StructureJson}, broadcasts all {@link ParameterObserver}s and delegates them to its {@link Element}s.
+     *
+     * @emit {@link Event.VARIANT_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters?: ParameterBag): Promise<Variant>;
+    /**
+     * Adds an observer function for camera matrix changes for given `dottedPath` representing the {@link Element}
+     * and the `traceable`. The `observer` gets 2 parameters: the `AbstractMesh` and a `ClientRect` object.
+     */
+    addTraceableObserver(dottedPath: DottedPathArgument, observer: CallableFunction, payload?: any): Promise<Element>;
+    /**
+     * Loads {@link glTFUri} with assets, adds them to the {@link Variant}'s `assetContainer` and deactivates the meshes.
+     * (for further processing).
+     * @emits {@link Event.ASSET_LOADING_START}
+     * @emits {@link Event.ASSET_LOADING_END}
+     */
+    protected loadAssets(): Promise<Variant>;
+    /**
+     * Commits given parameters to all {@link Element}s.
+     */
+    protected commitParametersToElements(parameters: ParameterBag): Promise<void>;
+    /**
+     * Commits given parameters to all {@link ViewerLight}s.
+     */
+    protected commitParametersToViewerLights(parameters: ParameterBag): Promise<void>;
+    /**
+     * Commits given parameters to a {@link VariantParameterizable} and updates the according definition with given
+     * key in the {@link StructureJson}. The `definitionKey` "elements" for example will update the definition in
+     * `this.structureJson.elements`.
+     */
+    protected commitParametersToVariantParameterizable(parameters: ParameterBag, parameterizable: VariantParameterizable, definitionKey: string): Promise<ParameterObservable>;
+    /**
+     * Commits given {@link Parameter} to the {@link Variant}'s {@link Element}s.
+     */
+    protected commitParameterToElements(parameter: string, value: ParameterValue): Promise<Variant>;
+    /**
+     * Commits given {@link Parameter} to the {@link Variant}'s {@link Element}s.
+     */
+    protected commitParameterToViewerLights(parameter: string, value: ParameterValue): Promise<Variant>;
+    /**
+     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
+     */
+    protected addParameterObservers(): Variant;
+    /**
+     * Creates {@link Element}s and clones nodes into them.
+     */
+    protected createElements(forInstance?: string): Promise<Variant>;
+    /**
+     * Creates {@link ViewerLight}s.
+     */
+    protected createViewerLights(): Promise<Variant>;
+    /**
+     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
+     */
+    protected bootstrapParameters(parameters?: ParameterBag): Promise<Variant>;
+    /**
+     * Ensures there is at least one "Main" {@link Element} for the {@link Variant} with all "root nodes" defined in path.
+     */
+    protected createElementDefinitionsIfNotExist(): void;
+}

package/dist/types/api/classes/variantInstance.d.ts

@@ -0,0 +1,53 @@
+import { Element } from './element';
+import { EventBroadcaster } from './eventBroadcaster';
+import { ParameterObservable } from './parameterObservable';
+import { Variant } from './variant';
+import { ViewerLight } from './viewerLight';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+/**
+ * Class VariantInstance.
+ */
+export declare class VariantInstance extends EventBroadcaster {
+    name: string;
+    protected _variant: Variant | null;
+    /**
+     * Constructor
+     */
+    protected constructor(name: string);
+    /**
+     * Creates a living clone of the given source {@link Variant} and instances a {@link VariantInstance} with given name
+     * and {@link ParameterBag}.
+     */
+    static createLiving(sourceVariant: Variant, name: string, parameters?: ParameterBag): Promise<VariantInstance>;
+    /**
+     * WORK IN PROGRESS
+     */
+    /**
+     * Gets the {@link Variant} attached to the {@link VariantInstance}.
+     */
+    get variant(): Variant;
+    /**
+     * A proxy for {@link Variant.getElement}.
+     */
+    getElement(dottedPath: DottedPathArgument): Promise<Element>;
+    /**
+     * A proxy for {@link Variant.getViewerLight}.
+     */
+    getViewerLight(dottedPath: DottedPathArgument): Promise<ViewerLight>;
+    /**
+     * A proxy for {@link Variant.getNode}.
+     */
+    getNode(elementDottedPath: DottedPathArgument, nodeDottedPath: DottedPathArgument): Promise<TransformNode>;
+    /**
+     * A proxy for {@link Variant.getMesh}.
+     */
+    getMesh(elementDottedPath: DottedPathArgument, meshDottedPath: DottedPathArgument): Promise<Mesh | null>;
+    /**
+     * A proxy for {@link Variant.commitParameters}.
+     */
+    commitParameters(parameters?: ParameterBag): Promise<Variant>;
+    /**
+     * A proxy for {@link ParameterObservable.commitParameter}.
+     */
+    commitParameter(parameter: string, value: ParameterValue): Promise<ParameterObservable>;
+}

package/dist/types/api/classes/variantParameterizable.d.ts

@@ -0,0 +1,17 @@
+import { Parameterizable } from './../classes/parameterizable';
+import { Variant } from './../classes/variant';
+export declare abstract class VariantParameterizable extends Parameterizable {
+    readonly variant: Variant;
+    readonly name: string;
+    protected readonly _parameterObservers: Map<string, ParameterObserver[]>;
+    protected constructor(variant: Variant, name: string);
+    /**
+     * Gets the inherited parameters from the {@link Variant} with cleaned {@link Parameterizable} prefix.
+     */
+    get inheritedParameters(): ParameterBag;
+    /**
+     * Places the given {@link ParameterBag} in the {@link VariantParameterizable}'s parameters, replaces all patterns in
+     * the {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+     */
+    commitParameters(parameters?: ParameterBag): Promise<VariantParameterizable>;
+}

package/dist/types/api/classes/viewer.d.ts

@@ -0,0 +1,200 @@
+import { AnimationManager } from '../manager/animationManager';
+import { GltfExportManager } from '../manager/gltfExportManager';
+import { SceneManager } from '../manager/sceneManager';
+import { TagManager } from '../manager/tagManager';
+import { VariantInstanceManager } from '../manager/variantInstanceManager';
+import { AnimationInterface } from './animationInterface';
+import { EventBroadcaster } from './eventBroadcaster';
+import { VariantInstance } from './variantInstance';
+import { Engine } from '@babylonjs/core/Engines/engine';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Scene } from '@babylonjs/core/scene';
+/**
+ * The main exposed object. This is the entry point into the application
+ *
+ * ```js
+ * const canvas = document.getElementById( 'babylon-canvas' );
+ * const viewer = Viewer( canvas, '/path/to/index.json' );
+ * ```
+ * The class does nothing on its own and needs to {@link bootstrap}
+ */
+export declare class Viewer extends EventBroadcaster {
+    readonly canvas: HTMLCanvasElement;
+    protected structureJson: string | StructureJson;
+    protected _scene: Scene | null;
+    protected _animationManager: AnimationManager | null;
+    protected _sceneManager: SceneManager | null;
+    protected _tagManager: TagManager | null;
+    protected _gltfExportManager: GltfExportManager | null;
+    protected _variantInstances: VariantInstanceManager | null;
+    protected _cloneMaterialsOnMutation: boolean;
+    protected _isRenderLoopPaused: boolean;
+    protected _inspectorLoaded: boolean;
+    protected _nodeNamingStrategyHandler: NodeNamingStrategyHandler | null;
+    static version: string;
+    private static readonly _autofocusConstants;
+    /**
+     * Help function for automatically creating a valid Spec from a list of variant names and dedicated GLB/babylon URLs.
+     * This data is most likely coming from babylon assets from the Combeenation system but other sources are also valid.
+     */
+    static generateSpec(genData: SpecGenerationData[]): AutoSpecStructureJson;
+    /**
+     * Constructor
+     */
+    constructor(canvas: HTMLCanvasElement, structureJson: string | StructureJson);
+    /**
+     * Gets the Babylon.js Scene that is attached to the instance.
+     *
+     * @throws Error if the `scene` has not been initialized.
+     */
+    get scene(): Scene;
+    /**
+     * Gets the {@link SceneManager} attached to the viewer.
+     *
+     * @throws Error if the {@link SceneManager} has not been initialized.
+     */
+    get sceneManager(): SceneManager;
+    /**
+     * Gets the {@link GltfExportManager} attached to the viewer.
+     *
+     * @throws Error if the {@link GltfExportManager} has not been initialized.
+     */
+    get gltfExportManager(): GltfExportManager;
+    /**
+     * Gets the Babylon.js Engine that is attached to the viewer.
+     */
+    get engine(): Engine;
+    /**
+     * Gets the {@link VariantInstanceManager} attached to the viewer.
+     *
+     * @throws Error if the {@link VariantInstanceManager} has not been initialized.
+     */
+    get variantInstances(): VariantInstanceManager;
+    /**
+     * Gets the {@link AnimationManager} attached to the viewer.
+     *
+     * @throws Error if the {@link AnimationManager} has not been initialized.
+     */
+    get animationManager(): AnimationManager;
+    get tagManager(): TagManager;
+    /**
+     * Gets the `cloneMaterialsOnMutation` flag, as defined in the spec
+     */
+    get cloneMaterialsOnMutation(): boolean;
+    /**
+     * Gets the strategy handler for naming cloned nodes.
+     */
+    get nodeNamingStrategyHandler(): NodeNamingStrategyHandler;
+    /**
+     * Sets the strategy handler for naming cloned nodes.\
+     * Check the docs of the tag managers
+     * [renaming](./../pages/documentation/Tag-Manager.html#uniqueness-of-node-and-tag-names)
+     * chapter for further details.
+     */
+    set nodeNamingStrategyHandler(value: NodeNamingStrategyHandler);
+    /**
+     * Starts the application. This will
+     * * load the given "index" JSON file
+     * * setup the scene with the "scene" JSON file
+     * * create an (optional) default setup with different variant settings
+     * * sets up resizing by attaching a debounced version of {@link resize}
+     *
+     * @throws Error if any of the files is not found/valid
+     *
+     * @emits {@link Event.BOOTSTRAP_START}
+     * @emits {@link Event.BOOTSTRAP_END}
+     */
+    bootstrap(tagManagerParameterValues: TagManagerParameterValue[]): Promise<Viewer>;
+    /**
+     * Enables the Babylon.js [Inspector](https://doc.babylonjs.com/toolsAndResources/tools/inspector).\
+     * Due to the additional size of the inspector, the CDN version is used instead of shipping the required code with
+     * the viewer.\
+     * This means that the code will be downloaded only when needed and calling `enableDebugLayer` can take a little while
+     * depending on your internet connection etc.
+     */
+    enableDebugLayer(options?: IInspectorOptions): Promise<void>;
+    /**
+     * Destroys all registered {@link VariantInstance}s that are registered
+     */
+    destroyVariantInstances(): Viewer;
+    /**
+     * Trigger a resize event for the `Engine`
+     */
+    resize(): Viewer;
+    /**
+     * A convenience method for directly getting a Node from a {@link VariantInstance} and an {@link Element} by its
+     * {@link DottedPath}s.
+     */
+    getNode(variantInstanceName: string, elementDottedPath: DottedPathArgument, nodeDottedPath: DottedPathArgument): Promise<TransformNode>;
+    /**
+     * A convenience method for directly getting a Node from a {@link VariantInstance} and an {@link Element} by its
+     * {@link DottedPath}s.
+     */
+    getMesh(variantInstanceName: string, elementDottedPath: DottedPathArgument, meshDottedPath: DottedPathArgument): Promise<Mesh | null>;
+    /**
+     * Switches the camera
+     *
+     * @emits {@link Event.CAMERA_SWITCHED}
+     */
+    switchCamera(newCamera: string, reset?: boolean): Viewer;
+    /**
+     * Moves or animates the active camera to given `placement`.
+     */
+    moveActiveCameraTo(placement: string | PlacementDefinition, animation?: string | AnimationDefinition): Promise<AnimationInterface>;
+    /**
+     * Takes a sceenshot the the current scene. The result is a string containing a base64 encoded image
+     */
+    screenshot(settings?: ScreenshotSettings): Promise<string>;
+    /**
+     * Checks whether the browser is capable of handling XR.
+     */
+    isBrowserARCapable(): Promise<boolean>;
+    /**
+     * Calculates the bounding box from all visible meshes on the scene.
+     */
+    calculateBoundingBox(excludeGeometry?: ExcludedGeometryList): Promise<Mesh>;
+    /**
+     * Focuses the camera to see every visible mesh in scene and tries to optimize wheel precision and panning
+     */
+    autofocusActiveCamera(settings?: AutofocusSettings): Promise<void>;
+    /**
+     * Resets everything by calling {@link destroy} to clear all references and {@link bootstrap} to setup a clean
+     * environment
+     */
+    reset(tagManagerParameterValues: TagManagerParameterValue[]): Promise<Viewer>;
+    /**
+     * Destroys
+     *
+     * * all {@link VariantInstance}s using {@link destroyVariantInstances}
+     * * calling `dispose` on the `Engine` and `Scene`
+     */
+    destroy(): Viewer;
+    /**
+     * Show coordinate system with given dimension (for debugging purpose).
+     */
+    showWorldCoordinates(dimension: number): void;
+    /**
+     * Pause render loop.
+     */
+    pauseRendering(): void;
+    /**
+     * Resume render loop when paused.
+     */
+    resumeRendering(): void;
+    /**
+     * @emits {@link Event.SCENE_PROCESSING_START}
+     * @emits {@link Event.SCENE_PROCESSING_END}
+     */
+    protected initScene(): Promise<Scene>;
+    /**
+     * Register custom file loader for babylon files which adds "missing-material" metadata to meshes which reference
+     * materials that are not present in the `materials` section of the given babylon file.
+     *
+     * Required for babylon files & materials loaded from "Combeenation configurator assets".
+     */
+    protected initCbnBabylonLoaderPlugin(): void;
+    /**
+     * Batch creation of multiple {@link VariantInstance} objects with a {@link SetupJson} object passed
+     */
+    protected createVariantInstances(): Promise<VariantInstance[]>;
+}

package/dist/types/api/classes/viewerLight.d.ts

@@ -0,0 +1,66 @@
+import { DottedPath } from './dottedPath';
+import { Variant } from './variant';
+import { VariantParameterizable } from './variantParameterizable';
+import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator';
+import '@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent';
+import { Light } from '@babylonjs/core/Lights/light';
+import { ShadowLight } from '@babylonjs/core/Lights/shadowLight';
+import '@babylonjs/loaders/glTF/2.0/Extensions/KHR_lights_punctual';
+/**
+ * A {@link ViewerLight} of a {@link Variant}. Acts as a container for Babylon.js lights. Lives only in the context of a
+ * {@link Variant}.
+ */
+export declare class ViewerLight extends VariantParameterizable {
+    readonly variant: Variant;
+    readonly name: string;
+    protected _light: Light | undefined;
+    /**
+     * Constructor.
+     */
+    protected constructor(variant: Variant, name: string);
+    /**
+     * Creates a {@link ViewerLight} with given name.
+     */
+    static create(variant: Variant, name: string): Promise<ViewerLight>;
+    /**
+     * The wrapped Light.
+     */
+    get light(): Light;
+    /**
+     * The {@link DottedPath} in the built tree of {@link ViewerLight}s.
+     * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
+     */
+    get dottedPath(): DottedPath;
+    /**
+     * The id representing a {@link DottedPath}.
+     */
+    get id(): string;
+    /**
+     * The {@link LightDefinition} of the {@link ViewerLight}.
+     */
+    get definition(): LightDefinition;
+    /**
+     * The type of the {@link ViewerLight}'s light.
+     */
+    get type(): string;
+    /**
+     * @see {@link VariantParameterizable.commitParameters}
+     * @emit {@link Event.VIEWER_LIGHT_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters?: ParameterBag): Promise<VariantParameterizable>;
+    /**
+     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
+     */
+    protected addParameterObservers(): ViewerLight;
+    /**
+     * @param definition
+     * @protected
+     */
+    protected createBabylonLightFromDefinition(definition: LightDefinition): Promise<Light>;
+    /**
+     * @param babylonLight
+     * @param definition
+     * @protected
+     */
+    protected processShadowGenerator(babylonLight: ShadowLight, definition: ShadowGeneratorDefinition): Promise<ShadowGenerator>;
+}

package/dist/types/api/internal/lensRendering.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Group the required LensRendering dependencies into a single file to allow a single "import"
+ *
+ * @internal
+ */
+import { LensRenderingPipeline } from '@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/lensRenderingPipeline';
+import '@babylonjs/core/Rendering/depthRendererSceneComponent';
+export { LensRenderingPipeline };

package/dist/types/api/internal/sceneSetup.d.ts

@@ -0,0 +1,13 @@
+import { Engine } from '@babylonjs/core/Engines/engine';
+import '@babylonjs/core/Helpers/sceneHelpers';
+import '@babylonjs/core/Materials/Textures/Loaders/ddsTextureLoader';
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+import { Scene } from '@babylonjs/core/scene';
+declare const defaultSceneClearColor: Color4;
+declare const defaultEnvHelperColor: Color4;
+/**
+ * @param engine
+ * @param sceneJson
+ */
+declare const sceneSetup: (engine: Engine, sceneJson: SceneJson) => Promise<Scene>;
+export { sceneSetup, defaultSceneClearColor, defaultEnvHelperColor };

package/dist/types/api/manager/animationManager.d.ts

@@ -0,0 +1,30 @@
+import { AnimationInterface } from '../classes/animationInterface';
+import { Scene as BabylonScene } from '@babylonjs/core/scene';
+export declare class AnimationManager {
+    protected scene: BabylonScene;
+    animations: AnimationInterface[];
+    /**
+     * Constructor.
+     */
+    protected constructor(scene: BabylonScene);
+    /**
+     * Creates an {@link AnimationManager} based on given Babylon.js scene.
+     */
+    static create(scene: BabylonScene): Promise<AnimationManager>;
+    /**
+     * @deprecated Use viewer.moveCameraTo().
+     */
+    resetCamera(animate?: boolean): void;
+    /**
+     * @deprecated Use viewer.moveCameraTo().
+     */
+    animateArcRotateCamera(targetAlpha: number, targetBeta: number, targetRadius: number): void;
+    /**
+     * Stops and kills all running animations.
+     */
+    killAllAnimations(): void;
+    /**
+     * @see {@link PlacementAnimation.play}
+     */
+    animateToPlacement(mutable: object, placement: PlacementDefinition | string, animation?: AnimationDefinition | string): Promise<AnimationInterface>;
+}