API
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class LinesMesh

Line mesh

see

https://doc.babylonjs.com/babylon101/parametric_shapes

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • Creates a new LinesMesh

    Parameters

    • name: string

      defines the name

    • Optional scene: Nullable<Scene>

      defines the hosting scene

    • Optional parent: Nullable<Node>

      defines the parent mesh if any

    • Optional source: Nullable<LinesMesh>

      defines the optional source LinesMesh used to clone data from

    • Optional doNotCloneChildren: boolean

      When cloning, skip cloning child meshes of source, default False. When false, achieved by calling a clone(), also passing False. This will make creation of children, recursive.

    • Optional useVertexColor: boolean | undefined

      defines if this LinesMesh supports vertex color

    • Optional useVertexAlpha: boolean | undefined

      defines if this LinesMesh supports vertex alpha

    • Optional material: Material

      material to use to draw the line. If not provided, will create a new one

    Returns LinesMesh

Properties

alphaSearch playground for alpha

alpha: number

Alpha of the line (Default: 1)

colorSearch playground for color

color: Color3

Color of the line (Default: White)

delayLoadStateSearch playground for delayLoadState

delayLoadState: number

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

see

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

delayLoadingFileSearch playground for delayLoadingFile

delayLoadingFile: string

Gets the file containing delay loading data for this mesh

edgesShareWithInstancesSearch playground for edgesShareWithInstances

edgesShareWithInstances: boolean

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

ignoreCameraMaxZSearch playground for ignoreCameraMaxZ

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.

instancesSearch playground for instances

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/how_to/how_to_use_instances

intersectionThresholdSearch playground for intersectionThreshold

intersectionThreshold: number

The intersection Threshold is the margin applied when intersection a segment of the LinesMesh with a Ray. This margin is expressed in world space coordinates, so its value may vary. Default value is 0.1

onLODLevelSelectionSearch playground for onLODLevelSelection

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

User defined function used to change how LOD level selection is done

see

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

Type declaration

onMeshReadyObservableSearch playground for onMeshReadyObservable

onMeshReadyObservable: Observable<Mesh>

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

overrideMaterialSideOrientationSearch playground for overrideMaterialSideOrientation

overrideMaterialSideOrientation: Nullable<number>

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

thinInstanceCountSearch playground for thinInstanceCount

thinInstanceCount: number

Gets / sets the number of thin instances to display. Note that you can't set a number higher than what the underlying buffer can handle.

thinInstanceEnablePickingSearch playground for thinInstanceEnablePicking

thinInstanceEnablePicking: boolean

Gets or sets a boolean defining if we want picking to pick thin instances as well

Optional Readonly useVertexAlphaSearch playground for useVertexAlpha

useVertexAlpha: boolean | undefined

If vertex alpha should be applied to the mesh

Optional Readonly useVertexColorSearch playground for useVertexColor

useVertexColor: boolean | undefined

If vertex color should be applied to the mesh

Static Readonly BACKSIDESearch playground for BACKSIDE

BACKSIDE: 1 = 1

Mesh side orientation : usually the internal or back surface

Static Readonly BOTTOMSearch playground for BOTTOM

BOTTOM: 4 = 4

Mesh tile positioning : part tiles on bottom

Static Readonly CAP_ALLSearch playground for CAP_ALL

CAP_ALL: 3 = 3

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

Static Readonly CAP_ENDSearch playground for CAP_END

CAP_END: 2 = 2

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

Static Readonly CAP_STARTSearch playground for CAP_START

CAP_START: 1 = 1

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

Static Readonly CENTERSearch playground for CENTER

CENTER: 0 = 0

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

Static Readonly DEFAULTSIDESearch playground for DEFAULTSIDE

DEFAULTSIDE: 0 = 0

Mesh side orientation : by default, FRONTSIDE

Static Readonly DOUBLESIDESearch playground for DOUBLESIDE

DOUBLESIDE: 2 = 2

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

Static Readonly FLIP_N_ROTATE_ROWSearch playground for FLIP_N_ROTATE_ROW

FLIP_N_ROTATE_ROW: 6 = 6

Mesh pattern setting : rotate pattern and rotate

Static Readonly FLIP_N_ROTATE_TILESearch playground for FLIP_N_ROTATE_TILE

FLIP_N_ROTATE_TILE: 5 = 5

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

Static Readonly FLIP_ROWSearch playground for FLIP_ROW

FLIP_ROW: 3 = 3

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

Static Readonly FLIP_TILESearch playground for FLIP_TILE

FLIP_TILE: 1 = 1

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

Static Readonly FRONTSIDESearch playground for FRONTSIDE

FRONTSIDE: 0 = 0

Mesh side orientation : usually the external or front surface

Static INSTANCEDMESH_SORT_TRANSPARENTSearch playground for INSTANCEDMESH_SORT_TRANSPARENT

INSTANCEDMESH_SORT_TRANSPARENT: boolean

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

Static Readonly LEFTSearch playground for LEFT

LEFT: 1 = 1

Mesh tile positioning : part tiles on left

Static Readonly NO_CAPSearch playground for NO_CAP

NO_CAP: 0 = 0

Mesh cap setting : no cap

Static Readonly NO_FLIPSearch playground for NO_FLIP

NO_FLIP: 0 = 0

Mesh pattern setting : no flip or rotate

Static Readonly RIGHTSearch playground for RIGHT

RIGHT: 2 = 2

Mesh tile positioning : part tiles on right

Static Readonly ROTATE_ROWSearch playground for ROTATE_ROW

ROTATE_ROW: 4 = 4

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

Static Readonly ROTATE_TILESearch playground for ROTATE_TILE

ROTATE_TILE: 2 = 2

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

Static Readonly TOPSearch playground for TOP

TOP: 3 = 3

Mesh tile positioning : part tiles on top

Accessors

areNormalsFrozen

  • 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

cloneMeshMap

  • 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<{}>

computeBonesUsingShaders

  • get computeBonesUsingShaders(): boolean
  • set computeBonesUsingShaders(value: boolean): any

forcedInstanceCount

  • get forcedInstanceCount(): number
  • set forcedInstanceCount(count: number): any

  • 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

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

    Parameters

    • count: number

    Returns any

geometry

hasInstances

  • get hasInstances(): boolean

hasLODLevels

  • get hasLODLevels(): boolean

  • Gets a boolean indicating if this mesh has LOD

    Returns boolean

hasThinInstances

  • get hasThinInstances(): boolean

isBlocked

  • get isBlocked(): boolean

isUnIndexed

  • get isUnIndexed(): boolean
  • set isUnIndexed(value: boolean): any

  • Gets or sets a boolean indicating that this mesh does not use index buffer

    Returns boolean

  • Gets or sets a boolean indicating that this mesh does not use index buffer

    Parameters

    • value: boolean

    Returns any

manualUpdateOfPreviousWorldMatrixInstancedBuffer

  • get manualUpdateOfPreviousWorldMatrixInstancedBuffer(): boolean
  • set manualUpdateOfPreviousWorldMatrixInstancedBuffer(value: boolean): any

manualUpdateOfWorldMatrixInstancedBuffer

  • get manualUpdateOfWorldMatrixInstancedBuffer(): boolean
  • set manualUpdateOfWorldMatrixInstancedBuffer(value: boolean): any

onAfterRenderObservable

onBeforeBindObservable

onBeforeDraw

  • set onBeforeDraw(callback: () => void): any

  • Sets a callback to call before drawing the mesh. It is recommended to use onBeforeDrawObservable instead

    Parameters

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

        • Returns void

    Returns any

onBeforeDrawObservable

onBeforeRenderObservable

onBetweenPassObservable

overridenInstanceCount

  • set overridenInstanceCount(count: number): any

  • Sets a value overriding the instance count. Only applicable when custom instanced InterleavedVertexBuffer are used rather than InstancedMeshs

    Parameters

    • count: number

    Returns any

previousWorldMatrixInstancedBuffer

  • get previousWorldMatrixInstancedBuffer(): Float32Array

  • Gets the array buffer used to store the instanced buffer used for instances' previous world matrices

    Returns Float32Array

source

  • Gets the source mesh (the one used to clone this one from)

    Returns Nullable<Mesh>

useLODScreenCoverage

  • get useLODScreenCoverage(): boolean
  • set useLODScreenCoverage(value: boolean): any

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

    Returns boolean

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

    Parameters

    • value: boolean

    Returns any

worldMatrixInstancedBuffer

  • get worldMatrixInstancedBuffer(): Float32Array

  • Gets the array buffer used to store the instanced buffer used for instances' world matrices

    Returns Float32Array

Methods

_invalidateInstanceVertexArrayObjectSearch playground for _invalidateInstanceVertexArrayObject

  • _invalidateInstanceVertexArrayObject(): void

addLODLevelSearch playground for addLODLevel

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

    see

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

    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.

    • mesh: Nullable<Mesh>

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

    Returns Mesh

    This mesh (for chaining)

applyDisplacementMapSearch playground for applyDisplacementMap

  • applyDisplacementMap(url: string, minHeight: number, maxHeight: number, onSuccess?: (mesh: Mesh) => void, uvOffset?: Vector2, uvScale?: Vector2, forceUpdate?: boolean): Mesh

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

    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

          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

    the Mesh.

applyDisplacementMapFromBufferSearch playground for applyDisplacementMapFromBuffer

  • applyDisplacementMapFromBuffer(buffer: Uint8Array, heightMapWidth: number, heightMapHeight: number, minHeight: number, maxHeight: number, uvOffset?: Vector2, uvScale?: Vector2, forceUpdate?: boolean): 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.

    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

    the Mesh.

applySkeletonSearch playground for applySkeleton

  • Updates the vertex buffer by applying transformation from the bones

    Parameters

    • skeleton: Skeleton

      defines the skeleton to apply to current mesh

    Returns Mesh

    the current mesh

bakeCurrentTransformIntoVerticesSearch playground for bakeCurrentTransformIntoVertices

  • bakeCurrentTransformIntoVertices(bakeIndependenlyOfChildren?: boolean): Mesh

  • 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/resources/baking_transformations

    Parameters

    • Optional bakeIndependenlyOfChildren: boolean

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

    Returns Mesh

    the current mesh

bakeTransformIntoVerticesSearch playground for bakeTransformIntoVertices

  • bakeTransformIntoVertices(transform: Matrix): 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/resources/baking_transformations

    Parameters

    • transform: Matrix

      defines the transform matrix to use

    Returns Mesh

    the current mesh

cleanMatrixWeightsSearch playground for cleanMatrixWeights

  • cleanMatrixWeights(): void

  • 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

cloneSearch playground for clone

  • Returns a new LineMesh object cloned from the current one.

    Parameters

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

    Returns LinesMesh

convertToFlatShadedMeshSearch playground for convertToFlatShadedMesh

  • convertToFlatShadedMesh(): Mesh

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

    current mesh

convertToUnIndexedMeshSearch playground for convertToUnIndexedMesh

  • convertToUnIndexedMesh(): 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 Mesh

    current mesh

createInstanceSearch playground for createInstance

createOrUpdateSubmeshesOctreeSearch playground for createOrUpdateSubmeshesOctree

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

disposeSearch playground for dispose

  • dispose(doNotRecurse?: boolean): void

  • Disposes of the line mesh

    Parameters

    • Optional doNotRecurse: boolean

      If children should be disposed

    Returns void

enableEdgesRenderingSearch playground for enableEdgesRendering

  • enableEdgesRendering(epsilon?: number, checkVerticesInsteadOfIndices?: boolean): AbstractMesh

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

    see

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

    Parameters

    • Optional epsilon: number

      defines the maximal distance between two angles to detect a face

    • Optional checkVerticesInsteadOfIndices: boolean

      indicates that we should check vertex list directly instead of faces

    Returns AbstractMesh

    the currentAbstractMesh

flipFacesSearch playground for flipFaces

  • flipFaces(flipNormals?: boolean): Mesh

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

    Parameters

    • Optional flipNormals: boolean

      will also inverts the normals

    Returns Mesh

    current mesh

forceSharedVerticesSearch playground for forceSharedVertices

  • forceSharedVertices(): void

  • 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

freezeNormalsSearch playground for freezeNormals

  • freezeNormals(): Mesh

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

    the current mesh

getAnimatablesSearch playground for getAnimatables

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

    Returns IAnimatable[]

    an array of IAnimatable

getClassNameSearch playground for getClassName

  • getClassName(): string

  • Returns the string "LineMesh"

    Returns string

getEmittedParticleSystemsSearch playground for getEmittedParticleSystems

getHierarchyEmittedParticleSystemsSearch playground for getHierarchyEmittedParticleSystems

getIndicesSearch playground for getIndices

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

    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>

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

getLODSearch playground for getLOD

getLODLevelAtDistanceSearch playground for getLODLevelAtDistance

getLODLevelsSearch playground for getLODLevels

  • Gets the list of MeshLODLevel associated with the current mesh

    Returns MeshLODLevel[]

    an array of MeshLODLevel

getTotalIndicesSearch playground for getTotalIndices

  • getTotalIndices(): number

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

    Returns number

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

getTotalVerticesSearch playground for getTotalVertices

  • getTotalVertices(): number

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

    Returns number

    the total number of vertices

getVertexBufferSearch playground for getVertexBuffer

  • Returns the mesh VertexBuffer object from the requested 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>

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

getVerticesDataSearch playground for getVerticesData

  • getVerticesData(kind: string, copyWhenShared?: boolean, forceCopy?: boolean): Nullable<FloatArray>

  • Returns the content of an associated vertex buffer

    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>

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

getVerticesDataKindsSearch playground for getVerticesDataKinds

  • getVerticesDataKinds(): string[]

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

    Returns string[]

    an array of strings

increaseVerticesSearch playground for increaseVertices

  • increaseVertices(numberPerEdge?: number): void

  • 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

instantiateHierarchySearch playground for instantiateHierarchy

isInFrustumSearch playground for isInFrustum

  • isInFrustum(frustumPlanes: Plane[]): boolean

  • Returns true if the mesh is within the frustum defined by the passed array of planes. A mesh is in the frustum if its bounding box intersects the frustum

    Parameters

    • frustumPlanes: Plane[]

      defines the frustum to test

    Returns boolean

    true if the mesh is in the frustum planes

isReadySearch playground for isReady

  • isReady(): boolean

isVertexBufferUpdatableSearch playground for isVertexBufferUpdatable

  • isVertexBufferUpdatable(kind: string): boolean

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

    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

    a boolean

isVerticesDataPresentSearch playground for isVerticesDataPresent

  • isVerticesDataPresent(kind: string): boolean

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

    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

    a boolean

makeGeometryUniqueSearch playground for makeGeometryUnique

  • makeGeometryUnique(): Mesh

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

    Returns Mesh

    the current mesh

markVerticesDataAsUpdatableSearch playground for markVerticesDataAsUpdatable

  • markVerticesDataAsUpdatable(kind: string, updatable?: boolean): void

  • 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

optimizeIndicesSearch playground for optimizeIndices

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

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

    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

    the current mesh

refreshBoundingInfoSearch playground for refreshBoundingInfo

  • refreshBoundingInfo(applySkeleton?: boolean, applyMorph?: boolean): 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.

    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

    the current mesh

registerAfterRenderSearch playground for registerAfterRender

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

    Parameters

    Returns Mesh

    the current mesh

registerBeforeRenderSearch playground for registerBeforeRender

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

    Parameters

    Returns Mesh

    the current mesh

registerInstancedBufferSearch playground for registerInstancedBuffer

  • registerInstancedBuffer(kind: string, stride: number): void

removeLODLevelSearch playground for removeLODLevel

removeVerticesDataSearch playground for removeVerticesData

  • removeVerticesData(kind: string): void

  • 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

renderSearch playground for render

  • 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

    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

    the current mesh

serializeSearch playground for serialize

  • serialize(serializationObject: any): void

  • Serializes this ground mesh

    Parameters

    • serializationObject: any

      object to write serialization to

    Returns void

setIndicesSearch playground for setIndices

  • Set the index buffer of this 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

    the current mesh

setMaterialByIDSearch playground for setMaterialByID

  • setMaterialByID(id: string): Mesh

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

    deprecated

    Please use MeshBuilder instead Please use setMaterialById instead

    Parameters

    • id: string

      is a string identifying the material or the multiMaterial

    Returns Mesh

    the current mesh

setMaterialByIdSearch playground for setMaterialById

  • setMaterialById(id: string): Mesh

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

    Parameters

    • id: string

      is a string identifying the material or the multiMaterial

    Returns Mesh

    the current mesh

setNormalsForCPUSkinningSearch playground for setNormalsForCPUSkinning

  • setNormalsForCPUSkinning(): Nullable<Float32Array>

  • Prepare internal normal array for software CPU skinning

    Returns Nullable<Float32Array>

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

setPositionsForCPUSkinningSearch playground for setPositionsForCPUSkinning

  • setPositionsForCPUSkinning(): Nullable<Float32Array>

  • Prepare internal position array for software CPU skinning

    Returns Nullable<Float32Array>

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

setVerticesBufferSearch playground for setVerticesBuffer

  • setVerticesBuffer(buffer: VertexBuffer, disposeExistingBuffer?: boolean): Mesh

  • Sets the mesh global Vertex Buffer

    Parameters

    • buffer: VertexBuffer

      defines the buffer to use

    • Optional disposeExistingBuffer: boolean

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

    Returns Mesh

    the current mesh

setVerticesDataSearch playground for setVerticesData

  • Copy a FloatArray into a specific associated vertex buffer

    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

    the current mesh

simplifySearch playground for simplify

  • Simplify the mesh according to the given array of settings. Function will return immediately and will simplify async

    Parameters

    • settings: Array<ISimplificationSettings>

      a collection of simplification settings

    • Optional parallelProcessing: boolean

      should all levels calculate parallel or one after the other

    • Optional simplificationType: SimplificationType

      the type of simplification to run

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

      optional success callback to be called after the simplification finished processing all settings

        • (mesh?: Mesh, submeshIndex?: number): void

        • Parameters

          • Optional mesh: Mesh
          • Optional submeshIndex: number

          Returns void

    Returns Mesh

    the current mesh

subdivideSearch playground for subdivide

  • subdivide(count: number): void

  • This function will subdivide the mesh into multiple submeshes

    Parameters

    • count: number

      defines the expected number of submeshes

    Returns void

synchronizeInstancesSearch playground for synchronizeInstances

  • synchronizeInstances(): Mesh

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

    the current mesh

thinInstanceAddSearch playground for thinInstanceAdd

  • Creates a new thin instance

    Parameters

    • matrix: DeepImmutableObject<Matrix> | Array<DeepImmutableObject<Matrix>>

      the matrix or array of matrices (position, rotation, scale) of the thin instance(s) to create

    • Optional refresh: boolean

      true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance

    Returns number

    the thin instance index number. If you pass an array of matrices, other instance indexes are index+1, index+2, etc

thinInstanceAddSelfSearch playground for thinInstanceAddSelf

  • thinInstanceAddSelf(refresh?: boolean): number

  • Adds the transformation (matrix) of the current mesh as a thin instance

    Parameters

    • Optional refresh: boolean

      true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance

    Returns number

    the thin instance index number

thinInstanceBufferUpdatedSearch playground for thinInstanceBufferUpdated

  • thinInstanceBufferUpdated(kind: string): void

  • Synchronize the gpu buffers with a thin instance buffer. Call this method if you update later on the buffers passed to thinInstanceSetBuffer

    Parameters

    • kind: string

      name of the attribute to update. Use "matrix" to update the buffer of matrices

    Returns void

thinInstanceGetWorldMatricesSearch playground for thinInstanceGetWorldMatrices

  • thinInstanceGetWorldMatrices(): Matrix[]

thinInstancePartialBufferUpdateSearch playground for thinInstancePartialBufferUpdate

  • thinInstancePartialBufferUpdate(kind: string, data: Float32Array, offset: number): void

  • Applies a partial update to a buffer directly on the GPU Note that the buffer located on the CPU is NOT updated! It's up to you to update it (or not) with the same data you pass to this method

    Parameters

    • kind: string

      name of the attribute to update. Use "matrix" to update the buffer of matrices

    • data: Float32Array

      the data to set in the GPU buffer

    • offset: number

      the offset in the GPU buffer where to update the data

    Returns void

thinInstanceRefreshBoundingInfoSearch playground for thinInstanceRefreshBoundingInfo

  • thinInstanceRefreshBoundingInfo(forceRefreshParentInfo?: boolean, applySkeleton?: boolean, applyMorph?: boolean): void

  • Refreshes the bounding info, taking into account all the thin instances defined

    Parameters

    • Optional forceRefreshParentInfo: boolean

      true to force recomputing the mesh bounding info and use it to compute the aggregated bounding info

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

thinInstanceRegisterAttributeSearch playground for thinInstanceRegisterAttribute

  • thinInstanceRegisterAttribute(kind: string, stride: number): void

  • Registers a custom attribute to be used with thin instances

    Parameters

    • kind: string

      name of the attribute

    • stride: number

      size in floats of the attribute

    Returns void

thinInstanceSetAttributeAtSearch playground for thinInstanceSetAttributeAt

  • thinInstanceSetAttributeAt(kind: string, index: number, value: Array<number>, refresh?: boolean): void

  • Sets the value of a custom attribute for a thin instance

    Parameters

    • kind: string

      name of the attribute

    • index: number

      index of the thin instance

    • value: Array<number>

      value to set

    • Optional refresh: boolean

      true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance

    Returns void

thinInstanceSetBufferSearch playground for thinInstanceSetBuffer

  • thinInstanceSetBuffer(kind: string, buffer: Nullable<Float32Array>, stride?: number, staticBuffer?: boolean): void

  • Sets a buffer to be used with thin instances. This method is a faster way to setup multiple instances than calling thinInstanceAdd repeatedly

    Parameters

    • kind: string

      name of the attribute. Use "matrix" to setup the buffer of matrices

    • buffer: Nullable<Float32Array>

      buffer to set

    • Optional stride: number

      size in floats of each value of the buffer

    • Optional staticBuffer: boolean

      indicates that the buffer is static, so that you won't change it after it is set (better performances - false by default)

    Returns void

thinInstanceSetMatrixAtSearch playground for thinInstanceSetMatrixAt

  • Sets the matrix of a thin instance

    Parameters

    • index: number

      index of the thin instance

    • matrix: DeepImmutableObject<Matrix>

      matrix to set

    • Optional refresh: boolean

      true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance

    Returns void

toLeftHandedSearch playground for toLeftHanded

  • toLeftHanded(): Mesh

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

    Returns Mesh

    the current mesh

toStringSearch playground for toString

  • toString(fullDetails?: boolean): string

  • Returns a description of this mesh

    Parameters

    • Optional fullDetails: boolean

      define if full details about this mesh must be used

    Returns string

    a descriptive string representing this mesh

unfreezeNormalsSearch playground for unfreezeNormals

  • unfreezeNormals(): Mesh

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

    the current mesh

unregisterAfterRenderSearch playground for unregisterAfterRender

unregisterBeforeRenderSearch playground for unregisterBeforeRender

updateIndicesSearch playground for updateIndices

  • Update the current index buffer

    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

    the current mesh

updateMeshPositionsSearch playground for updateMeshPositions

  • updateMeshPositions(positionFunction: (data: FloatArray) => void, computeNormals?: boolean): Mesh

updateVerticesDataSearch playground for updateVerticesData

  • updateVerticesData(kind: string, data: FloatArray, updateExtends?: boolean, makeItUnique?: boolean): AbstractMesh

  • Update a specific associated vertex buffer

    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

    the current mesh

validateSkinningSearch playground for validateSkinning

  • validateSkinning(): { report: string; skinned: boolean; valid: boolean }

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

    a validation object with skinned, valid and report string

    • report: string
    • skinned: boolean
    • valid: boolean

Static CenterSearch playground for Center

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

    Parameters

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

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

    Returns Vector3

    a vector3

Static CreateBoxSearch playground for CreateBox

  • CreateBox(name: string, size: number, scene: Nullable<Scene>, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates a box mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    Returns Mesh

    a new Mesh

Static CreateCapsuleSearch playground for CreateCapsule

  • Creates a Capsule Mesh

    see

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

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh.

    • options: ICreateCapsuleOptions

      the constructors options used to shape the mesh.

    • scene: Scene

      defines the scene the mesh is scoped to.

    Returns Mesh

    the capsule mesh

Static CreateCylinderSearch playground for CreateCylinder

  • CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions: any, scene?: Scene, updatable?: any, sideOrientation?: number): Mesh

  • Creates a cylinder or a cone mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • height: number

      sets the height size (float) of the cylinder/cone (float, default 2)

    • diameterTop: number

      set the top cap diameter (floats, default 1)

    • diameterBottom: number

      set the bottom cap diameter (floats, default 1). This value can't be zero

    • tessellation: number

      sets the number of cylinder sides (positive integer, default 24). Set it to 3 to get a prism for instance

    • subdivisions: any

      sets the number of rings along the cylinder height (positive integer, default 1)

    • Optional scene: Scene

      defines the hosting scene

    • Optional updatable: any

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    Returns Mesh

    a new Mesh

Static CreateDashedLinesSearch playground for CreateDashedLines

  • Creates a dashed line mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • points: Vector3[]

      is an array successive Vector3

    • dashSize: number

      is the size of the dashes relatively the dash number (positive float, default 3)

    • gapSize: number

      is the size of the gap between two successive dashes relatively the dash number (positive float, default 1)

    • dashNb: number

      is the intended total number of dashes (positive integer, default 200)

    • scene: Nullable<Scene>

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional instance: LinesMesh

      is an instance of an existing LineMesh object to be updated with the passed points parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#lines-and-dashedlines)

    Returns LinesMesh

    a new Mesh

Static CreateDecalSearch playground for CreateDecal

  • Creates a decal mesh. . A decal is a mesh usually applied as a model onto the surface of another mesh

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh

    • sourceMesh: AbstractMesh

      defines the mesh receiving the decal

    • position: Vector3

      sets the position of the decal in world coordinates

    • normal: Vector3

      sets the normal of the mesh where the decal is applied onto in world coordinates

    • size: Vector3

      sets the decal scaling

    • angle: number

      sets the angle to rotate the decal

    Returns Mesh

    a new Mesh

Static CreateDiscSearch playground for CreateDisc

  • CreateDisc(name: string, radius: number, tessellation: number, scene: Nullable<Scene>, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates a plane polygonal mesh. By default, this is a disc.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • radius: number

      sets the radius size (float) of the polygon (default 0.5)

    • tessellation: number

      sets the number of polygon sides (positive integer, default 64). So a tessellation valued to 3 will build a triangle, to 4 a square, etc

    • scene: Nullable<Scene>

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    Returns Mesh

    a new Mesh

Static CreateGroundSearch playground for CreateGround

  • CreateGround(name: string, width: number, height: number, subdivisions: number, scene?: Scene, updatable?: boolean): Mesh

  • Creates a ground mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • width: number

      set the width of the ground

    • height: number

      set the height of the ground

    • subdivisions: number

      sets the number of subdivisions per side

    • Optional scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    Returns Mesh

    a new Mesh

Static CreateGroundFromHeightMapSearch playground for CreateGroundFromHeightMap

  • CreateGroundFromHeightMap(name: string, url: string, width: number, height: number, subdivisions: number, minHeight: number, maxHeight: number, scene: Scene, updatable?: boolean, onReady?: (mesh: GroundMesh) => void, alphaFilter?: number): GroundMesh

  • Creates a ground mesh from a height map.

    see

    https://doc.babylonjs.com/babylon101/height_map

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • url: string

      sets the URL of the height map image resource

    • width: number

      set the ground width size

    • height: number

      set the ground height size

    • subdivisions: number

      sets the number of subdivision per side

    • minHeight: number

      is the minimum altitude on the ground

    • maxHeight: number

      is the maximum altitude on the ground

    • scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional onReady: (mesh: GroundMesh) => void

      is a callback function that will be called once the mesh is built (the height map download can last some time)

    • Optional alphaFilter: number

      will filter any data where the alpha channel is below this value, defaults 0 (all data visible)

    Returns GroundMesh

    a new Mesh

Static CreateHemisphereSearch playground for CreateHemisphere

  • CreateHemisphere(name: string, segments: number, diameter: number, scene?: Scene): Mesh

  • Creates a hemisphere mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • segments: number

      sets the sphere number of horizontal stripes (positive integer, default 32)

    • diameter: number

      sets the diameter size (float) of the sphere (default 1)

    • Optional scene: Scene

      defines the hosting scene

    Returns Mesh

    a new Mesh

Static CreateIcoSphereSearch playground for CreateIcoSphere

  • CreateIcoSphere(name: string, options: { flat?: boolean; radius?: number; sideOrientation?: number; subdivisions?: number; updatable?: boolean }, scene: Scene): Mesh

  • Creates a sphere based upon an icosahedron with 20 triangular faces which can be subdivided

    • The parameter radius sets the radius size (float) of the icosphere (default 1)
    • You can set some different icosphere dimensions, for instance to build an ellipsoid, by using the parameters radiusX, radiusY and radiusZ (all by default have the same value than radius)
    • The parameter subdivisions sets the number of subdivisions (positive integer, default 4). The more subdivisions, the more faces on the icosphere whatever its size
    • The parameter flat (boolean, default true) gives each side its own normals. Set it to false to get a smooth continuous light reflection on the surface
    • You can also set the mesh side orientation with the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
    • If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters frontUVs and backUVs (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
    • The mesh can be set to updatable with the boolean parameter updatable (default false) if its internal geometry is supposed to change once created
    see

    https://doc.babylonjs.com/how_to/polyhedra_shapes#icosphere

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh

    • options: { flat?: boolean; radius?: number; sideOrientation?: number; subdivisions?: number; updatable?: boolean }

      defines the options used to create the mesh

      • Optional flat?: boolean
      • Optional radius?: number
      • Optional sideOrientation?: number
      • Optional subdivisions?: number
      • Optional updatable?: boolean
    • scene: Scene

      defines the hosting scene

    Returns Mesh

    a new Mesh

Static CreateLatheSearch playground for CreateLathe

  • CreateLathe(name: string, shape: Vector3[], radius: number, tessellation: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates lathe mesh. The lathe is a shape with a symmetry axis : a 2D model shape is rotated around this axis to design the lathe.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • shape: Vector3[]

      is a required array of successive Vector3. This array depicts the shape to be rotated in its local space : the shape must be designed in the xOy plane and will be rotated around the Y axis. It's usually a 2D shape, so the Vector3 z coordinates are often set to zero

    • radius: number

      is the radius value of the lathe

    • tessellation: number

      is the side number of the lathe.

    • scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    Returns Mesh

    a new Mesh

Static CreateLinesSearch playground for CreateLines

Static CreatePlaneSearch playground for CreatePlane

  • CreatePlane(name: string, size: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates a plane mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    Returns Mesh

    a new Mesh

Static CreatePolygonSearch playground for CreatePolygon

  • CreatePolygon(name: string, shape: Vector3[], scene: Scene, holes?: Vector3[][], updatable?: boolean, sideOrientation?: number, earcutInjection?: any): Mesh

  • Creates a polygon mesh.Please consider using the same method from the MeshBuilder class instead The polygon's shape will depend on the input parameters and is constructed parallel to a ground mesh. The parameter shape is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors. You can set the mesh side orientation with the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE The mesh can be set to updatable with the boolean parameter updatable (default false) if its internal geometry is supposed to change once created. Remember you can only change the shape positions, not their number when updating a polygon.

    see

    https://doc.babylonjs.com/how_to/parametric_shapes#non-regular-polygon

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • shape: Vector3[]

      is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors

    • scene: Scene

      defines the hosting scene

    • Optional holes: Vector3[][]

      is a required array of arrays of successive Vector3 used to defines holes in the polygon

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    • Optional earcutInjection: any

      can be used to inject your own earcut reference

    Returns Mesh

    a new Mesh

Static CreatePolyhedronSearch playground for CreatePolyhedron

  • CreatePolyhedron(name: string, options: { custom?: any; faceColors?: Color4[]; faceUV?: Vector4[]; sideOrientation?: number; size?: number; sizeX?: number; sizeY?: number; sizeZ?: number; type?: number; updatable?: boolean }, scene: Scene): Mesh

  • Creates a polyhedron mesh. .

    • The parameter type (positive integer, max 14, default 0) sets the polyhedron type to build among the 15 embedded types. Please refer to the type sheet in the tutorial to choose the wanted type
    • The parameter size (positive float, default 1) sets the polygon size
    • You can overwrite the size on each dimension bu using the parameters sizeX, sizeY or sizeZ (positive floats, default to size value)
    • You can build other polyhedron types than the 15 embbeded ones by setting the parameter custom (polyhedronObject, default null). If you set the parameter custom, this overwrittes the parameter type
    • A polyhedronObject is a formatted javascript object. You'll find a full file with pre-set polyhedra here : https://github.com/BabylonJS/Extensions/tree/master/Polyhedron
    • You can set the color and the UV of each side of the polyhedron with the parameters faceColors (Color4, default (1, 1, 1, 1)) and faceUV (Vector4, default (0, 0, 1, 1))
    • To understand how to set faceUV or faceColors, please read this by considering the right number of faces of your polyhedron, instead of only 6 for the box : https://doc.babylonjs.com/how_to/createbox_per_face_textures_and_colors
    • The parameter flat (boolean, default true). If set to false, it gives the polyhedron a single global face, so less vertices and shared normals. In this case, faceColors and faceUV are ignored
    • You can also set the mesh side orientation with the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
    • If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters frontUVs and backUVs (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
    • The mesh can be set to updatable with the boolean parameter updatable (default false) if its internal geometry is supposed to change once created
    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • options: { custom?: any; faceColors?: Color4[]; faceUV?: Vector4[]; sideOrientation?: number; size?: number; sizeX?: number; sizeY?: number; sizeZ?: number; type?: number; updatable?: boolean }

      defines the options used to create the mesh

      • Optional custom?: any
      • Optional faceColors?: Color4[]
      • Optional faceUV?: Vector4[]
      • Optional sideOrientation?: number
      • Optional size?: number
      • Optional sizeX?: number
      • Optional sizeY?: number
      • Optional sizeZ?: number
      • Optional type?: number
      • Optional updatable?: boolean
    • scene: Scene

      defines the hosting scene

    Returns Mesh

    a new Mesh

Static CreateRibbonSearch playground for CreateRibbon

  • CreateRibbon(name: string, pathArray: Vector3[][], closeArray: boolean, closePath: boolean, offset: number, scene?: Scene, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh

  • Creates a ribbon mesh.

    see

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

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • pathArray: Vector3[][]

      is a required array of paths, what are each an array of successive Vector3. The pathArray parameter depicts the ribbon geometry.

    • closeArray: boolean

      creates a seam between the first and the last paths of the path array (default is false)

    • closePath: boolean

      creates a seam between the first and the last points of each path of the path array

    • offset: number

      is taken in account only if the pathArray is containing a single path

    • Optional scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    • Optional instance: Mesh

      defines an instance of an existing Ribbon object to be updated with the passed pathArray parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#ribbon)

    Returns Mesh

    a new Mesh

Static CreateSphereSearch playground for CreateSphere

  • CreateSphere(name: string, segments: number, diameter: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates a sphere mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • segments: number

      sets the sphere number of horizontal stripes (positive integer, default 32)

    • diameter: number

      sets the diameter size (float) of the sphere (default 1)

    • Optional scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    Returns Mesh

    a new Mesh

Static CreateTiledGroundSearch playground for CreateTiledGround

  • CreateTiledGround(name: string, xmin: number, zmin: number, xmax: number, zmax: number, subdivisions: { h: number; w: number }, precision: { h: number; w: number }, scene: Scene, updatable?: boolean): Mesh

  • Creates a tiled ground mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • xmin: number

      set the ground minimum X coordinate

    • zmin: number

      set the ground minimum Y coordinate

    • xmax: number

      set the ground maximum X coordinate

    • zmax: number

      set the ground maximum Z coordinate

    • subdivisions: { h: number; w: number }

      is an object {w: positive integer, h: positive integer} (default {w: 6, h: 6}). w and h are the numbers of subdivisions on the ground width and height. Each subdivision is called a tile

      • h: number
      • w: number
    • precision: { h: number; w: number }

      is an object {w: positive integer, h: positive integer} (default {w: 2, h: 2}). w and h are the numbers of subdivisions on the ground width and height of each tile

      • h: number
      • w: number
    • scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    Returns Mesh

    a new Mesh

Static CreateTorusSearch playground for CreateTorus

  • CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates a torus mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • diameter: number

      sets the diameter size (float) of the torus (default 1)

    • thickness: number

      sets the diameter size of the tube of the torus (float, default 0.5)

    • tessellation: number

      sets the number of torus sides (positive integer, default 16)

    • Optional scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    Returns Mesh

    a new Mesh

Static CreateTorusKnotSearch playground for CreateTorusKnot

  • CreateTorusKnot(name: string, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh

  • Creates a torus knot mesh.

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • radius: number

      sets the global radius size (float) of the torus knot (default 2)

    • tube: number

      sets the diameter size of the tube of the torus (float, default 0.5)

    • radialSegments: number

      sets the number of sides on each tube segments (positive integer, default 32)

    • tubularSegments: number

      sets the number of tubes to decompose the knot into (positive integer, default 32)

    • p: number

      the number of windings on X axis (positive integers, default 2)

    • q: number

      the number of windings on Y axis (positive integers, default 3)

    • Optional scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    Returns Mesh

    a new Mesh

Static CreateTubeSearch playground for CreateTube

  • CreateTube(name: string, path: Vector3[], radius: number, tessellation: number, radiusFunction: (i: number, distance: number) => number, cap: number, scene: Scene, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh

  • Creates a tube mesh. The tube is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.

    see

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

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • path: Vector3[]

      is a required array of successive Vector3. It is the curve used as the axis of the tube

    • radius: number

      sets the tube radius size

    • tessellation: number

      is the number of sides on the tubular surface

    • radiusFunction: (i: number, distance: number) => number

      is a custom function. If it is not null, it overrides the parameter radius. This function is called on each point of the tube path and is passed the index i of the i-th point and the distance of this point from the first point of the path

        • (i: number, distance: number): number

        • Parameters

          • i: number
          • distance: number

          Returns number

    • cap: number

      sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL

    • scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    • Optional instance: Mesh

      is an instance of an existing Tube object to be updated with the passed pathArray parameter (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#tube)

    Returns Mesh

    a new Mesh

Static ExtendToGoldbergSearch playground for ExtendToGoldberg

  • Extends a mesh to a Goldberg mesh Warning the mesh to convert MUST be an import of a perviously exported Goldberg mesh

    deprecated

    Please use ExtendMeshToGoldberg instead

    Parameters

    • mesh: Mesh

      the mesh to convert

    Returns Mesh

    the extended mesh

Static ExtrudePolygonSearch playground for ExtrudePolygon

  • ExtrudePolygon(name: string, shape: Vector3[], depth: number, scene: Scene, holes?: Vector3[][], updatable?: boolean, sideOrientation?: number, earcutInjection?: any): Mesh

  • Creates an extruded polygon mesh, with depth in the Y direction..

    see

    https://doc.babylonjs.com/how_to/parametric_shapes#extruded-non-regular-polygon

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • shape: Vector3[]

      is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors

    • depth: number

      defines the height of extrusion

    • scene: Scene

      defines the hosting scene

    • Optional holes: Vector3[][]

      is a required array of arrays of successive Vector3 used to defines holes in the polygon

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    • Optional earcutInjection: any

      can be used to inject your own earcut reference

    Returns Mesh

    a new Mesh

Static ExtrudeShapeSearch playground for ExtrudeShape

  • ExtrudeShape(name: string, shape: Vector3[], path: Vector3[], scale: number, rotation: number, cap: number, scene: Nullable<Scene>, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh

  • Creates an extruded shape mesh. The extrusion is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.

    see

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

    see

    https://doc.babylonjs.com/how_to/parametric_shapes#extruded-shapes

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • shape: Vector3[]

      is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis

    • path: Vector3[]

      is a required array of successive Vector3. This is the axis curve the shape is extruded along

    • scale: number

      is the value to scale the shape

    • rotation: number

      is the angle value to rotate the shape each step (each path point), from the former step (so rotation added each step) along the curve

    • cap: number

      sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL

    • scene: Nullable<Scene>

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    • Optional instance: Mesh

      is an instance of an existing ExtrudedShape object to be updated with the passed shape, path, scale or rotation parameters (https://doc.babylonjs.com/how_to/How_to_dynamically_morph_a_mesh#extruded-shape)

    Returns Mesh

    a new Mesh

Static ExtrudeShapeCustomSearch playground for ExtrudeShapeCustom

  • ExtrudeShapeCustom(name: string, shape: Vector3[], path: Vector3[], scaleFunction: Nullable<(i: number, distance: number) => number>, rotationFunction: Nullable<(i: number, distance: number) => number>, ribbonCloseArray: boolean, ribbonClosePath: boolean, cap: number, scene: Scene, updatable?: boolean, sideOrientation?: number, instance?: Mesh): Mesh

  • Creates an custom extruded shape mesh. The custom extrusion is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.

    see

    https://doc.babylonjs.com/how_to/parametric_shapes#extruded-shapes

    deprecated

    Please use MeshBuilder instead

    Parameters

    • name: string

      defines the name of the mesh to create

    • shape: Vector3[]

      is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis

    • path: Vector3[]

      is a required array of successive Vector3. This is the axis curve the shape is extruded along

    • scaleFunction: Nullable<(i: number, distance: number) => number>

      is a custom Javascript function called on each path point

    • rotationFunction: Nullable<(i: number, distance: number) => number>

      is a custom Javascript function called on each path point

    • ribbonCloseArray: boolean

      forces the extrusion underlying ribbon to close all the paths in its pathArray

    • ribbonClosePath: boolean

      forces the extrusion underlying ribbon to close its pathArray

    • cap: number

      sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL

    • scene: Scene

      defines the hosting scene

    • Optional updatable: boolean

      defines if the mesh must be flagged as updatable

    • Optional sideOrientation: number

      defines the mesh side orientation (https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation)

    • Optional instance: Mesh

      is an instance of an existing ExtrudedShape object to be updated with the passed shape, path, scale or rotation parameters (https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh#extruded-shape)

    Returns Mesh

    a new Mesh

Static MergeMeshesSearch playground for MergeMeshes

  • MergeMeshes(meshes: Array<Mesh>, disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Nullable<Mesh>

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

    Parameters

    • meshes: Array<Mesh>

      defines he vertices source. They should all be of the same material. Entries can empty

    • 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

      when set, vertices inserted into this Mesh. Meshes can then be merged into a Mesh sub-class.

    • Optional subdivideWithSubMeshes: boolean

      when true (false default), subdivide mesh to his subMesh array with meshes source.

    • Optional multiMultiMaterials: boolean

      when true (false default), subdivide mesh and accept multiple multi materials, ignores subdivideWithSubMeshes.

    Returns Nullable<Mesh>

    a new mesh

Static MergeMeshesAsyncSearch playground for MergeMeshesAsync

  • MergeMeshesAsync(meshes: Array<Mesh>, disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Promise<any>

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

    Parameters

    • meshes: Array<Mesh>

      defines he vertices source. They should all be of the same material. Entries can empty

    • 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

      when set, vertices inserted into this Mesh. Meshes can then be merged into a Mesh sub-class.

    • Optional subdivideWithSubMeshes: boolean

      when true (false default), subdivide mesh to his subMesh array with meshes source.

    • Optional multiMultiMaterials: boolean

      when true (false default), subdivide mesh and accept multiple multi materials, ignores subdivideWithSubMeshes.

    Returns Promise<any>

    a new mesh

Static MinMaxSearch playground for MinMax

  • 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

    Parameters

    Returns { max: Vector3; min: Vector3 }

    an object {min: Vector3, max: Vector3}

Static ParseSearch playground for Parse

  • Parses a serialized ground mesh

    Parameters

    • parsedMesh: any

      the serialized mesh

    • scene: Scene

      the scene to create the ground mesh in

    Returns LinesMesh

    the created ground mesh

Legend

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