@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/XR/webXRSessionManager.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Manages an XRSession to work with Babylon's engine
+ * @see https://doc.babylonjs.com/how_to/webxr_session_manager
+ */
+export class WebXRSessionManager {
+    /**
+     * Returns a promise that resolves with a boolean indicating if the provided session mode is supported by this browser
+     * @param sessionMode defines the session to test
+     * @returns a promise with boolean as final value
+     */
+    static IsSessionSupportedAsync(sessionMode: any): any;
+    /**
+     * Constructs a WebXRSessionManager, this must be initialized within a user action before usage
+     * @param scene The scene which the session should be created for
+     */
+    constructor(scene: any);
+    scene: any;
+    /** WebXR timestamp updated every frame */
+    currentTimestamp: number;
+    /**
+     * Used just in case of a failure to initialize an immersive session.
+     * The viewer reference space is compensated using this height, creating a kind of "viewer-floor" reference space
+     */
+    defaultHeightCompensation: number;
+    /**
+     * Fires every time a new xrFrame arrives which can be used to update the camera
+     */
+    onXRFrameObservable: Observable<any>;
+    /**
+     * Fires when the reference space changed
+     */
+    onXRReferenceSpaceChanged: Observable<any>;
+    /**
+     * Fires when the xr session is ended either by the device or manually done
+     */
+    onXRSessionEnded: Observable<any>;
+    /**
+     * Fires when the xr session is initialized: right after requestSession was called and returned with a successful result
+     */
+    onXRSessionInit: Observable<any>;
+    /**
+     * Are we currently in the XR loop?
+     */
+    inXRFrameLoop: boolean;
+    /**
+     * Are we in an XR session?
+     */
+    inXRSession: boolean;
+    _engine: any;
+    _onEngineDisposedObserver: any;
+    /**
+     * Set a new reference space and triggers the observable
+     */
+    set referenceSpace(arg: any);
+    /**
+     * The current reference space used in this session. This reference space can constantly change!
+     * It is mainly used to offset the camera's position.
+     */
+    get referenceSpace(): any;
+    _referenceSpace: any;
+    /**
+     * The mode for the managed XR session
+     */
+    get sessionMode(): string | undefined;
+    /**
+     * Disposes of the session manager
+     * This should be called explicitly by the dev, if required.
+     */
+    dispose(): void;
+    /**
+     * Stops the xrSession and restores the render loop
+     * @returns Promise which resolves after it exits XR
+     */
+    exitXRAsync(): any;
+    /**
+     * Attempts to set the framebuffer-size-normalized viewport to be rendered this frame for this view.
+     * In the event of a failure, the supplied viewport is not updated.
+     * @param viewport the viewport to which the view will be rendered
+     * @param view the view for which to set the viewport
+     * @returns whether the operation was successful
+     */
+    trySetViewportForView(viewport: any, view: any): any;
+    /**
+     * Gets the correct render target texture to be rendered this frame for this eye
+     * @param eye the eye for which to get the render target
+     * @returns the render target for the specified eye or null if not available
+     */
+    getRenderTargetTextureForEye(eye: any): any;
+    /**
+     * Gets the correct render target texture to be rendered this frame for this view
+     * @param view the view for which to get the render target
+     * @returns the render target for the specified view or null if not available
+     */
+    getRenderTargetTextureForView(view: any): any;
+    /**
+     * Creates a WebXRRenderTarget object for the XR session
+     * @param options optional options to provide when creating a new render target
+     * @returns a WebXR render target to which the session can render
+     */
+    getWebXRRenderTarget(options: any): NativeXRRenderTarget | WebXRManagedOutputCanvas;
+    /**
+     * Initializes the manager
+     * After initialization enterXR can be called to start an XR session
+     * @returns Promise which resolves after it is initialized
+     */
+    initializeAsync(): Promise<void>;
+    _xrNavigator: Navigator | undefined;
+    /**
+     * Initializes an xr session
+     * @param xrSessionMode mode to initialize
+     * @param xrSessionInit defines optional and required values to pass to the session builder
+     * @returns a promise which will resolve once the session has been initialized
+     */
+    initializeSessionAsync(xrSessionMode?: string, xrSessionInit?: {}): any;
+    session: any;
+    _sessionMode: string | undefined;
+    _baseLayerRTTProvider: any;
+    _baseLayerWrapper: any;
+    /**
+     * Checks if a session would be supported for the creation options specified
+     * @param sessionMode session mode to check if supported eg. immersive-vr
+     * @returns A Promise that resolves to true if supported and false if not
+     */
+    isSessionSupportedAsync(sessionMode: any): any;
+    /**
+     * Resets the reference space to the one started the session
+     */
+    resetReferenceSpace(): void;
+    /**
+     * Starts rendering to the xr layer
+     */
+    runXRRenderLoop(): void;
+    currentFrame: any;
+    /**
+     * Sets the reference space on the xr session
+     * @param referenceSpaceType space to set
+     * @returns a promise that will resolve once the reference space has been set
+     */
+    setReferenceSpaceTypeAsync(referenceSpaceType?: string): any;
+    viewerReferenceSpace: any;
+    baseReferenceSpace: any;
+    /**
+     * Updates the render state of the session.
+     * Note that this is deprecated in favor of WebXRSessionManager.updateRenderState().
+     * @param state state to set
+     * @returns a promise that resolves once the render state has been updated
+     * @deprecated
+     */
+    updateRenderStateAsync(state: any): Promise<any>;
+    /**
+     * @internal
+     */
+    _setBaseLayerWrapper(baseLayerWrapper: any): void;
+    /**
+     * Updates the render state of the session
+     * @param state state to set
+     */
+    updateRenderState(state: any): void;
+    /**
+     * Returns true if Babylon.js is using the BabylonNative backend, otherwise false
+     */
+    get isNative(): any;
+    /**
+     * The current frame rate as reported by the device
+     */
+    get currentFrameRate(): any;
+    /**
+     * A list of supported frame rates (only available in-session!
+     */
+    get supportedFrameRates(): any;
+    /**
+     * Set the framerate of the session.
+     * @param rate the new framerate. This value needs to be in the supportedFrameRates array
+     * @returns a promise that resolves once the framerate has been set
+     */
+    updateTargetFrameRate(rate: any): any;
+    /**
+     * Run a callback in the xr render loop
+     * @param callback the callback to call when in XR Frame
+     * @param ignoreIfNotInSession if no session is currently running, run it first thing on the next session
+     */
+    runInXRFrame(callback: any, ignoreIfNotInSession?: boolean): void;
+    /**
+     * Check if fixed foveation is supported on this device
+     */
+    get isFixedFoveationSupported(): any;
+    /**
+     * Set the fixed foveation to the specified value, as specified by the webxr specs
+     * This value will be normalized to be between 0 and 1, 1 being max foveation, 0 being no foveation
+     */
+    set fixedFoveation(arg: any);
+    /**
+     * Get the fixed foveation currently set, as specified by the webxr specs
+     * If this returns null, then fixed foveation is not supported
+     */
+    get fixedFoveation(): any;
+}
+import { Observable } from "../Misc/observable.js";
+import { NativeXRRenderTarget } from "./native/nativeXRRenderTarget.js";
+import { WebXRManagedOutputCanvas } from "./webXRManagedOutputCanvas.js";

package/dist/types/node_modules/@babylonjs/core/XR/webXRTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * States of the webXR experience
+ */
+export const WebXRState: any;
+/**
+ * The state of the XR camera's tracking
+ */
+export const WebXRTrackingState: any;

package/dist/types/node_modules/@babylonjs/core/XR/webXRWebGLLayer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Wraps xr webgl layers.
+ * @internal
+ */
+export class WebXRWebGLLayerWrapper extends WebXRLayerWrapper {
+    /**
+     * @param layer is the layer to be wrapped.
+     * @returns a new WebXRLayerWrapper wrapping the provided XRWebGLLayer.
+     */
+    constructor(layer: any);
+    layer: any;
+}
+/**
+ * Provides render target textures and other important rendering information for a given XRWebGLLayer.
+ * @internal
+ */
+export class WebXRWebGLLayerRenderTargetTextureProvider extends WebXRLayerRenderTargetTextureProvider {
+    constructor(scene: any, layerWrapper: any);
+    layerWrapper: any;
+    _layer: any;
+    _framebufferDimensions: {
+        framebufferWidth: any;
+        framebufferHeight: any;
+    };
+    trySetViewportForView(viewport: any, view: any): boolean;
+    getRenderTargetTextureForEye(eye: any): import("@babylonjs/core").RenderTargetTexture;
+    _rtt: import("@babylonjs/core").RenderTargetTexture | undefined;
+    _framebuffer: any;
+    getRenderTargetTextureForView(view: any): import("@babylonjs/core").RenderTargetTexture;
+}
+import { WebXRLayerWrapper } from "./webXRLayerWrapper.js";
+import { WebXRLayerRenderTargetTextureProvider } from "./webXRRenderTargetTextureProvider.js";

package/dist/types/node_modules/@babylonjs/core/abstractScene.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Base class of the scene acting as a container for the different elements composing a scene.
+ * This class is dynamically extended by the different components of the scene increasing
+ * flexibility and reducing coupling
+ */
+export class AbstractScene {
+    /**
+     * Adds a parser in the list of available ones
+     * @param name Defines the name of the parser
+     * @param parser Defines the parser to add
+     */
+    static AddParser(name: any, parser: any): void;
+    /**
+     * Gets a general parser from the list of available ones
+     * @param name Defines the name of the parser
+     * @returns the requested parser or null
+     */
+    static GetParser(name: any): any;
+    /**
+     * Adds n individual parser in the list of available ones
+     * @param name Defines the name of the parser
+     * @param parser Defines the parser to add
+     */
+    static AddIndividualParser(name: any, parser: any): void;
+    /**
+     * Gets an individual parser from the list of available ones
+     * @param name Defines the name of the parser
+     * @returns the requested parser or null
+     */
+    static GetIndividualParser(name: any): any;
+    /**
+     * Parser json data and populate both a scene and its associated container object
+     * @param jsonData Defines the data to parse
+     * @param scene Defines the scene to parse the data for
+     * @param container Defines the container attached to the parsing sequence
+     * @param rootUrl Defines the root url of the data
+     */
+    static Parse(jsonData: any, scene: any, container: any, rootUrl: any): void;
+    /**
+     * Gets the list of root nodes (ie. nodes with no parent)
+     */
+    rootNodes: any[];
+    /** All of the cameras added to this scene
+     * @see https://doc.babylonjs.com/babylon101/cameras
+     */
+    cameras: any[];
+    /**
+     * All of the lights added to this scene
+     * @see https://doc.babylonjs.com/babylon101/lights
+     */
+    lights: any[];
+    /**
+     * All of the (abstract) meshes added to this scene
+     */
+    meshes: any[];
+    /**
+     * The list of skeletons added to the scene
+     * @see https://doc.babylonjs.com/how_to/how_to_use_bones_and_skeletons
+     */
+    skeletons: any[];
+    /**
+     * All of the particle systems added to this scene
+     * @see https://doc.babylonjs.com/babylon101/particles
+     */
+    particleSystems: any[];
+    /**
+     * Gets a list of Animations associated with the scene
+     */
+    animations: any[];
+    /**
+     * All of the animation groups added to this scene
+     * @see https://doc.babylonjs.com/divingDeeper/animation/groupAnimations
+     */
+    animationGroups: any[];
+    /**
+     * All of the multi-materials added to this scene
+     * @see https://doc.babylonjs.com/how_to/multi_materials
+     */
+    multiMaterials: any[];
+    /**
+     * All of the materials added to this scene
+     * In the context of a Scene, it is not supposed to be modified manually.
+     * Any addition or removal should be done using the addMaterial and removeMaterial Scene methods.
+     * Note also that the order of the Material within the array is not significant and might change.
+     * @see https://doc.babylonjs.com/babylon101/materials
+     */
+    materials: any[];
+    /**
+     * The list of morph target managers added to the scene
+     * @see https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh
+     */
+    morphTargetManagers: any[];
+    /**
+     * The list of geometries used in the scene.
+     */
+    geometries: any[];
+    /**
+     * All of the transform nodes added to this scene
+     * In the context of a Scene, it is not supposed to be modified manually.
+     * Any addition or removal should be done using the addTransformNode and removeTransformNode Scene methods.
+     * Note also that the order of the TransformNode within the array is not significant and might change.
+     * @see https://doc.babylonjs.com/how_to/transformnode
+     */
+    transformNodes: any[];
+    /**
+     * ActionManagers available on the scene.
+     * @deprecated
+     */
+    actionManagers: any[];
+    /**
+     * Textures to keep.
+     */
+    textures: any[];
+    /** @internal */
+    _environmentTexture: any;
+    /**
+     * The list of postprocesses added to the scene
+     */
+    postProcesses: any[];
+    set environmentTexture(arg: any);
+    /**
+     * Texture used in all pbr material as the reflection texture.
+     * As in the majority of the scene they are the same (exception for multi room and so on),
+     * this is easier to reference from here than from all the materials.
+     */
+    get environmentTexture(): any;
+    /**
+     * @returns all meshes, lights, cameras, transformNodes and bones
+     */
+    getNodes(): any[];
+}
+export namespace AbstractScene {
+    const _BabylonFileParsers: {};
+    const _IndividualBabylonFileParsers: {};
+}

package/dist/types/node_modules/@babylonjs/core/assetContainer.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Set of assets to keep when moving a scene into an asset container.
+ */
+export class KeepAssets extends AbstractScene {
+}
+/**
+ * Class used to store the output of the AssetContainer.instantiateAllMeshesToScene function
+ */
+export class InstantiatedEntries {
+    /**
+     * List of new root nodes (eg. nodes with no parent)
+     */
+    rootNodes: any[];
+    /**
+     * List of new skeletons
+     */
+    skeletons: any[];
+    /**
+     * List of new animation groups
+     */
+    animationGroups: any[];
+}
+/**
+ * Container with a set of assets that can be added or removed from a scene.
+ */
+export class AssetContainer extends AbstractScene {
+    /**
+     * Instantiates an AssetContainer.
+     * @param scene The scene the AssetContainer belongs to.
+     */
+    constructor(scene: any);
+    _wasAddedToScene: boolean;
+    scene: any;
+    sounds: any[] | null;
+    effectLayers: any[];
+    layers: any[];
+    lensFlareSystems: any[];
+    proceduralTextures: any[];
+    reflectionProbes: any[];
+    _onContextRestoredObserver: any;
+    /**
+     * Instantiate or clone all meshes and add the new ones to the scene.
+     * Skeletons and animation groups will all be cloned
+     * @param nameFunction defines an optional function used to get new names for clones
+     * @param cloneMaterials defines an optional boolean that defines if materials must be cloned as well (false by default)
+     * @param options defines an optional list of options to control how to instantiate / clone models
+     * @param options.doNotInstantiate defines if the model must be instantiated or just cloned
+     * @param options.predicate defines a predicate used to filter whih mesh to instantiate/clone
+     * @returns a list of rootNodes, skeletons and animation groups that were duplicated
+     */
+    instantiateModelsToScene(nameFunction: any, cloneMaterials: boolean | undefined, options: any): InstantiatedEntries;
+    /**
+     * Adds all the assets from the container to the scene.
+     */
+    addAllToScene(): void;
+    /**
+     * Adds assets from the container to the scene.
+     * @param predicate defines a predicate used to select which entity will be added (can be null)
+     */
+    addToScene(predicate?: null): void;
+    /**
+     * Removes all the assets in the container from the scene
+     */
+    removeAllFromScene(): void;
+    /**
+     * Removes assets in the container from the scene
+     * @param predicate defines a predicate used to select which entity will be added (can be null)
+     */
+    removeFromScene(predicate?: null): void;
+    /**
+     * Disposes all the assets in the container
+     */
+    dispose(): void;
+    _moveAssets(sourceAssets: any, targetAssets: any, keepAssets: any): void;
+    /**
+     * Removes all the assets contained in the scene and adds them to the container.
+     * @param keepAssets Set of assets to keep in the scene. (default: empty)
+     */
+    moveAllFromScene(keepAssets: any): void;
+    /**
+     * Adds all meshes in the asset container to a root mesh that can be used to position all the contained meshes. The root mesh is then added to the front of the meshes in the assetContainer.
+     * @returns the root mesh
+     */
+    createRootMesh(): Mesh;
+    /**
+     * Merge animations (direct and animation groups) from this asset container into a scene
+     * @param scene is the instance of BABYLON.Scene to append to (default: last created scene)
+     * @param animatables set of animatables to retarget to a node from the scene
+     * @param targetConverter defines a function used to convert animation targets from the asset container to the scene (default: search node by name)
+     * @returns an array of the new AnimationGroup added to the scene (empty array if none)
+     */
+    mergeAnimationsTo(scene: import("@babylonjs/core").Nullable<import("@babylonjs/core").Scene> | undefined, animatables: any, targetConverter?: null): any[];
+}
+import { AbstractScene } from "./abstractScene.js";
+import { Mesh } from "./Meshes/mesh.js";

package/dist/types/node_modules/@babylonjs/core/index.d.ts

@@ -0,0 +1,45 @@
+export * from "./abstractScene.js";
+export * from "./Actions/index.js";
+export * from "./Animations/index.js";
+export * from "./assetContainer.js";
+export * from "./Audio/index.js";
+export * from "./BakedVertexAnimation/index.js";
+export * from "./Behaviors/index.js";
+export * from "./Bones/index.js";
+export * from "./Buffers/index.js";
+export * from "./Cameras/index.js";
+export * from "./Collisions/index.js";
+export * from "./Compute/index.js";
+export * from "./Culling/index.js";
+export * from "./Debug/index.js";
+export * from "./DeviceInput/index.js";
+export * from "./Engines/index.js";
+export * from "./Events/index.js";
+export * from "./Gamepads/index.js";
+export * from "./Gizmos/index.js";
+export * from "./Helpers/index.js";
+export * from "./Instrumentation/index.js";
+export * from "./Layers/index.js";
+export * from "./LensFlares/index.js";
+export * from "./Lights/index.js";
+export * from "./Loading/index.js";
+export * from "./Materials/index.js";
+export * from "./Maths/index.js";
+export * from "./Meshes/index.js";
+export * from "./Morph/index.js";
+export * from "./Navigation/index.js";
+export * from "./node.js";
+export * from "./Offline/index.js";
+export * from "./Particles/index.js";
+export * from "./Physics/index.js";
+export * from "./PostProcesses/index.js";
+export * from "./Probes/index.js";
+export * from "./Rendering/index.js";
+export * from "./scene.js";
+export * from "./sceneComponent.js";
+export * from "./Sprites/index.js";
+export * from "./States/index.js";
+export * from "./Misc/index.js";
+export * from "./XR/index.js";
+export * from "./types.js";
+export * from "./Compat/index.js";