Options
All
  • Public
  • Public/Protected
  • All
Menu

Class InstancedMesh

Creates an instance based on a source mesh.

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

actionManagerSearch playground for actionManager

Gets or sets the current action manager

see

https://doc.babylonjs.com/how_to/how_to_use_actions

alphaIndexSearch playground for alphaIndex

alphaIndex: number

Gets or sets the alpha index used to sort transparent meshes

see

https://doc.babylonjs.com/resources/transparency_and_how_meshes_are_rendered#alpha-index

alwaysSelectAsActiveMeshSearch playground for alwaysSelectAsActiveMesh

alwaysSelectAsActiveMesh: boolean

True if the mesh must be rendered in any case (this will shortcut the frustum clipping phase)

animationsSearch playground for animations

animations: Animation[]

Gets a list of Animations associated with the node

cullingStrategySearch playground for cullingStrategy

cullingStrategy: number

The culling strategy to use to check whether the mesh must be rendered or not. This value can be changed at any time and will be used on the next render mesh selection. The possible values are :

  • AbstractMesh.CULLINGSTRATEGY_STANDARD
  • AbstractMesh.CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY
  • AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION
  • AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY Please read each static variable documentation to get details about the culling process.

definedFacingForwardSearch playground for definedFacingForward

definedFacingForward: boolean

Gets or sets the orientation for POV movement & rotation

doNotSyncBoundingInfoSearch playground for doNotSyncBoundingInfo

doNotSyncBoundingInfo: boolean

Gets or sets a boolean indicating that the bounding info does not need to be kept in sync (for performance reason)

edgesColorSearch playground for edgesColor

edgesColor: Color4

Defines edge color used when edgesRenderer is enabled

see

https://www.babylonjs-playground.com/#10OJSG#13

edgesRendererSearch playground for edgesRenderer

edgesRenderer: Nullable<EdgesRenderer>

Gets the edgesRenderer associated with the mesh

edgesWidthSearch playground for edgesWidth

edgesWidth: number

Defines edge width used when edgesRenderer is enabled

see

https://www.babylonjs-playground.com/#10OJSG#13

ellipsoidSearch playground for ellipsoid

ellipsoid: Vector3

Gets or sets the ellipsoid used to impersonate this mesh when using collision engine (default is (0.5, 1, 0.5))

see

https://doc.babylonjs.com/babylon101/cameras,_mesh_collisions_and_gravity

ellipsoidOffsetSearch playground for ellipsoidOffset

ellipsoidOffset: Vector3

Gets or sets the ellipsoid offset used to impersonate this mesh when using collision engine (default is (0, 0, 0))

see

https://doc.babylonjs.com/babylon101/cameras,_mesh_collisions_and_gravity

enablePointerMoveEventsSearch playground for enablePointerMoveEvents

enablePointerMoveEvents: boolean

Gets or sets a boolean indicating that pointer move events must be supported on this mesh (false by default)

idSearch playground for id

id: string

Gets or sets the id of the node

ignoreNonUniformScalingSearch playground for ignoreNonUniformScaling

ignoreNonUniformScaling: boolean

Gets or sets a boolean indicating that non uniform scaling (when at least one component is different from others) should be ignored. By default the system will update normals to compensate

inspectableCustomPropertiesSearch playground for inspectableCustomProperties

inspectableCustomProperties: IInspectable[]

List of inspectable custom properties (used by the Inspector)

see

https://doc.babylonjs.com/how_to/debug_layer#extensibility

instancedBuffersSearch playground for instancedBuffers

instancedBuffers: {}

Object used to store instanced buffers defined by user

see

https://doc.babylonjs.com/how_to/how_to_use_instances#custom-buffers

Type declaration

  • [key: string]: any

isBlockerSearch playground for isBlocker

isBlocker: boolean

Gets or sets a boolean indicating if the mesh must be considered as a ray blocker for lens flares (false by default)

see

https://doc.babylonjs.com/how_to/how_to_use_lens_flares

isOccludedSearch playground for isOccluded

isOccluded: boolean

Gets or sets whether the mesh is occluded or not, it is used also to set the intial state of the mesh to be occluded or not

see

https://doc.babylonjs.com/features/occlusionquery

isOcclusionQueryInProgressSearch playground for isOcclusionQueryInProgress

isOcclusionQueryInProgress: boolean

Flag to check the progress status of the query

see

https://doc.babylonjs.com/features/occlusionquery

isPickableSearch playground for isPickable

isPickable: boolean

Gets or sets a boolean indicating if the mesh can be picked (by scene.pick for instance or through actions). Default is true

isVisibleSearch playground for isVisible

isVisible: boolean

Gets or sets a boolean indicating if the mesh is visible (renderable). Default is true

metadataSearch playground for metadata

metadata: any

Gets or sets an object used to store user defined information for the node

nameSearch playground for name

name: string

Gets or sets the name of the node

occlusionQueryAlgorithmTypeSearch playground for occlusionQueryAlgorithmType

occlusionQueryAlgorithmType: number

This property determines the type of occlusion query algorithm to run in WebGl, you can use:

  • AbstractMesh.OCCLUSION_ALGORITHM_TYPE_ACCURATE which is mapped to GL_ANY_SAMPLES_PASSED.
  • AbstractMesh.OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE (Default Value) which is mapped to GL_ANY_SAMPLES_PASSED_CONSERVATIVE which is a false positive algorithm that is faster than GL_ANY_SAMPLES_PASSED but less accurate.
see

https://doc.babylonjs.com/features/occlusionquery

occlusionRetryCountSearch playground for occlusionRetryCount

occlusionRetryCount: number

This number indicates the number of allowed retries before stop the occlusion query, this is useful if the occlusion query is taking long time before to the query result is retireved, the query result indicates if the object is visible within the scene or not and based on that Babylon.Js engine decideds to show or hide the object. The default value is -1 which means don't break the query and wait till the result

see

https://doc.babylonjs.com/features/occlusionquery

occlusionTypeSearch playground for occlusionType

occlusionType: number

This property is responsible for starting the occlusion query within the Mesh or not, this property is also used to determine what should happen when the occlusionRetryCount is reached. It has supports 3 values:

  • OCCLUSION_TYPE_NONE (Default Value): this option means no occlusion query whith the Mesh.
  • OCCLUSION_TYPE_OPTIMISTIC: this option is means use occlusion query and if occlusionRetryCount is reached and the query is broken show the mesh.
  • OCCLUSION_TYPE_STRICT: this option is means use occlusion query and if occlusionRetryCount is reached and the query is broken restore the last state of the mesh occlusion if the mesh was visible then show the mesh if was hidden then hide don't show.
see

https://doc.babylonjs.com/features/occlusionquery

onAfterWorldMatrixUpdateObservableSearch playground for onAfterWorldMatrixUpdateObservable

onAfterWorldMatrixUpdateObservable: Observable<TransformNode>

An event triggered after the world matrix is updated

onCollideObservableSearch playground for onCollideObservable

onCollideObservable: Observable<AbstractMesh>

An event triggered when this mesh collides with another one

onCollisionPositionChangeObservableSearch playground for onCollisionPositionChangeObservable

onCollisionPositionChangeObservable: Observable<Vector3>

An event triggered when the collision's position changes

onDisposeObservableSearch playground for onDisposeObservable

onDisposeObservable: Observable<Node>

An event triggered when the mesh is disposed

onMaterialChangedObservableSearch playground for onMaterialChangedObservable

onMaterialChangedObservable: Observable<AbstractMesh>

An event triggered when material is changed

onReadySearch playground for onReady

onReady: Nullable<(node: Node) => void>

Callback raised when the node is ready to be used

onRebuildObservableSearch playground for onRebuildObservable

onRebuildObservable: Observable<AbstractMesh>

An event triggered when the mesh is rebuilt.

outlineColorSearch playground for outlineColor

outlineColor: Color3

Defines color to use when rendering outline

outlineWidthSearch playground for outlineWidth

outlineWidth: number

Define width to use when rendering outline

overlayAlphaSearch playground for overlayAlpha

overlayAlpha: number

Defines alpha to use when rendering overlay

overlayColorSearch playground for overlayColor

overlayColor: Color3

Defines color to use when rendering overlay

physicsImpostorSearch playground for physicsImpostor

physicsImpostor: Nullable<PhysicsImpostor>

Gets or sets impostor used for physic simulation

see

https://doc.babylonjs.com/features/physics_engine

reIntegrateRotationIntoRotationQuaternionSearch playground for reIntegrateRotationIntoRotationQuaternion

reIntegrateRotationIntoRotationQuaternion: boolean

Gets or sets a boolean indicating that even if rotationQuaternion is defined, you can keep updating rotation property and Babylon.js will just mix both

renderOutlineSearch playground for renderOutline

renderOutline: boolean

Gets or sets a boolean indicating if the outline must be rendered as well

see

https://www.babylonjs-playground.com/#10WJ5S#3

renderOverlaySearch playground for renderOverlay

renderOverlay: boolean

Gets or sets a boolean indicating if the overlay must be rendered as well

see

https://www.babylonjs-playground.com/#10WJ5S#2

reservedDataStoreSearch playground for reservedDataStore

reservedDataStore: any

For internal use only. Please do not use.

scalingDeterminantSearch playground for scalingDeterminant

scalingDeterminant: number

Multiplication factor on scale x/y/z when computing the world matrix. Eg. for a 1x1x1 cube setting this to 2 will make it a 2x2x2 cube

showBoundingBoxSearch playground for showBoundingBox

showBoundingBox: boolean

Gets or sets a boolean indicating if the bounding box must be rendered as well (false by default)

showSubMeshesBoundingBoxSearch playground for showSubMeshesBoundingBox

showSubMeshesBoundingBox: boolean

Gets or sets a boolean indicating that bounding boxes of subMeshes must be rendered as well (false by default)

stateSearch playground for state

state: string

Gets or sets a string used to store user defined state for the node

subMeshesSearch playground for subMeshes

subMeshes: SubMesh[]

Gets or sets the list of subMeshes

see

https://doc.babylonjs.com/how_to/multi_materials

uniqueIdSearch playground for uniqueId

uniqueId: number

Gets or sets the unique id of the node

useOctreeForCollisionsSearch playground for useOctreeForCollisions

useOctreeForCollisions: boolean

Gets or sets a boolean indicating that internal octree (if available) can be used to boost submeshes collision (true by default)

useOctreeForPickingSearch playground for useOctreeForPicking

useOctreeForPicking: boolean

Gets or sets a boolean indicating that internal octree (if available) can be used to boost submeshes picking (true by default)

useOctreeForRenderingSelectionSearch playground for useOctreeForRenderingSelection

useOctreeForRenderingSelection: boolean

Gets or sets a boolean indicating that internal octree (if available) can be used to boost submeshes selection (true by default)

Static Readonly CULLINGSTRATEGY_BOUNDINGSPHERE_ONLYSearch playground for CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY

CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY: number

Culling strategy : Bounding Sphere Only. This is an exclusion test. It's faster than the standard strategy because the bounding box is not tested. It's also less accurate than the standard because some not visible objects can still be selected. Test : is the bounding sphere outside the frustum ? If not, then the cullable object is in the frustum.

Static Readonly CULLINGSTRATEGY_OPTIMISTIC_INCLUSIONSearch playground for CULLINGSTRATEGY_OPTIMISTIC_INCLUSION

CULLINGSTRATEGY_OPTIMISTIC_INCLUSION: number

Culling strategy : Optimistic Inclusion. This in an inclusion test first, then the standard exclusion test. This can be faster when a cullable object is expected to be almost always in the camera frustum. This could also be a little slower than the standard test when the tested object center is not the frustum but one of its bounding box vertex is still inside. Anyway, it's as accurate as the standard strategy. Test : Is the cullable object bounding sphere center in the frustum ? If not, apply the default culling strategy.

Static Readonly CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLYSearch playground for CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY

CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY: number

Culling strategy : Optimistic Inclusion then Bounding Sphere Only. This in an inclusion test first, then the bounding sphere only exclusion test. This can be the fastest test when a cullable object is expected to be almost always in the camera frustum. This could also be a little slower than the BoundingSphereOnly strategy when the tested object center is not in the frustum but its bounding sphere still intersects it. It's less accurate than the standard strategy and as accurate as the BoundingSphereOnly strategy. Test : Is the cullable object bounding sphere center in the frustum ? If not, apply the Bounding Sphere Only strategy. No Bounding Box is tested here.

Static Readonly CULLINGSTRATEGY_STANDARDSearch playground for CULLINGSTRATEGY_STANDARD

CULLINGSTRATEGY_STANDARD: number

Default culling strategy : this is an exclusion test and it's the more accurate. Test order : Is the bounding sphere outside the frustum ? If not, are the bounding box vertices outside the frustum ? It not, then the cullable object is in the frustum.

Static OCCLUSION_ALGORITHM_TYPE_ACCURATESearch playground for OCCLUSION_ALGORITHM_TYPE_ACCURATE

OCCLUSION_ALGORITHM_TYPE_ACCURATE: number

Use an accurante occlusion algorithm

Static OCCLUSION_ALGORITHM_TYPE_CONSERVATIVESearch playground for OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE

OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE: number

Use a conservative occlusion algorithm

Static OCCLUSION_TYPE_NONESearch playground for OCCLUSION_TYPE_NONE

OCCLUSION_TYPE_NONE: number

No occlusion

Static OCCLUSION_TYPE_OPTIMISTICSearch playground for OCCLUSION_TYPE_OPTIMISTIC

OCCLUSION_TYPE_OPTIMISTIC: number

Occlusion set to optimisitic

Static OCCLUSION_TYPE_STRICTSearch playground for OCCLUSION_TYPE_STRICT

OCCLUSION_TYPE_STRICT: number

Occlusion set to strict

Accessors

_positions

  • Returns Nullable<Vector3[]>

absolutePosition

absoluteRotationQuaternion

absoluteScaling

animationPropertiesOverride

applyFog

  • get applyFog(): boolean
  • set applyFog(value: boolean): any
  • Gets or sets a boolean indicating that this mesh will allow fog to be rendered on it (true by default)

    Returns boolean

  • Gets or sets a boolean indicating that this mesh will allow fog to be rendered on it (true by default)

    Parameters

    • value: boolean

    Returns any

behaviors

billboardMode

  • get billboardMode(): number
  • set billboardMode(value: number): any
  • Gets or sets the billboard mode. Default is 0.

    Value Type Description
    0 BILLBOARDMODE_NONE
    1 BILLBOARDMODE_X
    2 BILLBOARDMODE_Y
    4 BILLBOARDMODE_Z
    7 BILLBOARDMODE_ALL

    Returns number

  • Gets or sets the billboard mode. Default is 0.

    Value Type Description
    0 BILLBOARDMODE_NONE
    1 BILLBOARDMODE_X
    2 BILLBOARDMODE_Y
    4 BILLBOARDMODE_Z
    7 BILLBOARDMODE_ALL

    Parameters

    • value: number

    Returns any

checkCollisions

  • get checkCollisions(): boolean
  • set checkCollisions(collisionEnabled: boolean): any

collider

collisionGroup

  • get collisionGroup(): number
  • set collisionGroup(mask: number): any
  • Gets or sets the current collision group mask (-1 by default). A collision between A and B will happen if A.collisionGroup & b.collisionMask !== 0

    Returns number

  • Gets or sets the current collision group mask (-1 by default). A collision between A and B will happen if A.collisionGroup & b.collisionMask !== 0

    Parameters

    • mask: number

    Returns any

collisionMask

  • get collisionMask(): number
  • set collisionMask(mask: number): any
  • Gets or sets a collision mask used to mask collisions (default is -1). A collision between A and B will happen if A.collisionGroup & b.collisionMask !== 0

    Returns number

  • Gets or sets a collision mask used to mask collisions (default is -1). A collision between A and B will happen if A.collisionGroup & b.collisionMask !== 0

    Parameters

    • mask: number

    Returns any

collisionResponse

  • get collisionResponse(): boolean
  • set collisionResponse(response: boolean): any
  • Gets or sets a collision response flag (default is true). when collisionResponse is false, events are still triggered but colliding entity has no response This helps creating trigger volume when user wants collision feedback events but not position/velocity to respond to the collision.

    Returns boolean

  • Gets or sets a collision response flag (default is true). when collisionResponse is false, events are still triggered but colliding entity has no response This helps creating trigger volume when user wants collision feedback events but not position/velocity to respond to the collision.

    Parameters

    • response: boolean

    Returns any

computeBonesUsingShaders

  • get computeBonesUsingShaders(): boolean
  • set computeBonesUsingShaders(value: boolean): any
  • Gets or sets a boolean indicating that bone animations must be computed by the CPU (false by default)

    Returns boolean

  • Gets or sets a boolean indicating that bone animations must be computed by the CPU (false by default)

    Parameters

    • value: boolean

    Returns any

doNotSerialize

  • get doNotSerialize(): boolean
  • set doNotSerialize(value: boolean): any
  • Gets or sets a boolean used to define if the node must be serialized

    Returns boolean

  • Gets or sets a boolean used to define if the node must be serialized

    Parameters

    • value: boolean

    Returns any

facetDepthSortFrom

  • get facetDepthSortFrom(): Vector3
  • set facetDepthSortFrom(location: Vector3): any

facetNb

  • get facetNb(): number

forward

  • The forward direction of that transform in world space.

    Returns Vector3

hasInstances

  • get hasInstances(): boolean
  • Gets a boolean indicating if this mesh has instances

    Returns boolean

hasThinInstances

  • get hasThinInstances(): boolean
  • Gets a boolean indicating if this mesh has thin instances

    Returns boolean

hasVertexAlpha

  • get hasVertexAlpha(): boolean
  • set hasVertexAlpha(value: boolean): any
  • Gets or sets a boolean indicating that this mesh contains vertex color data with alpha values

    Returns boolean

  • Gets or sets a boolean indicating that this mesh contains vertex color data with alpha values

    Parameters

    • value: boolean

    Returns any

infiniteDistance

  • get infiniteDistance(): boolean
  • set infiniteDistance(value: boolean): any
  • Gets or sets the distance of the object to max, often used by skybox

    Returns boolean

  • Gets or sets the distance of the object to max, often used by skybox

    Parameters

    • value: boolean

    Returns any

isAnInstance

  • get isAnInstance(): boolean
  • Returns boolean

isBlocked

  • get isBlocked(): boolean
  • Returns true if the mesh is blocked. Implemented by child classes

    Returns boolean

isFacetDataEnabled

  • get isFacetDataEnabled(): boolean

isWorldMatrixFrozen

  • get isWorldMatrixFrozen(): boolean

layerMask

  • get layerMask(): number
  • set layerMask(value: number): any

lightSources

  • get lightSources(): Light[]
  • Gets the list of lights affecting that mesh

    Returns Light[]

material

mustDepthSortFacets

  • get mustDepthSortFacets(): boolean
  • set mustDepthSortFacets(sort: boolean): any

nonUniformScaling

  • get nonUniformScaling(): boolean
  • True if the scaling property of this object is non uniform eg. (1,2,1)

    Returns boolean

numBoneInfluencers

  • get numBoneInfluencers(): number
  • set numBoneInfluencers(value: number): any
  • Gets or sets the number of allowed bone influences per vertex (4 by default)

    Returns number

  • Gets or sets the number of allowed bone influences per vertex (4 by default)

    Parameters

    • value: number

    Returns any

onCollide

  • set onCollide(callback: () => void): any
  • Set a function to call when this mesh collides with another one

    Parameters

    • callback: () => void
        • (): void
        • Returns void

    Returns any

onCollisionPositionChange

  • set onCollisionPositionChange(callback: () => void): any
  • Set a function to call when the collision's position changes

    Parameters

    • callback: () => void
        • (): void
        • Returns void

    Returns any

onDispose

  • set onDispose(callback: () => void): any
  • Sets a callback that will be raised when the node will be disposed

    Parameters

    • callback: () => void
        • (): void
        • Returns void

    Returns any

parent

partitioningBBoxRatio

  • get partitioningBBoxRatio(): number
  • set partitioningBBoxRatio(ratio: number): any

partitioningSubdivisions

  • get partitioningSubdivisions(): number
  • set partitioningSubdivisions(nb: number): any

position

  • Gets or set the node position (default is (0.0, 0.0, 0.0))

    Returns Vector3

  • Gets or set the node position (default is (0.0, 0.0, 0.0))

    Parameters

    Returns any

preserveParentRotationForBillboard

  • get preserveParentRotationForBillboard(): boolean
  • set preserveParentRotationForBillboard(value: boolean): any
  • Gets or sets a boolean indicating that parent rotation should be preserved when using billboards. This could be useful for glTF objects where parent rotation helps converting from right handed to left handed

    Returns boolean

  • Gets or sets a boolean indicating that parent rotation should be preserved when using billboards. This could be useful for glTF objects where parent rotation helps converting from right handed to left handed

    Parameters

    • value: boolean

    Returns any

receiveShadows

  • get receiveShadows(): boolean
  • If the source mesh receives shadows

    Returns boolean

renderingGroupId

  • get renderingGroupId(): number
  • set renderingGroupId(value: number): any
  • Rendering ground id of the source mesh

    Returns number

  • Rendering ground id of the source mesh

    Parameters

    • value: number

    Returns any

right

  • The right direction of that transform in world space.

    Returns Vector3

rotation

  • Gets or sets the rotation property : a Vector3 defining the rotation value in radians around each local axis X, Y, Z (default is (0.0, 0.0, 0.0)). If rotation quaternion is set, this Vector3 will be ignored and copy from the quaternion

    Returns Vector3

  • Gets or sets the rotation property : a Vector3 defining the rotation value in radians around each local axis X, Y, Z (default is (0.0, 0.0, 0.0)). If rotation quaternion is set, this Vector3 will be ignored and copy from the quaternion

    Parameters

    Returns any

rotationQuaternion

  • Gets or sets the rotation Quaternion property : this a Quaternion object defining the node rotation by using a unit quaternion (undefined by default, but can be null). If set, only the rotationQuaternion is then used to compute the node rotation (ie. node.rotation will be ignored)

    Returns Nullable<Quaternion>

  • Gets or sets the rotation Quaternion property : this a Quaternion object defining the node rotation by using a unit quaternion (undefined by default, but can be null). If set, only the rotationQuaternion is then used to compute the node rotation (ie. node.rotation will be ignored)

    Parameters

    Returns any

scaling

  • Gets or sets a Vector3 depicting the mesh scaling along each local axis X, Y, Z. Default is (1.0, 1.0, 1.0)

    Returns Vector3

  • Gets or sets a Vector3 depicting the mesh scaling along each local axis X, Y, Z. Default is (1.0, 1.0, 1.0)

    Parameters

    Returns any

skeleton

sourceMesh

  • get sourceMesh(): Mesh
  • The source mesh of the instance

    Returns Mesh

surroundingMeshes

  • Gets or sets current surrounding meshes (null by default).

    By default collision detection is tested against every mesh in the scene. It is possible to set surroundingMeshes to a defined list of meshes and then only these specified meshes will be tested for the collision.

    Note: if set to an empty array no collision will happen when this mesh is moved.

    Returns Nullable<AbstractMesh[]>

  • Gets or sets current surrounding meshes (null by default).

    By default collision detection is tested against every mesh in the scene. It is possible to set surroundingMeshes to a defined list of meshes and then only these specified meshes will be tested for the collision.

    Note: if set to an empty array no collision will happen when this mesh is moved.

    Parameters

    Returns any

up

  • The up direction of that transform in world space.

    Returns Vector3

useBones

  • get useBones(): boolean
  • Gets a boolean indicating if this mesh has skinning data and an attached skeleton

    Returns boolean

useVertexColors

  • get useVertexColors(): boolean
  • set useVertexColors(value: boolean): any
  • Gets or sets a boolean indicating that this mesh needs to use vertex color data to render (if this kind of vertex data is available in the geometry)

    Returns boolean

  • Gets or sets a boolean indicating that this mesh needs to use vertex color data to render (if this kind of vertex data is available in the geometry)

    Parameters

    • value: boolean

    Returns any

visibility

  • get visibility(): number
  • Visibility of the source mesh

    Returns number

worldMatrixFromCache

  • get worldMatrixFromCache(): Matrix
  • Returns directly the latest state of the mesh World matrix. A Matrix is returned.

    Returns Matrix

Static BILLBOARDMODE_ALL

  • get BILLBOARDMODE_ALL(): number

Static BILLBOARDMODE_NONE

  • get BILLBOARDMODE_NONE(): number

Static BILLBOARDMODE_USE_POSITION

  • get BILLBOARDMODE_USE_POSITION(): number

Static BILLBOARDMODE_X

  • get BILLBOARDMODE_X(): number

Static BILLBOARDMODE_Y

  • get BILLBOARDMODE_Y(): number

Static BILLBOARDMODE_Z

  • get BILLBOARDMODE_Z(): number

Methods

_removeLightSourceSearch playground for _removeLightSource

  • _removeLightSource(light: Light, dispose: boolean): void
  • Parameters

    • light: Light
    • dispose: boolean

    Returns void

_resyncLightSourceSearch playground for _resyncLightSource

  • _resyncLightSource(light: Light): void
  • Parameters

    Returns void

_resyncLightSourcesSearch playground for _resyncLightSources

  • _resyncLightSources(): void
  • Returns void

addBehaviorSearch playground for addBehavior

addChildSearch playground for addChild

  • Adds the passed mesh as a child to the current mesh

    Parameters

    Returns AbstractMesh

    the current mesh

addRotationSearch playground for addRotation

  • Adds a rotation step to the mesh current rotation. x, y, z are Euler angles expressed in radians. This methods updates the current mesh rotation, either mesh.rotation, either mesh.rotationQuaternion if it's set. This means this rotation is made in the mesh local space only. It's useful to set a custom rotation order different from the BJS standard one YXZ. Example : this rotates the mesh first around its local X axis, then around its local Z axis, finally around its local Y axis.

    mesh.addRotation(x1, 0, 0).addRotation(0, 0, z2).addRotation(0, 0, y3);

    Note that addRotation() accumulates the passed rotation values to the current ones and computes the .rotation or .rotationQuaternion updated values. Under the hood, only quaternions are used. So it's a little faster is you use .rotationQuaternion because it doesn't need to translate them back to Euler angles.

    Parameters

    • x: number

      Rotation to add

    • y: number

      Rotation to add

    • z: number

      Rotation to add

    Returns TransformNode

    the TransformNode.

alignWithNormalSearch playground for alignWithNormal

  • Align the mesh with a normal

    Parameters

    • normal: Vector3

      defines the normal to use

    • Optional upDirection: Vector3

      can be used to redefined the up vector to use (will use the (0, 1, 0) by default)

    Returns AbstractMesh

    the current mesh

applyImpulseSearch playground for applyImpulse

attachToBoneSearch playground for attachToBone

  • Attach the current TransformNode to another TransformNode associated with a bone

    Parameters

    • bone: Bone

      Bone affecting the TransformNode

    • affectedTransformNode: TransformNode

      TransformNode associated with the bone

    Returns TransformNode

    this object

beginAnimationSearch playground for beginAnimation

  • beginAnimation(name: string, loop?: boolean, speedRatio?: number, onAnimationEnd?: () => void): Nullable<Animatable>
  • Will start the animation sequence

    Parameters

    • name: string

      defines the range frames for animation sequence

    • Optional loop: boolean

      defines if the animation should loop (false by default)

    • Optional speedRatio: number

      defines the speed factor in which to run the animation (1 by default)

    • Optional onAnimationEnd: () => void

      defines a function to be executed when the animation ended (undefined by default)

        • (): void
        • Returns void

    Returns Nullable<Animatable>

    the object created for this animation. If range does not exist, it will return null

calcMovePOVSearch playground for calcMovePOV

  • calcMovePOV(amountRight: number, amountUp: number, amountForward: number): Vector3
  • Calculate relative position change from the point of view of behind the front of the mesh. This is performed taking into account the meshes current rotation, so you do not have to care. Supports definition of mesh facing forward or backward

    Parameters

    • amountRight: number

      defines the distance on the right axis

    • amountUp: number

      defines the distance on the up axis

    • amountForward: number

      defines the distance on the forward axis

    Returns Vector3

    the new displacement vector

calcRotatePOVSearch playground for calcRotatePOV

  • calcRotatePOV(flipBack: number, twirlClockwise: number, tiltRight: number): Vector3
  • Calculate relative rotation change from the point of view of behind the front of the mesh. Supports definition of mesh facing forward or backward.

    Parameters

    • flipBack: number

      defines the flip

    • twirlClockwise: number

      defines the twirl

    • tiltRight: number

      defines the tilt

    Returns Vector3

    the new rotation vector

cloneSearch playground for clone

  • Creates a new InstancedMesh from the current mesh.

    • name (string) : the cloned mesh name
    • newParent (optional Node) : the optional Node to parent the clone to.
    • doNotCloneChildren (optional boolean, default false) : if true the model children aren't cloned.

    Returns the clone.

    Parameters

    • name: string
    • Optional newParent: Nullable<Node>
    • Optional doNotCloneChildren: boolean

    Returns InstancedMesh

computeWorldMatrixSearch playground for computeWorldMatrix

  • computeWorldMatrix(force?: boolean): Matrix
  • Computes the world matrix of the node

    Parameters

    • Optional force: boolean

      defines if the cache version should be invalidated forcing the world matrix to be created from scratch

    Returns Matrix

    the world matrix

createAnimationRangeSearch playground for createAnimationRange

  • createAnimationRange(name: string, from: number, to: number): void
  • Creates an animation range for this node

    Parameters

    • name: string

      defines the name of the range

    • from: number

      defines the starting key

    • to: number

      defines the end key

    Returns void

createInstanceSearch playground for createInstance

createNormalsSearch playground for createNormals

  • Creates new normals data for the mesh

    Parameters

    • updatable: boolean

      defines if the normal vertex buffer must be flagged as updatable

    Returns AbstractMesh

    the current mesh

createOrUpdateSubmeshesOctreeSearch playground for createOrUpdateSubmeshesOctree

  • createOrUpdateSubmeshesOctree(maxCapacity?: number, maxDepth?: number): Octree<SubMesh>

deleteAnimationRangeSearch playground for deleteAnimationRange

  • deleteAnimationRange(name: string, deleteFrames?: boolean): void
  • Delete a specific animation range

    Parameters

    • name: string

      defines the name of the range to delete

    • Optional deleteFrames: boolean

      defines if animation frames from the range must be deleted as well

    Returns void

detachFromBoneSearch playground for detachFromBone

disableEdgesRenderingSearch playground for disableEdgesRendering

disableFacetDataSearch playground for disableFacetData

disposeSearch playground for dispose

  • dispose(doNotRecurse?: boolean, disposeMaterialAndTextures?: boolean): void
  • Disposes the InstancedMesh. Returns nothing.

    Parameters

    • Optional doNotRecurse: boolean
    • Optional disposeMaterialAndTextures: boolean

    Returns void

enableEdgesRenderingSearch playground for enableEdgesRendering

  • Enables the edge rendering mode on the mesh. This mode makes the mesh edges visible

    see

    https://www.babylonjs-playground.com/#19O9TU#0

    Parameters

    • Optional epsilon: number

      defines the maximal distance between two angles to detect a face

    • Optional checkVerticesInsteadOfIndices: boolean

      indicates that we should check vertex list directly instead of faces

    • Optional options: IEdgesRendererOptions

      options to the edge renderer

    Returns AbstractMesh

    the currentAbstractMesh

freezeWorldMatrixSearch playground for freezeWorldMatrix

  • Prevents the World matrix to be computed any longer

    Parameters

    • Optional newWorldMatrix: Nullable<Matrix>

      defines an optional matrix to use as world matrix

    Returns TransformNode

    the TransformNode.

getAbsolutePivotPointSearch playground for getAbsolutePivotPoint

  • Returns a new Vector3 set with the mesh pivot point World coordinates.

    Returns Vector3

    a new Vector3 set with the mesh pivot point World coordinates.

getAbsolutePivotPointToRefSearch playground for getAbsolutePivotPointToRef

getAbsolutePositionSearch playground for getAbsolutePosition

getAnimationByNameSearch playground for getAnimationByName

  • Get an animation by name

    Parameters

    • name: string

      defines the name of the animation to look for

    Returns Nullable<Animation>

    null if not found else the requested animation

getAnimationRangeSearch playground for getAnimationRange

  • Get an animation range by name

    Parameters

    • name: string

      defines the name of the animation range to look for

    Returns Nullable<AnimationRange>

    null if not found else the requested animation range

getAnimationRangesSearch playground for getAnimationRanges

getBehaviorByNameSearch playground for getBehaviorByName

getBoundingInfoSearch playground for getBoundingInfo

  • Returns the mesh BoundingInfo object or creates a new one and returns if it was undefined. Note that it returns a shallow bounding of the mesh (i.e. it does not include children). To get the full bounding of all children, call getHierarchyBoundingVectors instead.

    Returns BoundingInfo

    a BoundingInfo

getChildMeshesSearch playground for getChildMeshes

  • getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node) => boolean): AbstractMesh[]
  • Get all child-meshes of this node

    Parameters

    • Optional directDescendantsOnly: boolean

      defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered (Default: false)

    • Optional predicate: (node: Node) => boolean

      defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored

        • (node: Node): boolean
        • Parameters

          Returns boolean

    Returns AbstractMesh[]

    an array of AbstractMesh

getChildTransformNodesSearch playground for getChildTransformNodes

  • getChildTransformNodes(directDescendantsOnly?: boolean, predicate?: (node: Node) => boolean): TransformNode[]
  • Get all child-transformNodes of this node

    Parameters

    • Optional directDescendantsOnly: boolean

      defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered

    • Optional predicate: (node: Node) => boolean

      defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored

        • (node: Node): boolean
        • Parameters

          Returns boolean

    Returns TransformNode[]

    an array of TransformNode

getChildrenSearch playground for getChildren

  • getChildren(predicate?: (node: Node) => boolean, directDescendantsOnly?: boolean): Node[]
  • Get all direct children of this node

    Parameters

    • Optional predicate: (node: Node) => boolean

      defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored

        • (node: Node): boolean
        • Parameters

          Returns boolean

    • Optional directDescendantsOnly: boolean

      defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered (Default: true)

    Returns Node[]

    an array of Node

getClassNameSearch playground for getClassName

  • getClassName(): string
  • Returns the string "InstancedMesh".

    Returns string

getClosestFacetAtCoordinatesSearch playground for getClosestFacetAtCoordinates

  • getClosestFacetAtCoordinates(x: number, y: number, z: number, projected?: Vector3, checkFace?: boolean, facing?: boolean): Nullable<number>
  • Returns the closest mesh facet index at (x,y,z) World coordinates, null if not found

    see

    https://doc.babylonjs.com/how_to/how_to_use_facetdata

    Parameters

    • x: number

      defines x coordinate

    • y: number

      defines y coordinate

    • z: number

      defines z coordinate

    • Optional projected: Vector3

      sets as the (x,y,z) world projection on the facet

    • Optional checkFace: boolean

      if true (default false), only the facet "facing" to (x,y,z) or only the ones "turning their backs", according to the parameter "facing" are returned

    • Optional facing: boolean

      if facing and checkFace are true, only the facet "facing" to (x, y, z) are returned : positive dot (x, y, z) * facet position. If facing si false and checkFace is true, only the facet "turning their backs" to (x, y, z) are returned : negative dot (x, y, z) * facet position

    Returns Nullable<number>

    the face index if found (or null instead)

getClosestFacetAtLocalCoordinatesSearch playground for getClosestFacetAtLocalCoordinates

  • getClosestFacetAtLocalCoordinates(x: number, y: number, z: number, projected?: Vector3, checkFace?: boolean, facing?: boolean): Nullable<number>
  • Returns the closest mesh facet index at (x,y,z) local coordinates, null if not found

    see

    https://doc.babylonjs.com/how_to/how_to_use_facetdata

    Parameters

    • x: number

      defines x coordinate

    • y: number

      defines y coordinate

    • z: number

      defines z coordinate

    • Optional projected: Vector3

      sets as the (x,y,z) local projection on the facet

    • Optional checkFace: boolean

      if true (default false), only the facet "facing" to (x,y,z) or only the ones "turning their backs", according to the parameter "facing" are returned

    • Optional facing: boolean

      if facing and checkFace are true, only the facet "facing" to (x, y, z) are returned : positive dot (x, y, z) * facet position. If facing si false and checkFace is true, only the facet "turning their backs" to (x, y, z) are returned : negative dot (x, y, z) * facet position

    Returns Nullable<number>

    the face index if found (or null instead)

getConnectedParticleSystemsSearch playground for getConnectedParticleSystems

  • This function returns all of the particle systems in the scene that use the mesh as an emitter.

    Returns IParticleSystem[]

    an array of particle systems in the scene that use the mesh as an emitter

getDescendantsSearch playground for getDescendants

  • getDescendants(directDescendantsOnly?: boolean, predicate?: (node: Node) => boolean): Node[]
  • Will return all nodes that have this node as ascendant

    Parameters

    • Optional directDescendantsOnly: boolean

      defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered

    • Optional predicate: (node: Node) => boolean

      defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored

        • (node: Node): boolean
        • Parameters

          Returns boolean

    Returns Node[]

    all children nodes of all types

getDirectionSearch playground for getDirection

  • Returns a new Vector3 that is the localAxis, expressed in the mesh local space, rotated like the mesh. This Vector3 is expressed in the World space.

    Parameters

    • localAxis: Vector3

      axis to rotate

    Returns Vector3

    a new Vector3 that is the localAxis, expressed in the mesh local space, rotated like the mesh.

getDirectionToRefSearch playground for getDirectionToRef

  • Sets the Vector3 "result" as the rotated Vector3 "localAxis" in the same rotation than the mesh. localAxis is expressed in the mesh local space. result is computed in the Wordl space from the mesh World matrix.

    Parameters

    • localAxis: Vector3

      axis to rotate

    • result: Vector3

      the resulting transformnode

    Returns TransformNode

    this TransformNode.

getDistanceToCameraSearch playground for getDistanceToCamera

  • Returns the distance from the mesh to the active camera

    Parameters

    Returns number

    the distance

getEngineSearch playground for getEngine

  • Gets the engine of the node

    Returns Engine

    a Engine

getFacetDataParametersSearch playground for getFacetDataParameters

  • getFacetDataParameters(): any

getFacetLocalNormalsSearch playground for getFacetLocalNormals

  • getFacetLocalNormals(): Vector3[]

getFacetLocalPartitioningSearch playground for getFacetLocalPartitioning

  • getFacetLocalPartitioning(): number[][]

getFacetLocalPositionsSearch playground for getFacetLocalPositions

  • getFacetLocalPositions(): Vector3[]

getFacetNormalSearch playground for getFacetNormal

  • getFacetNormal(i: number): Vector3

getFacetNormalToRefSearch playground for getFacetNormalToRef

  • getFacetNormalToRef(i: number, ref: Vector3): this

getFacetPositionSearch playground for getFacetPosition

  • getFacetPosition(i: number): Vector3

getFacetPositionToRefSearch playground for getFacetPositionToRef

getFacetsAtLocalCoordinatesSearch playground for getFacetsAtLocalCoordinates

  • getFacetsAtLocalCoordinates(x: number, y: number, z: number): Nullable<number[]>

getHierarchyBoundingVectorsSearch playground for getHierarchyBoundingVectors

  • Return the minimum and maximum world vectors of the entire hierarchy under current node

    Parameters

    • Optional includeDescendants: boolean

      Include bounding info from descendants as well (true by default)

    • Optional predicate: Nullable<(abstractMesh: AbstractMesh) => boolean>

      defines a callback function that can be customize to filter what meshes should be included in the list used to compute the bounding vectors

    Returns { max: Vector3; min: Vector3 }

    the new bounding vectors

getIndicesSearch playground for getIndices

getLODSearch playground for getLOD

getPhysicsImpostorSearch playground for getPhysicsImpostor

getPivotMatrixSearch playground for getPivotMatrix

  • Returns the mesh pivot matrix. Default : Identity.

    Returns Matrix

    the matrix

getPivotPointSearch playground for getPivotPoint

  • Returns a new Vector3 set with the mesh pivot point coordinates in the local space.

    Returns Vector3

    the pivot point

getPivotPointToRefSearch playground for getPivotPointToRef

  • Sets the passed Vector3 "result" with the coordinates of the mesh pivot point in the local space.

    Parameters

    • result: Vector3

      the vector3 to store the result

    Returns TransformNode

    this TransformNode.

getPoseMatrixSearch playground for getPoseMatrix

getPositionExpressedInLocalSpaceSearch playground for getPositionExpressedInLocalSpace

  • getPositionExpressedInLocalSpace(): Vector3

getPositionInCameraSpaceSearch playground for getPositionInCameraSpace

getSceneSearch playground for getScene

  • Gets the scene of the node

    Returns Scene

    a scene

getTotalIndicesSearch playground for getTotalIndices

  • getTotalIndices(): number
  • Returns a positive integer : the total number of indices in this mesh geometry.

    Returns number

    the numner of indices or zero if the mesh has no geometry.

getTotalVerticesSearch playground for getTotalVertices

  • getTotalVertices(): number
  • Returns the total number of vertices (integer).

    Returns number

getVerticesDataSearch playground for getVerticesData

  • Returns an array of integers or a typed array (Int32Array, Uint32Array, Uint16Array) populated with the mesh indices.

    Parameters

    • kind: string

      kind of verticies to retreive (eg. positons, normals, uvs, etc.)

    • Optional copyWhenShared: boolean

      If true (default false) and and if the mesh geometry is shared among some other meshes, the returned array is a copy of the internal one.

    Returns Nullable<FloatArray>

    a float array or a Float32Array of the requested kind of data : positons, normals, uvs, etc.

getWorldMatrixSearch playground for getWorldMatrix

instantiateHierarchySearch playground for instantiateHierarchy

intersectsSearch playground for intersects

  • Checks if the passed Ray intersects with the mesh

    see

    https://doc.babylonjs.com/babylon101/intersect_collisions_-_mesh

    Parameters

    • ray: Ray

      defines the ray to use

    • Optional fastCheck: boolean

      defines if fast mode (but less precise) must be used (false by default)

    • Optional trianglePredicate: TrianglePickingPredicate

      defines an optional predicate used to select faces when a mesh intersection is detected

    • Optional onlyBoundingInfo: boolean

      defines a boolean indicating if picking should only happen using bounding info (false by default)

    • Optional worldToUse: Matrix

      defines the world matrix to use to get the world coordinate of the intersection point

    • Optional skipBoundingInfo: boolean

      a boolean indicating if we should skip the bounding info check

    Returns PickingInfo

    the picking info

intersectsMeshSearch playground for intersectsMesh

  • True if the mesh intersects another mesh or a SolidParticle object

    Parameters

    • mesh: AbstractMesh | SolidParticle

      defines a target mesh or SolidParticle to test

    • Optional precise: boolean

      Unless the parameter precise is set to true the intersection is computed according to Axis Aligned Bounding Boxes (AABB), else according to OBB (Oriented BBoxes)

    • Optional includeDescendants: boolean

      Can be set to true to test if the mesh defined in parameters intersects with the current mesh or any child meshes

    Returns boolean

    true if there is an intersection

intersectsPointSearch playground for intersectsPoint

  • intersectsPoint(point: Vector3): boolean
  • Returns true if the passed point (Vector3) is inside the mesh bounding box

    Parameters

    • point: Vector3

      defines the point to test

    Returns boolean

    true if there is an intersection

isCompletelyInFrustumSearch playground for isCompletelyInFrustum

  • isCompletelyInFrustum(frustumPlanes: Plane[]): boolean
  • Returns true if the mesh is completely in the frustum defined be the passed array of planes. A mesh is completely in the frustum if its bounding box it completely inside the frustum.

    Parameters

    • frustumPlanes: Plane[]

      defines the frustum to test

    Returns boolean

    true if the mesh is completely in the frustum planes

isDescendantOfSearch playground for isDescendantOf

  • isDescendantOf(ancestor: Node): boolean
  • Is this node a descendant of the given node? The function will iterate up the hierarchy until the ancestor was found or no more parents defined

    Parameters

    • ancestor: Node

      defines the parent node to inspect

    Returns boolean

    a boolean indicating if this node is a descendant of the given node

isDisposedSearch playground for isDisposed

  • isDisposed(): boolean
  • Gets a boolean indicating if the node has been disposed

    Returns boolean

    true if the node was disposed

isEnabledSearch playground for isEnabled

  • isEnabled(checkAncestors?: boolean): boolean
  • Is this node enabled? If the node has a parent, all ancestors will be checked and false will be returned if any are false (not enabled), otherwise will return true

    Parameters

    • Optional checkAncestors: boolean

      indicates if this method should check the ancestors. The default is to check the ancestors. If set to false, the method will return the value of this node without checking ancestors

    Returns boolean

    whether this node (and its parent) is enabled

isInFrustumSearch playground for isInFrustum

  • isInFrustum(frustumPlanes: Plane[]): boolean
  • Returns true if the mesh is within the frustum defined by the passed array of planes. A mesh is in the frustum if its bounding box intersects the frustum

    Parameters

    • frustumPlanes: Plane[]

      defines the frustum to test

    Returns boolean

    true if the mesh is in the frustum planes

isReadySearch playground for isReady

  • isReady(completeCheck?: boolean): boolean
  • Is this node ready to be used/rendered

    Parameters

    • Optional completeCheck: boolean

      defines if a complete check (including materials and lights) has to be done (false by default)

    Returns boolean

    is it ready

isVerticesDataPresentSearch playground for isVerticesDataPresent

  • isVerticesDataPresent(kind: string): boolean

locallyTranslateSearch playground for locallyTranslate

  • Translates the mesh along the passed Vector3 in its local space.

    Parameters

    • vector3: Vector3

      the distance to translate in localspace

    Returns TransformNode

    the TransformNode.

lookAtSearch playground for lookAt

  • Orients a mesh towards a target point. Mesh must be drawn facing user.

    Parameters

    • targetPoint: Vector3

      the position (must be in same space as current mesh) to look at

    • Optional yawCor: number

      optional yaw (y-axis) correction in radians

    • Optional pitchCor: number

      optional pitch (x-axis) correction in radians

    • Optional rollCor: number

      optional roll (z-axis) correction in radians

    • Optional space: Space

      the choosen space of the target

    Returns TransformNode

    the TransformNode.

markAsDirtySearch playground for markAsDirty

  • Flag the transform node as dirty (Forcing it to update everything)

    Parameters

    • property: string

      if set to "rotation" the objects rotationQuaternion will be set to null

    Returns TransformNode

    this transform node

movePOVSearch playground for movePOV

  • movePOV(amountRight: number, amountUp: number, amountForward: number): AbstractMesh
  • Perform relative position change from the point of view of behind the front of the mesh. This is performed taking into account the meshes current rotation, so you do not have to care. Supports definition of mesh facing forward or backward

    Parameters

    • amountRight: number

      defines the distance on the right axis

    • amountUp: number

      defines the distance on the up axis

    • amountForward: number

      defines the distance on the forward axis

    Returns AbstractMesh

    the current mesh

moveWithCollisionsSearch playground for moveWithCollisions

normalizeToUnitCubeSearch playground for normalizeToUnitCube

  • Uniformly scales the mesh to fit inside of a unit cube (1 X 1 X 1 units)

    Parameters

    • Optional includeDescendants: boolean

      Use the hierarchy's bounding box instead of the mesh's bounding box. Default is false

    • Optional ignoreRotation: boolean

      ignore rotation when computing the scale (ie. object will be axis aligned). Default is false

    • Optional predicate: Nullable<(node: AbstractMesh) => boolean>

      predicate that is passed in to getHierarchyBoundingVectors when selecting which object should be included when scaling

    Returns AbstractMesh

    the current mesh

refreshBoundingInfoSearch playground for refreshBoundingInfo

  • This method recomputes and sets a new BoundingInfo to the mesh unless it is locked. This means the mesh underlying bounding box and sphere are recomputed.

    Parameters

    • Optional applySkeleton: boolean

      defines whether to apply the skeleton before computing the bounding info

    Returns InstancedMesh

    the current mesh

registerAfterWorldMatrixUpdateSearch playground for registerAfterWorldMatrixUpdate

releaseSubMeshesSearch playground for releaseSubMeshes

removeBehaviorSearch playground for removeBehavior

removeChildSearch playground for removeChild

resetLocalMatrixSearch playground for resetLocalMatrix

  • resetLocalMatrix(independentOfChildren?: boolean): void
  • Resets this nodeTransform's local matrix to Matrix.Identity().

    Parameters

    • Optional independentOfChildren: boolean

      indicates if all child nodeTransform's world-space transform should be preserved.

    Returns void

rotateSearch playground for rotate

  • Rotates the mesh around the axis vector for the passed angle (amount) expressed in radians, in the given space. space (default LOCAL) can be either Space.LOCAL, either Space.WORLD. Note that the property rotationQuaternion is then automatically updated and the property rotation is set to (0,0,0) and no longer used. The passed axis is also normalized.

    Parameters

    • axis: Vector3

      the axis to rotate around

    • amount: number

      the amount to rotate in radians

    • Optional space: Space

      Space to rotate in (Default: local)

    Returns TransformNode

    the TransformNode.

rotateAroundSearch playground for rotateAround

  • Rotates the mesh around the axis vector for the passed angle (amount) expressed in radians, in world space. Note that the property rotationQuaternion is then automatically updated and the property rotation is set to (0,0,0) and no longer used. The passed axis is also normalized. . Method is based on http://www.euclideanspace.com/maths/geometry/affine/aroundPoint/index.htm

    Parameters

    • point: Vector3

      the point to rotate around

    • axis: Vector3

      the axis to rotate around

    • amount: number

      the amount to rotate in radians

    Returns TransformNode

    the TransformNode

rotatePOVSearch playground for rotatePOV

  • rotatePOV(flipBack: number, twirlClockwise: number, tiltRight: number): AbstractMesh
  • Perform relative rotation change from the point of view of behind the front of the mesh. Supports definition of mesh facing forward or backward

    Parameters

    • flipBack: number

      defines the flip

    • twirlClockwise: number

      defines the twirl

    • tiltRight: number

      defines the tilt

    Returns AbstractMesh

    the current mesh

serializeSearch playground for serialize

  • serialize(currentSerializationObject?: any): any
  • Serializes the objects information.

    Parameters

    • Optional currentSerializationObject: any

      defines the object to serialize in

    Returns any

    the serialized object

serializeAnimationRangesSearch playground for serializeAnimationRanges

  • serializeAnimationRanges(): any
  • Serialize animation ranges into a JSON compatible object

    Returns any

    serialization object

setAbsolutePositionSearch playground for setAbsolutePosition

  • Sets the mesh absolute position in the World from a Vector3 or an Array(3).

    Parameters

    • absolutePosition: Vector3

      the absolute position to set

    Returns TransformNode

    the TransformNode.

setBoundingInfoSearch playground for setBoundingInfo

setDirectionSearch playground for setDirection

  • setDirection(localAxis: Vector3, yawCor?: number, pitchCor?: number, rollCor?: number): TransformNode
  • Sets this transform node rotation to the given local axis.

    Parameters

    • localAxis: Vector3

      the axis in local space

    • Optional yawCor: number

      optional yaw (y-axis) correction in radians

    • Optional pitchCor: number

      optional pitch (x-axis) correction in radians

    • Optional rollCor: number

      optional roll (z-axis) correction in radians

    Returns TransformNode

    this TransformNode

setEnabledSearch playground for setEnabled

  • setEnabled(value: boolean): void
  • Set the enabled state of this node

    Parameters

    • value: boolean

      defines the new enabled state

    Returns void

setIndicesSearch playground for setIndices

  • Sets the mesh indices. Expects an array populated with integers or a typed array (Int32Array, Uint32Array, Uint16Array). If the mesh has no geometry, a new Geometry object is created and set to the mesh. This method creates a new index buffer each call. Returns the Mesh.

    Parameters

    Returns Mesh

setParentSearch playground for setParent

setPhysicsLinkWithSearch playground for setPhysicsLinkWith

setPivotMatrixSearch playground for setPivotMatrix

  • Sets a new pivot matrix to the current node

    Parameters

    • matrix: DeepImmutable<Matrix>

      defines the new pivot matrix to use

    • Optional postMultiplyPivotMatrix: boolean

      defines if the pivot matrix must be cancelled in the world matrix. When this parameter is set to true (default), the inverse of the pivot matrix is also applied at the end to cancel the transformation effect

    Returns TransformNode

    the current TransformNode

setPivotPointSearch playground for setPivotPoint

  • Sets a new pivot point to the current node

    Parameters

    • point: Vector3

      defines the new pivot point to use

    • Optional space: Space

      defines if the point is in world or local space (local by default)

    Returns TransformNode

    the current TransformNode

setPositionWithLocalVectorSearch playground for setPositionWithLocalVector

setPreTransformMatrixSearch playground for setPreTransformMatrix

setVerticesDataSearch playground for setVerticesData

  • Sets the vertex data of the mesh geometry for the requested kind. If the mesh has no geometry, a new Geometry object is set to the mesh and then passed this vertex data. The data are either a numeric array either a Float32Array. The parameter updatable is passed as is to the underlying Geometry object constructor (if initianilly none) or updater. The parameter stride is an optional positive integer, it is usually automatically deducted from the kind (3 for positions or normals, 2 for UV, etc). Note that a new underlying VertexBuffer object is created each call. If the kind is the PositionKind, the mesh BoundingInfo is renewed, so the bounding box and sphere, and the mesh World Matrix is recomputed.

    Possible kind values :

    • VertexBuffer.PositionKind
    • VertexBuffer.UVKind
    • VertexBuffer.UV2Kind
    • VertexBuffer.UV3Kind
    • VertexBuffer.UV4Kind
    • VertexBuffer.UV5Kind
    • VertexBuffer.UV6Kind
    • VertexBuffer.ColorKind
    • VertexBuffer.MatricesIndicesKind
    • VertexBuffer.MatricesIndicesExtraKind
    • VertexBuffer.MatricesWeightsKind
    • VertexBuffer.MatricesWeightsExtraKind

    Returns the Mesh.

    Parameters

    • kind: string
    • data: FloatArray
    • Optional updatable: boolean
    • Optional stride: number

    Returns AbstractMesh

toStringSearch playground for toString

  • toString(fullDetails?: boolean): string
  • Gets a string representation of the current mesh

    Parameters

    • Optional fullDetails: boolean

      defines a boolean indicating if full details must be included

    Returns string

    a string representation of the current mesh

translateSearch playground for translate

  • Translates the mesh along the axis vector for the passed distance in the given space. space (default LOCAL) can be either Space.LOCAL, either Space.WORLD.

    Parameters

    • axis: Vector3

      the axis to translate in

    • distance: number

      the distance to translate

    • Optional space: Space

      Space to rotate in (Default: local)

    Returns TransformNode

    the TransformNode.

unfreezeWorldMatrixSearch playground for unfreezeWorldMatrix

  • unfreezeWorldMatrix(): this
  • Allows back the World matrix computation.

    Returns this

    the TransformNode.

unregisterAfterWorldMatrixUpdateSearch playground for unregisterAfterWorldMatrixUpdate

updateFacetDataSearch playground for updateFacetData

  • Updates the mesh facetData arrays and the internal partitioning when the mesh is morphed or updated. This method can be called within the render loop. You don't need to call this method by yourself in the render loop when you update/morph a mesh with the methods CreateXXX() as they automatically manage this computation

    see

    https://doc.babylonjs.com/how_to/how_to_use_facetdata

    Returns AbstractMesh

    the current mesh

updateIndicesSearch playground for updateIndices

  • Updates the AbstractMesh indices array

    Parameters

    • indices: IndicesArray

      defines the data source

    • Optional offset: number

      defines the offset in the index buffer where to store the new data (can be null)

    • Optional gpuMemoryOnly: boolean

      defines a boolean indicating that only the GPU memory must be updated leaving the CPU version of the indices unchanged (false by default)

    Returns AbstractMesh

    the current mesh

updatePoseMatrixSearch playground for updatePoseMatrix

  • Copies the parameter passed Matrix into the mesh Pose matrix.

    Parameters

    • matrix: Matrix

      the matrix to copy the pose from

    Returns TransformNode

    this TransformNode.

updateVerticesDataSearch playground for updateVerticesData

  • updateVerticesData(kind: string, data: FloatArray, updateExtends?: boolean, makeItUnique?: boolean): Mesh
  • Updates the existing vertex data of the mesh geometry for the requested kind. If the mesh has no geometry, it is simply returned as it is. The data are either a numeric array either a Float32Array. No new underlying VertexBuffer object is created. If the kind is the PositionKind and if updateExtends is true, the mesh BoundingInfo is renewed, so the bounding box and sphere, and the mesh World Matrix is recomputed. If the parameter makeItUnique is true, a new global geometry is created from this positions and is set to the mesh.

    Possible kind values :

    • VertexBuffer.PositionKind
    • VertexBuffer.UVKind
    • VertexBuffer.UV2Kind
    • VertexBuffer.UV3Kind
    • VertexBuffer.UV4Kind
    • VertexBuffer.UV5Kind
    • VertexBuffer.UV6Kind
    • VertexBuffer.ColorKind
    • VertexBuffer.MatricesIndicesKind
    • VertexBuffer.MatricesIndicesExtraKind
    • VertexBuffer.MatricesWeightsKind
    • VertexBuffer.MatricesWeightsExtraKind

    Returns the Mesh.

    Parameters

    • kind: string
    • data: FloatArray
    • Optional updateExtends: boolean
    • Optional makeItUnique: boolean

    Returns Mesh

Static AddNodeConstructorSearch playground for AddNodeConstructor

  • Add a new node constructor

    Parameters

    • type: string

      defines the type name of the node to construct

    • constructorFunc: NodeConstructor

      defines the constructor function

    Returns void

Static ConstructSearch playground for Construct

  • Construct(type: string, name: string, scene: Scene, options?: any): Nullable<() => Node>
  • Returns a node constructor based on type name

    Parameters

    • type: string

      defines the type name

    • name: string

      defines the new node name

    • scene: Scene

      defines the hosting scene

    • Optional options: any

      defines optional options to transmit to constructors

    Returns Nullable<() => Node>

    the new constructor or null

Static ParseSearch playground for Parse

  • Returns a new TransformNode object parsed from the source provided.

    Parameters

    • parsedTransformNode: any

      is the source.

    • scene: Scene

      the scne the object belongs to

    • rootUrl: string

      is a string, it's the root URL to prefix the delayLoadingFile property with

    Returns TransformNode

    a new TransformNode object parsed from the source provided.

Static ParseAnimationRangesSearch playground for ParseAnimationRanges

  • ParseAnimationRanges(node: Node, parsedNode: any, scene: Scene): void
  • Parse animation range data from a serialization object and store them into a given node

    Parameters

    • node: Node

      defines where to store the animation ranges

    • parsedNode: any

      defines the serialization object to read data from

    • scene: Scene

      defines the hosting scene

    Returns void

Legend

  • Constructor
  • Property
  • Method
  • Accessor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Property
  • Method
  • Static method