|
@@ -1565,7 +1565,7 @@ declare module "babylonjs/Maths/math.like" {
|
|
|
* @hidden
|
|
|
*/
|
|
|
export interface IMatrixLike {
|
|
|
- toArray(): DeepImmutable<Float32Array>;
|
|
|
+ toArray(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
updateFlag: int;
|
|
|
}
|
|
|
/**
|
|
@@ -2068,6 +2068,21 @@ declare module "babylonjs/Maths/math.plane" {
|
|
|
static SignedDistanceToPlaneFromPositionAndNormal(origin: DeepImmutable<Vector3>, normal: DeepImmutable<Vector3>, point: DeepImmutable<Vector3>): number;
|
|
|
}
|
|
|
}
|
|
|
+declare module "babylonjs/Engines/performanceConfigurator" {
|
|
|
+ /** @hidden */
|
|
|
+ export class PerformanceConfigurator {
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixUse64Bits: boolean;
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixTrackPrecisionChange: boolean;
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixCurrentType: any;
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixTrackedMatrices: Array<any> | null;
|
|
|
+ /** @hidden */
|
|
|
+ static SetMatrixPrecision(use64bits: boolean): void;
|
|
|
+ }
|
|
|
+}
|
|
|
declare module "babylonjs/Maths/math.vector" {
|
|
|
import { Viewport } from "babylonjs/Maths/math.viewport";
|
|
|
import { DeepImmutable, Nullable, FloatArray, float } from "babylonjs/types";
|
|
@@ -4045,6 +4060,10 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
* Class used to store matrix data (4x4)
|
|
|
*/
|
|
|
export class Matrix {
|
|
|
+ /**
|
|
|
+ * Gets the precision of matrix computations
|
|
|
+ */
|
|
|
+ static get Use64Bits(): boolean;
|
|
|
private static _updateFlagSeed;
|
|
|
private static _identityReadOnly;
|
|
|
private _isIdentity;
|
|
@@ -4061,7 +4080,7 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
/**
|
|
|
* Gets the internal data of the matrix
|
|
|
*/
|
|
|
- get m(): DeepImmutable<Float32Array>;
|
|
|
+ get m(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
/** @hidden */
|
|
|
_markAsUpdated(): void;
|
|
|
/** @hidden */
|
|
@@ -4086,15 +4105,15 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
*/
|
|
|
determinant(): number;
|
|
|
/**
|
|
|
- * Returns the matrix as a Float32Array
|
|
|
+ * Returns the matrix as a Float32Array or Array<number>
|
|
|
* @returns the matrix underlying array
|
|
|
*/
|
|
|
- toArray(): DeepImmutable<Float32Array>;
|
|
|
+ toArray(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
/**
|
|
|
- * Returns the matrix as a Float32Array
|
|
|
+ * Returns the matrix as a Float32Array or Array<number>
|
|
|
* @returns the matrix underlying array.
|
|
|
*/
|
|
|
- asArray(): DeepImmutable<Float32Array>;
|
|
|
+ asArray(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
/**
|
|
|
* Inverts the current matrix in place
|
|
|
* @returns the current inverted matrix
|
|
@@ -4200,7 +4219,7 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
* @param offset defines the offset in the target array where to start storing values
|
|
|
* @returns the current matrix
|
|
|
*/
|
|
|
- copyToArray(array: Float32Array, offset?: number): Matrix;
|
|
|
+ copyToArray(array: Float32Array | Array<number>, offset?: number): Matrix;
|
|
|
/**
|
|
|
* Sets the given matrix "result" with the multiplication result of the current Matrix and the given one
|
|
|
* @param other defines the second operand
|
|
@@ -4215,7 +4234,7 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
* @param offset defines the offset in the target array where to start storing values
|
|
|
* @returns the current matrix
|
|
|
*/
|
|
|
- multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array, offset: number): Matrix;
|
|
|
+ multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array | Array<number>, offset: number): Matrix;
|
|
|
/**
|
|
|
* Check equality between this matrix and a second one
|
|
|
* @param value defines the second matrix to compare
|
|
@@ -4344,7 +4363,7 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
* @param scale defines the scaling factor
|
|
|
* @param result defines the target matrix
|
|
|
*/
|
|
|
- static FromFloat32ArrayToRefScaled(array: DeepImmutable<Float32Array>, offset: number, scale: number, result: Matrix): void;
|
|
|
+ static FromFloat32ArrayToRefScaled(array: DeepImmutable<Float32Array | Array<number>>, offset: number, scale: number, result: Matrix): void;
|
|
|
/**
|
|
|
* Gets an identity matrix that must not be updated
|
|
|
*/
|
|
@@ -4767,13 +4786,13 @@ declare module "babylonjs/Maths/math.vector" {
|
|
|
* @param matrix defines the matrix to use
|
|
|
* @returns a new Float32Array array with 4 elements : the 2x2 matrix extracted from the given matrix
|
|
|
*/
|
|
|
- static GetAsMatrix2x2(matrix: DeepImmutable<Matrix>): Float32Array;
|
|
|
+ static GetAsMatrix2x2(matrix: DeepImmutable<Matrix>): Float32Array | Array<number>;
|
|
|
/**
|
|
|
* Extracts a 3x3 matrix from a given matrix and store the result in a Float32Array
|
|
|
* @param matrix defines the matrix to use
|
|
|
* @returns a new Float32Array array with 9 elements : the 3x3 matrix extracted from the given matrix
|
|
|
*/
|
|
|
- static GetAsMatrix3x3(matrix: DeepImmutable<Matrix>): Float32Array;
|
|
|
+ static GetAsMatrix3x3(matrix: DeepImmutable<Matrix>): Float32Array | Array<number>;
|
|
|
/**
|
|
|
* Compute the transpose of a given matrix
|
|
|
* @param matrix defines the matrix to transpose
|
|
@@ -16889,14 +16908,14 @@ declare module "babylonjs/Materials/shaderMaterial" {
|
|
|
* @param value Define the value to give to the uniform
|
|
|
* @return the material itself allowing "fluent" like uniform updates
|
|
|
*/
|
|
|
- setMatrix3x3(name: string, value: Float32Array): ShaderMaterial;
|
|
|
+ setMatrix3x3(name: string, value: Float32Array | Array<number>): ShaderMaterial;
|
|
|
/**
|
|
|
* Set a mat2 in the shader from a Float32Array.
|
|
|
* @param name Define the name of the uniform as defined in the shader
|
|
|
* @param value Define the value to give to the uniform
|
|
|
* @return the material itself allowing "fluent" like uniform updates
|
|
|
*/
|
|
|
- setMatrix2x2(name: string, value: Float32Array): ShaderMaterial;
|
|
|
+ setMatrix2x2(name: string, value: Float32Array | Array<number>): ShaderMaterial;
|
|
|
/**
|
|
|
* Set a vec2 array in the shader from a number array.
|
|
|
* @param name Define the name of the uniform as defined in the shader
|
|
@@ -20848,6 +20867,12 @@ declare module "babylonjs/Materials/Node/Blocks/Input/inputBlock" {
|
|
|
*/
|
|
|
constructor(name: string, target?: NodeMaterialBlockTargets, type?: NodeMaterialBlockConnectionPointTypes);
|
|
|
/**
|
|
|
+ * Validates if a name is a reserve word.
|
|
|
+ * @param newName the new name to be given to the node.
|
|
|
+ * @returns false if the name is a reserve word, else true.
|
|
|
+ */
|
|
|
+ validateBlockName(newName: string): boolean;
|
|
|
+ /**
|
|
|
* Gets the output component
|
|
|
*/
|
|
|
get output(): NodeMaterialConnectionPoint;
|
|
@@ -22004,6 +22029,7 @@ declare module "babylonjs/Materials/Node/nodeMaterialBlock" {
|
|
|
private _target;
|
|
|
private _isFinalMerger;
|
|
|
private _isInput;
|
|
|
+ private _name;
|
|
|
protected _isUnique: boolean;
|
|
|
/** Gets or sets a boolean indicating that only one input can be connected at a time */
|
|
|
inputsAreExclusive: boolean;
|
|
@@ -22016,9 +22042,13 @@ declare module "babylonjs/Materials/Node/nodeMaterialBlock" {
|
|
|
/** @hidden */
|
|
|
_preparationId: number;
|
|
|
/**
|
|
|
- * Gets or sets the name of the block
|
|
|
+ * Gets the name of the block
|
|
|
*/
|
|
|
- name: string;
|
|
|
+ get name(): string;
|
|
|
+ /**
|
|
|
+ * Sets the name of the block. Will check if the name is valid.
|
|
|
+ */
|
|
|
+ set name(newName: string);
|
|
|
/**
|
|
|
* Gets or sets the unique id of the node
|
|
|
*/
|
|
@@ -22201,6 +22231,12 @@ declare module "babylonjs/Materials/Node/nodeMaterialBlock" {
|
|
|
protected _linkConnectionTypes(inputIndex0: number, inputIndex1: number): void;
|
|
|
private _processBuild;
|
|
|
/**
|
|
|
+ * Validates the new name for the block node.
|
|
|
+ * @param newName the new name to be given to the node.
|
|
|
+ * @returns false if the name is a reserve word, else true.
|
|
|
+ */
|
|
|
+ validateBlockName(newName: string): boolean;
|
|
|
+ /**
|
|
|
* Compile the current node and generate the shader code
|
|
|
* @param state defines the current compilation state (uniforms, samplers, current string)
|
|
|
* @param activeBlocks defines the list of active blocks (i.e. blocks to compile)
|
|
@@ -34877,7 +34913,7 @@ declare module "babylonjs/Materials/effect" {
|
|
|
* @param matrices matrices to be set.
|
|
|
* @returns this effect.
|
|
|
*/
|
|
|
- setMatrices(uniformName: string, matrices: Float32Array): Effect;
|
|
|
+ setMatrices(uniformName: string, matrices: Float32Array | Array<number>): Effect;
|
|
|
/**
|
|
|
* Sets matrix on a uniform variable.
|
|
|
* @param uniformName Name of the variable.
|
|
@@ -34891,14 +34927,14 @@ declare module "babylonjs/Materials/effect" {
|
|
|
* @param matrix matrix to be set.
|
|
|
* @returns this effect.
|
|
|
*/
|
|
|
- setMatrix3x3(uniformName: string, matrix: Float32Array): Effect;
|
|
|
+ setMatrix3x3(uniformName: string, matrix: Float32Array | Array<number>): Effect;
|
|
|
/**
|
|
|
* Sets a 2x2 matrix on a uniform variable. (Speicified as [1,2,3,4] will result in [1,2][3,4] matrix)
|
|
|
* @param uniformName Name of the variable.
|
|
|
* @param matrix matrix to be set.
|
|
|
* @returns this effect.
|
|
|
*/
|
|
|
- setMatrix2x2(uniformName: string, matrix: Float32Array): Effect;
|
|
|
+ setMatrix2x2(uniformName: string, matrix: Float32Array | Array<number>): Effect;
|
|
|
/**
|
|
|
* Sets a float on a uniform variable.
|
|
|
* @param uniformName Name of the variable.
|
|
@@ -35527,6 +35563,10 @@ declare module "babylonjs/Engines/thinEngine" {
|
|
|
* Make the canvas XR Compatible for XR sessions
|
|
|
*/
|
|
|
xrCompatible?: boolean;
|
|
|
+ /**
|
|
|
+ * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default
|
|
|
+ */
|
|
|
+ useHighPrecisionMatrix?: boolean;
|
|
|
}
|
|
|
/**
|
|
|
* The base engine class (root of all engines)
|
|
@@ -48748,6 +48788,7 @@ declare module "babylonjs/Loading/sceneLoader" {
|
|
|
*/
|
|
|
static OnPluginActivatedObservable: Observable<ISceneLoaderPlugin | ISceneLoaderPluginAsync>;
|
|
|
private static _registeredPlugins;
|
|
|
+ private static _showingLoadingScreen;
|
|
|
private static _getDefaultPlugin;
|
|
|
private static _getPluginForExtension;
|
|
|
private static _getPluginForDirectLoad;
|
|
@@ -51416,6 +51457,7 @@ declare module "babylonjs/Gizmos/gizmo" {
|
|
|
import { IDisposable } from "babylonjs/scene";
|
|
|
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
import { Mesh } from "babylonjs/Meshes/mesh";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
import { UtilityLayerRenderer } from "babylonjs/Rendering/utilityLayerRenderer";
|
|
|
/**
|
|
|
* Renders gizmos on top of an existing scene which provide controls for position, rotation, etc.
|
|
@@ -51428,6 +51470,7 @@ declare module "babylonjs/Gizmos/gizmo" {
|
|
|
*/
|
|
|
_rootMesh: Mesh;
|
|
|
private _attachedMesh;
|
|
|
+ private _attachedNode;
|
|
|
/**
|
|
|
* Ratio for the scale of the gizmo (Default: 1)
|
|
|
*/
|
|
@@ -51443,6 +51486,12 @@ declare module "babylonjs/Gizmos/gizmo" {
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(value: Nullable<AbstractMesh>);
|
|
|
/**
|
|
|
+ * Node that the gizmo will be attached to. (eg. on a drag gizmo the mesh, bone or NodeTransform that will be dragged)
|
|
|
+ * * When set, interactions will be enabled
|
|
|
+ */
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(value: Nullable<Node>);
|
|
|
+ /**
|
|
|
* Disposes and replaces the current meshes in the gizmo with the specified mesh
|
|
|
* @param mesh The mesh to replace the default mesh of the gizmo
|
|
|
*/
|
|
@@ -51460,7 +51509,7 @@ declare module "babylonjs/Gizmos/gizmo" {
|
|
|
*/
|
|
|
updateScale: boolean;
|
|
|
protected _interactionsEnabled: boolean;
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
private _beforeRenderObserver;
|
|
|
private _tempVector;
|
|
|
/**
|
|
@@ -51475,6 +51524,11 @@ declare module "babylonjs/Gizmos/gizmo" {
|
|
|
*/
|
|
|
protected _update(): void;
|
|
|
/**
|
|
|
+ * computes the rotation/scaling/position of the transform once the Node world matrix has changed.
|
|
|
+ * @param value Node, TransformNode or mesh
|
|
|
+ */
|
|
|
+ protected _matrixChanged(): void;
|
|
|
+ /**
|
|
|
* Disposes of the gizmo
|
|
|
*/
|
|
|
dispose(): void;
|
|
@@ -51486,7 +51540,7 @@ declare module "babylonjs/Gizmos/planeDragGizmo" {
|
|
|
import { Vector3 } from "babylonjs/Maths/math.vector";
|
|
|
import { Color3 } from "babylonjs/Maths/math.color";
|
|
|
import { TransformNode } from "babylonjs/Meshes/transformNode";
|
|
|
- import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
import { PointerDragBehavior } from "babylonjs/Behaviors/Meshes/pointerDragBehavior";
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
|
import { UtilityLayerRenderer } from "babylonjs/Rendering/utilityLayerRenderer";
|
|
@@ -51529,7 +51583,7 @@ declare module "babylonjs/Gizmos/planeDragGizmo" {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(dragPlaneNormal: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, parent?: Nullable<PositionGizmo>);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -51545,6 +51599,7 @@ declare module "babylonjs/Gizmos/positionGizmo" {
|
|
|
import { Observable } from "babylonjs/Misc/observable";
|
|
|
import { Nullable } from "babylonjs/types";
|
|
|
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
import { Mesh } from "babylonjs/Meshes/mesh";
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
|
import { AxisDragGizmo } from "babylonjs/Gizmos/axisDragGizmo";
|
|
@@ -51582,6 +51637,7 @@ declare module "babylonjs/Gizmos/positionGizmo" {
|
|
|
* private variables
|
|
|
*/
|
|
|
private _meshAttached;
|
|
|
+ private _nodeAttached;
|
|
|
private _updateGizmoRotationToMatchAttachedMesh;
|
|
|
private _snapDistance;
|
|
|
private _scaleRatio;
|
|
@@ -51595,6 +51651,8 @@ declare module "babylonjs/Gizmos/positionGizmo" {
|
|
|
private _planarGizmoEnabled;
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(mesh: Nullable<AbstractMesh>);
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(node: Nullable<Node>);
|
|
|
/**
|
|
|
* Creates a PositionGizmo
|
|
|
* @param gizmoLayer The utility layer the gizmo will be added to
|
|
@@ -51634,7 +51692,7 @@ declare module "babylonjs/Gizmos/axisDragGizmo" {
|
|
|
import { Nullable } from "babylonjs/types";
|
|
|
import { Vector3 } from "babylonjs/Maths/math.vector";
|
|
|
import { TransformNode } from "babylonjs/Meshes/transformNode";
|
|
|
- import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
import { PointerDragBehavior } from "babylonjs/Behaviors/Meshes/pointerDragBehavior";
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
|
import { UtilityLayerRenderer } from "babylonjs/Rendering/utilityLayerRenderer";
|
|
@@ -51678,7 +51736,7 @@ declare module "babylonjs/Gizmos/axisDragGizmo" {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(dragAxis: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, parent?: Nullable<PositionGizmo>);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -52662,6 +52720,10 @@ declare module "babylonjs/Engines/nullEngine" {
|
|
|
* @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
|
|
|
*/
|
|
|
lockstepMaxSteps: number;
|
|
|
+ /**
|
|
|
+ * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default
|
|
|
+ */
|
|
|
+ useHighPrecisionMatrix?: boolean;
|
|
|
}
|
|
|
/**
|
|
|
* The null engine class provides support for headless version of babylon.js.
|
|
@@ -54089,6 +54151,7 @@ declare module "babylonjs/Engines/index" {
|
|
|
export * from "babylonjs/Engines/WebGL/webGL2ShaderProcessors";
|
|
|
export * from "babylonjs/Engines/nativeEngine";
|
|
|
export * from "babylonjs/Engines/Processors/shaderCodeInliner";
|
|
|
+ export * from "babylonjs/Engines/performanceConfigurator";
|
|
|
}
|
|
|
declare module "babylonjs/Events/clipboardEvents" {
|
|
|
/**
|
|
@@ -54693,6 +54756,7 @@ declare module "babylonjs/Gizmos/scaleGizmo" {
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
|
import { AxisScaleGizmo } from "babylonjs/Gizmos/axisScaleGizmo";
|
|
|
import { UtilityLayerRenderer } from "babylonjs/Rendering/utilityLayerRenderer";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
/**
|
|
|
* Gizmo that enables scaling a mesh along 3 axis
|
|
|
*/
|
|
@@ -54714,6 +54778,7 @@ declare module "babylonjs/Gizmos/scaleGizmo" {
|
|
|
*/
|
|
|
uniformScaleGizmo: AxisScaleGizmo;
|
|
|
private _meshAttached;
|
|
|
+ private _nodeAttached;
|
|
|
private _updateGizmoRotationToMatchAttachedMesh;
|
|
|
private _snapDistance;
|
|
|
private _scaleRatio;
|
|
@@ -54726,6 +54791,8 @@ declare module "babylonjs/Gizmos/scaleGizmo" {
|
|
|
onDragEndObservable: Observable<unknown>;
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(mesh: Nullable<AbstractMesh>);
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(node: Nullable<Node>);
|
|
|
/**
|
|
|
* Creates a ScaleGizmo
|
|
|
* @param gizmoLayer The utility layer the gizmo will be added to
|
|
@@ -54758,7 +54825,7 @@ declare module "babylonjs/Gizmos/axisScaleGizmo" {
|
|
|
import { Observable } from "babylonjs/Misc/observable";
|
|
|
import { Nullable } from "babylonjs/types";
|
|
|
import { Vector3 } from "babylonjs/Maths/math.vector";
|
|
|
- import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
import { Mesh } from "babylonjs/Meshes/mesh";
|
|
|
import { PointerDragBehavior } from "babylonjs/Behaviors/Meshes/pointerDragBehavior";
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
@@ -54805,7 +54872,7 @@ declare module "babylonjs/Gizmos/axisScaleGizmo" {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(dragAxis: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, parent?: Nullable<ScaleGizmo>);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -54892,11 +54959,11 @@ declare module "babylonjs/Gizmos/boundingBoxGizmo" {
|
|
|
*/
|
|
|
onRotationSphereDragEndObservable: Observable<{}>;
|
|
|
/**
|
|
|
- * Relative bounding box pivot used when scaling the attached mesh. When null object with scale from the opposite corner. 0.5,0.5,0.5 for center and 0.5,0,0.5 for bottom (Default: null)
|
|
|
+ * Relative bounding box pivot used when scaling the attached node. When null object with scale from the opposite corner. 0.5,0.5,0.5 for center and 0.5,0,0.5 for bottom (Default: null)
|
|
|
*/
|
|
|
scalePivot: Nullable<Vector3>;
|
|
|
/**
|
|
|
- * Mesh used as a pivot to rotate the attached mesh
|
|
|
+ * Mesh used as a pivot to rotate the attached node
|
|
|
*/
|
|
|
private _anchorMesh;
|
|
|
private _existingMeshScale;
|
|
@@ -54915,7 +54982,7 @@ declare module "babylonjs/Gizmos/boundingBoxGizmo" {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(color?: Color3, gizmoLayer?: UtilityLayerRenderer);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<AbstractMesh>): void;
|
|
|
private _selectNode;
|
|
|
/**
|
|
|
* Updates the bounding box information for the Gizmo
|
|
@@ -54961,7 +55028,7 @@ declare module "babylonjs/Gizmos/planeRotationGizmo" {
|
|
|
import { Nullable } from "babylonjs/types";
|
|
|
import { Vector3 } from "babylonjs/Maths/math.vector";
|
|
|
import { Color3 } from "babylonjs/Maths/math.color";
|
|
|
- import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
import { PointerDragBehavior } from "babylonjs/Behaviors/Meshes/pointerDragBehavior";
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
|
import { UtilityLayerRenderer } from "babylonjs/Rendering/utilityLayerRenderer";
|
|
@@ -54998,7 +55065,7 @@ declare module "babylonjs/Gizmos/planeRotationGizmo" {
|
|
|
* @param useEulerRotation Use and update Euler angle instead of quaternion
|
|
|
*/
|
|
|
constructor(planeNormal: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, tessellation?: number, parent?: Nullable<RotationGizmo>, useEulerRotation?: boolean);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -55018,6 +55085,7 @@ declare module "babylonjs/Gizmos/rotationGizmo" {
|
|
|
import { Gizmo } from "babylonjs/Gizmos/gizmo";
|
|
|
import { PlaneRotationGizmo } from "babylonjs/Gizmos/planeRotationGizmo";
|
|
|
import { UtilityLayerRenderer } from "babylonjs/Rendering/utilityLayerRenderer";
|
|
|
+ import { Node } from "babylonjs/node";
|
|
|
/**
|
|
|
* Gizmo that enables rotating a mesh along 3 axis
|
|
|
*/
|
|
@@ -55039,8 +55107,11 @@ declare module "babylonjs/Gizmos/rotationGizmo" {
|
|
|
/** Fires an event when any of it's sub gizmos are released from dragging */
|
|
|
onDragEndObservable: Observable<unknown>;
|
|
|
private _meshAttached;
|
|
|
+ private _nodeAttached;
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(mesh: Nullable<AbstractMesh>);
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(node: Nullable<Node>);
|
|
|
/**
|
|
|
* Creates a RotationGizmo
|
|
|
* @param gizmoLayer The utility layer the gizmo will be added to
|
|
@@ -79902,7 +79973,7 @@ declare module BABYLON {
|
|
|
* @hidden
|
|
|
*/
|
|
|
export interface IMatrixLike {
|
|
|
- toArray(): DeepImmutable<Float32Array>;
|
|
|
+ toArray(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
updateFlag: int;
|
|
|
}
|
|
|
/**
|
|
@@ -80402,6 +80473,21 @@ declare module BABYLON {
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
|
|
+ /** @hidden */
|
|
|
+ export class PerformanceConfigurator {
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixUse64Bits: boolean;
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixTrackPrecisionChange: boolean;
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixCurrentType: any;
|
|
|
+ /** @hidden */
|
|
|
+ static MatrixTrackedMatrices: Array<any> | null;
|
|
|
+ /** @hidden */
|
|
|
+ static SetMatrixPrecision(use64bits: boolean): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+declare module BABYLON {
|
|
|
/**
|
|
|
* Class representing a vector containing 2 coordinates
|
|
|
*/
|
|
@@ -82374,6 +82460,10 @@ declare module BABYLON {
|
|
|
* Class used to store matrix data (4x4)
|
|
|
*/
|
|
|
export class Matrix {
|
|
|
+ /**
|
|
|
+ * Gets the precision of matrix computations
|
|
|
+ */
|
|
|
+ static get Use64Bits(): boolean;
|
|
|
private static _updateFlagSeed;
|
|
|
private static _identityReadOnly;
|
|
|
private _isIdentity;
|
|
@@ -82390,7 +82480,7 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* Gets the internal data of the matrix
|
|
|
*/
|
|
|
- get m(): DeepImmutable<Float32Array>;
|
|
|
+ get m(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
/** @hidden */
|
|
|
_markAsUpdated(): void;
|
|
|
/** @hidden */
|
|
@@ -82415,15 +82505,15 @@ declare module BABYLON {
|
|
|
*/
|
|
|
determinant(): number;
|
|
|
/**
|
|
|
- * Returns the matrix as a Float32Array
|
|
|
+ * Returns the matrix as a Float32Array or Array<number>
|
|
|
* @returns the matrix underlying array
|
|
|
*/
|
|
|
- toArray(): DeepImmutable<Float32Array>;
|
|
|
+ toArray(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
/**
|
|
|
- * Returns the matrix as a Float32Array
|
|
|
+ * Returns the matrix as a Float32Array or Array<number>
|
|
|
* @returns the matrix underlying array.
|
|
|
*/
|
|
|
- asArray(): DeepImmutable<Float32Array>;
|
|
|
+ asArray(): DeepImmutable<Float32Array | Array<number>>;
|
|
|
/**
|
|
|
* Inverts the current matrix in place
|
|
|
* @returns the current inverted matrix
|
|
@@ -82529,7 +82619,7 @@ declare module BABYLON {
|
|
|
* @param offset defines the offset in the target array where to start storing values
|
|
|
* @returns the current matrix
|
|
|
*/
|
|
|
- copyToArray(array: Float32Array, offset?: number): Matrix;
|
|
|
+ copyToArray(array: Float32Array | Array<number>, offset?: number): Matrix;
|
|
|
/**
|
|
|
* Sets the given matrix "result" with the multiplication result of the current Matrix and the given one
|
|
|
* @param other defines the second operand
|
|
@@ -82544,7 +82634,7 @@ declare module BABYLON {
|
|
|
* @param offset defines the offset in the target array where to start storing values
|
|
|
* @returns the current matrix
|
|
|
*/
|
|
|
- multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array, offset: number): Matrix;
|
|
|
+ multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array | Array<number>, offset: number): Matrix;
|
|
|
/**
|
|
|
* Check equality between this matrix and a second one
|
|
|
* @param value defines the second matrix to compare
|
|
@@ -82673,7 +82763,7 @@ declare module BABYLON {
|
|
|
* @param scale defines the scaling factor
|
|
|
* @param result defines the target matrix
|
|
|
*/
|
|
|
- static FromFloat32ArrayToRefScaled(array: DeepImmutable<Float32Array>, offset: number, scale: number, result: Matrix): void;
|
|
|
+ static FromFloat32ArrayToRefScaled(array: DeepImmutable<Float32Array | Array<number>>, offset: number, scale: number, result: Matrix): void;
|
|
|
/**
|
|
|
* Gets an identity matrix that must not be updated
|
|
|
*/
|
|
@@ -83096,13 +83186,13 @@ declare module BABYLON {
|
|
|
* @param matrix defines the matrix to use
|
|
|
* @returns a new Float32Array array with 4 elements : the 2x2 matrix extracted from the given matrix
|
|
|
*/
|
|
|
- static GetAsMatrix2x2(matrix: DeepImmutable<Matrix>): Float32Array;
|
|
|
+ static GetAsMatrix2x2(matrix: DeepImmutable<Matrix>): Float32Array | Array<number>;
|
|
|
/**
|
|
|
* Extracts a 3x3 matrix from a given matrix and store the result in a Float32Array
|
|
|
* @param matrix defines the matrix to use
|
|
|
* @returns a new Float32Array array with 9 elements : the 3x3 matrix extracted from the given matrix
|
|
|
*/
|
|
|
- static GetAsMatrix3x3(matrix: DeepImmutable<Matrix>): Float32Array;
|
|
|
+ static GetAsMatrix3x3(matrix: DeepImmutable<Matrix>): Float32Array | Array<number>;
|
|
|
/**
|
|
|
* Compute the transpose of a given matrix
|
|
|
* @param matrix defines the matrix to transpose
|
|
@@ -94826,14 +94916,14 @@ declare module BABYLON {
|
|
|
* @param value Define the value to give to the uniform
|
|
|
* @return the material itself allowing "fluent" like uniform updates
|
|
|
*/
|
|
|
- setMatrix3x3(name: string, value: Float32Array): ShaderMaterial;
|
|
|
+ setMatrix3x3(name: string, value: Float32Array | Array<number>): ShaderMaterial;
|
|
|
/**
|
|
|
* Set a mat2 in the shader from a Float32Array.
|
|
|
* @param name Define the name of the uniform as defined in the shader
|
|
|
* @param value Define the value to give to the uniform
|
|
|
* @return the material itself allowing "fluent" like uniform updates
|
|
|
*/
|
|
|
- setMatrix2x2(name: string, value: Float32Array): ShaderMaterial;
|
|
|
+ setMatrix2x2(name: string, value: Float32Array | Array<number>): ShaderMaterial;
|
|
|
/**
|
|
|
* Set a vec2 array in the shader from a number array.
|
|
|
* @param name Define the name of the uniform as defined in the shader
|
|
@@ -98595,6 +98685,12 @@ declare module BABYLON {
|
|
|
*/
|
|
|
constructor(name: string, target?: NodeMaterialBlockTargets, type?: NodeMaterialBlockConnectionPointTypes);
|
|
|
/**
|
|
|
+ * Validates if a name is a reserve word.
|
|
|
+ * @param newName the new name to be given to the node.
|
|
|
+ * @returns false if the name is a reserve word, else true.
|
|
|
+ */
|
|
|
+ validateBlockName(newName: string): boolean;
|
|
|
+ /**
|
|
|
* Gets the output component
|
|
|
*/
|
|
|
get output(): NodeMaterialConnectionPoint;
|
|
@@ -99665,6 +99761,7 @@ declare module BABYLON {
|
|
|
private _target;
|
|
|
private _isFinalMerger;
|
|
|
private _isInput;
|
|
|
+ private _name;
|
|
|
protected _isUnique: boolean;
|
|
|
/** Gets or sets a boolean indicating that only one input can be connected at a time */
|
|
|
inputsAreExclusive: boolean;
|
|
@@ -99677,9 +99774,13 @@ declare module BABYLON {
|
|
|
/** @hidden */
|
|
|
_preparationId: number;
|
|
|
/**
|
|
|
- * Gets or sets the name of the block
|
|
|
+ * Gets the name of the block
|
|
|
*/
|
|
|
- name: string;
|
|
|
+ get name(): string;
|
|
|
+ /**
|
|
|
+ * Sets the name of the block. Will check if the name is valid.
|
|
|
+ */
|
|
|
+ set name(newName: string);
|
|
|
/**
|
|
|
* Gets or sets the unique id of the node
|
|
|
*/
|
|
@@ -99862,6 +99963,12 @@ declare module BABYLON {
|
|
|
protected _linkConnectionTypes(inputIndex0: number, inputIndex1: number): void;
|
|
|
private _processBuild;
|
|
|
/**
|
|
|
+ * Validates the new name for the block node.
|
|
|
+ * @param newName the new name to be given to the node.
|
|
|
+ * @returns false if the name is a reserve word, else true.
|
|
|
+ */
|
|
|
+ validateBlockName(newName: string): boolean;
|
|
|
+ /**
|
|
|
* Compile the current node and generate the shader code
|
|
|
* @param state defines the current compilation state (uniforms, samplers, current string)
|
|
|
* @param activeBlocks defines the list of active blocks (i.e. blocks to compile)
|
|
@@ -112087,7 +112194,7 @@ declare module BABYLON {
|
|
|
* @param matrices matrices to be set.
|
|
|
* @returns this effect.
|
|
|
*/
|
|
|
- setMatrices(uniformName: string, matrices: Float32Array): Effect;
|
|
|
+ setMatrices(uniformName: string, matrices: Float32Array | Array<number>): Effect;
|
|
|
/**
|
|
|
* Sets matrix on a uniform variable.
|
|
|
* @param uniformName Name of the variable.
|
|
@@ -112101,14 +112208,14 @@ declare module BABYLON {
|
|
|
* @param matrix matrix to be set.
|
|
|
* @returns this effect.
|
|
|
*/
|
|
|
- setMatrix3x3(uniformName: string, matrix: Float32Array): Effect;
|
|
|
+ setMatrix3x3(uniformName: string, matrix: Float32Array | Array<number>): Effect;
|
|
|
/**
|
|
|
* Sets a 2x2 matrix on a uniform variable. (Speicified as [1,2,3,4] will result in [1,2][3,4] matrix)
|
|
|
* @param uniformName Name of the variable.
|
|
|
* @param matrix matrix to be set.
|
|
|
* @returns this effect.
|
|
|
*/
|
|
|
- setMatrix2x2(uniformName: string, matrix: Float32Array): Effect;
|
|
|
+ setMatrix2x2(uniformName: string, matrix: Float32Array | Array<number>): Effect;
|
|
|
/**
|
|
|
* Sets a float on a uniform variable.
|
|
|
* @param uniformName Name of the variable.
|
|
@@ -112697,6 +112804,10 @@ declare module BABYLON {
|
|
|
* Make the canvas XR Compatible for XR sessions
|
|
|
*/
|
|
|
xrCompatible?: boolean;
|
|
|
+ /**
|
|
|
+ * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default
|
|
|
+ */
|
|
|
+ useHighPrecisionMatrix?: boolean;
|
|
|
}
|
|
|
/**
|
|
|
* The base engine class (root of all engines)
|
|
@@ -125370,6 +125481,7 @@ declare module BABYLON {
|
|
|
*/
|
|
|
static OnPluginActivatedObservable: Observable<ISceneLoaderPlugin | ISceneLoaderPluginAsync>;
|
|
|
private static _registeredPlugins;
|
|
|
+ private static _showingLoadingScreen;
|
|
|
private static _getDefaultPlugin;
|
|
|
private static _getPluginForExtension;
|
|
|
private static _getPluginForDirectLoad;
|
|
@@ -127873,6 +127985,7 @@ declare module BABYLON {
|
|
|
*/
|
|
|
_rootMesh: Mesh;
|
|
|
private _attachedMesh;
|
|
|
+ private _attachedNode;
|
|
|
/**
|
|
|
* Ratio for the scale of the gizmo (Default: 1)
|
|
|
*/
|
|
@@ -127888,6 +128001,12 @@ declare module BABYLON {
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(value: Nullable<AbstractMesh>);
|
|
|
/**
|
|
|
+ * Node that the gizmo will be attached to. (eg. on a drag gizmo the mesh, bone or NodeTransform that will be dragged)
|
|
|
+ * * When set, interactions will be enabled
|
|
|
+ */
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(value: Nullable<Node>);
|
|
|
+ /**
|
|
|
* Disposes and replaces the current meshes in the gizmo with the specified mesh
|
|
|
* @param mesh The mesh to replace the default mesh of the gizmo
|
|
|
*/
|
|
@@ -127905,7 +128024,7 @@ declare module BABYLON {
|
|
|
*/
|
|
|
updateScale: boolean;
|
|
|
protected _interactionsEnabled: boolean;
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
private _beforeRenderObserver;
|
|
|
private _tempVector;
|
|
|
/**
|
|
@@ -127920,6 +128039,11 @@ declare module BABYLON {
|
|
|
*/
|
|
|
protected _update(): void;
|
|
|
/**
|
|
|
+ * computes the rotation/scaling/position of the transform once the Node world matrix has changed.
|
|
|
+ * @param value Node, TransformNode or mesh
|
|
|
+ */
|
|
|
+ protected _matrixChanged(): void;
|
|
|
+ /**
|
|
|
* Disposes of the gizmo
|
|
|
*/
|
|
|
dispose(): void;
|
|
@@ -127962,7 +128086,7 @@ declare module BABYLON {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(dragPlaneNormal: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, parent?: Nullable<PositionGizmo>);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -128007,6 +128131,7 @@ declare module BABYLON {
|
|
|
* private variables
|
|
|
*/
|
|
|
private _meshAttached;
|
|
|
+ private _nodeAttached;
|
|
|
private _updateGizmoRotationToMatchAttachedMesh;
|
|
|
private _snapDistance;
|
|
|
private _scaleRatio;
|
|
@@ -128020,6 +128145,8 @@ declare module BABYLON {
|
|
|
private _planarGizmoEnabled;
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(mesh: Nullable<AbstractMesh>);
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(node: Nullable<Node>);
|
|
|
/**
|
|
|
* Creates a PositionGizmo
|
|
|
* @param gizmoLayer The utility layer the gizmo will be added to
|
|
@@ -128091,7 +128218,7 @@ declare module BABYLON {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(dragAxis: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, parent?: Nullable<PositionGizmo>);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -129001,6 +129128,10 @@ declare module BABYLON {
|
|
|
* @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
|
|
|
*/
|
|
|
lockstepMaxSteps: number;
|
|
|
+ /**
|
|
|
+ * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default
|
|
|
+ */
|
|
|
+ useHighPrecisionMatrix?: boolean;
|
|
|
}
|
|
|
/**
|
|
|
* The null engine class provides support for headless version of babylon.js.
|
|
@@ -130890,6 +131021,7 @@ declare module BABYLON {
|
|
|
*/
|
|
|
uniformScaleGizmo: AxisScaleGizmo;
|
|
|
private _meshAttached;
|
|
|
+ private _nodeAttached;
|
|
|
private _updateGizmoRotationToMatchAttachedMesh;
|
|
|
private _snapDistance;
|
|
|
private _scaleRatio;
|
|
@@ -130902,6 +131034,8 @@ declare module BABYLON {
|
|
|
onDragEndObservable: Observable<unknown>;
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(mesh: Nullable<AbstractMesh>);
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(node: Nullable<Node>);
|
|
|
/**
|
|
|
* Creates a ScaleGizmo
|
|
|
* @param gizmoLayer The utility layer the gizmo will be added to
|
|
@@ -130971,7 +131105,7 @@ declare module BABYLON {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(dragAxis: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, parent?: Nullable<ScaleGizmo>);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -131049,11 +131183,11 @@ declare module BABYLON {
|
|
|
*/
|
|
|
onRotationSphereDragEndObservable: Observable<{}>;
|
|
|
/**
|
|
|
- * Relative bounding box pivot used when scaling the attached mesh. When null object with scale from the opposite corner. 0.5,0.5,0.5 for center and 0.5,0,0.5 for bottom (Default: null)
|
|
|
+ * Relative bounding box pivot used when scaling the attached node. When null object with scale from the opposite corner. 0.5,0.5,0.5 for center and 0.5,0,0.5 for bottom (Default: null)
|
|
|
*/
|
|
|
scalePivot: Nullable<Vector3>;
|
|
|
/**
|
|
|
- * Mesh used as a pivot to rotate the attached mesh
|
|
|
+ * Mesh used as a pivot to rotate the attached node
|
|
|
*/
|
|
|
private _anchorMesh;
|
|
|
private _existingMeshScale;
|
|
@@ -131072,7 +131206,7 @@ declare module BABYLON {
|
|
|
* @param color The color of the gizmo
|
|
|
*/
|
|
|
constructor(color?: Color3, gizmoLayer?: UtilityLayerRenderer);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<AbstractMesh>): void;
|
|
|
private _selectNode;
|
|
|
/**
|
|
|
* Updates the bounding box information for the Gizmo
|
|
@@ -131145,7 +131279,7 @@ declare module BABYLON {
|
|
|
* @param useEulerRotation Use and update Euler angle instead of quaternion
|
|
|
*/
|
|
|
constructor(planeNormal: Vector3, color?: Color3, gizmoLayer?: UtilityLayerRenderer, tessellation?: number, parent?: Nullable<RotationGizmo>, useEulerRotation?: boolean);
|
|
|
- protected _attachedMeshChanged(value: Nullable<AbstractMesh>): void;
|
|
|
+ protected _attachedNodeChanged(value: Nullable<Node>): void;
|
|
|
/**
|
|
|
* If the gizmo is enabled
|
|
|
*/
|
|
@@ -131179,8 +131313,11 @@ declare module BABYLON {
|
|
|
/** Fires an event when any of it's sub gizmos are released from dragging */
|
|
|
onDragEndObservable: Observable<unknown>;
|
|
|
private _meshAttached;
|
|
|
+ private _nodeAttached;
|
|
|
get attachedMesh(): Nullable<AbstractMesh>;
|
|
|
set attachedMesh(mesh: Nullable<AbstractMesh>);
|
|
|
+ get attachedNode(): Nullable<Node>;
|
|
|
+ set attachedNode(node: Nullable<Node>);
|
|
|
/**
|
|
|
* Creates a RotationGizmo
|
|
|
* @param gizmoLayer The utility layer the gizmo will be added to
|