Internal__occlusionProtected_accessibilityInternal_binaryInternal_bonesProtected_boundingProtected_boundingInternal_cacheProtected Internal_childrenInternal_childInternal_creationInternal_currentInternal_decalInternal_delayInternal_delayInternal_disposeInternal_edgesInternal_geometryInternal_indexInternal_instanceInternal_internalInternal_internalInternal_intersectionsProtected_isReadonly Internal_isProtected_isInternal_lightInternal_localInternal_masterInternal_occlusionAccess property
Internal_occlusionInternal_originalInternal_parentProtected_parentInternal_physicsInternal_physicsInternal_poseInternal_postProtected_rangesInternal_renderInternal_renderingInternal_render(Backing field)
Internal_render(Backing field)
Protected_scalingInternal_sceneInternal_shouldInternal_show(Backing field)
Internal_submeshesBacking Field
Internal_thinInternal_transformInternal_uniformThe current mesh uniform buffer. Internal use only.
Internal_unInternal_userInternal_userInternal_waitingInternal_waitingInternal_waitingInternal_waitingInternal_waitingInternal_waitingInternal_worldInternal_worldInternal_worldGets or sets the current action manager
Gets or sets the alpha index used to sort transparent meshes
True if the mesh must be rendered in any case (this will shortcut the frustum clipping phase)
Gets a list of Animations associated with the node
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 :
Allow user to specify custom mechanism for mark as dirty
Gets or sets the decal map for this mesh
Gets or sets the orientation for POV movement & rotation
Gets the file containing delay loading data for this mesh
Gets the delay loading state of the mesh (when delay loading is turned on)
Gets or sets a boolean indicating that the bounding info does not need to be kept in sync (for performance reason)
Defines edge color used when edgesRenderer is enabled
Gets the edgesRenderer associated with the mesh
true to use the edge renderer for all instances of this mesh
Defines edge width used when edgesRenderer is enabled
Gets or sets the ellipsoid used to impersonate this mesh when using collision engine (default is (0.5, 1, 0.5))
Gets or sets the ellipsoid offset used to impersonate this mesh when using collision engine (default is (0, 0, 0))
Gets or sets a boolean indicating that pointer move events must be supported on this mesh (false by default)
Flag to force rendering the mesh even if occluded
Gets or sets the id of the node
Gets or sets a boolean indicating whether to render ignoring the active camera's max z setting. (false by default) You should not mix meshes that have this property set to true with meshes that have it set to false if they all write to the depth buffer, because the z-values are not comparable in the two cases and you will get rendering artifacts if you do. You can set the property to true for meshes that do not write to the depth buffer, or set the same value (either false or true) otherwise. Note this will reduce performance when set to true.
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
List of inspectable custom properties (used by the Inspector)
Object used to store instanced buffers defined by user
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.
Gets or sets a boolean indicating if the mesh must be considered as a ray blocker for lens flares (false by default)
Gets or sets a boolean indicating if the mesh can be grabbed. Default is false. Setting this to true, while using the XR near interaction feature, will trigger a pointer event when the mesh is grabbed. Grabbing means that the controller is using the squeeze or main trigger button to grab the mesh. This is different from nearPickable which only triggers the event when the mesh is touched by the controller
Gets or sets a boolean indicating if the mesh can be near picked (touched by the XR controller or hands). Default is false
Gets or sets whether the mesh is occluded or not, it is used also to set the initial state of the mesh to be occluded or not
Flag to check the progress status of the query
Gets or sets a boolean indicating if the mesh can be picked (by scene.pick for instance or through actions). Default is true
Gets or sets an object used to store user defined information for the node
Gets or sets the name of the node
This property determines the type of occlusion query algorithm to run in WebGl, you can use:
This number indicates the number of allowed retries before stop the occlusion query, this is useful if the occlusion query is taking long time before to the query result is retrieved, the query result indicates if the object is visible within the scene or not and based on that Babylon.Js engine decides to show or hide the object. The default value is -1 which means don't break the query and wait till the result
This property is responsible for starting the occlusion query within the Mesh or not, this property is also used to determine what should happen when the occlusionRetryCount is reached. It has supports 3 values:
Observable fired when an accessibility tag is changed
An event triggered after the world matrix is updated
An event triggered when this mesh collides with another one
An event triggered when the collision's position changes
An event triggered when the mesh is disposed
User defined function used to change how LOD level selection is done
An event triggered when material is changed
Will notify when the mesh is completely ready, including materials. Observers added to this observable will be removed once triggered
Callback raised when the node is ready to be used
An event triggered when the mesh is rebuilt.
Defines color to use when rendering outline
Define width to use when rendering outline
Defines alpha to use when rendering overlay
Defines color to use when rendering overlay
Gets or sets impostor used for physic simulation
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
Gets or sets a boolean indicating if the outline must be rendered as well
Gets or sets a boolean indicating if the overlay must be rendered as well
For internal use only. Please do not use.
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
Gets or sets a boolean indicating if the bounding box must be rendered as well (false by default)
Gets or sets a boolean indicating that bounding boxes of subMeshes must be rendered as well (false by default)
Gets or sets a string used to store user defined state for the node
Gets or sets the list of subMeshes
Indicates that a buffer created as static should be recreated if the buffer is updated (by calling thinInstanceSetMatrixAt or thinInstanceSetAttributeAt, for eg.) If this flag is false (the default behavior), a buffer created as "static" won't show any update done to it, and will stay the same as it was created. Note however that recreating a buffer each time there's a change will have some performance cost, that's why it is set to false by default. You should set this flag to true only if your static buffers should change infrequently. If they change frequently, you should create your buffers as "dynamic" instead.
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.
Gets or sets a boolean defining if we want picking to pick thin instances as well
Gets or sets the unique id of the node
Gets or sets a boolean indicating that internal octree (if available) can be used to boost submeshes collision (true by default)
Gets or sets a boolean indicating that internal octree (if available) can be used to boost submeshes picking (true by default)
Gets or sets a boolean indicating that internal octree (if available) can be used to boost submeshes selection (true by default)
Static Internal_Static Internal_Static Internal_Static Internal_Static Internal_Static Internal_Static Internal_Static ReadonlyBACKSIDEMesh side orientation : usually the internal or back surface
StaticBillboardChild transform with Billboard flags should or should not apply parent rotation (default if off)
Static ReadonlyBOTTOMMesh tile positioning : part tiles on bottom
Static ReadonlyCAP_Mesh cap setting : two caps, one at the beginning and one at the end of the mesh
Static ReadonlyCAP_Mesh cap setting : one cap at the end of the mesh
Static ReadonlyCAP_Mesh cap setting : one cap at the beginning of the mesh
Static ReadonlyCENTERMesh tile positioning : part tiles same on left/right or top/bottom
Static ReadonlyCULLINGSTRATEGY_Culling strategy : Bounding Sphere Only. This is an exclusion test. It's faster than the standard strategy because the bounding box is not tested. It's also less accurate than the standard because some not visible objects can still be selected. Test : is the bounding sphere outside the frustum ? If not, then the cullable object is in the frustum.
Static ReadonlyCULLINGSTRATEGY_Culling strategy : Optimistic Inclusion. This in an inclusion test first, then the standard exclusion test. This can be faster when a cullable object is expected to be almost always in the camera frustum. This could also be a little slower than the standard test when the tested object center is not the frustum but one of its bounding box vertex is still inside. Anyway, it's as accurate as the standard strategy. Test : Is the cullable object bounding sphere center in the frustum ? If not, apply the default culling strategy.
Static ReadonlyCULLINGSTRATEGY_Culling strategy : Optimistic Inclusion then Bounding Sphere Only. This in an inclusion test first, then the bounding sphere only exclusion test. This can be the fastest test when a cullable object is expected to be almost always in the camera frustum. This could also be a little slower than the BoundingSphereOnly strategy when the tested object center is not in the frustum but its bounding sphere still intersects it. It's less accurate than the standard strategy and as accurate as the BoundingSphereOnly strategy. Test : Is the cullable object bounding sphere center in the frustum ? If not, apply the Bounding Sphere Only strategy. No Bounding Box is tested here.
Static ReadonlyCULLINGSTRATEGY_Default culling strategy : this is an exclusion test and it's the more accurate. Test order : Is the bounding sphere outside the frustum ? If not, are the bounding box vertices outside the frustum ? It not, then the cullable object is in the frustum.
Static ReadonlyDEFAULTSIDEMesh side orientation : by default, FRONTSIDE
Static ReadonlyDOUBLESIDEMesh side orientation : both internal and external or front and back surfaces
Static ReadonlyFLIP_Mesh pattern setting : rotate pattern and rotate
Static ReadonlyFLIP_Mesh pattern setting : flip and rotate alternate tiles on each row or column
Static ReadonlyFLIP_Mesh pattern setting : flip (reflect in y axis) all tiles on alternate rows
Static ReadonlyFLIP_Mesh pattern setting : flip (reflect in y axis) alternate tiles on each row or column
Static ReadonlyFRONTSIDEMesh side orientation : usually the external or front surface
StaticINSTANCEDMESH_Indicates that the instanced meshes should be sorted from back to front before rendering if their material is transparent
Static ReadonlyLEFTMesh tile positioning : part tiles on left
Static ReadonlyNO_Mesh cap setting : no cap
Static ReadonlyNO_Mesh pattern setting : no flip or rotate
StaticOCCLUSION_Use an accurate occlusion algorithm
StaticOCCLUSION_Use a conservative occlusion algorithm
StaticOCCLUSION_No occlusion
StaticOCCLUSION_Occlusion set to optimistic
StaticOCCLUSION_Occlusion set to strict
Static ReadonlyRIGHTMesh tile positioning : part tiles on right
Static ReadonlyROTATE_Mesh pattern setting : rotate (180degs) all tiles on alternate rows
Static ReadonlyROTATE_Mesh pattern setting : rotate (180degs) alternate tiles on each row or column
Static ReadonlyTOPMesh tile positioning : part tiles on top
InternalInternalReturns the current mesh absolute position. Returns a Vector3.
Returns the current mesh absolute rotation. Returns a Quaternion.
Returns the current mesh absolute scaling. Returns a Vector3.
Gets or sets the accessibility tag to describe the node for accessibility purpose.
Gets or sets the animation properties override
Gets or sets a boolean indicating that this mesh will allow fog to be rendered on it (true by default)
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.
Gets or sets the baked vertex animation manager
Gets the list of attached behaviors
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 |
Gets or sets a boolean indicating that this mesh can be used in the collision engine
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
Gets Collider object used to compute collisions (not physics)
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
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
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.
number of collision detection tries. Change this value if not all collisions are detected and handled properly
Gets or sets a boolean indicating that bone animations must be computed by the GPU (true by default)
Gets or sets a boolean indicating that bone animations must be computed by the GPU (true by default)
Gets or sets a boolean used to define if the node must be serialized
When enabled, decompose picking matrices for better precision with large values for mesh position and scling
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
Gets the number of facets in the mesh
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)
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)
The forward direction of that transform in world space.
Gets the mesh internal Geometry object
Returns true if there is already a bounding info
Gets a boolean indicating if this mesh has instances
Gets a boolean indicating if this mesh has LOD
Gets a boolean indicating if this mesh has thin instances
Gets or sets a boolean indicating that this mesh needs to use vertex alpha data to render.
This property is misnamed and should be useVertexAlpha. Note that the mesh will be rendered
with alpha blending when this flag is set even if vertex alpha data is missing from the geometry.
Gets or sets the distance of the object to max, often used by skybox
If set to true, a mesh will only be visible only if its parent(s) are also visible (default is false)
Gets a boolean indicating if this mesh is an instance or a regular mesh
Returns true if the mesh is blocked. Implemented by child classes
gets a boolean indicating if facetData is enabled
Gets or sets a boolean indicating that this mesh does not use index buffer
Gets or sets a boolean indicating if the mesh is visible (renderable). Default is true
True if the World matrix has been frozen.
Gets or sets the current layer mask (default is 0x0FFFFFFF)
Gets the list of lights affecting that mesh
Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual
Gets or sets a boolean indicating that the update of the instance buffer of the world matrices is manual
Gets or sets current material
Gets or sets current material
Gets or sets the morph target manager
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
True if the scaling property of this object is non uniform eg. (1,2,1)
Gets or sets the number of allowed bone influences per vertex (4 by default)
An event triggered after rendering the mesh
An event triggered before binding the mesh
Sets a callback to call before drawing the mesh. It is recommended to use onBeforeDrawObservable instead
An event triggered before drawing the mesh
An event triggered before rendering the mesh
An event triggeredbetween rendering pass when using separateCullingPass = true
An event triggered when the node is cloned
Set a function to call when this mesh collides with another one
Set a function to call when the collision's position changes
Sets a callback that will be raised when the node will be disposed
An event triggered when the enabled state of the node changes
Sets a value overriding the instance count. Only applicable when custom instanced InterleavedVertexBuffer are used rather than InstancedMeshs
Use this property to override the Material's fillMode value
Gets or sets the parent of the node (without keeping the current position in the scene)
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
Gets or set the number (integer) of subdivisions per axis in the partitioning space
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.
Gets or set the node position (default is (0.0, 0.0, 0.0))
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
Gets the array buffer used to store the instanced buffer used for instances' previous world matrices
InternalGets or sets a boolean indicating that this mesh can receive realtime shadows
Specifies the rendering group id for this mesh (0 by default)
The right direction of that transform in world space.
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
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)
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)).
Use this property to change the original side orientation defined at construction time Material.sideOrientation will override this value if set User will still be able to change the material sideOrientation afterwards if they really need it
Gets or sets a skeleton to apply skinning transformations
Gets the source mesh (the one used to clone this one from)
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.
The up direction of that transform in world space.
Gets a boolean indicating if this mesh has skinning data and an attached skeleton
Determines if the LOD levels are intended to be calculated using screen coverage (surface area ratio) instead of distance.
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)
Gets or sets mesh visibility between 0 and 1 (default is 1)
Gets or sets mesh visibility between 0 and 1 (default is 1)
Returns directly the latest state of the mesh World matrix. A Matrix is returned.
Gets the array buffer used to store the instanced buffer used for instances' world matrices
StaticBILLBOARDMODE_Billboard on all axes
StaticBILLBOARDMODE_No billboard
StaticBILLBOARDMODE_Billboard on using position instead of orientation
StaticBILLBOARDMODE_Billboard on X axis
StaticBILLBOARDMODE_Billboard on Y axis
StaticBILLBOARDMODE_Billboard on Z axis
InternalInternalProtected_afterInternalProtected_buildInternalInternalInternalProtected_copyInternalInternalInternalInternalOptionalinstancesCount: numberInternalInternalProtected_getInternalInternalInternalInternalInvalidate VertexArrayObjects belonging to the mesh (but not to the Geometry of the mesh).
InternalInternalInternalOptionaldispose: booleanInternalInternalInternalInternalInternalInternalOptionaleffectiveMaterial: MaterialInternalOptionaldispose: booleanInternalInternalInternalInternalInternalInternalInternalInternalInternalProtected_setInternalInternalInternalInternalProtected_syncInternalInternalInternalOptionalstaticBuffer: booleanInternalOptionalnumInstances: numberInternalInternalInternalInternalOptional_ignoreParentClass: booleanInternalThis method will also draw the instances if fillMode and effect are passed
OptionalfillMode: numberOptionaleffect: EffectInternalInternalAttach a behavior to the node
defines the behavior to attach
OptionalattachImmediately: booleandefines that the behavior must be attached even if the scene is still loading
the current Node
Adds the passed mesh as a child to the current mesh. The node will remain exactly where it is and its position / rotation will be updated accordingly. This method is equivalent to calling setParent().
defines the child mesh
OptionalpreserveScalingSign: booleanif true, keep scaling sign of child. Otherwise, scaling sign might change.
the current mesh
InternalAdd a mesh as LOD level triggered at the given distance.
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
The mesh to be added as LOD level (can be null)
This mesh (for chaining)
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.
Rotation to add
Rotation to add
Rotation to add
the TransformNode.
Align the mesh with a normal
defines the normal to use
OptionalupDirection: Vector3can be used to redefined the up vector to use (will use the (0, 1, 0) by default)
the current mesh
Apply a physic angular impulse to the mesh
defines the torque to apply
the current 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.
is a string, the URL from the image file is to be downloaded.
is the lower limit of the displacement.
is the upper limit of the displacement.
OptionalonSuccess: (mesh: Mesh) => voidis an optional Javascript function to be called just after the mesh is modified. It is passed the modified mesh and must return nothing.
OptionaluvOffset: Vector2is an optional vector2 used to offset UV.
OptionaluvScale: Vector2is an optional vector2 used to scale UV.
OptionalforceUpdate: booleandefines whether or not to force an update of the generated buffers. This is useful to apply on a deserialized model for instance.
OptionalonError: (message?: string, exception?: any) => voiddefines a callback called when an error occurs during the processing of the request.
the 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.
is a Uint8Array buffer containing series of Uint8 lower than 255, the red, green, blue and alpha values of each successive pixel.
is the width of the buffer image.
is the height of the buffer image.
is the lower limit of the displacement.
is the upper limit of the displacement.
OptionaluvOffset: Vector2is an optional vector2 used to offset UV.
OptionaluvScale: Vector2is an optional vector2 used to scale UV.
OptionalforceUpdate: booleandefines whether or not to force an update of the generated buffers. This is useful to apply on a deserialized model for instance.
the Mesh.
Apply a physic impulse to the mesh
defines the force to apply
defines where to apply the force
the current mesh
Updates the vertex buffer by applying transformation from the bones
defines the skeleton to apply to current mesh
the current mesh
Attach the current TransformNode to another TransformNode associated with a bone
Bone affecting the TransformNode
TransformNode associated with the bone
this object
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.
OptionalbakeIndependentlyOfChildren: booleanindicates whether to preserve all child nodes' World Matrix during baking
OptionalforceUnique: booleanindicates whether to force the mesh geometry to be unique
the current 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.
defines the transform matrix to use
the current mesh
Will start the animation sequence
defines the range frames for animation sequence
Optionalloop: booleandefines if the animation should loop (false by default)
OptionalspeedRatio: numberdefines the speed factor in which to run the animation (1 by default)
OptionalonAnimationEnd: () => voiddefines a function to be executed when the animation ended (undefined by default)
the object created for this animation. If range does not exist, it will return null
Creates a new bounding info for the mesh
min vector of the bounding box/sphere
max vector of the bounding box/sphere
OptionalworldMatrix: DeepImmutableObject<Matrix>defines the new world matrix
the new bounding info
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.
defines the distance on the right axis
defines the distance on the up axis
defines the distance on the forward axis
the new displacement vector
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.
defines the flip
defines the twirl
defines the tilt
the new rotation vector
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 a new Mesh object generated from the current mesh properties. This method must not get confused with createInstance()
Optionalname: stringis a string, the name given to the new mesh
OptionalnewParent: MeshCloneOptions | Nullable<Node>can be any Node object (default null) or an instance of MeshCloneOptions. If the latter, doNotCloneChildren and clonePhysicsImpostor are unused.
OptionaldoNotCloneChildren: booleanallows/denies the recursive cloning of the original mesh children if any (default false)
OptionalclonePhysicsImpostor: booleanallows/denies the cloning in the same time of the original mesh body used by the physics engine, if any (default true)
a new mesh
Computes the world matrix of the node
Optionalforce: booleandefines if the cache version should be invalidated forcing the world matrix to be created from scratch
Optionalcamera: Nullable<Camera>defines the camera used if different from the scene active camera (This is used with modes like Billboard or infinite distance)
the world 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.
current 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.
current mesh
Copies the requested vertex data kind into the given vertex data map. Float data is constructed if the map doesn't have the data.
defines the vertex data kind to use
defines the map that stores the resulting data
Creates an animation range for this node
defines the name of the range
defines the starting key
defines the end key
Creates a new InstancedMesh object from the mesh model.
defines the name of the new instance
a new InstancedMesh
Creates new normals data for the mesh
defines if the normal vertex buffer must be flagged as updatable
the current mesh
This function will create an octree to help to select the right submeshes for rendering, picking and collision computations. Please note that you must have a decent number of submeshes to get performance improvements when using an octree
OptionalmaxCapacity: numberdefines the maximum size of each block (64 by default)
OptionalmaxDepth: numberdefines the maximum depth to use (no more than 2 levels by default)
the new octree
Delete a specific animation range
defines the name of the range to delete
OptionaldeleteFrames: booleandefines if animation frames from the range must be deleted as well
Detach the transform node if its associated with a bone
OptionalresetToPreviousParent: booleanIndicates 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)
this object
Disables the mesh edge rendering mode
the currentAbstractMesh
Disables the feature FacetData and frees the related memory
the current mesh
Releases resources associated with this mesh.
OptionaldoNotRecurse: booleanSet to true to not recurse into each children (recurse into each children by default)
OptionaldisposeMaterialAndTextures: booleanSet to true to also dispose referenced materials and textures (false by default)
Enables the edge rendering mode on the mesh. This mode makes the mesh edges visible
Optionalepsilon: numberdefines the maximal distance between two angles to detect a face
OptionalcheckVerticesInsteadOfIndices: booleanindicates that we should check vertex list directly instead of faces
Optionaloptions: IEdgesRendererOptionsoptions to the edge renderer
the currentAbstractMesh
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.
OptionalflipNormals: booleanwill also inverts the normals
current 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.
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.
the current mesh
Prevents the World matrix to be computed any longer
OptionalnewWorldMatrix: Nullable<Matrix>defines an optional matrix to use as world matrix
Optionaldecompose: booleandefines whether to decompose the given newWorldMatrix or directly assign
the TransformNode.
Returns a new Vector3 set with the mesh pivot point World coordinates.
a new Vector3 set with the mesh pivot point World coordinates.
Sets the Vector3 "result" coordinates with the mesh pivot point World coordinates.
vector3 to store the result
this TransformNode.
Returns the mesh absolute position in the World.
a Vector3.
Returns as a new array populated with the mesh material and/or skeleton, if any.
an array of IAnimatable
Get an animation by name
defines the name of the animation to look for
null if not found else the requested animation
Get an animation range by name
defines the name of the animation range to look for
null if not found else the requested animation range
Gets the list of all animation ranges defined on this node
an array
Gets an attached behavior by name
defines the name of the behavior to look for
null if behavior was not found else the requested behavior
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).
However, if the mesh contains thin instances, it will be expanded to include them. If you want the "raw" bounding data instead, then use getRawBoundingInfo().
To get the full bounding of all children, call getHierarchyBoundingVectors instead.
a BoundingInfo
Get all child-meshes of this node
OptionaldirectDescendantsOnly: booleandefines 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)
Optionalpredicate: (node: Node) => node is Tdefines 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
an array of AbstractMesh
Get all child-meshes of this node
OptionaldirectDescendantsOnly: booleandefines 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)
Optionalpredicate: (node: Node) => booleandefines 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
an array of AbstractMesh
Get all direct children of this node
Optionalpredicate: (node: Node) => node is Tdefines 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
OptionaldirectDescendantsOnly: booleandefines 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)
an array of Node
Get all direct children of this node
Optionalpredicate: (node: Node) => booleandefines 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
OptionaldirectDescendantsOnly: booleandefines 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)
an array of Node
Get all child-transformNodes of this node
OptionaldirectDescendantsOnly: booleandefines 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
Optionalpredicate: (node: Node) => booleandefines 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
an array of TransformNode
Gets the class name
the string "Mesh".
Returns the closest mesh facet index at (x,y,z) World coordinates, null if not found
defines x coordinate
defines y coordinate
defines z coordinate
Optionalprojected: Vector3sets as the (x,y,z) world projection on the facet
OptionalcheckFace: booleanif 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
Optionalfacing: booleanif 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
the face index if found (or null instead)
Returns the closest mesh facet index at (x,y,z) local coordinates, null if not found
defines x coordinate
defines y coordinate
defines z coordinate
Optionalprojected: Vector3sets as the (x,y,z) local projection on the facet
OptionalcheckFace: booleanif 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
Optionalfacing: booleanif 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
the face index if found (or null instead)
This function returns all of the particle systems in the scene that use the mesh as an emitter.
an array of particle systems in the scene that use the mesh as an emitter
Will return all nodes that have this node as ascendant
OptionaldirectDescendantsOnly: booleandefines 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
Optionalpredicate: (node: Node) => node is Tdefines 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
all children nodes of all types
Will return all nodes that have this node as ascendant
OptionaldirectDescendantsOnly: booleandefines 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
Optionalpredicate: (node: Node) => booleandefines 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
all children nodes of all types
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.
axis to rotate
a new Vector3 that is the localAxis, expressed in the mesh local space, rotated like the mesh.
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.
axis to rotate
the resulting transformnode
this TransformNode.
Returns the distance from the mesh to the active camera
Optionalcamera: Nullable<Camera>defines the camera to use
the distance
Returns an array populated with IParticleSystem objects whose the mesh is the emitter
an array of IParticleSystem
Gets the engine of the node
a Engine
Returns the object "parameter" set with all the expected parameters for facetData computation by ComputeNormals()
the parameters
Returns the facetLocalNormals array. The normals are expressed in the mesh local spac
an array of Vector3
Returns the facetLocalPartitioning array
an array of array of numbers
Returns the facetLocalPositions array. The facet positions are expressed in the mesh local space
an array of Vector3
Returns the i-th facet normal in the world system. This method allocates a new Vector3 per call
defines the facet index
a new Vector3
Sets the reference Vector3 with the i-th facet normal in the world system
defines the facet index
defines the target vector
the current mesh
Returns the i-th facet position in the world system. This method allocates a new Vector3 per call
defines the facet index
a new Vector3
Sets the reference Vector3 with the i-th facet position in the world system
defines the facet index
defines the target vector
the current mesh
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)
defines x coordinate
defines y coordinate
defines z coordinate
the array of facet indexes
Return the minimum and maximum world vectors of the entire hierarchy under current node
OptionalincludeDescendants: booleanInclude bounding info from descendants as well (true by default)
Optionalpredicate: 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
the new bounding vectors
Returns an array populated with IParticleSystem objects whose the mesh or its children are the emitter
an array of IParticleSystem
Returns an array of integers or a typed array (Int32Array, Uint32Array, Uint16Array) populated with the mesh indices.
OptionalcopyWhenShared: booleanIf 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.
OptionalforceCopy: booleandefines a boolean indicating that the returned array must be cloned upon returning it
the indices array or an empty array if the mesh has no geometry
Returns the registered LOD mesh distant from the parameter camera position if any, else returns the current mesh.
defines the camera to use to compute distance
OptionalboundingSphere: BoundingSpheredefines a custom bounding sphere to use instead of the one from this mesh
This mesh (for chaining)
Returns the LOD level mesh at the passed distance or null if not found.
The distance from the center of the object to show this level
a Mesh or null
Gets the list of MeshLODLevel associated with the current mesh
an array of MeshLODLevel
Gets the material used to render the mesh in a specific render pass
render pass id
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)
Gets the mesh uniform buffer.
the uniform buffer of the mesh.
Get the normals vertex data and optionally apply skeleton and morphing.
OptionalapplySkeleton: booleandefines whether to apply the skeleton
OptionalapplyMorph: booleandefines whether to apply the morph target
the normals data
Gets the current physics impostor
a physics impostor or null
Returns the mesh pivot matrix. Default : Identity.
the matrix
Returns a new Vector3 set with the mesh pivot point coordinates in the local space.
the pivot point
Sets the passed Vector3 "result" with the coordinates of the mesh pivot point in the local space.
the vector3 to store the result
this TransformNode.
Returns the mesh Pose matrix.
the pose matrix
Get the position vertex data and optionally apply skeleton and morphing.
OptionalapplySkeleton: booleandefines whether to apply the skeleton
OptionalapplyMorph: booleandefines whether to apply the morph target
Optionaldata: Nullable<FloatArray>defines the position data to apply the skeleton and morph to
the position data
Returns the mesh position in the local space from the current World matrix values.
a new Vector3.
Gets the position of the current mesh in camera space
Optionalcamera: Nullable<Camera>defines the camera to use
a position
Returns the bounding info unnafected by instance data.
the bounding info of the mesh unaffected by instance data.
Gets the scene of the node
a scene
Returns a positive integer : the total number of indices in this mesh geometry.
the number of indices or zero if the mesh has no geometry.
Returns the total number of vertices within the mesh geometry or zero if the mesh has no geometry.
the total number of vertices
Returns the mesh VertexBuffer object from the requested kind
defines which buffer to read from (positions, indices, normals, etc). Possible kind values :
OptionalbypassInstanceData: booleandefines a boolean indicating that the function should not take into account the instance data (applies only if the mesh has instances). Default: false
a FloatArray or null if the mesh has no vertex buffer for this kind.
Returns the content of an associated vertex buffer
defines which buffer to read from (positions, indices, normals, etc). Possible kind values :
OptionalcopyWhenShared: booleandefines a boolean indicating that if the mesh geometry is shared among some other meshes, the returned array is a copy of the internal one
OptionalforceCopy: booleandefines a boolean forcing the copy of the buffer no matter what the value of copyWhenShared is
OptionalbypassInstanceData: booleandefines a boolean indicating that the function should not take into account the instance data (applies only if the mesh has instances). Default: false
a FloatArray or null if the mesh has no geometry or no vertex buffer for this kind.
Returns a string which contains the list of existing kinds of Vertex Data associated with this mesh.
OptionalbypassInstanceData: booleandefines a boolean indicating that the function should not take into account the instance data (applies only if the mesh has instances). Default: false
an array of strings
Gets the current world matrix
a 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.
OptionalnumberPerEdge: numberthe number of new vertices to add to each edge of a facet, optional default 1
Instantiate (when possible) or clone that node with its hierarchy
OptionalnewParent: Nullable<TransformNode>defines the new parent to use for the instance (or clone)
Optionaloptions: { doNotInstantiate: boolean | ((node: TransformNode) => boolean) }defines options to configure how copy is done
defines if the model must be instantiated or just cloned
OptionalonNewNodeCreated: (source: TransformNode, clone: TransformNode) => voiddefines an option callback to call when a clone or an instance is created
an instance (or a clone) of the current node with its hierarchy
Checks if the passed Ray intersects with the mesh. A mesh triangle can be picked both from its front and back sides, irrespective of orientation.
defines the ray to use. It should be in the mesh's LOCAL coordinate space.
OptionalfastCheck: booleandefines if fast mode (but less precise) must be used (false by default)
OptionaltrianglePredicate: TrianglePickingPredicatedefines an optional predicate used to select faces when a mesh intersection is detected
OptionalonlyBoundingInfo: booleandefines a boolean indicating if picking should only happen using bounding info (false by default)
OptionalworldToUse: Matrixdefines the world matrix to use to get the world coordinate of the intersection point
OptionalskipBoundingInfo: booleana boolean indicating if we should skip the bounding info check
the picking info
True if the mesh intersects another mesh or a SolidParticle object
defines a target mesh or SolidParticle to test
Optionalprecise: booleanUnless the parameter precise is set to true the intersection is computed according to Axis Aligned Bounding Boxes (AABB), else according to OBB (Oriented BBoxes)
OptionalincludeDescendants: booleanCan be set to true to test if the mesh defined in parameters intersects with the current mesh or any child meshes
true if there is an intersection
Returns true if the passed point (Vector3) is inside the mesh bounding box
defines the point to test
true if there is an intersection
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.
defines the frustum to test
true if the mesh is completely in the frustum planes
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
defines the parent node to inspect
a boolean indicating if this node is a descendant of the given node
Gets a boolean indicating if the node has been disposed
true if the node was disposed
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
OptionalcheckAncestors: booleanindicates 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
whether this node (and its parent) is enabled
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
defines the frustum to test
true if the mesh is in the frustum planes
Determine if the current mesh is ready to be rendered
OptionalcompleteCheck: booleandefines if a complete check (including materials and lights) has to be done (false by default)
OptionalforceInstanceSupport: booleanwill check if the mesh will be ready when used with instances (false by default)
true if all associated assets are ready (material, textures, shaders)
InternalInternalreturn true if a pivot has been set
true if a pivot matrix is used
true if 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 a boolean defining if the vertex data for the requested kind is updatable.
defines which buffer to check (positions, indices, normals, etc). Possible kind values :
OptionalbypassInstanceData: booleandefines a boolean indicating that the function should not take into account the instance data (applies only if the mesh has instances). Default: false
a boolean
Tests if a specific vertex buffer is associated with this mesh
defines which buffer to check (positions, indices, normals, etc). Possible kind values :
OptionalbypassInstanceData: booleandefines a boolean indicating that the function should not take into account the instance data (applies only if the mesh has instances). Default: false
a boolean
Returns whether the transform node world matrix computation needs the camera information to be computed. This is the case when the node is a billboard or has an infinite distance for instance.
true if the world matrix computation needs the camera information to be computed
Translates the mesh along the passed Vector3 in its local space.
the distance to translate in localspace
the TransformNode.
Orients a mesh towards a target point. Mesh must be drawn facing user.
the position (must be in same space as current mesh) to look at
OptionalyawCor: numberoptional yaw (y-axis) correction in radians
OptionalpitchCor: numberoptional pitch (x-axis) correction in radians
OptionalrollCor: numberoptional roll (z-axis) correction in radians
Optionalspace: Spacethe chosen space of the target
the TransformNode.
Creates a un-shared specific occurence of the geometry for the mesh.
the current mesh
Flag the AbstractMesh as dirty (Forcing it to update everything)
Optionalproperty: stringif set to "rotation" the objects rotationQuaternion will be set to null
this AbstractMesh
Flags an associated vertex buffer as updatable
defines which buffer to use (positions, indices, normals, etc). Possible kind values :
Optionalupdatable: booleandefines if the updated vertex buffer must be flagged as updatable
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.
defines the distance on the right axis
defines the distance on the up axis
defines the distance on the forward axis
the current mesh
Move the mesh using collision engine
defines the requested displacement vector
the current mesh
Uniformly scales the mesh to fit inside of a unit cube (1 X 1 X 1 units)
OptionalincludeDescendants: booleanUse the hierarchy's bounding box instead of the mesh's bounding box. Default is false
OptionalignoreRotation: booleanignore rotation when computing the scale (ie. object will be axis aligned). Default is false
Optionalpredicate: Nullable<(node: AbstractMesh) => boolean>predicate that is passed in to getHierarchyBoundingVectors when selecting which object should be included when scaling
the current 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.
OptionalsuccessCallback: (mesh?: Mesh) => voidan optional success callback to be called after the optimization finished.
the current mesh
Optimize the indices order so that we keep the faces with similar indices together
the current 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.
OptionalapplySkeletonOrOptions: boolean | IMeshDataOptionsdefines whether to apply the skeleton before computing the bounding info or a set of options
OptionalapplyMorph: booleandefines whether to apply the morph target before computing the bounding info
the current mesh
Registers for this mesh a javascript function called just after the rendering is complete
defines the function to call after rendering this mesh
the current mesh
If you'd like to be called back after the mesh position, rotation or scaling has been updated.
callback function to add
the TransformNode.
Registers for this mesh a javascript function called just before the rendering process
defines the function to call before rendering this mesh
the current mesh
Register a custom buffer that will be instanced
defines the buffer kind
defines the stride in floats
Disposes all the submeshes of the current mesh
Optionalimmediate: booleanshould dispose the effects immediately or not
the current mesh
Remove an attached behavior
defines the behavior to attach
the current Node
Removes the passed mesh from the current mesh children list
defines the child mesh
OptionalpreserveScalingSign: booleanif true, keep scaling sign of child. Otherwise, scaling sign might change.
the current mesh
InternalRemove a mesh from the LOD array
defines the mesh to be removed
This mesh (for chaining)
Delete a vertex buffer associated with this mesh
defines which buffer to delete (positions, indices, normals, etc). Possible kind values :
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
defines the subMesh to render
defines if alpha mode can be changed
OptionaleffectiveMeshReplacement: AbstractMeshdefines an optional mesh used to provide info for the rendering
the current mesh
Triggers the draw call for the mesh (or a submesh), for a specific render pass id
OptionalrenderPassId: numberdefines the render pass id to use to draw the mesh / submesh. If not provided, use the current renderPassId of the engine.
OptionalenableAlphaMode: booleandefines if alpha mode can be changed (default: false)
OptionaleffectiveMeshReplacement: AbstractMeshdefines an optional mesh used to provide info for the rendering (default: undefined)
OptionalsubMesh: SubMeshdefines the subMesh to render. If not provided, draw all mesh submeshes (default: undefined)
OptionalcheckFrustumCulling: booleandefines if frustum culling must be checked (default: true). If you know the mesh is in the frustum (or if you don't care!), you can pass false to optimize.
the current mesh
Resets the draw wrappers cache for all submeshes of this abstract mesh
OptionalpassId: numberIf provided, releases only the draw wrapper corresponding to this render pass id
Optionalimmediate: booleanIf true, the effect will be released immediately, otherwise it will be released at the next frame
Resets this nodeTransform's local matrix to Matrix.Identity().
OptionalindependentOfChildren: booleanindicates if all child nodeTransform's world-space transform should be preserved.
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.
the axis to rotate around
the amount to rotate in radians
Optionalspace: SpaceSpace to rotate in (Default: local)
the 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
the point to rotate around
the axis to rotate around
the amount to rotate in radians
the 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.
defines the flip
defines the twirl
defines the tilt
the current mesh
Serialize current mesh
OptionalserializationObject: anydefines the object which will receive the serialization data
the serialized object
Serialize animation ranges into a JSON compatible object
serialization object
Sets the mesh absolute position in the World from a Vector3 or an Array(3).
the absolute position to set
the TransformNode.
Overwrite the current bounding info
defines the new bounding info
the current mesh
Sets this transform node rotation to the given local axis.
the axis in local space
OptionalyawCor: numberoptional yaw (y-axis) correction in radians
OptionalpitchCor: numberoptional pitch (x-axis) correction in radians
OptionalrollCor: numberoptional roll (z-axis) correction in radians
this TransformNode
Set the enabled state of this node
defines the new enabled state
Sets the index buffer of this mesh.
Defines the index buffer to use for this mesh
Defines the total number of vertices used by the buffer
Defines the total number of indices in the index buffer
Optionalis32Bits: Nullable<boolean>Defines if the indices are 32 bits. If null (default), the value is guessed from the number of vertices
Set the index buffer of this mesh
defines the source data
OptionaltotalVertices: Nullable<number>defines the total number of vertices referenced by this index data (can be null)
Optionalupdatable: booleandefines if the updated index buffer must be flagged as updatable (default is false)
OptionaldontForceSubMeshRecreation: booleandefines a boolean indicating that we don't want to force the recreation of sub-meshes if we don't have to (false by default)
the current mesh
Sets the mesh material by the material or multiMaterial id property
is a string identifying the material or the multiMaterial
the current mesh
Sets the material to be used to render the mesh in a specific render pass
render pass id
Optionalmaterial: Materialmaterial 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)
Prepare internal normal array for software CPU skinning
original normals used for CPU skinning. Useful for integrating Morphing with skeletons in same mesh.
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. If you don't want to preserve the current rotation / position, assign the parent through parent accessor. 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
the node ot set as the parent
OptionalpreserveScalingSign: booleanif true, keep scaling sign of child. Otherwise, scaling sign might change.
OptionalupdatePivot: booleanif true, update the pivot matrix to keep the node in the same space as before
this TransformNode.
Creates a physic joint between two meshes
defines the other mesh to use
defines the pivot to use on this mesh
defines the pivot to use on the other mesh
Optionaloptions: anydefines additional options (can be plugin dependent)
the current mesh
Sets a new pivot matrix to the current node
defines the new pivot matrix to use
OptionalpostMultiplyPivotMatrix: booleandefines 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
the current TransformNode
Sets a new pivot point to the current node
defines the new pivot point to use
Optionalspace: Spacedefines if the point is in world or local space (local by default)
the current TransformNode
Prepare internal position array for software CPU skinning
original positions used for CPU skinning. Useful for integrating Morphing with skeletons in same mesh
Sets the mesh position in its local space.
the position to set in localspace
the TransformNode.
Sets a new matrix to apply before all other transformation
defines the transform matrix
the current TransformNode
Sets the mesh global Vertex Buffer
defines the buffer to use
OptionaldisposeExistingBuffer: booleandisposes the existing buffer, if any (default: true)
the current mesh
Copy a FloatArray into a specific associated vertex buffer
defines which buffer to write to (positions, indices, normals, etc). Possible kind values :
defines the data source
Optionalupdatable: booleandefines if the updated vertex buffer must be flagged as updatable
Optionalstride: numberdefines the data stride size (can be null)
the current mesh
Simplify the mesh according to the given array of settings. Function will return immediately and will simplify async
a collection of simplification settings
OptionalparallelProcessing: booleanshould all levels calculate parallel or one after the other
OptionalsimplificationType: SimplificationTypethe type of simplification to run
OptionalsuccessCallback: (mesh?: Mesh, submeshIndex?: number) => voidoptional success callback to be called after the simplification finished processing all settings
the current mesh
This function will subdivide the mesh into multiple submeshes
defines the expected number of submeshes
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.
the current mesh
Creates a new thin instance
the matrix or array of matrices (position, rotation, scale) of the thin instance(s) to create
Optionalrefresh: booleantrue 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
the thin instance index number. If you pass an array of matrices, other instance indexes are index+1, index+2, etc
Adds the transformation (matrix) of the current mesh as a thin instance
Optionalrefresh: booleantrue 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
the thin instance index number
Synchronize the gpu buffers with a thin instance buffer. Call this method if you update later on the buffers passed to thinInstanceSetBuffer
name of the attribute to update. Use "matrix" to update the buffer of matrices
Gets the list of world matrices
an array containing all the world matrices from the thin instances
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
name of the attribute to update. Use "matrix" to update the buffer of matrices
the data to set in the GPU buffer
the offset in the GPU buffer where to update the data
Refreshes the bounding info, taking into account all the thin instances defined
OptionalforceRefreshParentInfo: booleantrue to force recomputing the mesh bounding info and use it to compute the aggregated bounding info
OptionalapplySkeleton: booleandefines whether to apply the skeleton before computing the bounding info
OptionalapplyMorph: booleandefines whether to apply the morph target before computing the bounding info
Registers a custom attribute to be used with thin instances
name of the attribute
size in floats of the attribute
Sets the value of a custom attribute for a thin instance
name of the attribute
index of the thin instance
value to set
Optionalrefresh: booleantrue 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
Sets a buffer to be used with thin instances. This method is a faster way to setup multiple instances than calling thinInstanceAdd repeatedly
name of the attribute. Use "matrix" to setup the buffer of matrices
buffer to set
Optionalstride: numbersize in floats of each value of the buffer
OptionalstaticBuffer: booleanindicates that the buffer is static, so that you won't change it after it is set (better performances - true by default)
Sets the matrix of a thin instance
index of the thin instance
matrix to set
Optionalrefresh: booleantrue 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
Invert the geometry to move from a right handed system to a left handed one.
the current mesh
Returns a description of this mesh
OptionalfullDetails: booleandefine if full details about this mesh must be used
a descriptive string representing this mesh
Transfer the mesh values to its UBO.
The world matrix associated with the mesh
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.
the axis to translate in
the distance to translate
Optionalspace: SpaceSpace to rotate in (Default: local)
the 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
the current mesh
Allows back the World matrix computation.
the TransformNode.
Disposes a previously registered javascript function called after the rendering.
defines the function to remove
the current mesh
Removes a registered callback function.
callback function to remove
the TransformNode.
Disposes a previously registered javascript function called before the rendering
defines the function to remove
the current mesh
InternalOptionalforce: booleanUpdates 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
the current mesh
Update the current index buffer
defines the source data
Optionaloffset: numberdefines the offset in the index buffer where to store the new data (can be null)
OptionalgpuMemoryOnly: booleandefines a boolean indicating that only the GPU memory must be updated leaving the CPU version of the indices unchanged (false by default)
the current mesh
This method updates the vertex positions of an updatable mesh according to the positionFunction returned values.
is a simple JS function what is passed the mesh positions array. It doesn't need to return anything
OptionalcomputeNormals: booleanis a boolean (default true) to enable/disable the mesh normal recomputation after the vertex position update
the current mesh
Copies the parameter passed Matrix into the mesh Pose matrix.
the matrix to copy the pose from
this TransformNode.
Update a specific associated vertex buffer
defines which buffer to write to (positions, indices, normals, etc). Possible kind values :
defines the data source
OptionalupdateExtends: booleandefines if extends info of the mesh must be updated (can be null). This is mostly useful for "position" kind
OptionalmakeItUnique: booleandefines 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)
the current mesh
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
a validation object with skinned, valid and report string
Static_InternalGets the default side orientation.
Optionalorientation: numberthe orientation to value to attempt to get
the default orientation
Static_instancedInternalStatic_StaticAddAdd a new node constructor
defines the type name of the node to construct
defines the constructor function
StaticCenterReturns the center of the {min: Vector3, max: Vector3} or the center of MinMax vector3 computed from a mesh array
could be an array of meshes or a {min: Vector3, max: Vector3} object
a vector3
StaticConstructReturns a node constructor based on type name
defines the type name
defines the new node name
defines the hosting scene
Optionaloptions: anydefines optional options to transmit to constructors
the new constructor or null
StaticCreateCreates a box mesh.
defines the name of the mesh to create
sets the size (float) of each box side (default 1)
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a Capsule Mesh
defines the name of the mesh.
the constructors options used to shape the mesh.
defines the scene the mesh is scoped to.
the capsule mesh
StaticCreateCreates a cylinder or a cone mesh.
defines the name of the mesh to create
sets the height size (float) of the cylinder/cone (float, default 2)
set the top cap diameter (floats, default 1)
set the bottom cap diameter (floats, default 1). This value can't be zero
sets the number of cylinder sides (positive integer, default 24). Set it to 3 to get a prism for instance
sets the number of rings along the cylinder height (positive integer, default 1)
Optionalscene: Scenedefines the hosting scene
Optionalupdatable: anydefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a dashed line mesh.
defines the name of the mesh to create
is an array successive Vector3
is the size of the dashes relatively the dash number (positive float, default 3)
is the size of the gap between two successive dashes relatively the dash number (positive float, default 1)
is the intended total number of dashes (positive integer, default 200)
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
Optionalinstance: LinesMeshis 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)
a new Mesh
StaticCreateCreates a decal mesh. . A decal is a mesh usually applied as a model onto the surface of another mesh
defines the name of the mesh
defines the mesh receiving the decal
sets the position of the decal in world coordinates
sets the normal of the mesh where the decal is applied onto in world coordinates
sets the decal scaling
sets the angle to rotate the decal
a new Mesh
StaticCreateCreates a plane polygonal mesh. By default, this is a disc.
defines the name of the mesh to create
sets the radius size (float) of the polygon (default 0.5)
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
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a ground mesh.
defines the name of the mesh to create
set the width of the ground
set the height of the ground
sets the number of subdivisions per side
Optionalscene: Scenedefines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
a new Mesh
StaticCreateCreates a ground mesh from a height map.
defines the name of the mesh to create
sets the URL of the height map image resource
set the ground width size
set the ground height size
sets the number of subdivision per side
is the minimum altitude on the ground
is the maximum altitude on the ground
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalonReady: (mesh: GroundMesh) => voidis a callback function that will be called once the mesh is built (the height map download can last some time)
OptionalalphaFilter: numberwill filter any data where the alpha channel is below this value, defaults 0 (all data visible)
a new Mesh
StaticCreateCreates a hemisphere mesh.
defines the name of the mesh to create
sets the sphere number of horizontal stripes (positive integer, default 32)
sets the diameter size (float) of the sphere (default 1)
Optionalscene: Scenedefines the hosting scene
a new Mesh
StaticCreateCreates a sphere based upon an icosahedron with 20 triangular faces which can be subdivided
radius sets the radius size (float) of the icosphere (default 1)radiusX, radiusY and radiusZ (all by default have the same value than radius)subdivisions sets the number of subdivisions (positive integer, default 4). The more subdivisions, the more faces on the icosphere whatever its sizeflat (boolean, default true) gives each side its own normals. Set it to false to get a smooth continuous light reflection on the surfacefrontUVs and backUVs (Vector4). Detail here : https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientationupdatable (default false) if its internal geometry is supposed to change once createddefines the name of the mesh
defines the options used to create the mesh
defines the hosting scene
a new Mesh
StaticCreateCreates lathe mesh. The lathe is a shape with a symmetry axis : a 2D model shape is rotated around this axis to design the lathe.
defines the name of the mesh to create
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
is the radius value of the lathe
is the side number of the lathe.
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a line mesh..
defines the name of the mesh to create
is an array successive Vector3
defines the hosting scene
defines if the mesh must be flagged as updatable
Optionalinstance: Nullable<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).
a new Mesh
StaticCreateCreates a plane mesh.
defines the name of the mesh to create
sets the size (float) of both sides of the plane at once (default 1)
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates 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.
defines the name of the mesh to create
is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors
defines the hosting scene
Optionalholes: Vector3[][]is a required array of arrays of successive Vector3 used to defines holes in the polygon
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
OptionalearcutInjection: anycan be used to inject your own earcut reference
a new Mesh
StaticCreateCreates a polyhedron mesh. .
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 typesize (positive float, default 1) sets the polygon sizesize on each dimension bu using the parameters sizeX, sizeY or sizeZ (positive floats, default to size value)custom (polyhedronObject, default null). If you set the parameter custom, this overwrittes the parameter typepolyhedronObject is a formatted javascript object. You'll find a full file with pre-set polyhedra here : https://github.com/BabylonJS/Extensions/tree/master/PolyhedronfaceColors (Color4, default (1, 1, 1, 1)) and faceUV (Vector4, default (0, 0, 1, 1))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/features/featuresDeepDive/materials/using/texturePerBoxFaceflat (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 ignoredfrontUVs and backUVs (Vector4). Detail here : https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientationupdatable (default false) if its internal geometry is supposed to change once createddefines the name of the mesh to create
defines the options used to create the mesh
defines the hosting scene
a new Mesh
StaticCreateCreates a ribbon mesh.
defines the name of the mesh to create
is a required array of paths, what are each an array of successive Vector3. The pathArray parameter depicts the ribbon geometry.
creates a seam between the first and the last paths of the path array (default is false)
creates a seam between the first and the last points of each path of the path array
is taken in account only if the pathArray is containing a single path
Optionalscene: Scenedefines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
Optionalinstance: Meshdefines 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)
a new Mesh
StaticCreateCreates a sphere mesh.
defines the name of the mesh to create
sets the sphere number of horizontal stripes (positive integer, default 32)
sets the diameter size (float) of the sphere (default 1)
Optionalscene: Scenedefines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a tiled ground mesh.
defines the name of the mesh to create
set the ground minimum X coordinate
set the ground minimum Y coordinate
set the ground maximum X coordinate
set the ground maximum Z coordinate
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
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
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
a new Mesh
StaticCreateCreates a torus mesh.
defines the name of the mesh to create
sets the diameter size (float) of the torus (default 1)
sets the diameter size of the tube of the torus (float, default 0.5)
sets the number of torus sides (positive integer, default 16)
Optionalscene: Scenedefines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a torus knot mesh.
defines the name of the mesh to create
sets the global radius size (float) of the torus knot (default 2)
sets the diameter size of the tube of the torus (float, default 0.5)
sets the number of sides on each tube segments (positive integer, default 32)
sets the number of tubes to decompose the knot into (positive integer, default 32)
the number of windings on X axis (positive integers, default 2)
the number of windings on Y axis (positive integers, default 3)
Optionalscene: Scenedefines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
a new Mesh
StaticCreateCreates a tube mesh. The tube is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.
defines the name of the mesh to create
is a required array of successive Vector3. It is the curve used as the axis of the tube
sets the tube radius size
is the number of sides on the tubular surface
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
sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
Optionalinstance: Meshis 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)
a new Mesh
StaticExtendStaticExtrudeCreates an extruded polygon mesh, with depth in the Y direction..
defines the name of the mesh to create
is a required array of successive Vector3 representing the corners of the polygon in th XoZ plane, that is y = 0 for all vectors
defines the height of extrusion
defines the hosting scene
Optionalholes: Vector3[][]is a required array of arrays of successive Vector3 used to defines holes in the polygon
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
OptionalearcutInjection: anycan be used to inject your own earcut reference
a new Mesh
StaticExtrudeCreates an extruded shape mesh. The extrusion is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.
defines the name of the mesh to create
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
is a required array of successive Vector3. This is the axis curve the shape is extruded along
is the value to scale the shape
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
sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
Optionalinstance: Meshis 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)
a new Mesh
StaticExtrudeCreates 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.
defines the name of the mesh to create
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
is a required array of successive Vector3. This is the axis curve the shape is extruded along
is a custom Javascript function called on each path point
is a custom Javascript function called on each path point
forces the extrusion underlying ribbon to close all the paths in its pathArray
forces the extrusion underlying ribbon to close its pathArray
sets the way the extruded shape is capped. Possible values : Mesh.NO_CAP (default), Mesh.CAP_START, Mesh.CAP_END, Mesh.CAP_ALL
defines the hosting scene
Optionalupdatable: booleandefines if the mesh must be flagged as updatable
OptionalsideOrientation: numberdefines the mesh side orientation (https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/set#side-orientation)
Optionalinstance: Meshis an instance of an existing ExtrudedShape object to be updated with the passed shape, path, scale or rotation parameters (https://doc.babylonjs.com/features/featuresDeepDive/mesh/dynamicMeshMorph#extruded-shape)
a new Mesh
StaticMergeMerge the array of meshes into a single mesh for performance reasons.
array of meshes with the vertices to merge. Entries cannot be empty meshes.
OptionaldisposeSource: booleanwhen true (default), dispose of the vertices from the source meshes.
Optionalallow32BitsIndices: booleanwhen the sum of the vertices > 64k, this must be set to true.
OptionalmeshSubclass: Mesh(optional) can be set to a Mesh where the merged vertices will be inserted.
OptionalsubdivideWithSubMeshes: booleanwhen true (false default), subdivide mesh into subMeshes.
OptionalmultiMultiMaterials: booleanwhen true (false default), subdivide mesh into subMeshes with multiple materials, ignores subdivideWithSubMeshes.
a new mesh
StaticMergeMerge the array of meshes into a single mesh for performance reasons.
array of meshes with the vertices to merge. Entries cannot be empty meshes.
OptionaldisposeSource: booleanwhen true (default), dispose of the vertices from the source meshes.
Optionalallow32BitsIndices: booleanwhen the sum of the vertices > 64k, this must be set to true.
OptionalmeshSubclass: Mesh(optional) can be set to a Mesh where the merged vertices will be inserted.
OptionalsubdivideWithSubMeshes: booleanwhen true (false default), subdivide mesh into subMeshes.
OptionalmultiMultiMaterials: booleanwhen true (false default), subdivide mesh into subMeshes with multiple materials, ignores subdivideWithSubMeshes.
a new mesh
StaticMinReturns 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
defines the list of meshes to scan
an object {min: Vector3, max: Vector3}
StaticParseReturns a new Mesh object parsed from the source provided.
is the source
defines the hosting scene
is the root URL to prefix the delayLoadingFile property with
a new Mesh
StaticParseParse animation range data from a serialization object and store them into a given node
defines where to store the animation ranges
defines the serialization object to read data from
defines the hosting scene
Backing filed