@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Culling/boundingSphere.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Class used to store bounding sphere information
+ */
+export class BoundingSphere {
+    /**
+     * Checks if two sphere intersect
+     * @param sphere0 sphere 0
+     * @param sphere1 sphere 1
+     * @returns true if the spheres intersect
+     */
+    static Intersects(sphere0: any, sphere1: any): boolean;
+    /**
+     * Creates a sphere from a center and a radius
+     * @param center The center
+     * @param radius radius
+     * @param matrix Optional worldMatrix
+     * @returns The sphere
+     */
+    static CreateFromCenterAndRadius(center: any, radius: any, matrix: any): BoundingSphere;
+    /**
+     * Creates a new bounding sphere
+     * @param min defines the minimum vector (in local space)
+     * @param max defines the maximum vector (in local space)
+     * @param worldMatrix defines the new world matrix
+     */
+    constructor(min: any, max: any, worldMatrix: any);
+    /**
+     * Gets the center of the bounding sphere in local space
+     */
+    center: Vector3;
+    /**
+     * Gets the center of the bounding sphere in world space
+     */
+    centerWorld: Vector3;
+    /**
+     * Gets the minimum vector in local space
+     */
+    minimum: Vector3;
+    /**
+     * Gets the maximum vector in local space
+     */
+    maximum: Vector3;
+    /**
+     * Recreates the entire bounding sphere from scratch as if we call the constructor in place
+     * @param min defines the new minimum vector (in local space)
+     * @param max defines the new maximum vector (in local space)
+     * @param worldMatrix defines the new world matrix
+     */
+    reConstruct(min: any, max: any, worldMatrix: any): void;
+    radius: number | undefined;
+    /**
+     * Scale the current bounding sphere by applying a scale factor
+     * @param factor defines the scale factor to apply
+     * @returns the current bounding box
+     */
+    scale(factor: any): BoundingSphere;
+    /**
+     * Gets the world matrix of the bounding box
+     * @returns a matrix
+     */
+    getWorldMatrix(): any;
+    /**
+     * @internal
+     */
+    _update(worldMatrix: any): void;
+    radiusWorld: number | undefined;
+    /**
+     * Tests if the bounding sphere is intersecting the frustum planes
+     * @param frustumPlanes defines the frustum planes to test
+     * @returns true if there is an intersection
+     */
+    isInFrustum(frustumPlanes: any): boolean;
+    /**
+     * Tests if the bounding sphere center is in between the frustum planes.
+     * Used for optimistic fast inclusion.
+     * @param frustumPlanes defines the frustum planes to test
+     * @returns true if the sphere center is in between the frustum planes
+     */
+    isCenterInFrustum(frustumPlanes: any): boolean;
+    /**
+     * Tests if a point is inside the bounding sphere
+     * @param point defines the point to test
+     * @returns true if the point is inside the bounding sphere
+     */
+    intersectsPoint(point: any): boolean;
+}
+export namespace BoundingSphere {
+    const _TmpVector3: Vector3[];
+}
+import { Vector3 } from "../Maths/math.vector.js";

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

@@ -0,0 +1,5 @@
+export * from "./boundingBox.js";
+export * from "./boundingInfo.js";
+export * from "./boundingSphere.js";
+export * from "./Octrees/index.js";
+export * from "./ray.js";

package/dist/types/node_modules/@babylonjs/core/Culling/ray.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Class representing a ray with position and direction
+ */
+export class Ray {
+    /**
+     * Creates a ray with origin and direction of 0,0,0
+     * @returns the new ray
+     */
+    static Zero(): Ray;
+    /**
+     * Creates a new ray from screen space and viewport
+     * @param x position
+     * @param y y position
+     * @param viewportWidth viewport width
+     * @param viewportHeight viewport height
+     * @param world world matrix
+     * @param view view matrix
+     * @param projection projection matrix
+     * @returns new ray
+     */
+    static CreateNew(x: any, y: any, viewportWidth: any, viewportHeight: any, world: any, view: any, projection: any): Ray;
+    /**
+     * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
+     * transformed to the given world matrix.
+     * @param origin The origin point
+     * @param end The end point
+     * @param world a matrix to transform the ray to. Default is the identity matrix.
+     * @returns the new ray
+     */
+    static CreateNewFromTo(origin: any, end: any, world?: import("@babylonjs/core").DeepImmutableObject<Matrix>): Ray;
+    /**
+     * Transforms a ray by a matrix
+     * @param ray ray to transform
+     * @param matrix matrix to apply
+     * @returns the resulting new ray
+     */
+    static Transform(ray: any, matrix: any): Ray;
+    /**
+     * Transforms a ray by a matrix
+     * @param ray ray to transform
+     * @param matrix matrix to apply
+     * @param result ray to store result in
+     */
+    static TransformToRef(ray: any, matrix: any, result: any): void;
+    /**
+     * Creates a new ray
+     * @param origin origin point
+     * @param direction direction
+     * @param length length of the ray
+     */
+    constructor(origin: any, direction: any, length?: number);
+    origin: any;
+    direction: any;
+    length: number;
+    /**
+     * Clone the current ray
+     * @returns a new ray
+     */
+    clone(): Ray;
+    /**
+     * Checks if the ray intersects a box
+     * This does not account for the ray length by design to improve perfs.
+     * @param minimum bound of the box
+     * @param maximum bound of the box
+     * @param intersectionTreshold extra extend to be added to the box in all direction
+     * @returns if the box was hit
+     */
+    intersectsBoxMinMax(minimum: any, maximum: any, intersectionTreshold?: number): boolean;
+    /**
+     * Checks if the ray intersects a box
+     * This does not account for the ray lenght by design to improve perfs.
+     * @param box the bounding box to check
+     * @param intersectionTreshold extra extend to be added to the BoundingBox in all direction
+     * @returns if the box was hit
+     */
+    intersectsBox(box: any, intersectionTreshold?: number): boolean;
+    /**
+     * If the ray hits a sphere
+     * @param sphere the bounding sphere to check
+     * @param intersectionTreshold extra extend to be added to the BoundingSphere in all direction
+     * @returns true if it hits the sphere
+     */
+    intersectsSphere(sphere: any, intersectionTreshold?: number): boolean;
+    /**
+     * If the ray hits a triange
+     * @param vertex0 triangle vertex
+     * @param vertex1 triangle vertex
+     * @param vertex2 triangle vertex
+     * @returns intersection information if hit
+     */
+    intersectsTriangle(vertex0: any, vertex1: any, vertex2: any): IntersectionInfo | null;
+    /**
+     * Checks if ray intersects a plane
+     * @param plane the plane to check
+     * @returns the distance away it was hit
+     */
+    intersectsPlane(plane: any): number | null;
+    /**
+     * Calculate the intercept of a ray on a given axis
+     * @param axis to check 'x' | 'y' | 'z'
+     * @param offset from axis interception (i.e. an offset of 1y is intercepted above ground)
+     * @returns a vector containing the coordinates where 'axis' is equal to zero (else offset), or null if there is no intercept.
+     */
+    intersectsAxis(axis: any, offset?: number): Vector3 | null;
+    /**
+     * Checks if ray intersects a mesh
+     * @param mesh the mesh to check
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @returns picking info of the intersection
+     */
+    intersectsMesh(mesh: any, fastCheck: any): any;
+    _tmpRay: Ray | undefined;
+    /**
+     * Checks if ray intersects a mesh
+     * @param meshes the meshes to check
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @param results array to store result in
+     * @returns Array of picking infos
+     */
+    intersectsMeshes(meshes: any, fastCheck: any, results: any): any;
+    _comparePickingInfo(pickingInfoA: any, pickingInfoB: any): 1 | -1 | 0;
+    /**
+     * Intersection test between the ray and a given segment within a given tolerance (threshold)
+     * @param sega the first point of the segment to test the intersection against
+     * @param segb the second point of the segment to test the intersection against
+     * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
+     * @returns the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
+     */
+    intersectionSegment(sega: any, segb: any, threshold: any): number;
+    /**
+     * Update the ray from viewport position
+     * @param x position
+     * @param y y position
+     * @param viewportWidth viewport width
+     * @param viewportHeight viewport height
+     * @param world world matrix
+     * @param view view matrix
+     * @param projection projection matrix
+     * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
+     * @returns this ray updated
+     */
+    update(x: any, y: any, viewportWidth: any, viewportHeight: any, world: any, view: any, projection: any, enableDistantPicking?: boolean): Ray;
+    /**
+     * Unproject a ray from screen space to object space
+     * @param sourceX defines the screen space x coordinate to use
+     * @param sourceY defines the screen space y coordinate to use
+     * @param viewportWidth defines the current width of the viewport
+     * @param viewportHeight defines the current height of the viewport
+     * @param world defines the world matrix to use (can be set to Identity to go to world space)
+     * @param view defines the view matrix to use
+     * @param projection defines the projection matrix to use
+     */
+    unprojectRayToRef(sourceX: any, sourceY: any, viewportWidth: any, viewportHeight: any, world: any, view: any, projection: any): void;
+}
+export namespace Ray {
+    const _TmpVector3: Vector3[];
+    const _RayDistant: Ray;
+    const _Smallnum: number;
+    const _Rayl: number;
+}
+import { IntersectionInfo } from "../Collisions/intersectionInfo.js";
+import { Vector3 } from "../Maths/math.vector.js";
+import { Matrix } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Debug/ISkeletonViewer.d.ts

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

package/dist/types/node_modules/@babylonjs/core/Debug/axesViewer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The Axes viewer will show 3 axes in a specific point in space
+ * @see https://doc.babylonjs.com/toolsAndResources/utilities/World_Axes
+ */
+export class AxesViewer {
+    static _SetRenderingGroupId(node: any, id: any): void;
+    /**
+     * Creates a new AxesViewer
+     * @param scene defines the hosting scene
+     * @param scaleLines defines a number used to scale line length (1 by default)
+     * @param renderingGroupId defines a number used to set the renderingGroupId of the meshes (2 by default)
+     * @param xAxis defines the node hierarchy used to render the x-axis
+     * @param yAxis defines the node hierarchy used to render the y-axis
+     * @param zAxis defines the node hierarchy used to render the z-axis
+     * @param lineThickness The line thickness to use when creating the arrow. defaults to 1.
+     */
+    constructor(scene: any, scaleLines: number | undefined, renderingGroupId: number | undefined, xAxis: any, yAxis: any, zAxis: any, lineThickness?: number);
+    _scaleLinesFactor: number;
+    _instanced: boolean;
+    /**
+     * Gets the hosting scene
+     */
+    scene: any;
+    /**
+     * Gets or sets a number used to scale line length
+     */
+    scaleLines: number;
+    _xAxis: any;
+    _yAxis: any;
+    _zAxis: any;
+    /** Gets the node hierarchy used to render x-axis */
+    get xAxis(): any;
+    /** Gets the node hierarchy used to render y-axis */
+    get yAxis(): any;
+    /** Gets the node hierarchy used to render z-axis */
+    get zAxis(): any;
+    /**
+     * Force the viewer to update
+     * @param position defines the position of the viewer
+     * @param xaxis defines the x axis of the viewer
+     * @param yaxis defines the y axis of the viewer
+     * @param zaxis defines the z axis of the viewer
+     */
+    update(position: any, xaxis: any, yaxis: any, zaxis: any): void;
+    /**
+     * Creates an instance of this axes viewer.
+     * @returns a new axes viewer with instanced meshes
+     */
+    createInstance(): AxesViewer;
+    /** Releases resources */
+    dispose(): void;
+}

package/dist/types/node_modules/@babylonjs/core/Debug/boneAxesViewer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The BoneAxesViewer will attach 3 axes to a specific bone of a specific mesh
+ * @see demo here: https://www.babylonjs-playground.com/#0DE8F4#8
+ */
+export class BoneAxesViewer extends AxesViewer {
+    /**
+     * Creates a new BoneAxesViewer
+     * @param scene defines the hosting scene
+     * @param bone defines the target bone
+     * @param mesh defines the target mesh
+     * @param scaleLines defines a scaling factor for line length (1 by default)
+     */
+    constructor(scene: any, bone: any, mesh: any, scaleLines?: number);
+    /** Gets current position */
+    pos: Vector3;
+    /** Gets direction of X axis */
+    xaxis: Vector3;
+    /** Gets direction of Y axis */
+    yaxis: Vector3;
+    /** Gets direction of Z axis */
+    zaxis: Vector3;
+    mesh: any;
+    bone: any;
+    /**
+     * Force the viewer to update
+     */
+    update(): void;
+}
+import { AxesViewer } from "../Debug/axesViewer.js";
+import { Vector3 } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Debug/debugLayer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Enum of inspector action tab
+ */
+export const DebugLayerTab: any;
+/**
+ * The debug layer (aka Inspector) is the go to tool in order to better understand
+ * what is happening in your scene
+ * @see https://doc.babylonjs.com/toolsAndResources/inspector
+ */
+export class DebugLayer {
+    /**
+     * Instantiates a new debug layer.
+     * The debug layer (aka Inspector) is the go to tool in order to better understand
+     * what is happening in your scene
+     * @see https://doc.babylonjs.com/toolsAndResources/inspector
+     * @param scene Defines the scene to inspect
+     */
+    constructor(scene: any);
+    BJSINSPECTOR: any;
+    _scene: any;
+    /**
+     * Observable triggered when a property is changed through the inspector.
+     */
+    get onPropertyChangedObservable(): any;
+    _onPropertyChangedObservable: Observable<any> | undefined;
+    /**
+     * Observable triggered when the selection is changed through the inspector.
+     */
+    get onSelectionChangedObservable(): any;
+    _onSelectionChangedObservable: Observable<any> | undefined;
+    /**
+     * Creates the inspector window.
+     * @param config
+     */
+    _createInspector(config: any): void;
+    /**
+     * Select a specific entity in the scene explorer and highlight a specific block in that entity property grid
+     * @param entity defines the entity to select
+     * @param lineContainerTitles defines the specific blocks to highlight (could be a string or an array of strings)
+     */
+    select(entity: any, lineContainerTitles: any): void;
+    /** Get the inspector from bundle or global */
+    _getGlobalInspector(): any;
+    /**
+     * Get if the inspector is visible or not.
+     * @returns true if visible otherwise, false
+     */
+    isVisible(): any;
+    /**
+     * Hide the inspector and close its window.
+     */
+    hide(): void;
+    /**
+     * Update the scene in the inspector
+     */
+    setAsActiveScene(): void;
+    /**
+     * Launch the debugLayer.
+     * @param config Define the configuration of the inspector
+     * @returns a promise fulfilled when the debug layer is visible
+     */
+    show(config: any): Promise<any>;
+}
+export namespace DebugLayer {
+    const InspectorURL: string;
+}
+import { Observable } from "../Misc/observable.js";

package/dist/types/node_modules/@babylonjs/core/Debug/directionalLightFrustumViewer.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Class used to render a debug view of the frustum for a directional light
+ * @see https://playground.babylonjs.com/#7EFGSG#4
+ * @since 5.0.0
+ */
+export class DirectionalLightFrustumViewer {
+    /**
+     * Creates a new frustum viewer
+     * @param light directional light to display the frustum for
+     * @param camera camera used to retrieve the minZ / maxZ values if the shadowMinZ/shadowMaxZ values of the light are not setup
+     */
+    constructor(light: any, camera: any);
+    _oldPosition: Vector3;
+    _oldDirection: Vector3;
+    _transparency: number;
+    _showLines: boolean;
+    _showPlanes: boolean;
+    _scene: any;
+    _light: any;
+    _camera: any;
+    _inverseViewMatrix: Matrix;
+    _lightHelperFrustumMeshes: any[];
+    set transparency(arg: number);
+    /**
+     * Gets or sets the transparency of the frustum planes
+     */
+    get transparency(): number;
+    set showLines(arg: boolean);
+    /**
+     * true to display the edges of the frustum
+     */
+    get showLines(): boolean;
+    set showPlanes(arg: boolean);
+    /**
+     * true to display the planes of the frustum
+     */
+    get showPlanes(): boolean;
+    /**
+     * Shows the frustum
+     */
+    show(): void;
+    _visible: boolean | undefined;
+    /**
+     * Hides the frustum
+     */
+    hide(): void;
+    /**
+     * Updates the frustum.
+     * Call this method to update the frustum view if the light has changed position/direction
+     */
+    update(): void;
+    _oldAutoCalc: any;
+    _oldMinZ: any;
+    _oldMaxZ: any;
+    /**
+     * Dispose of the class / remove the frustum view
+     */
+    dispose(): void;
+    _createGeometry(): void;
+    _rootNode: TransformNode | undefined;
+    _nearLinesPoints: import("@babylonjs/core").DeepImmutableObject<Vector3>[] | undefined;
+    _farLinesPoints: import("@babylonjs/core").DeepImmutableObject<Vector3>[] | undefined;
+    _trLinesPoints: import("@babylonjs/core").DeepImmutableObject<Vector3>[] | undefined;
+    _brLinesPoints: import("@babylonjs/core").DeepImmutableObject<Vector3>[] | undefined;
+    _tlLinesPoints: import("@babylonjs/core").DeepImmutableObject<Vector3>[] | undefined;
+    _blLinesPoints: import("@babylonjs/core").DeepImmutableObject<Vector3>[] | undefined;
+    _nearPlaneVertices: number[] | undefined;
+    _farPlaneVertices: number[] | undefined;
+    _rightPlaneVertices: number[] | undefined;
+    _leftPlaneVertices: number[] | undefined;
+    _topPlaneVertices: number[] | undefined;
+    _bottomPlaneVertices: number[] | undefined;
+    _getInvertViewMatrix(): Matrix;
+}
+import { Vector3 } from "../Maths/math.vector.js";
+import { Matrix } from "../Maths/math.vector.js";
+import { TransformNode } from "../Meshes/transformNode.js";

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

@@ -0,0 +1,8 @@
+export * from "./axesViewer.js";
+export * from "./boneAxesViewer.js";
+export * from "./debugLayer.js";
+export * from "./physicsViewer.js";
+export * from "./rayHelper.js";
+export * from "./skeletonViewer.js";
+export * from "./ISkeletonViewer.js";
+export * from "./directionalLightFrustumViewer.js";

package/dist/types/node_modules/@babylonjs/core/Debug/physicsViewer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Used to show the physics impostor around the specific mesh
+ */
+export class PhysicsViewer {
+    /**
+     * Creates a new PhysicsViewer
+     * @param scene defines the hosting scene
+     */
+    constructor(scene: any);
+    /** @internal */
+    _impostors: any[];
+    /** @internal */
+    _meshes: any[];
+    /** @internal */
+    _numMeshes: number;
+    _debugMeshMeshes: any[];
+    _scene: any;
+    _physicsEnginePlugin: any;
+    _utilityLayer: UtilityLayerRenderer | undefined;
+    /** @internal */
+    _updateDebugMeshes(): void;
+    /**
+     * Renders a specified physic impostor
+     * @param impostor defines the impostor to render
+     * @param targetMesh defines the mesh represented by the impostor
+     * @returns the new debug mesh used to render the impostor
+     */
+    showImpostor(impostor: any, targetMesh: any): Mesh | import("@babylonjs/core").InstancedMesh | null;
+    _renderFunction: (() => void) | undefined;
+    /**
+     * Hides a specified physic impostor
+     * @param impostor defines the impostor to hide
+     */
+    hideImpostor(impostor: any): void;
+    _getDebugMaterial(scene: any): StandardMaterial;
+    _debugMaterial: StandardMaterial | undefined;
+    _getDebugBoxMesh(scene: any): import("@babylonjs/core").InstancedMesh;
+    _debugBoxMesh: Mesh | undefined;
+    _getDebugSphereMesh(scene: any): import("@babylonjs/core").InstancedMesh;
+    _debugSphereMesh: Mesh | undefined;
+    _getDebugCapsuleMesh(scene: any): import("@babylonjs/core").InstancedMesh;
+    _debugCapsuleMesh: Mesh | undefined;
+    _getDebugCylinderMesh(scene: any): import("@babylonjs/core").InstancedMesh;
+    _debugCylinderMesh: Mesh | undefined;
+    _getDebugMeshMesh(mesh: any, scene: any): Mesh;
+    _getDebugMesh(impostor: any, targetMesh: any): Mesh | import("@babylonjs/core").InstancedMesh | null;
+    /** Releases all resources */
+    dispose(): void;
+}
+import { UtilityLayerRenderer } from "../Rendering/utilityLayerRenderer.js";
+import { Mesh } from "../Meshes/mesh.js";
+import { StandardMaterial } from "../Materials/standardMaterial.js";

package/dist/types/node_modules/@babylonjs/core/Debug/rayHelper.d.ts

@@ -0,0 +1,61 @@
+/**
+ * As raycast might be hard to debug, the RayHelper can help rendering the different rays
+ * in order to better appreciate the issue one might have.
+ * @see https://doc.babylonjs.com/babylon101/raycasts#debugging
+ */
+export class RayHelper {
+    /**
+     * Helper function to create a colored helper in a scene in one line.
+     * @param ray Defines the ray we are currently tryin to visualize
+     * @param scene Defines the scene the ray is used in
+     * @param color Defines the color we want to see the ray in
+     * @returns The newly created ray helper.
+     */
+    static CreateAndShow(ray: any, scene: any, color: any): RayHelper;
+    /**
+     * Instantiate a new ray helper.
+     * As raycast might be hard to debug, the RayHelper can help rendering the different rays
+     * in order to better appreciate the issue one might have.
+     * @see https://doc.babylonjs.com/babylon101/raycasts#debugging
+     * @param ray Defines the ray we are currently tryin to visualize
+     */
+    constructor(ray: any);
+    ray: any;
+    /**
+     * Shows the ray we are willing to debug.
+     * @param scene Defines the scene the ray needs to be rendered in
+     * @param color Defines the color the ray needs to be rendered in
+     */
+    show(scene: any, color: any): void;
+    _renderFunction: (() => void) | null | undefined;
+    _scene: any;
+    _renderPoints: any[] | undefined;
+    _renderLine: import("@babylonjs/core").LinesMesh | null | undefined;
+    /**
+     * Hides the ray we are debugging.
+     */
+    hide(): void;
+    _render(): void;
+    /**
+     * Attach a ray helper to a mesh so that we can easily see its orientation for instance or information like its normals.
+     * @param mesh Defines the mesh we want the helper attached to
+     * @param meshSpaceDirection Defines the direction of the Ray in mesh space (local space of the mesh node)
+     * @param meshSpaceOrigin Defines the origin of the Ray in mesh space (local space of the mesh node)
+     * @param length Defines the length of the ray
+     */
+    attachToMesh(mesh: any, meshSpaceDirection: any, meshSpaceOrigin: any, length: any): void;
+    _attachedToMesh: any;
+    _meshSpaceDirection: any;
+    _meshSpaceOrigin: any;
+    _onAfterRenderObserver: any;
+    _onAfterStepObserver: any;
+    /**
+     * Detach the ray helper from the mesh it has previously been attached to.
+     */
+    detachFromMesh(): void;
+    _updateToMesh(): void;
+    /**
+     * Dispose the helper and release its associated resources.
+     */
+    dispose(): void;
+}