@combeenation/3d-viewer 0.0.1

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

@@ -0,0 +1,78 @@
+import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
+import { IExportOptions } from '@babylonjs/serializers/glTF/2.0';
+export declare class GltfExportManager {
+    protected viewer: Viewer;
+    static readonly UNIQUE_MESH_METADATA_PROPERTY = "originalName";
+    /**
+     * Constructor.
+     */
+    protected constructor(viewer: Viewer);
+    /**
+     * Creates an {@link GltfExportManager}.
+     */
+    static create(viewer: Viewer): Promise<GltfExportManager>;
+    /**
+     * Exports selected nodes to a file.
+     * @param filename optional name of the exported .GLB file.
+     * @param exportOptions export options to be merged with default options.\
+     *                      `exportOptions.createUniqueMeshNames` defaults to `true` if not given.
+     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
+     */
+    exportGlb(filename?: string, { createUniqueMeshNames, ...exportOptionsRest }?: IExportOptionsExtended, excluded?: ExcludedGeometryList): Promise<File | undefined>;
+    /**
+     * Exports selected nodes to GLTF. This may result in more than one file, since textures are exported separately.
+     * @param filename name of the main (text-based) .GLTF file referring to separate texture files.
+     * @param exportOptions export options to be merged with default options.\
+     *                      `exportOptions.createUniqueMeshNames` defaults to `true` if not given.
+     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
+     */
+    exportGltfToFile(filename: string, { createUniqueMeshNames, ...exportOptionsRest }?: IExportOptionsExtended, excluded?: ExcludedGeometryList): Promise<void>;
+    /**
+     * Exports selected nodes to GLB. This results in one binary file.
+     * @param filename name of the .GLB file.
+     * @param exportOptions export options to be merged with default options.\
+     *                      `exportOptions.createUniqueMeshNames` defaults to `true` if not given.
+     * @param excluded optional list of geometry (meshes, elements, variants, variantInstances) to be excluded from export
+     */
+    exportGlbToFile(filename: string, { createUniqueMeshNames, ...exportOptionsRest }?: IExportOptionsExtended, excluded?: ExcludedGeometryList): Promise<void>;
+    /**
+     * Gets predefined {@link IExportOptionsExtended } merged with given ones.
+     */
+    protected gltfExportOptions(mergeWithOptions?: IExportOptionsExtended, excluded?: ExcludedGeometryList): IExportOptions;
+    /**
+     * Stuff to be done before exporting to GLTF
+     */
+    protected exportPreProcess({ createUniqueMeshNames }: IExportOptionsExtended): void;
+    /**
+     * Stuff to be done after the GLTF export
+     */
+    protected exportPostProcess(): void;
+    /**
+     * Materials with refraction set are not exported properly.
+     * Exchange all such (relevant) materials with a more export-friendly version
+     */
+    protected exchangeRefractionMaterials(): void;
+    /**
+     * Restore original materials with set refraction.
+     */
+    protected restoreRefractionMaterials(): void;
+    /**
+     * Create an export-friendly replacement material for a material using refraction.
+     * @param mat Material to be replaced
+     */
+    protected createRefractionMaterialReplacement(mat: PBRMaterial): PBRMaterial;
+    /**
+     * Inspect if a material was temporarily cloned for GLB export
+     * @param mat Material to be inspected
+     */
+    protected isMaterialClonedForExport(mat: PBRMaterial): boolean;
+    /**
+     * Set unique mesh names for GLB export
+     */
+    protected setUniqueMeshNames(): void;
+    /**
+     * Restore original mesh names for meshes that were
+     * renamed with {@link setUniqueMeshNames()}
+     */
+    protected restoreOriginalMeshNames(): void;
+}

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

@@ -0,0 +1,33 @@
+import { ParameterObservable } from '../classes/parameterObservable';
+import { TextureLoadManager } from './textureLoadManager';
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { Scene as BabylonScene } from '@babylonjs/core/scene';
+export declare class SceneManager extends ParameterObservable {
+    scene: BabylonScene;
+    protected readonly _parameterObservers: Map<string, ParameterObserver[]>;
+    protected _textureLoadManager: TextureLoadManager | null;
+    /**
+     * Constructor.
+     */
+    protected constructor(scene: BabylonScene);
+    /**
+     * Creates a {@link SceneManager} based on given Babylon.js scene.
+     */
+    static create(scene: BabylonScene): Promise<SceneManager>;
+    /**
+     * The active `Camera`.
+     */
+    get activeCamera(): Camera;
+    /**
+     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
+     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+     *
+     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters?: ParameterBag): Promise<SceneManager>;
+    protected addParameterObservers(): SceneManager;
+    /**
+     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
+     */
+    protected bootstrapParameters(parameters?: ParameterBag): Promise<SceneManager>;
+}

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

@@ -0,0 +1,108 @@
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+export declare class TagManager {
+    protected viewer: Viewer;
+    readonly parameters: TagManagerParameterBag;
+    readonly parameterObservers: TagManagerParameterObserverBag;
+    /**
+     * Constructor.
+     */
+    constructor(viewer: Viewer);
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * nodes with given tagName.
+     */
+    setTagParameterValue(tagName: string, parameterName: string, value: ParameterValue): Promise<ParameterObserverResult>;
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * nodes with given nodeName.
+     */
+    setNodeParameterValue(nodeName: string, parameterName: string, value: ParameterValue): Promise<ParameterObserverResult>;
+    /**
+     * Splits the passed {@link TagManagerParameterValue}s into individual values and calls all {@link ParameterObserver}s
+     * of all {@link Parameter}s with the respective {@link TagManagerSubject} and {@link ParameterValue}. The result is a
+     * map of passed {@link TagManagerParameterValue}s and the associated {@link ParameterObserverResult} of the
+     * {@link ParameterObserver}.
+     */
+    setParameterValues(values: TagManagerParameterValue[]): Promise<Map<TagManagerParameterValue, ParameterObserverResult>>;
+    /**
+     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
+     * {@link parameters} and the given node.
+     */
+    getSubjectsFor(node: TransformNode): TagManagerSubject[];
+    /**
+     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
+     * {@link parameters} and the given nodes.
+     */
+    getApplicableSubjectsFor(nodes: TransformNode[]): TagManagerSubject[];
+    /**
+     * Applies all existing states of the {@link TagManager}'s {@link parameters} for given {@link TagManagerSubject}s.
+     */
+    applyExistingParameterValuesFor(subjects: TagManagerSubject[]): Promise<Map<TagManagerSubject, ParameterObserverResult>>;
+    /**
+     * Does the same as {@link setParameterValues} with the difference that all existing states of the
+     * {@link TagManager}'s {@link parameters} are applied to all given nodes.
+     */
+    applyExistingParameterValuesTo(nodes: TransformNode[]): Promise<Map<TagManagerSubject, ParameterObserverResult>>;
+    /**
+     * Applies all existing states of the {@link TagManager}'s {@link parameters} for all {@link TagManagerSubject}s.
+     */
+    applyExistingParameterValues(): Promise<Map<TagManagerSubject, ParameterObserverResult>>;
+    /**
+     * Maps all tags on given nodes with the {@link TagMapping} and updates the state of the {@link TagManager}'s
+     * {@link parameters} for all new tags.
+     * Also updates the state of all nodes in the tag managers parameter state.
+     */
+    mapNodesAndTags(nodes: TransformNode[], tagMapping: TagMapping): TagManager;
+    /**
+     * Prints the state of the {@link TagManager}'s {@link parameters} to the console.
+     */
+    printAllTags(): void;
+    /**
+     * Prints the state of the {@link TagManager}'s {@link parameters} for one tagName to the console.
+     */
+    printTagInfo(tagName: string): void;
+    /**
+     * Sets a {@link ParameterObserver} for the given {@link Parameter}.
+     */
+    setParameterObserver(parameter: string, observer: TagManagerParameterObserver): TagManager;
+    /**
+     * Gets all nodes for given {@link TagManagerSubject} on the Babylon.js scene.
+     */
+    getNodesBySubject(subject: TagManagerSubject, predicate?: (node: TransformNode) => boolean): TransformNode[];
+    /**
+     * Registers observers that are called on every new node added to the Babylon.js scene. The observers ensure that each
+     * new node gets the state of the {@link TagManager}'s {@link parameters} applied.
+     */
+    registerNewTransformNodeObservers(scene: Scene): void;
+    /**
+     * Adds the default {@link ParameterObserver}s.
+     * @protected
+     */
+    protected addParameterObservers(): TagManager;
+    /**
+     * Passes all {@link ParameterValue}s of the given {@link ParameterBag} for given {@link TagManagerSubject} to
+     * {@link handleParameter}.
+     * @protected
+     */
+    protected handleParameterBag(subject: TagManagerSubject, parameters: ParameterBag): Promise<ParameterObserver>[];
+    /**
+     * Asserts the given {@link Parameter} and its {@link ParameterValue}, stores the state in the {@link TagManager}'s
+     * {@link parameters}, calculates the applicable nodes, injects the {@link ParameterValue} in the node's metadata,
+     * calls the responsible {@link ParameterObserver}s and emits the event {@link Event.TAG_MANAGER_PARAMETER_COMMITTED}.
+     * @protected
+     */
+    protected handleParameter(subject: TagManagerSubject, parameter: string, parameterValue: ParameterValue): Promise<ParameterObserver>;
+    /**
+     * Updates the state of the {@link TagManager}'s {@link parameters} for all new nodes and tags given in
+     * {@link TagMapping}.
+     * @protected
+     */
+    protected updateParametersWithNodeAndTagMapping(nodes: TransformNode[], tagMapping: TagMapping): void;
+    /**
+     * Clears the applied {@link ParameterBag} state of the node's metadata to ensure that observers trigger (once again).
+     * This is necessary e.g. after mapping tags when a nodeName subject shall override the parameterValue of a mapped
+     * tag.
+     * @protected
+     */
+    protected clearAppliedNodeMetadataParameters(nodes: TransformNode[]): void;
+}

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

@@ -0,0 +1,22 @@
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { Scene as BabylonScene } from '@babylonjs/core/scene';
+/**
+ * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
+ * {@link Event.TEXTURE_LOADING_END} events.
+ */
+export declare class TextureLoadManager extends EventBroadcaster {
+    scene: BabylonScene;
+    private readonly _loadingTextures;
+    private _readyStatePollingIntervalMs;
+    private _readyStatePollingId;
+    private constructor();
+    static create(scene: BabylonScene): TextureLoadManager;
+    private startReadyStatePollingIfNeeded;
+    private endReadyStatePollingIfNeeded;
+    /**
+     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
+     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
+     */
+    private checkLoadingTexturesState;
+    private onTextureAdded;
+}

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

@@ -0,0 +1,103 @@
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { Variant } from '../classes/variant';
+import { VariantInstance } from '../classes/variantInstance';
+/**
+ * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
+ * {@link Viewer} instance via its {@link Viewer.variantInstances}
+ */
+export declare class VariantInstanceManager extends EventBroadcaster {
+    viewer: Viewer;
+    protected rootVariant: Variant;
+    protected variantInstancePromises: Map<string, Promise<VariantInstance>>;
+    protected variantInstances: Map<string, VariantInstance>;
+    protected variantInstanceDefinitions: Map<string, VariantInstanceDefinition>;
+    protected parameters: ParameterBag;
+    protected queues: {
+        [name: string]: Promise<VariantInstance>[];
+    };
+    /**
+     * Constructor.
+     */
+    protected constructor(viewer: Viewer, rootVariant: Variant);
+    /**
+     * Creates a {@link VariantInstanceManager} based on given root Variant.
+     */
+    static create(viewer: Viewer): Promise<VariantInstanceManager>;
+    /**
+     * Gets all instances.
+     */
+    get all(): VariantInstance[];
+    /**
+     * Gets all instance definitions.
+     */
+    get allDefinitions(): VariantInstanceDefinition[];
+    /**
+     * Gets all {@link VariantInstance}s with given {@link Variant}'s name.
+     */
+    allWithVariantName(name: string): VariantInstance[];
+    /**
+     * Checks whether a {@link VariantInstance} is either registered or created.
+     */
+    has(name: string): boolean;
+    /**
+     * Retrieves a {@link VariantInstance}.
+     * If the instance has been created, the created instance will be returned.
+     * If the instance is registered, the instance will be created and returned.
+     * if the instance has already been requested and is currently pending, the dedicated promise will be returned.
+     * If none of these apply, an Error is thrown.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    get(name: string): Promise<VariantInstance>;
+    /**
+     * Creates and registers a unique {@link VariantInstance}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    create(dottedPath: DottedPathArgument, name?: string, parameters?: ParameterBag): Promise<VariantInstance>;
+    /**
+     * Registers a unique {@link VariantInstanceDefinition}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
+     */
+    register(instanceDefinition: VariantInstanceDefinition): VariantInstanceDefinition;
+    /**
+     * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
+     */
+    commitParameters(parameters?: ParameterBag, onlyVisible?: boolean): Promise<VariantInstanceManager>;
+    /**
+     * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
+     * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
+     * the calls end up in a queue according to the FIFO principle (the last one wins).
+     */
+    show(name: string, exclusive?: boolean): Promise<VariantInstance>;
+    /**
+     * Clones and registers a new {@link VariantInstance} with a new, unique name.
+     *
+     * @param tagMapping Object for renaming tags on the clone, whereas the "key" is the tag name of orignal variant
+     * instance and the "value" is the new tag name that should be created from it.\
+     * Check the docs of the tag managers
+     * [renaming](./../pages/documentation/Tag-Manager.html#uniqueness-of-node-and-tag-names)
+     * chapter for further details.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CLONED}
+     */
+    clone(name: string, newName: string, parameters?: ParameterBag, tagMapping?: TagMapping): Promise<VariantInstance>;
+    /**
+     * Destroys the instance by removing the {@link Variant} and de-registering the instance.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
+     */
+    destroy(name: string): VariantInstanceManager;
+    /**
+     * Creates and registers a unique {@link VariantInstance} from `definition`.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    protected createFromDefinition(definition: VariantInstanceDefinition): Promise<VariantInstance>;
+    /**
+     * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
+     * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
+     */
+    protected ensureUniqueName(name: string): string;
+}

package/dist/types/api/store/specStorage.d.ts

@@ -0,0 +1,32 @@
+export declare class SpecStorage {
+    protected spec: StructureJson;
+    static instance: SpecStorage | undefined;
+    /**
+     * Constructor.
+     */
+    protected constructor(spec: StructureJson);
+    /**
+     * Creates {@link SpecStorage} from spec.
+     */
+    static createFromSpec(structureJson: StructureJson): SpecStorage;
+    /**
+     * Gets the {@link SpecStorage} instance.
+     */
+    static getInstance(): SpecStorage;
+    /**
+     * Gets the spec from the {@link SpecStorage}.
+     */
+    static getSpec(): StructureJson;
+    /**
+     * Destroys the current instance to allow reinstantiating the SpecStorage.
+     */
+    static destroy(): void;
+    /**
+     * Gets spec from key.
+     */
+    static get<T>(key?: string): T;
+    /**
+     * Sets value for spec for given key.
+     */
+    static set<T>(key: string, value: T): typeof SpecStorage;
+}

package/dist/types/api/util/babylonHelper.d.ts

@@ -0,0 +1,235 @@
+import { DottedPath } from '../classes/dottedPath';
+import { HighlightLayer } from '@babylonjs/core/Layers/highlightLayer';
+import { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator';
+import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
+import { Material } from '@babylonjs/core/Materials/material';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Observable } from '@babylonjs/core/Misc/observable';
+import { Node } from '@babylonjs/core/node';
+import { Scene } from '@babylonjs/core/scene';
+declare const backgroundDomeName = "BackgroundDome_ViewerGenerated";
+declare const envHelperMetadataName = "viewerEnvHelper";
+/**
+ * @param node
+ * @return Node
+ */
+declare const getRootNode: (node: Node) => Node;
+/**
+ * @param nodes
+ * @param predicate
+ * @return Map<DottedPath, T>
+ */
+declare const mapToDottedNodes: <T>(nodes: Node[], predicate?: ((node: Node) => boolean) | undefined) => Map<DottedPath, T>;
+/**
+ * @param node
+ * @return DottedPath
+ */
+declare const getDottedPathForNode: (node: Node) => DottedPath;
+/**
+ * @param node
+ * @param nodeNamingStrategy
+ * @param predicate
+ * @param deep
+ * @return TransformNode | null
+ */
+declare const cloneTransformNode: (node: TransformNode, nodeNamingStrategy: NodeNamingStrategy, predicate?: ((node: TransformNode) => boolean) | undefined, deep?: boolean) => TransformNode | null;
+/**
+ * @param node
+ */
+declare const cloneNodeWithParents: (node: Node | null) => Node | null;
+/**
+ * @param node
+ * @param deep
+ * @param prefix
+ * @return TransformNode
+ */
+declare const cloneTransformNodeMaterial: (node: TransformNode, prefix?: DottedPathArgument, deep?: boolean) => TransformNode;
+/**
+ * @param node
+ * @param deep
+ * @param metadata
+ */
+declare const injectNodeMetadata: (node: Node, metadata: {}, deep?: boolean) => void;
+/**
+ * @param node
+ * @param assertCallable
+ * @param callableParameters
+ * @param deep
+ */
+declare const assertTransformNode: (node: TransformNode, assertCallable: (node: TransformNode, ...args: any[]) => void, callableParameters?: any[], deep?: boolean) => void;
+/**
+ * @param node
+ * @param parameter
+ */
+declare const assertMeshCapability: (node: TransformNode, parameter: string) => void;
+/**
+ * @param node
+ * @param deep
+ */
+declare const activateTransformNode: (node: TransformNode, deep?: boolean) => void;
+/**
+ * @param node
+ * @param deep
+ */
+declare const deactivateTransformNode: (node: TransformNode, deep?: boolean) => void;
+/**
+ * @param node
+ */
+declare const enableNodeWithParents: (node: Node) => void;
+/**
+ * @param node
+ */
+declare const disableNodeWithParents: (node: Node) => void;
+/**
+ * Applies a {@link TransformationDefinition} consecutively to ensure dependencies in positioning etc.
+ * @param node
+ * @param transformation
+ */
+declare const transformTransformNode: (node: TransformNode, transformation: TransformationDefinition) => void;
+/**
+ * Apply changes of environment (background texture, etc.) consecutively in order to avoid dependency related issues.
+ * @param scene
+ * @param envDef
+ */
+declare const changeEnvironment: (scene: Scene, envDef: EnvironmentDefinition) => void;
+/**
+ * Sets a material by a given material id as material property on the given node.
+ *
+ * If the material is not already available in the scene, the viewer tries to create a material based on a Combeenation
+ * [material asset](https://docs.combeenation.com/docs/howto-create-and-use-babylon-and-material-asset).
+ * This of course only works if the viewer is used inside a Combeenation configurator.
+ *
+ * Furthermore this function also defers the material creation if the node is not visible yet to improve network &
+ * viewer bootstrap performance as textures are automatically being lazy loaded only when they are actually visible in
+ * the scene.
+ *
+ * Finally the material will not be applied before all its textures have been loaded. In this way "flickering" effects
+ * will be avoided, since the material would be incomplete without its loaded textures.
+ */
+declare const setMaterial: (node: TransformNode, materialId: string, deep?: boolean, variant?: Variant) => void;
+/**
+ * Gets the Material either from the given {@link Variant}, the given scene or tries to create it from an Combeenation
+ * material asset when inside a Combeenation configurator.
+ */
+declare const getOrCreateMaterial: (scene: Scene, materialId: string, variant?: Variant) => Material;
+/**
+ * Waits until the materials textures are loaded and shaders are compiled.
+ * Then sets the material on the node if there is no newer "set material" request
+ */
+declare const applyMaterial: (material: Material, node: AbstractMesh) => Promise<void>;
+/**
+ * !!! Warning !!!
+ * This function is not public API. Whilst it can help solving certain problems, it only works reliably in well defined
+ * situations and can cause unwanted side effects under some conditions. Use carefully at your own risk!
+ *
+ * See https://combeenation.myjetbrains.com/youtrack/issue/CB-5906 for further details regarding this warning.
+ *
+ * Set material of an instanced meshes source mesh.
+ * Changes the material of all instanced meshes which have the same source mesh.
+ *
+ * @param node
+ * @param material
+ * @param deep
+ *
+ * @ignore
+ */
+declare const setSourceNodeMaterial: (node: TransformNode, material: Material, deep?: boolean) => void;
+/**
+ * @param node
+ * @param color
+ * @param deep
+ */
+declare const setMaterialColor: (node: TransformNode, color: Color3, deep?: boolean) => void;
+/**
+ * @param node
+ * @param texture
+ * @param deep
+ */
+declare const setMaterialTexture: (node: TransformNode, texture: Texture, deep?: boolean) => void;
+/**
+ * @param node
+ * @param metallness
+ * @param deep
+ */
+declare const setMaterialMetallness: (node: TransformNode, metallness: number, deep?: boolean) => void;
+/**
+ * @param node
+ * @param roughness
+ * @param deep
+ */
+declare const setMaterialRoughness: (node: TransformNode, roughness: number, deep?: boolean) => void;
+/**
+ * @param node
+ * @param layer
+ * @param color
+ * @param deep
+ */
+declare const addToHighlightLayer: (layer: HighlightLayer, color: Color3, node: TransformNode, deep?: boolean) => void;
+/**
+ * @param node
+ * @param layer
+ * @param deep
+ */
+declare const removeFromHighlightLayer: (layer: HighlightLayer, node: TransformNode, deep?: boolean) => void;
+/**
+ * @param node
+ * @param receiveShadows
+ * @param deep
+ */
+declare const setReceiveShadows: (node: TransformNode, receiveShadows: boolean, deep?: boolean) => void;
+/**
+ * @param node
+ * @param generator
+ * @param deep
+ */
+declare const addToShadowGenerator: (generator: ShadowGenerator, node: TransformNode, deep?: boolean) => void;
+/**
+ * @param node
+ * @param generator
+ * @param deep
+ */
+declare const removeFromShadowGenerator: (generator: ShadowGenerator, node: TransformNode, deep?: boolean) => void;
+/**
+ * https://forum.babylonjs.com/t/get-mesh-bounding-box-position-and-size-in-2d-screen-coordinates/1058/3
+ * @param mesh
+ * @param scene
+ * @param canvas
+ */
+declare const getClientRectFromMesh: (mesh: AbstractMesh, scene: Scene, canvas: HTMLCanvasElement) => ClientRect;
+declare type BaseTextureWithOnLoadObservable = BaseTexture & {
+    onLoadObservable: Observable<BaseTexture>;
+};
+/**
+ * This type guard checks whether the given `BaseTextures` is any of its subtypes which comes with an
+ * `onLoadObservable`.
+ *
+ * !!! Timing of when this function is called is important !!!
+ * See the following for more details: https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/6
+ */
+declare const isTextureWithOnLoadObservable: (texture: BaseTexture) => texture is BaseTextureWithOnLoadObservable;
+/**
+ * @param objects
+ * @param tagMapping
+ */
+declare const mapTags: (objects: object[], tagMapping: TagMapping) => string[];
+/**
+ * Gets an array of ids for nodeIds that exist in both TransformNode arrays.
+ * @param nodes1
+ * @param nodes2
+ * @param predicate
+ */
+declare const intersectingNodeNames: (nodes1: Node[], nodes2: Node[], predicate?: ((node: Node) => boolean) | undefined) => string[];
+/**
+ * Gets an array of ids for duplicate nodeIds in given node array.
+ * @param nodes
+ * @param predicate
+ */
+declare const duplicateNodeNames: (nodes: Node[], predicate?: ((node: Node) => boolean) | undefined) => string[];
+/**
+ * Reports duplicate nodeIds.
+ * @param nodeNames
+ */
+declare const reportDuplicateNodeNames: (nodeNames: string[]) => void;
+export { getRootNode, isTextureWithOnLoadObservable, mapToDottedNodes, getDottedPathForNode, cloneTransformNode, cloneNodeWithParents, cloneTransformNodeMaterial, getOrCreateMaterial, applyMaterial, injectNodeMetadata, assertTransformNode, assertMeshCapability, activateTransformNode, deactivateTransformNode, enableNodeWithParents, disableNodeWithParents, transformTransformNode, setMaterial, setSourceNodeMaterial, setMaterialColor, setMaterialTexture, setMaterialMetallness, setMaterialRoughness, addToHighlightLayer, removeFromHighlightLayer, setReceiveShadows, addToShadowGenerator, removeFromShadowGenerator, getClientRectFromMesh, changeEnvironment, backgroundDomeName, envHelperMetadataName, mapTags, intersectingNodeNames, duplicateNodeNames, reportDuplicateNodeNames, };