@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Bones/skeleton.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Class used to handle skinning animations
+ * @see https://doc.babylonjs.com/how_to/how_to_use_bones_and_skeletons
+ */
+export class Skeleton {
+    /**
+     * Convert the keyframes for a range of animation on a skeleton to be relative to a given reference frame.
+     * @param skeleton defines the Skeleton containing the animation range to convert
+     * @param referenceFrame defines the frame that keyframes in the range will be relative to
+     * @param range defines the name of the AnimationRange belonging to the Skeleton to convert
+     * @returns the original skeleton
+     */
+    static MakeAnimationAdditive(skeleton: any, referenceFrame: number | undefined, range: any): any;
+    /**
+     * Creates a new skeleton from serialized data
+     * @param parsedSkeleton defines the serialized data
+     * @param scene defines the hosting scene
+     * @returns a new skeleton
+     */
+    static Parse(parsedSkeleton: any, scene: any): Skeleton;
+    /**
+     * Creates a new skeleton
+     * @param name defines the skeleton name
+     * @param id defines the skeleton Id
+     * @param scene defines the hosting scene
+     */
+    constructor(name: any, id: any, scene: any);
+    name: any;
+    id: any;
+    /**
+     * Defines the list of child bones
+     */
+    bones: any[];
+    /**
+     * Defines a boolean indicating if the root matrix is provided by meshes or by the current skeleton (this is the default value)
+     */
+    needInitialSkinMatrix: boolean;
+    _isDirty: boolean;
+    _meshesWithPoseMatrix: any[];
+    _identity: Matrix;
+    _ranges: {};
+    _absoluteTransformIsDirty: boolean;
+    _canUseTextureForBones: any;
+    _uniqueId: any;
+    /** @internal */
+    _numBonesWithLinkedTransformNode: number;
+    /** @internal */
+    _hasWaitingData: any;
+    /** @internal */
+    _parentContainer: any;
+    /**
+     * Specifies if the skeleton should be serialized
+     */
+    doNotSerialize: boolean;
+    _useTextureToStoreBoneMatrices: boolean;
+    _animationPropertiesOverride: any;
+    /**
+     * An observable triggered before computing the skeleton's matrices
+     */
+    onBeforeComputeObservable: Observable<any>;
+    _scene: any;
+    set useTextureToStoreBoneMatrices(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating that bone matrices should be stored as a texture instead of using shader uniforms (default is true).
+     * Please note that this option is not available if the hardware does not support it
+     */
+    get useTextureToStoreBoneMatrices(): boolean;
+    set animationPropertiesOverride(arg: any);
+    /**
+     * Gets or sets the animation properties override
+     */
+    get animationPropertiesOverride(): any;
+    /**
+     * Gets a boolean indicating that the skeleton effectively stores matrices into a texture
+     */
+    get isUsingTextureForMatrices(): any;
+    /**
+     * Gets the unique ID of this skeleton
+     */
+    get uniqueId(): any;
+    /**
+     * Gets the current object class name.
+     * @returns the class name
+     */
+    getClassName(): string;
+    /**
+     * Returns an array containing the root bones
+     * @returns an array containing the root bones
+     */
+    getChildren(): any[];
+    /**
+     * Gets the list of transform matrices to send to shaders (one matrix per bone)
+     * @param mesh defines the mesh to use to get the root matrix (if needInitialSkinMatrix === true)
+     * @returns a Float32Array containing matrices data
+     */
+    getTransformMatrices(mesh: any): any;
+    /**
+     * Gets the list of transform matrices to send to shaders inside a texture (one matrix per bone)
+     * @param mesh defines the mesh to use to get the root matrix (if needInitialSkinMatrix === true)
+     * @returns a raw texture containing the data
+     */
+    getTransformMatrixTexture(mesh: any): any;
+    /**
+     * Gets the current hosting scene
+     * @returns a scene object
+     */
+    getScene(): any;
+    /**
+     * Gets a string representing the current skeleton data
+     * @param fullDetails defines a boolean indicating if we want a verbose version
+     * @returns a string representing the current skeleton data
+     */
+    toString(fullDetails: any): string;
+    /**
+     * Get bone's index searching by name
+     * @param name defines bone's name to search for
+     * @returns the indice of the bone. Returns -1 if not found
+     */
+    getBoneIndexByName(name: any): number;
+    /**
+     * Create a new animation range
+     * @param name defines the name of the range
+     * @param from defines the start key
+     * @param to defines the end key
+     */
+    createAnimationRange(name: any, from: any, to: any): void;
+    /**
+     * Delete a specific animation range
+     * @param name defines the name of the range
+     * @param deleteFrames defines if frames must be removed as well
+     */
+    deleteAnimationRange(name: any, deleteFrames?: boolean): void;
+    /**
+     * Gets a specific animation range
+     * @param name defines the name of the range to look for
+     * @returns the requested animation range or null if not found
+     */
+    getAnimationRange(name: any): any;
+    /**
+     * Gets the list of all animation ranges defined on this skeleton
+     * @returns an array
+     */
+    getAnimationRanges(): any[];
+    /**
+     * Copy animation range from a source skeleton.
+     * This is not for a complete retargeting, only between very similar skeleton's with only possible bone length differences
+     * @param source defines the source skeleton
+     * @param name defines the name of the range to copy
+     * @param rescaleAsRequired defines if rescaling must be applied if required
+     * @returns true if operation was successful
+     */
+    copyAnimationRange(source: any, name: any, rescaleAsRequired?: boolean): boolean;
+    /**
+     * Forces the skeleton to go to rest pose
+     */
+    returnToRest(): void;
+    _getHighestAnimationFrame(): number;
+    /**
+     * Begin a specific animation range
+     * @param name defines the name of the range to start
+     * @param loop defines if looping must be turned on (false by default)
+     * @param speedRatio defines the speed ratio to apply (1 by default)
+     * @param onAnimationEnd defines a callback which will be called when animation will end
+     * @returns a new animatable
+     */
+    beginAnimation(name: any, loop: any, speedRatio: any, onAnimationEnd: any): any;
+    /** @internal */
+    _markAsDirty(): void;
+    /**
+     * @internal
+     */
+    _registerMeshWithPoseMatrix(mesh: any): void;
+    /**
+     * @internal
+     */
+    _unregisterMeshWithPoseMatrix(mesh: any): void;
+    _computeTransformMatrices(targetMatrix: any, initialSkinMatrix: any): void;
+    /**
+     * Build all resources required to render a skeleton
+     */
+    prepare(): void;
+    _synchronizedWithMesh: any;
+    _transformMatrices: Float32Array | undefined;
+    _transformMatrixTexture: RawTexture | null | undefined;
+    /**
+     * Gets the list of animatables currently running for this skeleton
+     * @returns an array of animatables
+     */
+    getAnimatables(): any[];
+    _animatables: any[] | undefined;
+    /**
+     * Clone the current skeleton
+     * @param name defines the name of the new skeleton
+     * @param id defines the id of the new skeleton
+     * @returns the new skeleton
+     */
+    clone(name: any, id: any): Skeleton;
+    /**
+     * Enable animation blending for this skeleton
+     * @param blendingSpeed defines the blending speed to apply
+     * @see https://doc.babylonjs.com/babylon101/animations#animation-blending
+     */
+    enableBlending(blendingSpeed?: number): void;
+    /**
+     * Releases all resources associated with the current skeleton
+     */
+    dispose(): void;
+    /**
+     * Serialize the skeleton in a JSON object
+     * @returns a JSON object
+     */
+    serialize(): {
+        name: any;
+        id: any;
+        dimensionsAtRest: any;
+        bones: any[];
+        needInitialSkinMatrix: boolean;
+        ranges: any[];
+    };
+    /**
+     * Compute all node absolute transforms
+     * @param forceUpdate defines if computation must be done even if cache is up to date
+     */
+    computeAbsoluteTransforms(forceUpdate?: boolean): void;
+    /**
+     * Gets the root pose matrix
+     * @returns a matrix
+     */
+    getPoseMatrix(): any;
+    /**
+     * Sorts bones per internal index
+     */
+    sortBones(): void;
+    _sortBones(index: any, bones: any, visited: any): void;
+    /**
+     * Set the current local matrix as the restPose for all bones in the skeleton.
+     */
+    setCurrentPoseAsRest(): void;
+}
+import { Matrix } from "../Maths/math.vector.js";
+import { Observable } from "../Misc/observable.js";
+import { RawTexture } from "../Materials/Textures/rawTexture.js";

package/dist/types/node_modules/@babylonjs/core/Buffers/buffer.d.ts

@@ -0,0 +1,265 @@
+/**
+ * Class used to store data that will be store in GPU memory
+ */
+export class Buffer {
+    /**
+     * Constructor
+     * @param engine the engine
+     * @param data the data to use for this buffer
+     * @param updatable whether the data is updatable
+     * @param stride the stride (optional)
+     * @param postponeInternalCreation whether to postpone creating the internal WebGL buffer (optional)
+     * @param instanced whether the buffer is instanced (optional)
+     * @param useBytes set to true if the stride in in bytes (optional)
+     * @param divisor sets an optional divisor for instances (1 by default)
+     */
+    constructor(engine: any, data: any, updatable: any, stride: number | undefined, postponeInternalCreation: boolean | undefined, instanced: boolean | undefined, useBytes: boolean | undefined, divisor: any);
+    _isAlreadyOwned: boolean;
+    _engine: any;
+    _updatable: any;
+    _instanced: boolean;
+    _divisor: any;
+    _data: any;
+    _buffer: DataBuffer | null;
+    byteStride: number;
+    /**
+     * Create a new VertexBuffer based on the current buffer
+     * @param kind defines the vertex buffer kind (position, normal, etc.)
+     * @param offset defines offset in the buffer (0 by default)
+     * @param size defines the size in floats of attributes (position is 3 for instance)
+     * @param stride defines the stride size in floats in the buffer (the offset to apply to reach next value when data is interleaved)
+     * @param instanced defines if the vertex buffer contains indexed data
+     * @param useBytes defines if the offset and stride are in bytes     *
+     * @param divisor sets an optional divisor for instances (1 by default)
+     * @returns the new vertex buffer
+     */
+    createVertexBuffer(kind: any, offset: any, size: any, stride: any, instanced: any, useBytes: boolean | undefined, divisor: any): VertexBuffer;
+    /**
+     * Gets a boolean indicating if the Buffer is updatable?
+     * @returns true if the buffer is updatable
+     */
+    isUpdatable(): any;
+    /**
+     * Gets current buffer's data
+     * @returns a DataArray or null
+     */
+    getData(): any;
+    /**
+     * Gets underlying native buffer
+     * @returns underlying native buffer
+     */
+    getBuffer(): DataBuffer | null;
+    /**
+     * Gets the stride in float32 units (i.e. byte stride / 4).
+     * May not be an integer if the byte stride is not divisible by 4.
+     * @returns the stride in float32 units
+     * @deprecated Please use byteStride instead.
+     */
+    getStrideSize(): number;
+    /**
+     * Store data into the buffer. Creates the buffer if not used already.
+     * If the buffer was already used, it will be updated only if it is updatable, otherwise it will do nothing.
+     * @param data defines the data to store
+     */
+    create(data?: null): void;
+    /** @internal */
+    _rebuild(): void;
+    /**
+     * Update current buffer data
+     * @param data defines the data to store
+     */
+    update(data: any): void;
+    /**
+     * Updates the data directly.
+     * @param data the new data
+     * @param offset the new offset
+     * @param vertexCount the vertex count (optional)
+     * @param useBytes set to true if the offset is in bytes
+     */
+    updateDirectly(data: any, offset: any, vertexCount: any, useBytes?: boolean): void;
+    /** @internal */
+    _increaseReferences(): void;
+    /**
+     * Release all resources
+     */
+    dispose(): void;
+}
+/**
+ * Specialized buffer used to store vertex data
+ */
+export class VertexBuffer {
+    /**
+     * Deduces the stride given a kind.
+     * @param kind The kind string to deduce
+     * @returns The deduced stride
+     */
+    static DeduceStride(kind: any): 4 | 2 | 3;
+    /**
+     * Gets the byte length of the given type.
+     * @param type the type
+     * @returns the number of bytes
+     */
+    static GetTypeByteLength(type: any): 1 | 4 | 2;
+    /**
+     * Enumerates each value of the given parameters as numbers.
+     * @param data the data to enumerate
+     * @param byteOffset the byte offset of the data
+     * @param byteStride the byte stride of the data
+     * @param componentCount the number of components per element
+     * @param componentType the type of the component
+     * @param count the number of values to enumerate
+     * @param normalized whether the data is normalized
+     * @param callback the callback function called for each value
+     */
+    static ForEach(data: any, byteOffset: any, byteStride: any, componentCount: any, componentType: any, count: any, normalized: any, callback: any): void;
+    static _GetFloatValue(dataView: any, type: any, byteOffset: any, normalized: any): any;
+    /**
+     * Constructor
+     * @param engine the engine
+     * @param data the data to use for this vertex buffer
+     * @param kind the vertex buffer kind
+     * @param updatable whether the data is updatable
+     * @param postponeInternalCreation whether to postpone creating the internal WebGL buffer (optional)
+     * @param stride the stride (optional)
+     * @param instanced whether the buffer is instanced (optional)
+     * @param offset the offset of the data (optional)
+     * @param size the number of components (optional)
+     * @param type the type of the component (optional)
+     * @param normalized whether the data contains normalized data (optional)
+     * @param useBytes set to true if stride and offset are in bytes (optional)
+     * @param divisor defines the instance divisor to use (1 by default)
+     * @param takeBufferOwnership defines if the buffer should be released when the vertex buffer is disposed
+     */
+    constructor(engine: any, data: any, kind: any, updatable: any, postponeInternalCreation: any, stride: any, instanced: any, offset: any, size: any, type: any, normalized?: boolean, useBytes?: boolean, divisor?: number, takeBufferOwnership?: boolean);
+    _buffer: Buffer;
+    _ownsBuffer: boolean;
+    uniqueId: number;
+    _kind: any;
+    type: any;
+    _size: any;
+    byteStride: any;
+    byteOffset: any;
+    normalized: boolean;
+    _instanced: any;
+    _instanceDivisor: number;
+    set instanceDivisor(arg: number);
+    /**
+     * Gets or sets the instance divisor when in instanced mode
+     */
+    get instanceDivisor(): number;
+    _computeHashCode(): void;
+    hashCode: number | undefined;
+    /** @internal */
+    _rebuild(): void;
+    /**
+     * Returns the kind of the VertexBuffer (string)
+     * @returns a string
+     */
+    getKind(): any;
+    /**
+     * Gets a boolean indicating if the VertexBuffer is updatable?
+     * @returns true if the buffer is updatable
+     */
+    isUpdatable(): any;
+    /**
+     * Gets current buffer's data
+     * @returns a DataArray or null
+     */
+    getData(): any;
+    /**
+     * Gets current buffer's data as a float array. Float data is constructed if the vertex buffer data cannot be returned directly.
+     * @param totalVertices number of vertices in the buffer to take into account
+     * @param forceCopy defines a boolean indicating that the returned array must be cloned upon returning it
+     * @returns a float array containing vertex data
+     */
+    getFloatData(totalVertices: any, forceCopy: any): any[] | Float32Array | null;
+    /**
+     * Gets underlying native buffer
+     * @returns underlying native buffer
+     */
+    getBuffer(): DataBuffer | null;
+    /**
+     * Gets the stride in float32 units (i.e. byte stride / 4).
+     * May not be an integer if the byte stride is not divisible by 4.
+     * @returns the stride in float32 units
+     * @deprecated Please use byteStride instead.
+     */
+    getStrideSize(): number;
+    /**
+     * Returns the offset as a multiple of the type byte length.
+     * @returns the offset in bytes
+     * @deprecated Please use byteOffset instead.
+     */
+    getOffset(): number;
+    /**
+     * Returns the number of components or the byte size per vertex attribute
+     * @param sizeInBytes If true, returns the size in bytes or else the size in number of components of the vertex attribute (default: false)
+     * @returns the number of components
+     */
+    getSize(sizeInBytes?: boolean): any;
+    /**
+     * Gets a boolean indicating is the internal buffer of the VertexBuffer is instanced
+     * @returns true if this buffer is instanced
+     */
+    getIsInstanced(): any;
+    /**
+     * Returns the instancing divisor, zero for non-instanced (integer).
+     * @returns a number
+     */
+    getInstanceDivisor(): number;
+    /**
+     * Store data into the buffer. If the buffer was already used it will be either recreated or updated depending on isUpdatable property
+     * @param data defines the data to store
+     */
+    create(data: any): void;
+    /**
+     * Updates the underlying buffer according to the passed numeric array or Float32Array.
+     * This function will create a new buffer if the current one is not updatable
+     * @param data defines the data to store
+     */
+    update(data: any): void;
+    /**
+     * Updates directly the underlying WebGLBuffer according to the passed numeric array or Float32Array.
+     * Returns the directly updated WebGLBuffer.
+     * @param data the new data
+     * @param offset the new offset
+     * @param useBytes set to true if the offset is in bytes
+     */
+    updateDirectly(data: any, offset: any, useBytes?: boolean): void;
+    /**
+     * Disposes the VertexBuffer and the underlying WebGLBuffer.
+     */
+    dispose(): void;
+    /**
+     * Enumerates each value of this vertex buffer as numbers.
+     * @param count the number of values to enumerate
+     * @param callback the callback function called for each value
+     */
+    forEach(count: any, callback: any): void;
+}
+export namespace VertexBuffer {
+    const _Counter: number;
+    const BYTE: number;
+    const UNSIGNED_BYTE: number;
+    const SHORT: number;
+    const UNSIGNED_SHORT: number;
+    const INT: number;
+    const UNSIGNED_INT: number;
+    const FLOAT: number;
+    const PositionKind: string;
+    const NormalKind: string;
+    const TangentKind: string;
+    const UVKind: string;
+    const UV2Kind: string;
+    const UV3Kind: string;
+    const UV4Kind: string;
+    const UV5Kind: string;
+    const UV6Kind: string;
+    const ColorKind: string;
+    const ColorInstanceKind: string;
+    const MatricesIndicesKind: string;
+    const MatricesWeightsKind: string;
+    const MatricesIndicesExtraKind: string;
+    const MatricesWeightsExtraKind: string;
+}
+import { DataBuffer } from "./dataBuffer.js";

package/dist/types/node_modules/@babylonjs/core/Buffers/dataBuffer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Class used to store gfx data (like WebGLBuffer)
+ */
+export class DataBuffer {
+    /**
+     * Gets or sets the number of objects referencing this buffer
+     */
+    references: number;
+    /** Gets or sets the size of the underlying buffer */
+    capacity: number;
+    /**
+     * Gets or sets a boolean indicating if the buffer contains 32bits indices
+     */
+    is32Bits: boolean;
+    uniqueId: number;
+    /**
+     * Gets the underlying buffer
+     */
+    get underlyingResource(): null;
+}
+export namespace DataBuffer {
+    const _Counter: number;
+}

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

@@ -0,0 +1,3 @@
+export * from "./buffer.js";
+export * from "./dataBuffer.js";
+export * from "./storageBuffer.js";

package/dist/types/node_modules/@babylonjs/core/Buffers/storageBuffer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This class is a small wrapper around a native buffer that can be read and/or written
+ */
+export class StorageBuffer {
+    /**
+     * Creates a new storage buffer instance
+     * @param engine The engine the buffer will be created inside
+     * @param size The size of the buffer in bytes
+     * @param creationFlags flags to use when creating the buffer (see undefined). The BUFFER_CREATIONFLAG_STORAGE flag will be automatically added.
+     */
+    constructor(engine: any, size: any, creationFlags?: number);
+    _engine: any;
+    _create(size: any, creationFlags: any): void;
+    _bufferSize: any;
+    _creationFlags: any;
+    _buffer: any;
+    /** @internal */
+    _rebuild(): void;
+    /**
+     * Gets underlying native buffer
+     * @returns underlying native buffer
+     */
+    getBuffer(): any;
+    /**
+     * Updates the storage buffer
+     * @param data the data used to update the storage buffer
+     * @param byteOffset the byte offset of the data (optional)
+     * @param byteLength the byte length of the data (optional)
+     */
+    update(data: any, byteOffset: any, byteLength: any): void;
+    /**
+     * Reads data from the storage buffer
+     * @param offset The offset in the storage buffer to start reading from (default: 0)
+     * @param size  The number of bytes to read from the storage buffer (default: capacity of the buffer)
+     * @param buffer The buffer to write the data we have read from the storage buffer to (optional)
+     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
+     */
+    read(offset: any, size: any, buffer: any): any;
+    /**
+     * Disposes the storage buffer
+     */
+    dispose(): void;
+}

package/dist/types/node_modules/@babylonjs/core/Cameras/Inputs/BaseCameraMouseWheelInput.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Base class for mouse wheel input..
+ * See FollowCameraMouseWheelInput in src/Cameras/Inputs/freeCameraMouseWheelInput.ts
+ * for example usage.
+ */
+export class BaseCameraMouseWheelInput {
+    /**
+     * How fast is the camera moves in relation to X axis mouseWheel events.
+     * Use negative value to reverse direction.
+     */
+    wheelPrecisionX: number;
+    /**
+     * How fast is the camera moves in relation to Y axis mouseWheel events.
+     * Use negative value to reverse direction.
+     */
+    wheelPrecisionY: number;
+    /**
+     * How fast is the camera moves in relation to Z axis mouseWheel events.
+     * Use negative value to reverse direction.
+     */
+    wheelPrecisionZ: number;
+    /**
+     * Observable for when a mouse wheel move event occurs.
+     */
+    onChangedObservable: Observable<any>;
+    /**
+     * Incremental value of multiple mouse wheel movements of the X axis.
+     * Should be zero-ed when read.
+     */
+    _wheelDeltaX: number;
+    /**
+     * Incremental value of multiple mouse wheel movements of the Y axis.
+     * Should be zero-ed when read.
+     */
+    _wheelDeltaY: number;
+    /**
+     * Incremental value of multiple mouse wheel movements of the Z axis.
+     * Should be zero-ed when read.
+     */
+    _wheelDeltaZ: number;
+    /**
+     * Firefox uses a different scheme to report scroll distances to other
+     * browsers. Rather than use complicated methods to calculate the exact
+     * multiple we need to apply, let's just cheat and use a constant.
+     * https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode
+     * https://stackoverflow.com/questions/20110224/what-is-the-height-of-a-line-in-a-wheel-event-deltamode-dom-delta-line
+     */
+    _ffMultiplier: number;
+    /**
+     * Different event attributes for wheel data fall into a few set ranges.
+     * Some relevant but dated date here:
+     * https://stackoverflow.com/questions/5527601/normalizing-mousewheel-speed-across-browsers
+     */
+    _normalize: number;
+    /**
+     * Attach the input controls to a specific dom element to get the input from.
+     * @param noPreventDefault Defines whether event caught by the controls
+     *   should call preventdefault().
+     *   (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+     */
+    attachControl(noPreventDefault: any, ...args: any[]): void;
+    _wheel: ((pointer: any) => void) | null | undefined;
+    _observer: any;
+    /**
+     * Detach the current controls from the specified dom element.
+     */
+    detachControl(): void;
+    /**
+     * Called for each rendered frame.
+     */
+    checkInputs(): void;
+    /**
+     * Gets the class name of the current input.
+     * @returns the class name
+     */
+    getClassName(): string;
+    /**
+     * Get the friendly name associated with the input class.
+     * @returns the input friendly name
+     */
+    getSimpleName(): string;
+}
+import { Observable } from "../../Misc/observable.js";