@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Morph/morphTargetManager.d.ts

@@ -0,0 +1,155 @@
+/**
+ * This class is used to deform meshes using morphing between different targets
+ * @see https://doc.babylonjs.com/how_to/how_to_use_morphtargets
+ */
+export class MorphTargetManager {
+    /**
+     * Creates a new MorphTargetManager from serialized data
+     * @param serializationObject defines the serialized data
+     * @param scene defines the hosting scene
+     * @returns the new MorphTargetManager
+     */
+    static Parse(serializationObject: any, scene: any): MorphTargetManager;
+    /**
+     * Creates a new MorphTargetManager
+     * @param scene defines the current scene
+     */
+    constructor(scene?: null);
+    _targets: any[];
+    _targetInfluenceChangedObservers: any[];
+    _targetDataLayoutChangedObservers: any[];
+    _activeTargets: SmartArray<any>;
+    _supportsNormals: boolean;
+    _supportsTangents: boolean;
+    _supportsUVs: boolean;
+    _vertexCount: number;
+    _textureVertexStride: number;
+    _textureWidth: number;
+    _textureHeight: number;
+    _uniqueId: any;
+    _tempInfluences: any[];
+    _canUseTextureForTargets: any;
+    _blockCounter: number;
+    /** @internal */
+    _parentContainer: any;
+    /**
+     * Gets or sets a boolean indicating if influencers must be optimized (eg. recompiling the shader if less influencers are used)
+     */
+    optimizeInfluencers: boolean;
+    /**
+     * Gets or sets a boolean indicating if normals must be morphed
+     */
+    enableNormalMorphing: boolean;
+    /**
+     * Gets or sets a boolean indicating if tangents must be morphed
+     */
+    enableTangentMorphing: boolean;
+    /**
+     * Gets or sets a boolean indicating if UV must be morphed
+     */
+    enableUVMorphing: boolean;
+    _useTextureToStoreTargets: boolean;
+    _scene: any;
+    /**
+     * Sets a boolean indicating that adding new target or updating an existing target will not update the underlying data buffers
+     */
+    set areUpdatesFrozen(arg: boolean);
+    get areUpdatesFrozen(): boolean;
+    /**
+     * Gets the unique ID of this manager
+     */
+    get uniqueId(): any;
+    /**
+     * Gets the number of vertices handled by this manager
+     */
+    get vertexCount(): number;
+    /**
+     * Gets a boolean indicating if this manager supports morphing of normals
+     */
+    get supportsNormals(): boolean;
+    /**
+     * Gets a boolean indicating if this manager supports morphing of tangents
+     */
+    get supportsTangents(): boolean;
+    /**
+     * Gets a boolean indicating if this manager supports morphing of texture coordinates
+     */
+    get supportsUVs(): boolean;
+    /**
+     * Gets the number of targets stored in this manager
+     */
+    get numTargets(): number;
+    /**
+     * Gets the number of influencers (ie. the number of targets with influences > 0)
+     */
+    get numInfluencers(): number;
+    /**
+     * Gets the list of influences (one per target)
+     */
+    get influences(): any;
+    set useTextureToStoreTargets(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating that targets should be stored as a texture instead of using vertex attributes (default is true).
+     * Please note that this option is not available if the hardware does not support it
+     */
+    get useTextureToStoreTargets(): boolean;
+    /**
+     * Gets a boolean indicating that the targets are stored into a texture (instead of as attributes)
+     */
+    get isUsingTextureForTargets(): any;
+    /**
+     * Gets the active target at specified index. An active target is a target with an influence > 0
+     * @param index defines the index to check
+     * @returns the requested target
+     */
+    getActiveTarget(index: any): any;
+    /**
+     * Gets the target at specified index
+     * @param index defines the index to check
+     * @returns the requested target
+     */
+    getTarget(index: any): any;
+    /**
+     * Add a new target to this manager
+     * @param target defines the target to add
+     */
+    addTarget(target: any): void;
+    /**
+     * Removes a target from the manager
+     * @param target defines the target to remove
+     */
+    removeTarget(target: any): void;
+    /**
+     * @internal
+     */
+    _bind(effect: any): void;
+    /**
+     * Clone the current manager
+     * @returns a new MorphTargetManager
+     */
+    clone(): MorphTargetManager;
+    /**
+     * Serializes the current manager into a Serialization object
+     * @returns the serialized object
+     */
+    serialize(): {
+        id: any;
+        targets: any[];
+    };
+    _syncActiveTargets(needUpdate: any): void;
+    _morphTargetTextureIndices: Float32Array | undefined;
+    _influences: any;
+    /**
+     * Synchronize the targets with all the meshes using this morph target manager
+     */
+    synchronize(): void;
+    _targetStoreTexture: any;
+    /**
+     * Release all resources
+     */
+    dispose(): void;
+}
+export namespace MorphTargetManager {
+    const EnableTextureStorage: boolean;
+}
+import { SmartArray } from "../Misc/smartArray.js";

package/dist/types/node_modules/@babylonjs/core/Navigation/INavigationEngine.d.ts

@@ -0,0 +1 @@
+export {};

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

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

package/dist/types/node_modules/@babylonjs/core/Navigation/Plugins/recastJSPlugin.d.ts

@@ -0,0 +1,359 @@
+/**
+ * RecastJS navigation plugin
+ */
+export class RecastJSPlugin {
+    /**
+     * Initializes the recastJS plugin
+     * @param recastInjection can be used to inject your own recast reference
+     */
+    constructor(recastInjection?: any);
+    /**
+     * Reference to the Recast library
+     */
+    bjsRECAST: any;
+    /**
+     * plugin name
+     */
+    name: string;
+    _maximumSubStepCount: number;
+    _timeStep: number;
+    _timeFactor: number;
+    _worker: Worker | null;
+    _tempVec1: any;
+    _tempVec2: any;
+    /**
+     * Set worker URL to be used when generating a new navmesh
+     * @param workerURL url string
+     * @returns boolean indicating if worker is created
+     */
+    setWorkerURL(workerURL: any): boolean;
+    /**
+     * Set the time step of the navigation tick update.
+     * Default is 1/60.
+     * A value of 0 will disable fixed time update
+     * @param newTimeStep the new timestep to apply to this world.
+     */
+    setTimeStep(newTimeStep?: number): void;
+    /**
+     * Get the time step of the navigation tick update.
+     * @returns the current time step
+     */
+    getTimeStep(): number;
+    /**
+     * If delta time in navigation tick update is greater than the time step
+     * a number of sub iterations are done. If more iterations are need to reach deltatime
+     * they will be discarded.
+     * A value of 0 will set to no maximum and update will use as many substeps as needed
+     * @param newStepCount the maximum number of iterations
+     */
+    setMaximumSubStepCount(newStepCount?: number): void;
+    /**
+     * Get the maximum number of iterations per navigation tick update
+     * @returns the maximum number of iterations
+     */
+    getMaximumSubStepCount(): number;
+    /**
+     * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
+     * @param value the time factor applied at update
+     */
+    set timeFactor(arg: number);
+    /**
+     * Get the time factor used for crowd agent update
+     * @returns the time factor
+     */
+    get timeFactor(): number;
+    /**
+     * Creates a navigation mesh
+     * @param meshes array of all the geometry used to compute the navigation mesh
+     * @param parameters bunch of parameters used to filter geometry
+     * @param completion callback when data is available from the worker. Not used without a worker
+     */
+    createNavMesh(meshes: any, parameters: any, completion: any): void;
+    navMesh: any;
+    /**
+     * Create a navigation mesh debug mesh
+     * @param scene is where the mesh will be added
+     * @returns debug display mesh
+     */
+    createDebugNavMesh(scene: any): Mesh;
+    /**
+     * Get a navigation mesh constrained position, closest to the parameter position
+     * @param position world position
+     * @returns the closest point to position constrained by the navigation mesh
+     */
+    getClosestPoint(position: any): Vector3;
+    /**
+     * Get a navigation mesh constrained position, closest to the parameter position
+     * @param position world position
+     * @param result output the closest point to position constrained by the navigation mesh
+     */
+    getClosestPointToRef(position: any, result: any): void;
+    /**
+     * Get a navigation mesh constrained position, within a particular radius
+     * @param position world position
+     * @param maxRadius the maximum distance to the constrained world position
+     * @returns the closest point to position constrained by the navigation mesh
+     */
+    getRandomPointAround(position: any, maxRadius: any): Vector3;
+    /**
+     * Get a navigation mesh constrained position, within a particular radius
+     * @param position world position
+     * @param maxRadius the maximum distance to the constrained world position
+     * @param result output the closest point to position constrained by the navigation mesh
+     */
+    getRandomPointAroundToRef(position: any, maxRadius: any, result: any): void;
+    /**
+     * Compute the final position from a segment made of destination-position
+     * @param position world position
+     * @param destination world position
+     * @returns the resulting point along the navmesh
+     */
+    moveAlong(position: any, destination: any): Vector3;
+    /**
+     * Compute the final position from a segment made of destination-position
+     * @param position world position
+     * @param destination world position
+     * @param result output the resulting point along the navmesh
+     */
+    moveAlongToRef(position: any, destination: any, result: any): void;
+    /**
+     * Compute a navigation path from start to end. Returns an empty array if no path can be computed
+     * @param start world position
+     * @param end world position
+     * @returns array containing world position composing the path
+     */
+    computePath(start: any, end: any): Vector3[];
+    /**
+     * Create a new Crowd so you can add agents
+     * @param maxAgents the maximum agent count in the crowd
+     * @param maxAgentRadius the maximum radius an agent can have
+     * @param scene to attach the crowd to
+     * @returns the crowd you can add agents to
+     */
+    createCrowd(maxAgents: any, maxAgentRadius: any, scene: any): RecastJSCrowd;
+    /**
+     * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+     * The queries will try to find a solution within those bounds
+     * default is (1,1,1)
+     * @param extent x,y,z value that define the extent around the queries point of reference
+     */
+    setDefaultQueryExtent(extent: any): void;
+    /**
+     * Get the Bounding box extent specified by setDefaultQueryExtent
+     * @returns the box extent values
+     */
+    getDefaultQueryExtent(): Vector3;
+    /**
+     * build the navmesh from a previously saved state using getNavmeshData
+     * @param data the Uint8Array returned by getNavmeshData
+     */
+    buildFromNavmeshData(data: any): void;
+    /**
+     * returns the navmesh data that can be used later. The navmesh must be built before retrieving the data
+     * @returns data the Uint8Array that can be saved and reused
+     */
+    getNavmeshData(): Uint8Array;
+    /**
+     * Get the Bounding box extent result specified by setDefaultQueryExtent
+     * @param result output the box extent values
+     */
+    getDefaultQueryExtentToRef(result: any): void;
+    /**
+     * Disposes
+     */
+    dispose(): void;
+    /**
+     * Creates a cylinder obstacle and add it to the navigation
+     * @param position world position
+     * @param radius cylinder radius
+     * @param height cylinder height
+     * @returns the obstacle freshly created
+     */
+    addCylinderObstacle(position: any, radius: any, height: any): any;
+    /**
+     * Creates an oriented box obstacle and add it to the navigation
+     * @param position world position
+     * @param extent box size
+     * @param angle angle in radians of the box orientation on Y axis
+     * @returns the obstacle freshly created
+     */
+    addBoxObstacle(position: any, extent: any, angle: any): any;
+    /**
+     * Removes an obstacle created by addCylinderObstacle or addBoxObstacle
+     * @param obstacle obstacle to remove from the navigation
+     */
+    removeObstacle(obstacle: any): void;
+    /**
+     * If this plugin is supported
+     * @returns true if plugin is supported
+     */
+    isSupported(): boolean;
+}
+/**
+ * Recast detour crowd implementation
+ */
+export class RecastJSCrowd {
+    /**
+     * Constructor
+     * @param plugin recastJS plugin
+     * @param maxAgents the maximum agent count in the crowd
+     * @param maxAgentRadius the maximum radius an agent can have
+     * @param scene to attach the crowd to
+     * @returns the crowd you can add agents to
+     */
+    constructor(plugin: any, maxAgents: any, maxAgentRadius: any, scene: any);
+    /**
+     * Link to the detour crowd
+     */
+    recastCrowd: any;
+    /**
+     * One transform per agent
+     */
+    transforms: any[];
+    /**
+     * All agents created
+     */
+    agents: any[];
+    /**
+     * agents reach radius
+     */
+    reachRadii: any[];
+    /**
+     * true when a destination is active for an agent and notifier hasn't been notified of reach
+     */
+    _agentDestinationArmed: any[];
+    /**
+     * agent current target
+     */
+    _agentDestination: any[];
+    /**
+     * Observer for crowd updates
+     */
+    _onBeforeAnimationsObserver: any;
+    /**
+     * Fires each time an agent is in reach radius of its destination
+     */
+    onReachTargetObservable: Observable<any>;
+    bjsRECASTPlugin: any;
+    _scene: any;
+    /**
+     * Add a new agent to the crowd with the specified parameter a corresponding transformNode.
+     * You can attach anything to that node. The node position is updated in the scene update tick.
+     * @param pos world position that will be constrained by the navigation mesh
+     * @param parameters agent parameters
+     * @param transform hooked to the agent that will be update by the scene
+     * @returns agent index
+     */
+    addAgent(pos: any, parameters: any, transform: any): any;
+    /**
+     * Returns the agent position in world space
+     * @param index agent index returned by addAgent
+     * @returns world space position
+     */
+    getAgentPosition(index: any): Vector3;
+    /**
+     * Returns the agent position result in world space
+     * @param index agent index returned by addAgent
+     * @param result output world space position
+     */
+    getAgentPositionToRef(index: any, result: any): void;
+    /**
+     * Returns the agent velocity in world space
+     * @param index agent index returned by addAgent
+     * @returns world space velocity
+     */
+    getAgentVelocity(index: any): Vector3;
+    /**
+     * Returns the agent velocity result in world space
+     * @param index agent index returned by addAgent
+     * @param result output world space velocity
+     */
+    getAgentVelocityToRef(index: any, result: any): void;
+    /**
+     * Returns the agent next target point on the path
+     * @param index agent index returned by addAgent
+     * @returns world space position
+     */
+    getAgentNextTargetPath(index: any): Vector3;
+    /**
+     * Returns the agent next target point on the path
+     * @param index agent index returned by addAgent
+     * @param result output world space position
+     */
+    getAgentNextTargetPathToRef(index: any, result: any): void;
+    /**
+     * Gets the agent state
+     * @param index agent index returned by addAgent
+     * @returns agent state
+     */
+    getAgentState(index: any): any;
+    /**
+     * returns true if the agent in over an off mesh link connection
+     * @param index agent index returned by addAgent
+     * @returns true if over an off mesh link connection
+     */
+    overOffmeshConnection(index: any): any;
+    /**
+     * Asks a particular agent to go to a destination. That destination is constrained by the navigation mesh
+     * @param index agent index returned by addAgent
+     * @param destination targeted world position
+     */
+    agentGoto(index: any, destination: any): void;
+    /**
+     * Teleport the agent to a new position
+     * @param index agent index returned by addAgent
+     * @param destination targeted world position
+     */
+    agentTeleport(index: any, destination: any): void;
+    /**
+     * Update agent parameters
+     * @param index agent index returned by addAgent
+     * @param parameters agent parameters
+     */
+    updateAgentParameters(index: any, parameters: any): void;
+    /**
+     * remove a particular agent previously created
+     * @param index agent index returned by addAgent
+     */
+    removeAgent(index: any): void;
+    /**
+     * get the list of all agents attached to this crowd
+     * @returns list of agent indices
+     */
+    getAgents(): any[];
+    /**
+     * Tick update done by the Scene. Agent position/velocity/acceleration is updated by this function
+     * @param deltaTime in seconds
+     */
+    update(deltaTime: any): void;
+    /**
+     * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+     * The queries will try to find a solution within those bounds
+     * default is (1,1,1)
+     * @param extent x,y,z value that define the extent around the queries point of reference
+     */
+    setDefaultQueryExtent(extent: any): void;
+    /**
+     * Get the Bounding box extent specified by setDefaultQueryExtent
+     * @returns the box extent values
+     */
+    getDefaultQueryExtent(): Vector3;
+    /**
+     * Get the Bounding box extent result specified by setDefaultQueryExtent
+     * @param result output the box extent values
+     */
+    getDefaultQueryExtentToRef(result: any): void;
+    /**
+     * Get the next corner points composing the path (max 4 points)
+     * @param index agent index returned by addAgent
+     * @returns array containing world position composing the path
+     */
+    getCorners(index: any): Vector3[];
+    /**
+     * Release all resources
+     */
+    dispose(): void;
+}
+import { Mesh } from "../../Meshes/mesh.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Observable } from "../../Misc/observable.js";

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

@@ -0,0 +1,2 @@
+export * from "./INavigationEngine.js";
+export * from "./Plugins/index.js";

package/dist/types/node_modules/@babylonjs/core/Offline/IOfflineProvider.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/node_modules/@babylonjs/core/Offline/database.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Class used to enable access to IndexedDB
+ * @see https://doc.babylonjs.com/how_to/caching_resources_in_indexeddb
+ */
+export class Database {
+    /**
+     * Validates if xhr data is correct
+     * @param xhr defines the request to validate
+     * @param dataType defines the expected data type
+     * @returns true if data is correct
+     */
+    static _ValidateXHRData(xhr: any, dataType?: number): boolean;
+    /**
+     * Creates a new Database
+     * @param urlToScene defines the url to load the scene
+     * @param callbackManifestChecked defines the callback to use when manifest is checked
+     * @param disableManifestCheck defines a boolean indicating that we want to skip the manifest validation (it will be considered validated and up to date)
+     */
+    constructor(urlToScene: any, callbackManifestChecked: any, disableManifestCheck?: boolean);
+    _idbFactory: IDBFactory | undefined;
+    _currentSceneUrl: any;
+    _db: any;
+    _enableSceneOffline: boolean;
+    _enableTexturesOffline: boolean;
+    _manifestVersionFound: number;
+    _mustUpdateRessources: boolean;
+    _hasReachedQuota: boolean;
+    /**
+     * Gets a boolean indicating if scene must be saved in the database
+     */
+    get enableSceneOffline(): boolean;
+    /**
+     * Gets a boolean indicating if textures must be saved in the database
+     */
+    get enableTexturesOffline(): boolean;
+    _checkManifestFile(callbackManifestChecked: any): void;
+    /**
+     * Open the database and make it available
+     * @param successCallback defines the callback to call on success
+     * @param errorCallback defines the callback to call on error
+     */
+    open(successCallback: any, errorCallback: any): void;
+    _isSupported: boolean | undefined;
+    /**
+     * Loads an image from the database
+     * @param url defines the url to load from
+     * @param image defines the target DOM image
+     */
+    loadImage(url: any, image: any): void;
+    _loadImageFromDBAsync(url: any, image: any, notInDBCallback: any): void;
+    _saveImageIntoDBAsync(url: any, image: any): void;
+    _checkVersionFromDB(url: any, versionLoaded: any): void;
+    _loadVersionFromDBAsync(url: any, callback: any, updateInDBCallback: any): void;
+    _saveVersionIntoDBAsync(url: any, callback: any): void;
+    /**
+     * Loads a file from database
+     * @param url defines the URL to load from
+     * @param sceneLoaded defines a callback to call on success
+     * @param progressCallBack defines a callback to call when progress changed
+     * @param errorCallback defines a callback to call on error
+     * @param useArrayBuffer defines a boolean to use array buffer instead of text string
+     */
+    loadFile(url: any, sceneLoaded: any, progressCallBack: any, errorCallback: any, useArrayBuffer: any): void;
+    _loadFileAsync(url: any, callback: any, notInDBCallback: any): void;
+    _saveFileAsync(url: any, callback: any, progressCallback: any, useArrayBuffer: any, errorCallback: any): void;
+}
+export namespace Database {
+    const _IsUASupportingBlobStorage: boolean;
+    const IDBStorageEnabled: boolean;
+    function _ParseURL(url: any): any;
+    function _ReturnFullUrlLocation(url: any): any;
+}

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

@@ -0,0 +1,2 @@
+export * from "./database.js";
+export * from "./IOfflineProvider.js";

package/dist/types/node_modules/@babylonjs/core/Particles/EmitterTypes/IParticleEmitterType.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/node_modules/@babylonjs/core/Particles/EmitterTypes/boxParticleEmitter.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Particle emitter emitting particles from the inside of a box.
+ * It emits the particles randomly between 2 given directions.
+ */
+export class BoxParticleEmitter {
+    /**
+     * Random direction of each particle after it has been emitted, between direction1 and direction2 vectors.
+     */
+    direction1: Vector3;
+    /**
+     * Random direction of each particle after it has been emitted, between direction1 and direction2 vectors.
+     */
+    direction2: Vector3;
+    /**
+     * Minimum box point around our emitter. Our emitter is the center of particles source, but if you want your particles to emit from more than one point, then you can tell it to do so.
+     */
+    minEmitBox: Vector3;
+    /**
+     * Maximum box point around our emitter. Our emitter is the center of particles source, but if you want your particles to emit from more than one point, then you can tell it to do so.
+     */
+    maxEmitBox: Vector3;
+    /**
+     * Called by the particle System when the direction is computed for the created particle.
+     * @param worldMatrix is the world matrix of the particle system
+     * @param directionToUpdate is the direction vector to update with the result
+     * @param particle is the particle we are computed the direction for
+     * @param isLocal defines if the direction should be set in local space
+     */
+    startDirectionFunction(worldMatrix: any, directionToUpdate: any, particle: any, isLocal: any): void;
+    /**
+     * Called by the particle System when the position is computed for the created particle.
+     * @param worldMatrix is the world matrix of the particle system
+     * @param positionToUpdate is the position vector to update with the result
+     * @param particle is the particle we are computed the position for
+     * @param isLocal defines if the position should be set in local space
+     */
+    startPositionFunction(worldMatrix: any, positionToUpdate: any, particle: any, isLocal: any): void;
+    /**
+     * Clones the current emitter and returns a copy of it
+     * @returns the new emitter
+     */
+    clone(): BoxParticleEmitter;
+    /**
+     * Called by the GPUParticleSystem to setup the update shader
+     * @param uboOrEffect defines the update shader
+     */
+    applyToShader(uboOrEffect: any): void;
+    /**
+     * Creates the structure of the ubo for this particle emitter
+     * @param ubo ubo to create the structure for
+     */
+    buildUniformLayout(ubo: any): void;
+    /**
+     * Returns a string to use to update the GPU particles update shader
+     * @returns a string containing the defines string
+     */
+    getEffectDefines(): string;
+    /**
+     * Returns the string "BoxParticleEmitter"
+     * @returns a string containing the class name
+     */
+    getClassName(): string;
+    /**
+     * Serializes the particle system to a JSON object.
+     * @returns the JSON object
+     */
+    serialize(): {
+        type: string;
+        direction1: number[];
+        direction2: number[];
+        minEmitBox: number[];
+        maxEmitBox: number[];
+    };
+    /**
+     * Parse properties from a JSON object
+     * @param serializationObject defines the JSON object
+     */
+    parse(serializationObject: any): void;
+}
+import { Vector3 } from "../../Maths/math.vector.js";