Hierarchy

  • Mesh
    • ThickLinesMesh

Constructors

Properties

_accessibilityTag _boundingInfo _boundingInfoIsDirty _isDirty _isWorldMatrixFrozen _parentNode _ranges _scaling actionManager alphaIndex alwaysSelectAsActiveMesh animations color cullingStrategy definedFacingForward delayLoadState delayLoadingFile doNotSyncBoundingInfo edgesColor edgesRenderer edgesShareWithInstances edgesWidth ellipsoid ellipsoidOffset enablePointerMoveEvents id ignoreCameraMaxZ ignoreNonUniformScaling inspectableCustomProperties instancedBuffers instances isBlocker isNearGrabbable isNearPickable isPickable isVisible metadata name onAccessibilityTagChangedObservable onAfterWorldMatrixUpdateObservable onCollideObservable onCollisionPositionChangeObservable onDisposeObservable onLODLevelSelection onMaterialChangedObservable onMeshReadyObservable onReady onRebuildObservable outlineColor outlineWidth overlayAlpha overlayColor overrideMaterialSideOrientation reIntegrateRotationIntoRotationQuaternion reservedDataStore scalingDeterminant showBoundingBox showSubMeshesBoundingBox state subMeshes thickness uniqueId useOctreeForCollisions useOctreeForPicking useOctreeForRenderingSelection BACKSIDE BOTTOM BillboardUseParentOrientation CAP_ALL CAP_END CAP_START CENTER CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY CULLINGSTRATEGY_OPTIMISTIC_INCLUSION CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY CULLINGSTRATEGY_STANDARD DEFAULTSIDE DOUBLESIDE FLIP_N_ROTATE_ROW FLIP_N_ROTATE_TILE FLIP_ROW FLIP_TILE FRONTSIDE INSTANCEDMESH_SORT_TRANSPARENT LEFT NO_CAP NO_FLIP OCCLUSION_ALGORITHM_TYPE_ACCURATE OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE OCCLUSION_TYPE_NONE OCCLUSION_TYPE_OPTIMISTIC OCCLUSION_TYPE_STRICT RIGHT ROTATE_ROW ROTATE_TILE TOP

Accessors

absolutePosition absoluteRotationQuaternion absoluteScaling accessibilityTag animationPropertiesOverride applyFog areNormalsFrozen bakedVertexAnimationManager behaviors billboardMode checkCollisions cloneMeshMap collider collisionGroup collisionMask collisionResponse collisionRetryCount computeBonesUsingShaders doNotSerialize enableDistantPicking facetDepthSortFrom facetNb forceWorldMatrixInstancedBufferUpdate forcedInstanceCount forward geometry hasBoundingInfo hasInstances hasLODLevels hasThinInstances hasVertexAlpha infiniteDistance isAnInstance isBlocked isFacetDataEnabled isUnIndexed isWorldMatrixFrozen layerMask lightSources manualUpdateOfPreviousWorldMatrixInstancedBuffer manualUpdateOfWorldMatrixInstancedBuffer material morphTargetManager mustDepthSortFacets nonUniformScaling numBoneInfluencers onAfterRenderObservable onBeforeBindObservable onBeforeDraw onBeforeDrawObservable onBeforeRenderObservable onBetweenPassObservable onClonedObservable onCollide onCollisionPositionChange onDispose onEnabledStateChangedObservable overridenInstanceCount parent partitioningBBoxRatio partitioningSubdivisions pointerOverDisableMeshTesting position preserveParentRotationForBillboard previousWorldMatrixInstancedBuffer receiveShadows renderingGroupId right rotation rotationQuaternion scaling skeleton source surroundingMeshes up useBones useLODScreenCoverage useVertexColors visibility worldMatrixFromCache worldMatrixInstancedBuffer BILLBOARDMODE_ALL BILLBOARDMODE_NONE BILLBOARDMODE_USE_POSITION BILLBOARDMODE_X BILLBOARDMODE_Y BILLBOARDMODE_Z

Methods

_afterComputeWorldMatrix _bind _buildUniformLayout _invalidateInstanceVertexArrayObject addBehavior addChild addLODLevel addRotation alignWithNormal applyDisplacementMap applyDisplacementMapFromBuffer applySkeleton attachToBone bakeCurrentTransformIntoVertices bakeTransformIntoVertices beginAnimation buildBoundingInfo calcMovePOV calcRotatePOV cleanMatrixWeights clone computeWorldMatrix convertToFlatShadedMesh convertToUnIndexedMesh createAnimationRange createInstance createNormals deleteAnimationRange detachFromBone disableEdgesRendering disableFacetData dispose enableEdgesRendering flipFaces forceSharedVertices freezeNormals freezeWorldMatrix getAbsolutePivotPoint getAbsolutePivotPointToRef getAbsolutePosition getAnimatables getAnimationByName getAnimationRange getAnimationRanges getBehaviorByName getBoundingInfo getChildMeshes getChildTransformNodes getChildren getClassName getClosestFacetAtCoordinates getClosestFacetAtLocalCoordinates getConnectedParticleSystems getDescendants getDirection getDirectionToRef getDistanceToCamera getEngine getFacetDataParameters getFacetLocalNormals getFacetLocalPartitioning getFacetLocalPositions getFacetNormal getFacetNormalToRef getFacetPosition getFacetPositionToRef getFacetsAtLocalCoordinates getHierarchyBoundingVectors getIndices getLOD getLODLevelAtDistance getLODLevels getMaterialForRenderPass getMeshUniformBuffer getNormalsData getPivotMatrix getPivotPoint getPivotPointToRef getPoseMatrix getPositionData getPositionExpressedInLocalSpace getPositionInCameraSpace getScene getTotalIndices getTotalVertices getVertexBuffer getVerticesData getVerticesDataKinds getWorldMatrix increaseVertices instantiateHierarchy intersects intersectsMesh intersectsPoint isCompletelyInFrustum isDescendantOf isDisposed isEnabled isInFrustum isReady isUsingPivotMatrix isVertexBufferUpdatable isVerticesDataPresent locallyTranslate lookAt makeGeometryUnique markAsDirty markVerticesDataAsUpdatable movePOV moveWithCollisions normalizeToUnitCube optimizeIndices refreshBoundingInfo registerAfterRender registerAfterWorldMatrixUpdate registerBeforeRender registerInstancedBuffer releaseSubMeshes removeBehavior removeChild removeLODLevel removeVerticesData render resetDrawCache resetLocalMatrix rotate rotateAround rotatePOV serialize serializeAnimationRanges setAbsolutePosition setBoundingInfo setDirection setEnabled setIndices setMaterialByID setMaterialById setMaterialForRenderPass setNormalsForCPUSkinning setParent setPivotMatrix setPivotPoint setPositionWithLocalVector setPositionsForCPUSkinning setPreTransformMatrix setVerticesBuffer setVerticesData subdivide synchronizeInstances toLeftHanded toString transferToEffect translate unfreezeNormals unfreezeWorldMatrix unregisterAfterRender unregisterAfterWorldMatrixUpdate unregisterBeforeRender updateFacetData updateIndices updateMeshPositions updatePoseMatrix updateVerticesData validateSkinning AddNodeConstructor Center Construct CreateThickLines MergeMeshes MergeMeshesAsync MinMax Parse ParseAnimationRanges

Constructors

  • Parameters

    • pName: string
    • pScene: Scene
    • pParent: null | Node = null
    • Optional pSource: ThickLinesMesh
    • Optional pDoNotCloneChildren: boolean

    Returns ThickLinesMesh

Properties

_accessibilityTag: Nullable<IAccessibilityTag>
_boundingInfo: Nullable<BoundingInfo>
_boundingInfoIsDirty: boolean
_isDirty: boolean
_isWorldMatrixFrozen: boolean
_parentNode: Nullable<Node>
_ranges: {
    [name: string]: Nullable<AnimationRange>;
}

Type declaration

  • [name: string]: Nullable<AnimationRange>
_scaling: Vector3
actionManager: Nullable<AbstractActionManager>

Gets or sets the current action manager

See

https://doc.babylonjs.com/features/featuresDeepDive/events/actions

alphaIndex: number
alwaysSelectAsActiveMesh: boolean

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

animations: Animation[]

Gets a list of Animations associated with the node

color: Color4
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.
definedFacingForward: boolean

Gets or sets the orientation for POV movement & rotation

delayLoadState: number

Gets the delay loading state of the mesh (when delay loading is turned on)

See

https://doc.babylonjs.com/features/featuresDeepDive/importers/incrementalLoading

delayLoadingFile: string

Gets the file containing delay loading data for this mesh

doNotSyncBoundingInfo: boolean

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

edgesColor: Color4

Defines edge color used when edgesRenderer is enabled

See

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

edgesRenderer: Nullable<EdgesRenderer>

Gets the edgesRenderer associated with the mesh

edgesShareWithInstances: boolean

true to use the edge renderer for all instances of this mesh

edgesWidth: number

Defines edge width used when edgesRenderer is enabled

See

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

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/features/featuresDeepDive/cameras/camera_collisions

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/features/featuresDeepDive/cameras/camera_collisions

enablePointerMoveEvents: boolean

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

id: string

Gets or sets the id of the node

ignoreCameraMaxZ: boolean

Gets or sets a boolean indicating whether to render ignoring the active camera's max z setting. (false by default) Note this will reduce performance when set to true.

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

inspectableCustomProperties: IInspectable[]

List of inspectable custom properties (used by the Inspector)

See

https://doc.babylonjs.com/toolsAndResources/inspector#extensibility

instancedBuffers: {
    [key: string]: any;
}

Object used to store instanced buffers defined by user

See

https://doc.babylonjs.com/features/featuresDeepDive/mesh/copies/instances#custom-buffers

Type declaration

  • [key: string]: any
instances: InstancedMesh[]

Gets the list of instances created from this mesh it is not supposed to be modified manually. Note also that the order of the InstancedMesh wihin the array is not significant and might change.

See

https://doc.babylonjs.com/features/featuresDeepDive/mesh/copies/instances

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/features/featuresDeepDive/environment/lenseFlare

isNearGrabbable: boolean

Gets or sets a boolean indicating if the mesh can be near grabbed. Default is false

isNearPickable: boolean

Gets or sets a boolean indicating if the mesh can be near picked. Default is false

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

isVisible: boolean

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

metadata: any

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

name: string

Gets or sets the name of the node

onAccessibilityTagChangedObservable: Observable<Nullable<IAccessibilityTag>>
onAfterWorldMatrixUpdateObservable: Observable<TransformNode>

An event triggered after the world matrix is updated

onCollideObservable: Observable<AbstractMesh>

An event triggered when this mesh collides with another one

onCollisionPositionChangeObservable: Observable<Vector3>

An event triggered when the collision's position changes

onDisposeObservable: Observable<Node>

An event triggered when the mesh is disposed

onLODLevelSelection: ((distance: number, mesh: Mesh, selectedLevel: Nullable<Mesh>) => void)

Type declaration

onMaterialChangedObservable: Observable<AbstractMesh>

An event triggered when material is changed

onMeshReadyObservable: Observable<Mesh>

Will notify when the mesh is completely ready, including materials. Observers added to this observable will be removed once triggered

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

Callback raised when the node is ready to be used

onRebuildObservable: Observable<AbstractMesh>

An event triggered when the mesh is rebuilt.

outlineColor: Color3

Defines color to use when rendering outline

outlineWidth: number

Define width to use when rendering outline

overlayAlpha: number

Defines alpha to use when rendering overlay

overlayColor: Color3

Defines color to use when rendering overlay

overrideMaterialSideOrientation: Nullable<number>

Use this property to change the original side orientation defined at construction time

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

reservedDataStore: any

For internal use only. Please do not use.

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

showBoundingBox: boolean

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

showSubMeshesBoundingBox: boolean

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

state: string

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

subMeshes: SubMesh[]
thickness: number
uniqueId: number

Gets or sets the unique id of the node

useOctreeForCollisions: boolean

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

useOctreeForPicking: boolean

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

useOctreeForRenderingSelection: boolean

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

BACKSIDE: 1 = 1

Mesh side orientation : usually the internal or back surface

BOTTOM: 4 = 4

Mesh tile positioning : part tiles on bottom

BillboardUseParentOrientation: boolean

Child transform with Billboard flags should or should not apply parent rotation (default if off)

CAP_ALL: 3 = 3

Mesh cap setting : two caps, one at the beginning and one at the end of the mesh

CAP_END: 2 = 2

Mesh cap setting : one cap at the end of the mesh

CAP_START: 1 = 1

Mesh cap setting : one cap at the beginning of the mesh

CENTER: 0 = 0

Mesh tile positioning : part tiles same on left/right or top/bottom

CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY: 1 = 1

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.

CULLINGSTRATEGY_OPTIMISTIC_INCLUSION: 2 = 2

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.

CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY: 3 = 3

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.

CULLINGSTRATEGY_STANDARD: 0 = 0

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.

DEFAULTSIDE: 0 = 0

Mesh side orientation : by default, FRONTSIDE

DOUBLESIDE: 2 = 2

Mesh side orientation : both internal and external or front and back surfaces

FLIP_N_ROTATE_ROW: 6 = 6

Mesh pattern setting : rotate pattern and rotate

FLIP_N_ROTATE_TILE: 5 = 5

Mesh pattern setting : flip and rotate alternate tiles on each row or column

FLIP_ROW: 3 = 3

Mesh pattern setting : flip (reflect in y axis) all tiles on alternate rows

FLIP_TILE: 1 = 1

Mesh pattern setting : flip (reflect in y axis) alternate tiles on each row or column

FRONTSIDE: 0 = 0

Mesh side orientation : usually the external or front surface

INSTANCEDMESH_SORT_TRANSPARENT: boolean

Indicates that the instanced meshes should be sorted from back to front before rendering if their material is transparent

LEFT: 1 = 1

Mesh tile positioning : part tiles on left

NO_CAP: 0 = 0

Mesh cap setting : no cap

NO_FLIP: 0 = 0

Mesh pattern setting : no flip or rotate

OCCLUSION_ALGORITHM_TYPE_ACCURATE: number

Use an accurate occlusion algorithm

OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE: number

Use a conservative occlusion algorithm

OCCLUSION_TYPE_NONE: number

No occlusion

OCCLUSION_TYPE_OPTIMISTIC: number

Occlusion set to optimistic

OCCLUSION_TYPE_STRICT: number

Occlusion set to strict

RIGHT: 2 = 2

Mesh tile positioning : part tiles on right

ROTATE_ROW: 4 = 4

Mesh pattern setting : rotate (180degs) all tiles on alternate rows

ROTATE_TILE: 2 = 2

Mesh pattern setting : rotate (180degs) alternate tiles on each row or column

TOP: 3 = 3

Mesh tile positioning : part tiles on top

Accessors

  • get absolutePosition(): Vector3
  • Returns the current mesh absolute position. Returns a Vector3.

    Returns Vector3

  • get absoluteRotationQuaternion(): Quaternion
  • Returns the current mesh absolute rotation. Returns a Quaternion.

    Returns Quaternion

  • get absoluteScaling(): Vector3
  • Returns the current mesh absolute scaling. Returns a Vector3.

    Returns Vector3

  • get accessibilityTag(): Nullable<IAccessibilityTag>
  • Returns Nullable<IAccessibilityTag>

  • set accessibilityTag(value: Nullable<IAccessibilityTag>): void
  • Gets or sets the accessibility tag to describe the node for accessibility purpose.

    Parameters

    • value: Nullable<IAccessibilityTag>

    Returns void

  • get animationPropertiesOverride(): Nullable<AnimationPropertiesOverride>
  • Gets or sets the animation properties override

    Returns Nullable<AnimationPropertiesOverride>

  • set animationPropertiesOverride(value: Nullable<AnimationPropertiesOverride>): void
  • Parameters

    • value: Nullable<AnimationPropertiesOverride>

    Returns void

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

    Returns boolean

  • set applyFog(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get areNormalsFrozen(): boolean
  • Gets a boolean indicating if the normals aren't to be recomputed on next mesh positions array update. This property is pertinent only for updatable parametric shapes.

    Returns boolean

  • get bakedVertexAnimationManager(): Nullable<IBakedVertexAnimationManager>
  • Returns Nullable<IBakedVertexAnimationManager>

  • set bakedVertexAnimationManager(value: Nullable<IBakedVertexAnimationManager>): void
  • Parameters

    • value: Nullable<IBakedVertexAnimationManager>

    Returns void

  • get billboardMode(): 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

    Returns number

  • set billboardMode(value: number): void
  • Parameters

    • value: number

    Returns void

  • get checkCollisions(): boolean
  • Returns boolean

  • set checkCollisions(pValue: boolean): void
  • Parameters

    • pValue: boolean

    Returns void

  • get cloneMeshMap(): Nullable<{
        [id: string]: Mesh | undefined;
    }>
  • Gets the list of clones of this mesh The scene must have been constructed with useClonedMeshMap=true for this to work! Note that useClonedMeshMap=true is the default setting

    Returns Nullable<{
        [id: string]: Mesh | undefined;
    }>

  • get collisionGroup(): 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

    Returns number

  • set collisionGroup(mask: number): void
  • Parameters

    • mask: number

    Returns void

  • get collisionMask(): 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

    Returns number

  • set collisionMask(mask: number): void
  • Parameters

    • mask: number

    Returns void

  • get collisionResponse(): 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.

    Returns boolean

  • set collisionResponse(response: boolean): void
  • Parameters

    • response: boolean

    Returns void

  • get collisionRetryCount(): number
  • number of collision detection tries. Change this value if not all collisions are detected and handled properly

    Returns number

  • set collisionRetryCount(retryCount: number): void
  • Parameters

    • retryCount: number

    Returns void

  • get computeBonesUsingShaders(): boolean
  • Returns boolean

  • set computeBonesUsingShaders(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

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

    Returns boolean

  • set doNotSerialize(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get enableDistantPicking(): boolean
  • When enabled, decompose picking matrices for better precision with large values for mesh position and scling

    Returns boolean

  • set enableDistantPicking(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get facetDepthSortFrom(): Vector3
  • The location (Vector3) where the facet depth sort must be computed from. By default, the active camera position. Used only when facet depth sort is enabled

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#facet-depth-sort

    Returns Vector3

  • set facetDepthSortFrom(location: Vector3): void
  • Parameters

    • location: Vector3

    Returns void

  • get forceWorldMatrixInstancedBufferUpdate(): boolean
  • Gets or sets a boolean indicating that the update of the instance buffer of the world matrices must be performed in all cases (and notably even in frozen mode)

    Returns boolean

  • set forceWorldMatrixInstancedBufferUpdate(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get forcedInstanceCount(): number
  • Gets or sets the forced number of instances to display. If 0 (default value), the number of instances is not forced and depends on the draw type (regular / instance / thin instances mesh)

    Returns number

  • set forcedInstanceCount(count: number): void
  • Parameters

    • count: number

    Returns void

  • get forward(): Vector3
  • The forward direction of that transform in world space.

    Returns Vector3

  • get geometry(): Nullable<Geometry>
  • Gets the mesh internal Geometry object

    Returns Nullable<Geometry>

  • get hasBoundingInfo(): boolean
  • Returns true if there is already a bounding info

    Returns boolean

  • get hasInstances(): boolean
  • Returns boolean

  • get hasLODLevels(): boolean
  • Gets a boolean indicating if this mesh has LOD

    Returns boolean

  • get hasThinInstances(): boolean
  • Returns boolean

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

    Returns boolean

  • set hasVertexAlpha(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

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

    Returns boolean

  • set infiniteDistance(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get isAnInstance(): boolean
  • Gets a boolean indicating if this mesh is an instance or a regular mesh

    Returns boolean

  • get isBlocked(): boolean
  • Returns boolean

  • get isUnIndexed(): boolean
  • Gets or sets a boolean indicating that this mesh does not use index buffer

    Returns boolean

  • set isUnIndexed(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get isWorldMatrixFrozen(): boolean
  • True if the World matrix has been frozen.

    Returns boolean

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

    Returns Light[]

  • get manualUpdateOfPreviousWorldMatrixInstancedBuffer(): boolean
  • Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual

    Returns boolean

  • set manualUpdateOfPreviousWorldMatrixInstancedBuffer(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get manualUpdateOfWorldMatrixInstancedBuffer(): boolean
  • Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual

    Returns boolean

  • set manualUpdateOfWorldMatrixInstancedBuffer(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get material(): Material
  • Returns Material

  • set material(pValue: Material): void
  • Parameters

    • pValue: Material

    Returns void

  • get morphTargetManager(): Nullable<MorphTargetManager>
  • Returns Nullable<MorphTargetManager>

  • set morphTargetManager(value: Nullable<MorphTargetManager>): void
  • Parameters

    • value: Nullable<MorphTargetManager>

    Returns void

  • get mustDepthSortFacets(): boolean
  • Gets or sets a boolean indicating that the facets must be depth sorted on next call to updateFacetData(). Works only for updatable meshes. Doesn't work with multi-materials

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#facet-depth-sort

    Returns boolean

  • set mustDepthSortFacets(sort: boolean): void
  • Parameters

    • sort: boolean

    Returns void

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

    Returns boolean

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

    Returns number

  • set numBoneInfluencers(value: number): void
  • Parameters

    • value: number

    Returns void

  • get onAfterRenderObservable(): Observable<Mesh>
  • An event triggered after rendering the mesh

    Returns Observable<Mesh>

  • get onBeforeBindObservable(): Observable<Mesh>
  • An event triggered before binding the mesh

    Returns Observable<Mesh>

  • set onBeforeDraw(callback: (() => void)): void
  • Sets a callback to call before drawing the mesh. It is recommended to use onBeforeDrawObservable instead

    Parameters

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

    Returns void

  • get onBeforeDrawObservable(): Observable<Mesh>
  • An event triggered before drawing the mesh

    Returns Observable<Mesh>

  • get onBeforeRenderObservable(): Observable<Mesh>
  • An event triggered before rendering the mesh

    Returns Observable<Mesh>

  • get onBetweenPassObservable(): Observable<SubMesh>
  • An event triggeredbetween rendering pass when using separateCullingPass = true

    Returns Observable<SubMesh>

  • get onClonedObservable(): Observable<Node>
  • An event triggered when the node is cloned

    Returns Observable<Node>

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

    Parameters

    • callback: ((collidedMesh?: AbstractMesh) => void)
        • (collidedMesh?: AbstractMesh): void
        • Parameters

          • Optional collidedMesh: AbstractMesh

          Returns void

    Returns void

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

    Parameters

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

    Returns void

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

    Parameters

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

    Returns void

  • get onEnabledStateChangedObservable(): Observable<boolean>
  • An event triggered when the enabled state of the node changes

    Returns Observable<boolean>

  • set overridenInstanceCount(count: number): void
  • Sets a value overriding the instance count. Only applicable when custom instanced InterleavedVertexBuffer are used rather than InstancedMeshs

    Parameters

    • count: number

    Returns void

  • get partitioningBBoxRatio(): number
  • The ratio (float) to apply to the bounding box size to set to the partitioning space. Ex : 1.01 (default) the partitioning space is 1% bigger than the bounding box

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#tweaking-the-partitioning

    Returns number

  • set partitioningBBoxRatio(ratio: number): void
  • Parameters

    • ratio: number

    Returns void

  • get pointerOverDisableMeshTesting(): boolean
  • Gets or sets the property which disables the test that is checking that the mesh under the pointer is the same than the previous time we tested for it (default: false). Set this property to true if you want thin instances picking to be reported accurately when moving over the mesh. Note that setting this property to true will incur some performance penalties when dealing with pointer events for this mesh so use it sparingly.

    Returns boolean

  • set pointerOverDisableMeshTesting(disable: boolean): void
  • Parameters

    • disable: boolean

    Returns void

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

    Returns Vector3

  • set position(newPosition: Vector3): void
  • Parameters

    • newPosition: Vector3

    Returns void

  • get preserveParentRotationForBillboard(): 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

    Returns boolean

  • set preserveParentRotationForBillboard(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get previousWorldMatrixInstancedBuffer(): Float32Array
  • Gets the array buffer used to store the instanced buffer used for instances' previous world matrices

    Returns Float32Array

  • get receiveShadows(): boolean
  • Gets or sets a boolean indicating that this mesh can receive realtime shadows

    See

    https://doc.babylonjs.com/features/featuresDeepDive/lights/shadows

    Returns boolean

  • set receiveShadows(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get right(): Vector3
  • The right direction of that transform in world space.

    Returns Vector3

  • get rotation(): 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

    Returns Vector3

  • set rotation(newRotation: Vector3): void
  • Parameters

    • newRotation: Vector3

    Returns void

  • get rotationQuaternion(): 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)

    Returns Nullable<Quaternion>

  • set rotationQuaternion(quaternion: Nullable<Quaternion>): void
  • Parameters

    • quaternion: Nullable<Quaternion>

    Returns void

  • get scaling(): Vector3
  • Gets or sets the scaling property : a Vector3 defining the node scaling along each local axis X, Y, Z (default is (1.0, 1.0, 1.0)).

    Returns Vector3

  • set scaling(newScaling: Vector3): void
  • Parameters

    • newScaling: Vector3

    Returns void

  • get source(): Nullable<Mesh>
  • Gets the source mesh (the one used to clone this one from)

    Returns Nullable<Mesh>

  • get surroundingMeshes(): 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.

    Returns Nullable<AbstractMesh[]>

  • set surroundingMeshes(meshes: Nullable<AbstractMesh[]>): void
  • Parameters

    • meshes: Nullable<AbstractMesh[]>

    Returns void

  • get up(): Vector3
  • The up direction of that transform in world space.

    Returns Vector3

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

    Returns boolean

  • get useLODScreenCoverage(): boolean
  • Determines if the LOD levels are intended to be calculated using screen coverage (surface area ratio) instead of distance.

    Returns boolean

  • set useLODScreenCoverage(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get useVertexColors(): 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)

    Returns boolean

  • set useVertexColors(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get visibility(): number
  • Gets or sets mesh visibility between 0 and 1 (default is 1)

    Returns number

  • set visibility(value: number): void
  • Gets or sets mesh visibility between 0 and 1 (default is 1)

    Parameters

    • value: number

    Returns void

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

    Returns Matrix

  • get worldMatrixInstancedBuffer(): Float32Array
  • Gets the array buffer used to store the instanced buffer used for instances' world matrices

    Returns Float32Array

  • get BILLBOARDMODE_ALL(): number
  • Billboard on all axes

    Returns number

  • get BILLBOARDMODE_NONE(): number
  • No billboard

    Returns number

  • get BILLBOARDMODE_USE_POSITION(): number
  • Billboard on using position instead of orientation

    Returns number

  • get BILLBOARDMODE_X(): number
  • Billboard on X axis

    Returns number

  • get BILLBOARDMODE_Y(): number
  • Billboard on Y axis

    Returns number

  • get BILLBOARDMODE_Z(): number
  • Billboard on Z axis

    Returns number

Methods

  • Returns void

  • Parameters

    • pSubMesh: SubMesh
    • pEffect: Effect
    • pFillMode: number

    Returns ThickLinesMesh

  • Returns void

  • Invalidate VertexArrayObjects belonging to the mesh (but not to the Geometry of the mesh).

    Returns void

  • Attach a behavior to the node

    See

    https://doc.babylonjs.com/features/featuresDeepDive/behaviors

    Returns

    the current Node

    Parameters

    • behavior: Behavior<Node>

      defines the behavior to attach

    • Optional attachImmediately: boolean

      defines that the behavior must be attached even if the scene is still loading

    Returns Node

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

    Returns

    the current mesh

    Parameters

    • mesh: AbstractMesh

      defines the child mesh

    • Optional preserveScalingSign: boolean

      if true, keep scaling sign of child. Otherwise, scaling sign might change.

    Returns AbstractMesh

  • Add a mesh as LOD level triggered at the given distance.

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/LOD

    Returns

    This mesh (for chaining)

    Parameters

    • distanceOrScreenCoverage: number

      Either distance from the center of the object to show this level or the screen coverage if useScreenCoverage is set to true. If screen coverage, value is a fraction of the screen's total surface, between 0 and 1. Example Playground for distance https://playground.babylonjs.com/#QE7KM#197 Example Playground for screen coverage https://playground.babylonjs.com/#QE7KM#196

    • mesh: Nullable<Mesh>

      The mesh to be added as LOD level (can be null)

    Returns Mesh

  • 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.

    Returns

    the TransformNode.

    Parameters

    • x: number

      Rotation to add

    • y: number

      Rotation to add

    • z: number

      Rotation to add

    Returns TransformNode

  • Align the mesh with a normal

    Returns

    the current mesh

    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

  • Modifies the mesh geometry according to a displacement map. A displacement map is a colored image. Each pixel color value (actually a gradient computed from red, green, blue values) will give the displacement to apply to each mesh vertex. The mesh must be set as updatable. Its internal geometry is directly modified, no new buffer are allocated.

    Returns

    the Mesh.

    Parameters

    • url: string

      is a string, the URL from the image file is to be downloaded.

    • minHeight: number

      is the lower limit of the displacement.

    • maxHeight: number

      is the upper limit of the displacement.

    • Optional onSuccess: ((mesh: Mesh) => void)

      is an optional Javascript function to be called just after the mesh is modified. It is passed the modified mesh and must return nothing.

        • (mesh: Mesh): void
        • Parameters

          • mesh: Mesh

          Returns void

    • Optional uvOffset: Vector2

      is an optional vector2 used to offset UV.

    • Optional uvScale: Vector2

      is an optional vector2 used to scale UV.

    • Optional forceUpdate: boolean

      defines whether or not to force an update of the generated buffers. This is useful to apply on a deserialized model for instance.

    Returns Mesh

  • Modifies the mesh geometry according to a displacementMap buffer. A displacement map is a colored image. Each pixel color value (actually a gradient computed from red, green, blue values) will give the displacement to apply to each mesh vertex. The mesh must be set as updatable. Its internal geometry is directly modified, no new buffer are allocated.

    Returns

    the Mesh.

    Parameters

    • buffer: Uint8Array

      is a Uint8Array buffer containing series of Uint8 lower than 255, the red, green, blue and alpha values of each successive pixel.

    • heightMapWidth: number

      is the width of the buffer image.

    • heightMapHeight: number

      is the height of the buffer image.

    • minHeight: number

      is the lower limit of the displacement.

    • maxHeight: number

      is the upper limit of the displacement.

    • Optional uvOffset: Vector2

      is an optional vector2 used to offset UV.

    • Optional uvScale: Vector2

      is an optional vector2 used to scale UV.

    • Optional forceUpdate: boolean

      defines whether or not to force an update of the generated buffers. This is useful to apply on a deserialized model for instance.

    Returns Mesh

  • Updates the vertex buffer by applying transformation from the bones

    Returns

    the current mesh

    Parameters

    • skeleton: Skeleton

      defines the skeleton to apply to current mesh

    Returns Mesh

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

    Returns

    this object

    Parameters

    • bone: Bone

      Bone affecting the TransformNode

    • affectedTransformNode: TransformNode

      TransformNode associated with the bone

    Returns TransformNode

  • Modifies the mesh geometry according to its own current World Matrix. The mesh World Matrix is then reset. This method returns nothing but really modifies the mesh even if it's originally not set as updatable. Note that, under the hood, this method sets a new VertexBuffer each call.

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/bakingTransforms

    Returns

    the current mesh

    Parameters

    • Optional bakeIndependentlyOfChildren: boolean

      indicates whether to preserve all child nodes' World Matrix during baking

    Returns Mesh

  • Modifies the mesh geometry according to the passed transformation matrix. This method returns nothing, but it really modifies the mesh even if it's originally not set as updatable. The mesh normals are modified using the same transformation. Note that, under the hood, this method sets a new VertexBuffer each call.

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/bakingTransforms

    Returns

    the current mesh

    Parameters

    • transform: Matrix

      defines the transform matrix to use

    Returns Mesh

  • Will start the animation sequence

    Returns

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

    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>

  • Creates a new bounding info for the mesh

    Returns

    the new bounding info

    Parameters

    • minimum: DeepImmutableObject<Vector3>

      min vector of the bounding box/sphere

    • maximum: DeepImmutableObject<Vector3>

      max vector of the bounding box/sphere

    • Optional worldMatrix: DeepImmutableObject<Matrix>

      defines the new world matrix

    Returns BoundingInfo

  • 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 definedFacingForwardSearch | See definedFacingForwardSearch.

    Returns

    the new displacement vector

    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

  • Calculate relative rotation change from the point of view of behind the front of the mesh. Supports definition of mesh facing forward or backward definedFacingForwardSearch | See definedFacingForwardSearch.

    Returns

    the new rotation vector

    Parameters

    • flipBack: number

      defines the flip

    • twirlClockwise: number

      defines the twirl

    • tiltRight: number

      defines the tilt

    Returns Vector3

  • Renormalize the mesh and patch it up if there are no weights Similar to normalization by adding the weights compute the reciprocal and multiply all elements, this wil ensure that everything adds to 1. However in the case of zero weights then we set just a single influence to 1. We check in the function for extra's present and if so we use the normalizeSkinWeightsWithExtras rather than the FourWeights version.

    Returns void

  • Parameters

    • pName: string
    • Optional pNewParent: null | Node
    • Optional pDoNotCloneChildren: boolean

    Returns ThickLinesMesh

  • Computes the world matrix of the node

    Returns

    the world matrix

    Parameters

    • Optional force: boolean

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

    Returns Matrix

  • Modify the mesh to get a flat shading rendering. This means each mesh facet will then have its own normals. Usually new vertices are added in the mesh geometry to get this result. Warning : the mesh is really modified even if not set originally as updatable and, under the hood, a new VertexBuffer is allocated.

    Returns

    current mesh

    Returns Mesh

  • This method removes all the mesh indices and add new vertices (duplication) in order to unfold facets into buffers. In other words, more vertices, no more indices and a single bigger VBO. The mesh is really modified even if not set originally as updatable. Under the hood, a new VertexBuffer is allocated.

    Returns

    current mesh

    Returns Mesh

  • 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

  • Parameters

    • name: string

    Returns InstancedMesh

  • Creates new normals data for the mesh

    Returns

    the current mesh

    Parameters

    • updatable: boolean

      defines if the normal vertex buffer must be flagged as updatable

    Returns AbstractMesh

  • 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

  • Detach the transform node if its associated with a bone

    Returns

    this object

    Parameters

    • Optional resetToPreviousParent: boolean

      Indicates if the parent that was in effect when attachToBone was called should be set back or if we should set parent to null instead (defaults to the latter)

    Returns TransformNode

  • Disables the mesh edge rendering mode

    Returns

    the currentAbstractMesh

    Returns AbstractMesh

  • Parameters

    • Optional pDoNotRecurse: boolean
    • Optional pDisposeMaterialAndTextures: boolean

    Returns void

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

    Returns

    the currentAbstractMesh

    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

  • Inverses facet orientations. Warning : the mesh is really modified even if not set originally as updatable. A new VertexBuffer is created under the hood each call.

    Returns

    current mesh

    Parameters

    • Optional flipNormals: boolean

      will also inverts the normals

    Returns Mesh

  • Force adjacent facets to share vertices and remove any facets that have all vertices in a line This will undo any application of covertToFlatShadedMesh Warning : the mesh is really modified even if not set originally as updatable. A new VertexBuffer is created under the hood each call.

    Returns void

  • This function affects parametric shapes on vertex position update only : ribbons, tubes, etc. It has no effect at all on other shapes. It prevents the mesh normals from being recomputed on next positions array update.

    Returns

    the current mesh

    Returns Mesh

  • Prevents the World matrix to be computed any longer

    Returns

    the TransformNode.

    Parameters

    • Optional newWorldMatrix: Nullable<Matrix>

      defines an optional matrix to use as world matrix

    • Optional decompose: boolean

      defines whether to decompose the given newWorldMatrix or directly assign

    Returns TransformNode

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

    Returns

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

    Returns Vector3

  • Sets the Vector3 "result" coordinates with the mesh pivot point World coordinates.

    Returns

    this TransformNode.

    Parameters

    • result: Vector3

      vector3 to store the result

    Returns TransformNode

  • Returns the mesh absolute position in the World.

    Returns

    a Vector3.

    Returns Vector3

  • Returns as a new array populated with the mesh material and/or skeleton, if any.

    Returns

    an array of IAnimatable

    Returns IAnimatable[]

  • Get an animation by name

    Returns

    null if not found else the requested animation

    Parameters

    • name: string

      defines the name of the animation to look for

    Returns Nullable<Animation>

  • Get an animation range by name

    Returns

    null if not found else the requested animation range

    Parameters

    • name: string

      defines the name of the animation range to look for

    Returns Nullable<AnimationRange>

  • Gets the list of all animation ranges defined on this node

    Returns

    an array

    Returns Nullable<AnimationRange>[]

  • Gets an attached behavior by name

    See

    https://doc.babylonjs.com/features/featuresDeepDive/behaviors

    Returns

    null if behavior was not found else the requested behavior

    Parameters

    • name: string

      defines the name of the behavior to look for

    Returns Nullable<Behavior<Node>>

  • 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

    a BoundingInfo

    Returns BoundingInfo

  • Get all child-meshes of this node

    Returns

    an array of AbstractMesh

    Type Parameters

    • T extends AbstractMesh<T>

    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) => node is T)

      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): node is T
        • Parameters

          • node: Node

          Returns node is T

    Returns T[]

  • Get all child-meshes of this node

    Returns

    an array of AbstractMesh

    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

          • node: Node

          Returns boolean

    Returns AbstractMesh[]

  • Get all child-transformNodes of this node

    Returns

    an array of TransformNode

    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

          • node: Node

          Returns boolean

    Returns TransformNode[]

  • Get all direct children of this node

    Returns

    an array of Node

    Type Parameters

    • T extends Node<T>

    Parameters

    • Optional predicate: ((node: Node) => node is T)

      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): node is T
        • Parameters

          • node: Node

          Returns node is T

    • 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 T[]

  • Get all direct children of this node

    Returns

    an array of 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

          • node: Node

          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[]

  • Returns string

  • Returns the closest mesh facet index at (x,y,z) World coordinates, null if not found

    Returns

    the face index if found (or null instead)

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/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>

  • Returns the closest mesh facet index at (x,y,z) local coordinates, null if not found

    Returns

    the face index if found (or null instead)

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/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>

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

    Returns

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

    Returns IParticleSystem[]

  • Will return all nodes that have this node as ascendant

    Returns

    all children nodes of all types

    Type Parameters

    • T extends Node<T>

    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) => node is T)

      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): node is T
        • Parameters

          • node: Node

          Returns node is T

    Returns T[]

  • Will return all nodes that have this node as ascendant

    Returns

    all children nodes of all types

    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

          • node: Node

          Returns boolean

    Returns Node[]

  • 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.

    Returns

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

    Parameters

    • localAxis: Vector3

      axis to rotate

    Returns Vector3

  • 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 World space from the mesh World matrix.

    Returns

    this TransformNode.

    Parameters

    • localAxis: Vector3

      axis to rotate

    • result: Vector3

      the resulting transformnode

    Returns TransformNode

  • Returns the distance from the mesh to the active camera

    Returns

    the distance

    Parameters

    • Optional camera: Nullable<Camera>

      defines the camera to use

    Returns number

  • Gets the engine of the node

    Returns

    a Engine

    Returns Engine

  • Sets the reference Vector3 with the i-th facet position in the world system

    Returns

    the current mesh

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData

    Parameters

    • i: number

      defines the facet index

    • ref: Vector3

      defines the target vector

    Returns AbstractMesh

  • Returns the facets (in an array) in the same partitioning block than the one the passed coordinates are located (expressed in the mesh local system)

    Returns

    the array of facet indexes

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData

    Parameters

    • x: number

      defines x coordinate

    • y: number

      defines y coordinate

    • z: number

      defines z coordinate

    Returns Nullable<number[]>

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

    Returns

    the new bounding vectors

    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;
    }

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

    Returns

    the indices array or an empty array if the mesh has no geometry

    Parameters

    • 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.

    • Optional forceCopy: boolean

      defines a boolean indicating that the returned array must be cloned upon returning it

    Returns Nullable<IndicesArray>

  • Returns the registered LOD mesh distant from the parameter camera position if any, else returns the current mesh.

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/LOD

    Returns

    This mesh (for chaining)

    Parameters

    • camera: Camera

      defines the camera to use to compute distance

    • Optional boundingSphere: BoundingSphere

      defines a custom bounding sphere to use instead of the one from this mesh

    Returns Nullable<AbstractMesh>

  • Returns the LOD level mesh at the passed distance or null if not found.

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/LOD

    Returns

    a Mesh or null

    Parameters

    • distance: number

      The distance from the center of the object to show this level

    Returns Nullable<Mesh>

  • Gets the list of MeshLODLevel associated with the current mesh

    Returns

    an array of MeshLODLevel

    Returns MeshLODLevel[]

  • Gets the material used to render the mesh in a specific render pass

    Returns

    material used for the render pass. If no specific material is used for this render pass, undefined is returned (meaning mesh.material is used for this pass)

    Parameters

    • renderPassId: number

      render pass id

    Returns undefined | Material

  • Gets the mesh uniform buffer.

    Returns

    the uniform buffer of the mesh.

    Returns UniformBuffer

  • Get the normals vertex data and optionally apply skeleton and morphing.

    Returns

    the normals data

    Parameters

    • Optional applySkeleton: boolean

      defines whether to apply the skeleton

    • Optional applyMorph: boolean

      defines whether to apply the morph target

    Returns Nullable<FloatArray>

  • Returns the mesh pivot matrix. Default : Identity.

    Returns

    the matrix

    Returns Matrix

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

    Returns

    the pivot point

    Returns Vector3

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

    Returns

    this TransformNode.

    Parameters

    • result: Vector3

      the vector3 to store the result

    Returns TransformNode

  • Returns the mesh Pose matrix.

    Returns

    the pose matrix

    Returns Matrix

  • Get the position vertex data and optionally apply skeleton and morphing.

    Returns

    the position data

    Parameters

    • Optional applySkeleton: boolean

      defines whether to apply the skeleton

    • Optional applyMorph: boolean

      defines whether to apply the morph target

    • Optional data: Nullable<FloatArray>

      defines the position data to apply the skeleton and morph to

    Returns Nullable<FloatArray>

  • Returns the mesh position in the local space from the current World matrix values.

    Returns

    a new Vector3.

    Returns Vector3

  • Gets the position of the current mesh in camera space

    Returns

    a position

    Parameters

    • Optional camera: Nullable<Camera>

      defines the camera to use

    Returns Vector3

  • Gets the scene of the node

    Returns

    a scene

    Returns Scene

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

    Returns

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

    Returns number

  • Returns the total number of vertices within the mesh geometry or zero if the mesh has no geometry.

    Returns

    the total number of vertices

    Returns number

  • Returns the mesh VertexBuffer object from the requested kind

    Returns

    a FloatArray or null if the mesh has no vertex buffer for this kind.

    Parameters

    • kind: string

      defines which buffer to read from (positions, indices, normals, etc). Possible kind values :

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

    Returns Nullable<VertexBuffer>

  • Returns the content of an associated vertex buffer

    Returns

    a FloatArray or null if the mesh has no geometry or no vertex buffer for this kind.

    Parameters

    • kind: string

      defines which buffer to read from (positions, indices, normals, etc). 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
    • Optional copyWhenShared: boolean

      defines a boolean indicating that if the mesh geometry is shared among some other meshes, the returned array is a copy of the internal one

    • Optional forceCopy: boolean

      defines a boolean forcing the copy of the buffer no matter what the value of copyWhenShared is

    Returns Nullable<FloatArray>

  • Returns a string which contains the list of existing kinds of Vertex Data associated with this mesh.

    Returns

    an array of strings

    Returns string[]

  • Gets the current world matrix

    Returns

    a Matrix

    Returns Matrix

  • Increase the number of facets and hence vertices in a mesh Vertex normals are interpolated from existing vertex normals Warning : the mesh is really modified even if not set originally as updatable. A new VertexBuffer is created under the hood each call.

    Parameters

    • Optional numberPerEdge: number

      the number of new vertices to add to each edge of a facet, optional default 1

    Returns void

  • Parameters

    • Optional newParent: Nullable<TransformNode>
    • Optional options: {
          doNotInstantiate: boolean | ((node: TransformNode) => boolean);
      }
      • doNotInstantiate: boolean | ((node: TransformNode) => boolean)
    • Optional onNewNodeCreated: ((source: TransformNode, clone: TransformNode) => void)
        • (source: TransformNode, clone: TransformNode): void
        • Parameters

          • source: TransformNode
          • clone: TransformNode

          Returns void

    Returns Nullable<TransformNode>

  • Checks if the passed Ray intersects with the mesh

    Returns

    the picking info

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/interactions/mesh_intersect

    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

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

    Returns

    true if there is an intersection

    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

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

    Returns

    true if there is an intersection

    Parameters

    • point: Vector3

      defines the point to test

    Returns 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.

    Returns

    true if the mesh is completely in the frustum planes

    Parameters

    • frustumPlanes: Plane[]

      defines the frustum to test

    Returns 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

    Returns

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

    Parameters

    • ancestor: Node

      defines the parent node to inspect

    Returns boolean

  • Gets a boolean indicating if the node has been disposed

    Returns

    true if the node was disposed

    Returns 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

    Returns

    whether this node (and its parent) is enabled

    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

  • 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

    Returns

    true if the mesh is in the frustum planes

    Parameters

    • frustumPlanes: Plane[]

      defines the frustum to test

    Returns boolean

  • Determine if the current mesh is ready to be rendered

    Returns

    true if all associated assets are ready (material, textures, shaders)

    Parameters

    • Optional completeCheck: boolean

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

    • Optional forceInstanceSupport: boolean

      will check if the mesh will be ready when used with instances (false by default)

    Returns boolean

  • return true if a pivot has been set

    Returns

    true if a pivot matrix is used

    Returns boolean

  • Returns a boolean defining if the vertex data for the requested kind is updatable.

    Returns

    a boolean

    Parameters

    • kind: string

      defines which buffer to check (positions, indices, normals, etc). 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 boolean

  • Tests if a specific vertex buffer is associated with this mesh

    Returns

    a boolean

    Parameters

    • kind: string

      defines which buffer to check (positions, indices, normals, etc). Possible kind values :

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

    Returns boolean

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

    Returns

    the TransformNode.

    Parameters

    • vector3: Vector3

      the distance to translate in localspace

    Returns TransformNode

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

    Returns

    the TransformNode.

    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 chosen space of the target

    Returns TransformNode

  • Creates a un-shared specific occurence of the geometry for the mesh.

    Returns

    the current mesh

    Returns Mesh

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

    Returns

    this AbstractMesh

    Parameters

    • Optional property: string

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

    Returns AbstractMesh

  • Flags an associated vertex buffer as updatable

    Parameters

    • kind: string

      defines which buffer to use (positions, indices, normals, etc). 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
    • Optional updatable: boolean

      defines if the updated vertex buffer must be flagged as updatable

    Returns void

  • 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 definedFacingForwardSearch | See definedFacingForwardSearch.

    Returns

    the current mesh

    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

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

    Returns

    the current mesh

    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

  • Optimization of the mesh's indices, in case a mesh has duplicated vertices. The function will only reorder the indices and will not remove unused vertices to avoid problems with submeshes. This should be used together with the simplification to avoid disappearing triangles.

    Returns

    the current mesh

    Parameters

    • Optional successCallback: ((mesh?: Mesh) => void)

      an optional success callback to be called after the optimization finished.

        • (mesh?: Mesh): void
        • Parameters

          • Optional mesh: Mesh

          Returns void

    Returns Mesh

  • 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.

    Returns

    the current mesh

    Parameters

    • Optional applySkeleton: boolean

      defines whether to apply the skeleton before computing the bounding info

    • Optional applyMorph: boolean

      defines whether to apply the morph target before computing the bounding info

    Returns Mesh

  • Registers for this mesh a javascript function called just after the rendering is complete

    Returns

    the current mesh

    Parameters

    • func: ((mesh: AbstractMesh) => void)

      defines the function to call after rendering this mesh

        • (mesh: AbstractMesh): void
        • Parameters

          • mesh: AbstractMesh

          Returns void

    Returns Mesh

  • If you'd like to be called back after the mesh position, rotation or scaling has been updated.

    Returns

    the TransformNode.

    Parameters

    • func: ((mesh: TransformNode) => void)

      callback function to add

        • (mesh: TransformNode): void
        • Parameters

          • mesh: TransformNode

          Returns void

    Returns TransformNode

  • Registers for this mesh a javascript function called just before the rendering process

    Returns

    the current mesh

    Parameters

    • func: ((mesh: AbstractMesh) => void)

      defines the function to call before rendering this mesh

        • (mesh: AbstractMesh): void
        • Parameters

          • mesh: AbstractMesh

          Returns void

    Returns Mesh

  • Disposes all the submeshes of the current meshnp

    Returns

    the current mesh

    Returns AbstractMesh

  • Removes the passed mesh from the current mesh children list

    Returns

    the current mesh

    Parameters

    • mesh: AbstractMesh

      defines the child mesh

    • Optional preserveScalingSign: boolean

      if true, keep scaling sign of child. Otherwise, scaling sign might change.

    Returns AbstractMesh

  • Delete a vertex buffer associated with this mesh

    Parameters

    • kind: string

      defines which buffer to delete (positions, indices, normals, etc). 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 void

  • Triggers the draw call for the mesh. Usually, you don't need to call this method by your own because the mesh rendering is handled by the scene rendering manager

    Returns

    the current mesh

    Parameters

    • subMesh: SubMesh

      defines the subMesh to render

    • enableAlphaMode: boolean

      defines if alpha mode can be changed

    • Optional effectiveMeshReplacement: AbstractMesh

      defines an optional mesh used to provide info for the rendering

    Returns Mesh

  • Resets the draw wrappers cache for all submeshes of this abstract mesh

    Parameters

    • Optional passId: number

      If provided, releases only the draw wrapper corresponding to this render pass id

    Returns 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

  • 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.

    Returns

    the TransformNode.

    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

  • 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

    Returns

    the TransformNode

    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

  • Perform relative rotation change from the point of view of behind the front of the mesh. Supports definition of mesh facing forward or backward definedFacingForwardSearch | See definedFacingForwardSearch.

    Returns

    the current mesh

    Parameters

    • flipBack: number

      defines the flip

    • twirlClockwise: number

      defines the twirl

    • tiltRight: number

      defines the tilt

    Returns AbstractMesh

  • Serialize current mesh

    Parameters

    • Optional serializationObject: any

      defines the object which will receive the serialization data

    Returns any

  • Serialize animation ranges into a JSON compatible object

    Returns

    serialization object

    Returns any

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

    Returns

    the TransformNode.

    Parameters

    • absolutePosition: Vector3

      the absolute position to set

    Returns TransformNode

  • Overwrite the current bounding info

    Returns

    the current mesh

    Parameters

    • boundingInfo: BoundingInfo

      defines the new bounding info

    Returns AbstractMesh

  • Sets this transform node rotation to the given local axis.

    Returns

    this TransformNode

    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

  • Set the enabled state of this node

    Parameters

    • value: boolean

      defines the new enabled state

    Returns void

  • Set the index buffer of this mesh

    Returns

    the current mesh

    Parameters

    • indices: IndicesArray

      defines the source data

    • Optional totalVertices: Nullable<number>

      defines the total number of vertices referenced by this index data (can be null)

    • Optional updatable: boolean

      defines if the updated index buffer must be flagged as updatable (default is false)

    Returns AbstractMesh

  • Sets the mesh material by the material or multiMaterial id property

    Returns

    the current mesh

    Deprecated

    Please use MeshBuilder instead Please use setMaterialById instead

    Parameters

    • id: string

      is a string identifying the material or the multiMaterial

    Returns Mesh

  • Sets the mesh material by the material or multiMaterial id property

    Returns

    the current mesh

    Parameters

    • id: string

      is a string identifying the material or the multiMaterial

    Returns Mesh

  • Sets the material to be used to render the mesh in a specific render pass

    Parameters

    • renderPassId: number

      render pass id

    • Optional material: Material

      material to use for this render pass. If undefined is passed, no specific material will be used for this render pass but the regular material will be used instead (mesh.material)

    Returns void

  • Prepare internal normal array for software CPU skinning

    Returns

    original normals used for CPU skinning. Useful for integrating Morphing with skeletons in same mesh.

    Returns Nullable<Float32Array>

  • Defines the passed node as the parent of the current node. The node will remain exactly where it is and its position / rotation will be updated accordingly. Note that if the mesh has a pivot matrix / point defined it will be applied after the parent was updated. In that case the node will not remain in the same space as it is, as the pivot will be applied. To avoid this, you can set updatePivot to true and the pivot will be updated to identity

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/parent_pivot/parent

    Returns

    this TransformNode.

    Parameters

    • node: Nullable<Node>

      the node ot set as the parent

    • Optional preserveScalingSign: boolean

      if true, keep scaling sign of child. Otherwise, scaling sign might change.

    • Optional updatePivot: boolean

      if true, update the pivot matrix to keep the node in the same space as before

    Returns TransformNode

  • Sets a new pivot matrix to the current node

    Returns

    the current TransformNode

    Parameters

    • matrix: DeepImmutableObject<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

  • Sets a new pivot point to the current node

    Returns

    the current TransformNode

    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

  • Sets the mesh position in its local space.

    Returns

    the TransformNode.

    Parameters

    • vector3: Vector3

      the position to set in localspace

    Returns TransformNode

  • Prepare internal position array for software CPU skinning

    Returns

    original positions used for CPU skinning. Useful for integrating Morphing with skeletons in same mesh

    Returns Nullable<Float32Array>

  • Sets a new matrix to apply before all other transformation

    Returns

    the current TransformNode

    Parameters

    • matrix: Matrix

      defines the transform matrix

    Returns TransformNode

  • Sets the mesh global Vertex Buffer

    Returns

    the current mesh

    Parameters

    • buffer: VertexBuffer

      defines the buffer to use

    • Optional disposeExistingBuffer: boolean

      disposes the existing buffer, if any (default: true)

    Returns Mesh

  • Copy a FloatArray into a specific associated vertex buffer

    Returns

    the current mesh

    Parameters

    • kind: string

      defines which buffer to write to (positions, indices, normals, etc). 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
    • data: FloatArray

      defines the data source

    • Optional updatable: boolean

      defines if the updated vertex buffer must be flagged as updatable

    • Optional stride: number

      defines the data stride size (can be null)

    Returns AbstractMesh

  • This function will subdivide the mesh into multiple submeshes

    Parameters

    • count: number

      defines the expected number of submeshes

    Returns void

  • Synchronises all the mesh instance submeshes to the current mesh submeshes, if any. After this call, all the mesh instances have the same submeshes than the current mesh.

    Returns

    the current mesh

    Returns Mesh

  • Invert the geometry to move from a right handed system to a left handed one.

    Returns

    the current mesh

    Returns Mesh

  • Returns a description of this mesh

    Returns

    a descriptive string representing this mesh

    Parameters

    • Optional fullDetails: boolean

      define if full details about this mesh must be used

    Returns string

  • Transfer the mesh values to its UBO.

    Parameters

    • world: Matrix

      The world matrix associated with the mesh

    Returns void

  • 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.

    Returns

    the TransformNode.

    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

  • This function affects parametric shapes on vertex position update only : ribbons, tubes, etc. It has no effect at all on other shapes. It reactivates the mesh normals computation if it was previously frozen

    Returns

    the current mesh

    Returns Mesh

  • Allows back the World matrix computation.

    Returns

    the TransformNode.

    Returns ThickLinesMesh

  • Disposes a previously registered javascript function called after the rendering.

    Returns

    the current mesh

    Parameters

    • func: ((mesh: AbstractMesh) => void)

      defines the function to remove

        • (mesh: AbstractMesh): void
        • Parameters

          • mesh: AbstractMesh

          Returns void

    Returns Mesh

  • Removes a registered callback function.

    Returns

    the TransformNode.

    Parameters

    • func: ((mesh: TransformNode) => void)

      callback function to remove

        • (mesh: TransformNode): void
        • Parameters

          • mesh: TransformNode

          Returns void

    Returns TransformNode

  • Disposes a previously registered javascript function called before the rendering

    Returns

    the current mesh

    Parameters

    • func: ((mesh: AbstractMesh) => void)

      defines the function to remove

        • (mesh: AbstractMesh): void
        • Parameters

          • mesh: AbstractMesh

          Returns void

    Returns Mesh

  • 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

    Returns

    the current mesh

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData

    Returns AbstractMesh

  • Update the current index buffer

    Returns

    the current mesh

    Parameters

    • indices: IndicesArray

      defines the source data

    • 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

  • This method updates the vertex positions of an updatable mesh according to the positionFunction returned values.

    See

    https://doc.babylonjs.com/features/featuresDeepDive/mesh/dynamicMeshMorph#other-shapes-updatemeshpositions

    Returns

    the current mesh

    Parameters

    • positionFunction: ((data: FloatArray) => void)

      is a simple JS function what is passed the mesh positions array. It doesn't need to return anything

        • (data: FloatArray): void
        • Parameters

          • data: FloatArray

          Returns void

    • Optional computeNormals: boolean

      is a boolean (default true) to enable/disable the mesh normal recomputation after the vertex position update

    Returns Mesh

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

    Returns

    this TransformNode.

    Parameters

    • matrix: Matrix

      the matrix to copy the pose from

    Returns TransformNode

  • Update a specific associated vertex buffer

    Returns

    the current mesh

    Parameters

    • kind: string

      defines which buffer to write to (positions, indices, normals, etc). 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
    • data: FloatArray

      defines the data source

    • Optional updateExtends: boolean

      defines if extends info of the mesh must be updated (can be null). This is mostly useful for "position" kind

    • Optional makeItUnique: boolean

      defines if the geometry associated with the mesh must be cloned to make the change only for this mesh (and not all meshes associated with the same geometry)

    Returns AbstractMesh

  • ValidateSkinning is used to determine that a mesh has valid skinning data along with skin metrics, if missing weights, or not normalized it is returned as invalid mesh the string can be used for console logs, or on screen messages to let the user know there was an issue with importing the mesh

    Returns

    a validation object with skinned, valid and report string

    Returns {
        report: string;
        skinned: boolean;
        valid: boolean;
    }

    • report: string
    • skinned: boolean
    • valid: boolean
  • 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

  • Returns the center of the {min: Vector3, max: Vector3} or the center of MinMax vector3 computed from a mesh array

    Returns

    a vector3

    Parameters

    • meshesOrMinMaxVector: AbstractMesh[] | {
          max: Vector3;
          min: Vector3;
      }

      could be an array of meshes or a {min: Vector3, max: Vector3} object

    Returns Vector3

  • Returns a node constructor based on type name

    Returns

    the new constructor or null

    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)>

  • Parameters

    • pName: string
    • pScene: Scene
    • pLines: Vector3[]

    Returns ThickLinesMesh

  • Merge the array of meshes into a single mesh for performance reasons.

    Returns

    a new mesh

    Parameters

    • meshes: Mesh[]

      array of meshes with the vertices to merge. Entries cannot be empty meshes.

    • Optional disposeSource: boolean

      when true (default), dispose of the vertices from the source meshes.

    • Optional allow32BitsIndices: boolean

      when the sum of the vertices > 64k, this must be set to true.

    • Optional meshSubclass: Mesh

      (optional) can be set to a Mesh where the merged vertices will be inserted.

    • Optional subdivideWithSubMeshes: boolean

      when true (false default), subdivide mesh into subMeshes.

    • Optional multiMultiMaterials: boolean

      when true (false default), subdivide mesh into subMeshes with multiple materials, ignores subdivideWithSubMeshes.

    Returns Nullable<Mesh>

  • Merge the array of meshes into a single mesh for performance reasons.

    Returns

    a new mesh

    Parameters

    • meshes: Mesh[]

      array of meshes with the vertices to merge. Entries cannot be empty meshes.

    • Optional disposeSource: boolean

      when true (default), dispose of the vertices from the source meshes.

    • Optional allow32BitsIndices: boolean

      when the sum of the vertices > 64k, this must be set to true.

    • Optional meshSubclass: Mesh

      (optional) can be set to a Mesh where the merged vertices will be inserted.

    • Optional subdivideWithSubMeshes: boolean

      when true (false default), subdivide mesh into subMeshes.

    • Optional multiMultiMaterials: boolean

      when true (false default), subdivide mesh into subMeshes with multiple materials, ignores subdivideWithSubMeshes.

    Returns Promise<any>

  • Returns an object containing a min and max Vector3 which are the minimum and maximum vectors of each mesh bounding box from the passed array, in the world coordinates

    Returns

    an object {min: Vector3, max: Vector3}

    Parameters

    • meshes: AbstractMesh[]

      defines the list of meshes to scan

    Returns {
        max: Vector3;
        min: Vector3;
    }

    • max: Vector3
    • min: Vector3
  • Returns a new Mesh object parsed from the source provided.

    Returns

    a new Mesh

    Parameters

    • parsedMesh: any

      is the source

    • scene: Scene

      defines the hosting scene

    • rootUrl: string

      is the root URL to prefix the delayLoadingFile property with

    Returns Mesh

  • 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

Generated using TypeDoc