Class VertexData

This class contains the various kinds of data on every vertex of a mesh used in determining its shape and appearance

Implements

IVertexDataLike

Constructors

constructor

new VertexData(): VertexData
Creates a new VertexData

Returns VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:295

Properties

colors

colors: Nullable<FloatArray>

An array of the r, g, b, a, color of each vertex [...., r, g, b, a, .....]

hasVertexAlpha

hasVertexAlpha: boolean

Gets or sets a value indicating that the mesh must be flagged with hasVertexAlpha = true

indices

indices: Nullable<IndicesArray>

An array of i, j, k the three vertex indices required for each triangular facet [...., i, j, k .....]

materialInfos

materialInfos: Nullable<VertexDataMaterialInfo[]>

An array defining material association for sub sections of the vertex data

matricesIndices

matricesIndices: Nullable<FloatArray>

An array containing the list of indices to the array of matrices produced by bones, each vertex have up to 4 indices (8 if the matricesIndicesExtra is set).

matricesIndicesExtra

matricesIndicesExtra: Nullable<FloatArray>

An array extending the number of possible indices

matricesWeights

matricesWeights: Nullable<FloatArray>

An array containing the list of weights defining the weight of each indexed matrix in the final computation

matricesWeightsExtra

matricesWeightsExtra: Nullable<FloatArray>

An array extending the number of possible weights when the number of indices is extended

metadata

metadata: any = {}

Metadata used to store contextual values

normals

normals: Nullable<FloatArray>

An array of the x, y, z normal vector of each vertex [...., x, y, z, .....]

positions

positions: Nullable<FloatArray>

An array of the x, y, z position of each vertex [...., x, y, z, .....]

tangents

tangents: Nullable<FloatArray>

An array of the x, y, z, w tangent vector of each vertex [...., x, y, z, w, .....]

uniqueId

uniqueId: number = 0

Gets the unique ID of this vertex Data

uvs

uvs: Nullable<FloatArray>

An array of u,v which maps a texture image onto each vertex [...., u, v, .....]

uvs2

uvs2: Nullable<FloatArray>

A second array of u,v which maps a texture image onto each vertex [...., u, v, .....]

uvs3

uvs3: Nullable<FloatArray>

A third array of u,v which maps a texture image onto each vertex [...., u, v, .....]

uvs4

uvs4: Nullable<FloatArray>

A fourth array of u,v which maps a texture image onto each vertex [...., u, v, .....]

uvs5

uvs5: Nullable<FloatArray>

A fifth array of u,v which maps a texture image onto each vertex [...., u, v, .....]

uvs6

uvs6: Nullable<FloatArray>

A sixth array of u,v which maps a texture image onto each vertex [...., u, v, .....]

`Static` `Readonly`BACKSIDE

BACKSIDE: 1

Mesh side orientation : usually the internal or back surface

`Static` `Readonly`DEFAULTSIDE

DEFAULTSIDE: 0

Mesh side orientation : by default, FRONTSIDE

`Static` `Readonly`DOUBLESIDE

DOUBLESIDE: 2

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

`Static` `Readonly`FRONTSIDE

FRONTSIDE: 0

Mesh side orientation : usually the external or front surface

Methods

applyToGeometry

applyToGeometry(geometry: Geometry, updatable?: boolean): VertexData
Associates the vertexData to the passed Geometry. Sets it as updatable or not (default false)
Parameters
- geometry: Geometry
  the geometry the vertexData is applied to
- Optionalupdatable: boolean
  when used and having the value true allows new data to update the vertexData
Returns VertexData
VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:375

applyToMesh

applyToMesh(mesh: Mesh, updatable?: boolean): VertexData
Associates the vertexData to the passed Mesh. Sets it as updatable or not (default false)
Parameters
- mesh: Mesh
  the mesh the vertexData is applied to
- Optionalupdatable: boolean
  when used and having the value true allows new data to update the vertexData
Returns VertexData
the VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:363

clone

clone(): VertexData
Clone the current vertex data

Returns VertexData
a copy of the current data
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1345

merge

merge(
    others: VertexData | VertexData[],
    use32BitsIndices?: boolean,
    forceCloneIndices?: boolean,
    mergeMaterialIds?: boolean,
    enableCompletion?: boolean,
): VertexData
Merges the passed VertexData into the current one
Parameters
- others: VertexData | VertexData[]
  the VertexData to be merged into the current one
- use32BitsIndices: boolean = false
  defines a boolean indicating if indices must be store in a 32 bits array
- forceCloneIndices: boolean = false
  defines a boolean indicating if indices are forced to be cloned
- mergeMaterialIds: boolean = false
  defines a boolean indicating if we need to merge the material infos
- enableCompletion: boolean = false
  defines a boolean indicating if the vertex data should be completed to be compatible
Returns VertexData
the modified VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:767

serialize

serialize(): any
Serializes the VertexData

Returns any
a serialized object
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1354

set

set(data: FloatArray, kind: string): void
Uses the passed data array to set the set the values for the specified kind of data
Parameters
- data: FloatArray
  a linear array of floating numbers
- kind: string
  the type of data that is being set, eg positions, colors etc
Returns void
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:305

splitBasedOnMaterialID

splitBasedOnMaterialID(): VertexData[]
Generates an array of vertex data where each vertex data only has one material info

Returns VertexData[]
An array of VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:672

transform

transform(matrix: Matrix): VertexData
Transforms each position and each normal of the vertexData according to the passed Matrix
Parameters
- matrix: Matrix
  the transforming matrix
Returns VertexData
the VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:646

updateGeometry

updateGeometry(geometry: Geometry): VertexData
Updates the associated geometry
Parameters
- geometry: Geometry
  the geometry to be updated
Returns VertexData
VertexData.
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:395

updateMesh

updateMesh(mesh: Mesh): VertexData
Updates the associated mesh
Parameters
- mesh: Mesh
  the mesh to be updated
Returns VertexData
VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:385

`Static`ComputeNormals

ComputeNormals(
    positions: any,
    indices: any,
    normals: any,
    options?: {
        bbSize?: Vector3;
        bInfo?: any;
        depthSort?: boolean;
        depthSortedFacets?: any;
        distanceTo?: Vector3;
        facetNormals?: any;
        facetPartitioning?: any;
        facetPositions?: any;
        ratio?: number;
        subDiv?: any;
        useRightHandedSystem?: boolean;
    },
): void
Compute normals for given positions and indices
Parameters
- positions: any
  an array of vertex positions, [...., x, y, z, ......]
- indices: any
  an array of indices in groups of three for each triangular facet, [...., i, j, k, ......]
- normals: any
  an array of vertex normals, [...., x, y, z, ......]
- Optionaloptions: {
      bbSize?: Vector3;
      bInfo?: any;
      depthSort?: boolean;
      depthSortedFacets?: any;
      distanceTo?: Vector3;
      facetNormals?: any;
      facetPartitioning?: any;
      facetPositions?: any;
      ratio?: number;
      subDiv?: any;
      useRightHandedSystem?: boolean;
  }
  an object used to set the following optional parameters for the TorusKnot, optional
  
  facetNormals : optional array of facet normals (vector3)
  
  facetPositions : optional array of facet positions (vector3)
  
  facetPartitioning : optional partitioning array. facetPositions is required for facetPartitioning computation
  
  ratio : optional partitioning ratio / bounding box, required for facetPartitioning computation
  
  bInfo : optional bounding info, required for facetPartitioning computation
  
  bbSize : optional bounding box size data, required for facetPartitioning computation
  
  subDiv : optional partitioning data about subdivisions on each axis (int), required for facetPartitioning computation
  
  useRightHandedSystem: optional boolean to for right handed system computation
  
  depthSort : optional boolean to enable the facet depth sort computation
  
  distanceTo : optional Vector3 to compute the facet depth from this location
  
  depthSortedFacets : optional array of depthSortedFacets to store the facet distances from the reference location
Returns void
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:2035

`Static`CreateBox

CreateBox(
    options: {
        backUVs?: Vector4;
        depth?: number;
        faceColors?: Color4[];
        faceUV?: Vector4[];
        frontUVs?: Vector4;
        height?: number;
        sideOrientation?: number;
        size?: number;
        width?: number;
    },
): VertexData
Creates the VertexData for a box
Parameters
- options: {
      backUVs?: Vector4;
      depth?: number;
      faceColors?: Color4[];
      faceUV?: Vector4[];
      frontUVs?: Vector4;
      height?: number;
      sideOrientation?: number;
      size?: number;
      width?: number;
  }
  an object used to set the following optional parameters for the box, required but can be empty
  
  size sets the width, height and depth of the box to the value of size, optional default 1
  
  width sets the width (x direction) of the box, overwrites the width set by size, optional, default size
  
  height sets the height (y direction) of the box, overwrites the height set by size, optional, default size
  
  depth sets the depth (z direction) of the box, overwrites the depth set by size, optional, default size
  
  faceUV an array of 6 Vector4 elements used to set different images to each box side
  
  faceColors an array of 6 Color3 elements used to set different colors to each box side
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the box

Deprecated
Please use CreateBoxVertexData from the BoxBuilder file instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1584

`Static`CreateCapsule

CreateCapsule(options?: ICreateCapsuleOptions): VertexData
Creates the VertexData for a Capsule, inspired from https://github.com/maximeq/three-js-capsule-geometry/blob/master/src/CapsuleBufferGeometry.js
Parameters
- options: ICreateCapsuleOptions = ...
  an object used to set the following optional parameters for the capsule, required but can be empty
Returns VertexData
the VertexData of the Capsule

Deprecated
Please use CreateCapsuleVertexData from the capsuleBuilder file instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1972

`Static`CreateCylinder

CreateCylinder(
    options: {
        arc?: number;
        backUVs?: Vector4;
        diameter?: number;
        diameterBottom?: number;
        diameterTop?: number;
        enclose?: boolean;
        faceColors?: Color4[];
        faceUV?: Vector4[];
        frontUVs?: Vector4;
        hasRings?: boolean;
        height?: number;
        sideOrientation?: number;
        subdivisions?: number;
        tessellation?: number;
    },
): VertexData
Creates the VertexData for a cylinder, cone or prism
Parameters
- options: {
      arc?: number;
      backUVs?: Vector4;
      diameter?: number;
      diameterBottom?: number;
      diameterTop?: number;
      enclose?: boolean;
      faceColors?: Color4[];
      faceUV?: Vector4[];
      frontUVs?: Vector4;
      hasRings?: boolean;
      height?: number;
      sideOrientation?: number;
      subdivisions?: number;
      tessellation?: number;
  }
  an object used to set the following optional parameters for the box, required but can be empty
  
  height sets the height (y direction) of the cylinder, optional, default 2
  
  diameterTop sets the diameter of the top of the cone, overwrites diameter, optional, default diameter
  
  diameterBottom sets the diameter of the bottom of the cone, overwrites diameter, optional, default diameter
  
  diameter sets the diameter of the top and bottom of the cone, optional default 1
  
  tessellation the number of prism sides, 3 for a triangular prism, optional, default 24
  
  subdivisions the number of rings along the cylinder height, optional, default 1
  
  arc a number from 0 to 1, to create an unclosed cylinder based on the fraction of the circumference given by the arc value, optional, default 1
  
  faceColors an array of Color3 elements used to set different colors to the top, rings and bottom respectively
  
  faceUV an array of Vector4 elements used to set different images to the top, rings and bottom respectively
  
  hasRings when true makes each subdivision independently treated as a face for faceUV and faceColors, optional, default false
  
  enclose when true closes an open cylinder by adding extra flat faces between the height axis and vertical edges, think cut cake
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the cylinder, cone or prism

Deprecated
please use CreateCylinderVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1714

`Static`CreateDashedLines

CreateDashedLines(
    options: {
        dashNb?: number;
        dashSize?: number;
        gapSize?: number;
        points: Vector3[];
    },
): VertexData
Create the VertexData for a DashedLines
Parameters
- options: { dashNb?: number; dashSize?: number; gapSize?: number; points: Vector3[] }
  an object used to set the following optional parameters for the DashedLines, required but can be empty
  
  points an array successive Vector3
  
  dashSize the size of the dashes relative to the dash number, optional, default 3
  
  gapSize the size of the gap between two successive dashes relative to the dash number, optional, default 1
  
  dashNb the intended total number of dashes, optional, default 200
Returns VertexData
the VertexData for the DashedLines

Deprecated
use CreateDashedLinesVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1778

`Static`CreateDisc

CreateDisc(
    options: {
        arc?: number;
        backUVs?: Vector4;
        frontUVs?: Vector4;
        radius?: number;
        sideOrientation?: number;
        tessellation?: number;
    },
): VertexData
Creates the VertexData of the Disc or regular Polygon
Parameters
- options: {
      arc?: number;
      backUVs?: Vector4;
      frontUVs?: Vector4;
      radius?: number;
      sideOrientation?: number;
      tessellation?: number;
  }
  an object used to set the following optional parameters for the disc, required but can be empty
  
  radius the radius of the disc, optional default 0.5
  
  tessellation the number of polygon sides, optional, default 64
  
  arc a number from 0 to 1, to create an unclosed polygon based on the fraction of the circumference given by the arc value, optional, default 1
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the box

Deprecated
use CreateDiscVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1877

`Static`CreateGround

CreateGround(
    options: {
        height?: number;
        subdivisions?: number;
        subdivisionsX?: number;
        subdivisionsY?: number;
        width?: number;
    },
): VertexData
Creates the VertexData for a Ground
Parameters
- options: {
      height?: number;
      subdivisions?: number;
      subdivisionsX?: number;
      subdivisionsY?: number;
      width?: number;
  }
  an object used to set the following optional parameters for the Ground, required but can be empty
  
  width the width (x direction) of the ground, optional, default 1
  
  height the height (z direction) of the ground, optional, default 1
  
  subdivisions the number of subdivisions per side, optional, default 1
Returns VertexData
the VertexData of the Ground

Deprecated
Please use CreateGroundVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1791

`Static`CreateGroundFromHeightMap

CreateGroundFromHeightMap(
    options: {
        alphaFilter: number;
        buffer: Uint8Array;
        bufferHeight: number;
        bufferWidth: number;
        colorFilter: Color3;
        height: number;
        maxHeight: number;
        minHeight: number;
        subdivisions: number;
        width: number;
    },
): VertexData
Creates the VertexData of the Ground designed from a heightmap
Parameters
- options: {
      alphaFilter: number;
      buffer: Uint8Array;
      bufferHeight: number;
      bufferWidth: number;
      colorFilter: Color3;
      height: number;
      maxHeight: number;
      minHeight: number;
      subdivisions: number;
      width: number;
  }
  an object used to set the following parameters for the Ground, required and provided by CreateGroundFromHeightMap
  
  width the width (x direction) of the ground
  
  height the height (z direction) of the ground
  
  subdivisions the number of subdivisions per side
  
  minHeight the minimum altitude on the ground, optional, default 0
  
  maxHeight the maximum altitude on the ground, optional default 1
  
  colorFilter the filter to apply to the image pixel colors to compute the height, optional Color3, default (0.3, 0.59, 0.11)
  
  buffer the array holding the image color data
  
  bufferWidth the width of image
  
  bufferHeight the height of image
  
  alphaFilter Remove any data where the alpha channel is below this value, defaults 0 (all data visible)
Returns VertexData
the VertexData of the Ground designed from a heightmap

Deprecated
use CreateGroundFromHeightMapVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1834

`Static`CreateIcoSphere

CreateIcoSphere(
    options: {
        backUVs?: Vector4;
        flat?: boolean;
        frontUVs?: Vector4;
        radius?: number;
        radiusX?: number;
        radiusY?: number;
        radiusZ?: number;
        sideOrientation?: number;
        subdivisions?: number;
    },
): VertexData
Creates the VertexData of the IcoSphere
Parameters
- options: {
      backUVs?: Vector4;
      flat?: boolean;
      frontUVs?: Vector4;
      radius?: number;
      radiusX?: number;
      radiusY?: number;
      radiusZ?: number;
      sideOrientation?: number;
      subdivisions?: number;
  }
  an object used to set the following optional parameters for the IcoSphere, required but can be empty
  
  radius the radius of the IcoSphere, optional default 1
  
  radiusX allows stretching in the x direction, optional, default radius
  
  radiusY allows stretching in the y direction, optional, default radius
  
  radiusZ allows stretching in the z direction, optional, default radius
  
  flat when true creates a flat shaded mesh, optional, default true
  
  subdivisions increasing the subdivisions increases the number of faces, optional, default 4
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the IcoSphere

Deprecated
use CreateIcoSphereVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1913

`Static`CreateLineSystem

CreateLineSystem(
options: { colors?: Nullable<Color4[][]>; lines: Vector3[][] },
): VertexData
Creates the VertexData of the LineSystem
Parameters
- options: { colors?: Nullable<Color4[][]>; lines: Vector3[][] }
  an object used to set the following optional parameters for the LineSystem, required but can be empty
  
  lines an array of lines, each line being an array of successive Vector3
  
  colors an array of line colors, each of the line colors being an array of successive Color4, one per line point
Returns VertexData
the VertexData of the LineSystem

Deprecated
use CreateLineSystemVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1764

`Static`CreatePlane

CreatePlane(
    options: {
        backUVs?: Vector4;
        frontUVs?: Vector4;
        height?: number;
        sideOrientation?: number;
        size?: number;
        width?: number;
    },
): VertexData
Creates the VertexData for a Plane
Parameters
- options: {
      backUVs?: Vector4;
      frontUVs?: Vector4;
      height?: number;
      sideOrientation?: number;
      size?: number;
      width?: number;
  }
  an object used to set the following optional parameters for the plane, required but can be empty
  
  size sets the width and height of the plane to the value of size, optional default 1
  
  width sets the width (x direction) of the plane, overwrites the width set by size, optional, default size
  
  height sets the height (y direction) of the plane, overwrites the height set by size, optional, default size
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the box

Deprecated
use CreatePlaneVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1861

`Static`CreatePolygon

CreatePolygon(
    polygon: Mesh,
    sideOrientation: number,
    fUV?: Vector4[],
    fColors?: Color4[],
    frontUVs?: Vector4,
    backUVs?: Vector4,
    wrap?: boolean,
): VertexData
Creates the VertexData for an irregular Polygon in the XoZ plane using a mesh built by polygonTriangulation.build() All parameters are provided by CreatePolygon as needed
Parameters
- polygon: Mesh
  a mesh built from polygonTriangulation.build()
- sideOrientation: number
  takes the values Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
- OptionalfUV: Vector4[]
  an array of Vector4 elements used to set different images to the top, rings and bottom respectively
- OptionalfColors: Color4[]
  an array of Color3 elements used to set different colors to the top, rings and bottom respectively
- OptionalfrontUVs: Vector4
  only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
- OptionalbackUVs: Vector4
  only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
- Optionalwrap: boolean
  a boolean, default false, when true and fUVs used texture is wrapped around all sides, when false texture is applied side
Returns VertexData
the VertexData of the Polygon

Deprecated
use CreatePolygonVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1894

`Static`CreatePolyhedron

CreatePolyhedron(
    options: {
        backUVs?: Vector4;
        custom?: any;
        faceColors?: Color4[];
        faceUV?: Vector4[];
        flat?: boolean;
        frontUVs?: Vector4;
        sideOrientation?: number;
        size?: number;
        sizeX?: number;
        sizeY?: number;
        sizeZ?: number;
        type?: number;
    },
): VertexData
Creates the VertexData for a Polyhedron
Parameters
- options: {
      backUVs?: Vector4;
      custom?: any;
      faceColors?: Color4[];
      faceUV?: Vector4[];
      flat?: boolean;
      frontUVs?: Vector4;
      sideOrientation?: number;
      size?: number;
      sizeX?: number;
      sizeY?: number;
      sizeZ?: number;
      type?: number;
  }
  an object used to set the following optional parameters for the polyhedron, required but can be empty
  
  type provided types are:
  
  0 : Tetrahedron, 1 : Octahedron, 2 : Dodecahedron, 3 : Icosahedron, 4 : Rhombicuboctahedron, 5 : Triangular Prism, 6 : Pentagonal Prism, 7 : Hexagonal Prism, 8 : Square Pyramid (J1)
  
  9 : Pentagonal Pyramid (J2), 10 : Triangular Dipyramid (J12), 11 : Pentagonal Dipyramid (J13), 12 : Elongated Square Dipyramid (J15), 13 : Elongated Pentagonal Dipyramid (J16), 14 : Elongated Pentagonal Cupola (J20)
  
  size the size of the IcoSphere, optional default 1
  
  sizeX allows stretching in the x direction, optional, default size
  
  sizeY allows stretching in the y direction, optional, default size
  
  sizeZ allows stretching in the z direction, optional, default size
  
  custom a number that overwrites the type to create from an extended set of polyhedron from https://www.babylonjs-playground.com/#21QRSK#15 with minimised editor
  
  faceUV an array of Vector4 elements used to set different images to the top, rings and bottom respectively
  
  faceColors an array of Color3 elements used to set different colors to the top, rings and bottom respectively
  
  flat when true creates a flat shaded mesh, optional, default true
  
  subdivisions increasing the subdivisions increases the number of faces, optional, default 4
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the Polyhedron

Deprecated
use CreatePolyhedronVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1949

`Static`CreateRibbon

CreateRibbon(
    options: {
        backUVs?: Vector4;
        closeArray?: boolean;
        closePath?: boolean;
        colors?: Color4[];
        frontUVs?: Vector4;
        invertUV?: boolean;
        offset?: number;
        pathArray: Vector3[][];
        sideOrientation?: number;
        uvs?: Vector2[];
    },
): VertexData
Creates the VertexData for a Ribbon
Parameters
- options: {
      backUVs?: Vector4;
      closeArray?: boolean;
      closePath?: boolean;
      colors?: Color4[];
      frontUVs?: Vector4;
      invertUV?: boolean;
      offset?: number;
      pathArray: Vector3[][];
      sideOrientation?: number;
      uvs?: Vector2[];
  }
  an object used to set the following optional parameters for the ribbon, required but can be empty
  
  pathArray array of paths, each of which an array of successive Vector3
  
  closeArray creates a seam between the first and the last paths of the pathArray, optional, default false
  
  closePath creates a seam between the first and the last points of each path of the path array, optional, default false
  
  offset a positive integer, only used when pathArray contains a single path (offset = 10 means the point 1 is joined to the point 11), default rounded half size of the pathArray length
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
  
  invertUV swaps in the U and V coordinates when applying a texture, optional, default false
  
  uvs a linear array, of length 2 * number of vertices, of custom UV values, optional
  
  colors a linear array, of length 4 * number of vertices, of custom color values, optional
Returns VertexData
the VertexData of the ribbon

Deprecated
use CreateRibbonVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1554

`Static`CreateSphere

CreateSphere(
    options: {
        arc?: number;
        backUVs?: Vector4;
        diameter?: number;
        diameterX?: number;
        diameterY?: number;
        diameterZ?: number;
        frontUVs?: Vector4;
        segments?: number;
        sideOrientation?: number;
        slice?: number;
    },
): VertexData
Creates the VertexData for an ellipsoid, defaults to a sphere
Parameters
- options: {
      arc?: number;
      backUVs?: Vector4;
      diameter?: number;
      diameterX?: number;
      diameterY?: number;
      diameterZ?: number;
      frontUVs?: Vector4;
      segments?: number;
      sideOrientation?: number;
      slice?: number;
  }
  an object used to set the following optional parameters for the box, required but can be empty
  
  segments sets the number of horizontal strips optional, default 32
  
  diameter sets the axes dimensions, diameterX, diameterY and diameterZ to the value of diameter, optional default 1
  
  diameterX sets the diameterX (x direction) of the ellipsoid, overwrites the diameterX set by diameter, optional, default diameter
  
  diameterY sets the diameterY (y direction) of the ellipsoid, overwrites the diameterY set by diameter, optional, default diameter
  
  diameterZ sets the diameterZ (z direction) of the ellipsoid, overwrites the diameterZ set by diameter, optional, default diameter
  
  arc a number from 0 to 1, to create an unclosed ellipsoid based on the fraction of the circumference (latitude) given by the arc value, optional, default 1
  
  slice a number from 0 to 1, to create an unclosed ellipsoid based on the fraction of the height (latitude) given by the arc value, optional, default 1
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the ellipsoid

Deprecated
use CreateSphereVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1679

`Static`CreateTiledBox

CreateTiledBox(
    options: {
        alignHorizontal?: number;
        alignVertical?: number;
        depth?: number;
        faceColors?: Color4[];
        faceUV?: Vector4[];
        height?: number;
        pattern?: number;
        sideOrientation?: number;
        tileHeight?: number;
        tileSize?: number;
        tileWidth?: number;
        width?: number;
    },
): VertexData
Creates the VertexData for a tiled box
Parameters
- options: {
      alignHorizontal?: number;
      alignVertical?: number;
      depth?: number;
      faceColors?: Color4[];
      faceUV?: Vector4[];
      height?: number;
      pattern?: number;
      sideOrientation?: number;
      tileHeight?: number;
      tileSize?: number;
      tileWidth?: number;
      width?: number;
  }
  an object used to set the following optional parameters for the box, required but can be empty
  
  pattern sets the pattern
  
  width sets the width
  
  height sets the height
  
  depth sets the depth
  
  tileSize sets the tile size
  
  tileWidth sets the tile width
  
  tileHeight sets the tile height
  
  alignHorizontal sets the horizontal alignment
  
  alignVertical sets the vertical alignment
  
  faceUV an array of 6 Vector4 elements used to set different images to each box side
  
  faceColors an array of 6 Color3 elements used to set different colors to each box side
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
Returns VertexData
the VertexData of the box

Deprecated
Please use CreateTiledBoxVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1616

`Static`CreateTiledGround

CreateTiledGround(
    options: {
        precision?: { h: number; w: number };
        subdivisions?: { h: number; w: number };
        xmax: number;
        xmin: number;
        zmax: number;
        zmin: number;
    },
): VertexData
Creates the VertexData for a TiledGround by subdividing the ground into tiles
Parameters
- options: {
      precision?: { h: number; w: number };
      subdivisions?: { h: number; w: number };
      xmax: number;
      xmin: number;
      zmax: number;
      zmin: number;
  }
  an object used to set the following optional parameters for the Ground, required but can be empty
  
  xmin the ground minimum X coordinate, optional, default -1
  
  zmin the ground minimum Z coordinate, optional, default -1
  
  xmax the ground maximum X coordinate, optional, default 1
  
  zmax the ground maximum Z coordinate, optional, default 1
  
  subdivisions a javascript object \{w: positive integer, h: positive integer\}, w and h are the numbers of subdivisions on the ground width and height creating 'tiles', default \{w: 6, h: 6\}
  
  precision a javascript object \{w: positive integer, h: positive integer\}, w and h are the numbers of subdivisions on the tile width and height, default \{w: 2, h: 2\}
Returns VertexData
the VertexData of the TiledGround

Deprecated
use CreateTiledGroundVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1807

`Static`CreateTiledPlane

CreateTiledPlane(
    options: {
        alignHorizontal?: number;
        alignVertical?: number;
        backUVs?: Vector4;
        frontUVs?: Vector4;
        height?: number;
        pattern?: number;
        sideOrientation?: number;
        size?: number;
        tileHeight?: number;
        tileSize?: number;
        tileWidth?: number;
        width?: number;
    },
): VertexData
Creates the VertexData for a tiled plane
Parameters
- options: {
      alignHorizontal?: number;
      alignVertical?: number;
      backUVs?: Vector4;
      frontUVs?: Vector4;
      height?: number;
      pattern?: number;
      sideOrientation?: number;
      size?: number;
      tileHeight?: number;
      tileSize?: number;
      tileWidth?: number;
      width?: number;
  }
  an object used to set the following optional parameters for the box, required but can be empty
  
  pattern a limited pattern arrangement depending on the number
  
  tileSize sets the width, height and depth of the tile to the value of size, optional default 1
  
  tileWidth sets the width (x direction) of the tile, overwrites the width set by size, optional, default size
  
  tileHeight sets the height (y direction) of the tile, overwrites the height set by size, optional, default size
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the tiled plane

Deprecated
use CreateTiledPlaneVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1646

`Static`CreateTorus

CreateTorus(
    options: {
        backUVs?: Vector4;
        diameter?: number;
        frontUVs?: Vector4;
        sideOrientation?: number;
        tessellation?: number;
        thickness?: number;
    },
): VertexData
Creates the VertexData for a torus
Parameters
- options: {
      backUVs?: Vector4;
      diameter?: number;
      frontUVs?: Vector4;
      sideOrientation?: number;
      tessellation?: number;
      thickness?: number;
  }
  an object used to set the following optional parameters for the box, required but can be empty
  
  diameter the diameter of the torus, optional default 1
  
  thickness the diameter of the tube forming the torus, optional default 0.5
  
  tessellation the number of prism sides, 3 for a triangular prism, optional, default 24
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the torus

Deprecated
use CreateTorusVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1745

`Static`CreateTorusKnot

CreateTorusKnot(
    options: {
        backUVs?: Vector4;
        frontUVs?: Vector4;
        p?: number;
        q?: number;
        radialSegments?: number;
        radius?: number;
        sideOrientation?: number;
        tube?: number;
        tubularSegments?: number;
    },
): VertexData
Creates the VertexData for a TorusKnot
Parameters
- options: {
      backUVs?: Vector4;
      frontUVs?: Vector4;
      p?: number;
      q?: number;
      radialSegments?: number;
      radius?: number;
      sideOrientation?: number;
      tube?: number;
      tubularSegments?: number;
  }
  an object used to set the following optional parameters for the TorusKnot, required but can be empty
  
  radius the radius of the torus knot, optional, default 2
  
  tube the thickness of the tube, optional, default 0.5
  
  radialSegments the number of sides on each tube segments, optional, default 32
  
  tubularSegments the number of tubes to decompose the knot into, optional, default 32
  
  p the number of windings around the z axis, optional, default 2
  
  q the number of windings around the x axis, optional, default 3
  
  sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
  
  frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
  
  backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
Returns VertexData
the VertexData of the Torus Knot

Deprecated
use CreateTorusKnotVertexData instead
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:2001

`Static`ExtractFromGeometry

ExtractFromGeometry(
    geometry: Geometry,
    copyWhenShared?: boolean,
    forceCopy?: boolean,
): VertexData
Extracts the vertexData from the geometry
Parameters
- geometry: Geometry
  the geometry from which to extract the VertexData
- OptionalcopyWhenShared: boolean
  defines if the VertexData must be cloned when the geometry is shared between multiple meshes, optional, default false
- OptionalforceCopy: boolean
  indicating that the VertexData must be cloned, optional, default false
Returns VertexData
the object VertexData associated to the passed mesh
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1454

`Static`ExtractFromMesh

ExtractFromMesh(
    mesh: Mesh,
    copyWhenShared?: boolean,
    forceCopy?: boolean,
): VertexData
Extracts the vertexData from a mesh
Parameters
- mesh: Mesh
  the mesh from which to extract the VertexData
- OptionalcopyWhenShared: boolean
  defines if the VertexData must be cloned when shared between multiple meshes, optional, default false
- OptionalforceCopy: boolean
  indicating that the VertexData must be cloned, optional, default false
Returns VertexData
the object VertexData associated to the passed mesh
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:1443

`Static`ImportVertexData

ImportVertexData(parsedVertexData: any, geometry: Geometry): void
Applies VertexData created from the imported parameters to the geometry
Parameters
- parsedVertexData: any
  the parsed data from an imported file
- geometry: Geometry
  the geometry to apply the VertexData to
Returns void
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:2423

`Static`Parse

Parse(parsedVertexData: any): VertexData
Creates a VertexData from serialized data
Parameters
- parsedVertexData: any
  the parsed data from an imported file
Returns VertexData
a VertexData
- Defined in packages/dev/core/src/Meshes/mesh.vertexData.ts:2316

Class VertexData

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Returns VertexData

Properties

colors

hasVertexAlpha

indices

materialInfos

matricesIndices

matricesIndicesExtra

matricesWeights

matricesWeightsExtra

metadata

normals

positions

tangents

uniqueId

uvs

uvs2

uvs3

uvs4

uvs5

uvs6

Static ReadonlyBACKSIDE

Static ReadonlyDEFAULTSIDE

Static ReadonlyDOUBLESIDE

Static ReadonlyFRONTSIDE

Methods

applyToGeometry

Parameters

Returns VertexData

applyToMesh

Parameters

Returns VertexData

clone

Returns VertexData

merge

Parameters

Returns VertexData

serialize

Returns any

set

Parameters

Returns void

splitBasedOnMaterialID

Returns VertexData[]

transform

Parameters

Returns VertexData

updateGeometry

Parameters

Returns VertexData

updateMesh

Parameters

Returns VertexData

StaticComputeNormals

Parameters

Returns void

StaticCreateBox

Parameters

Returns VertexData

Deprecated

StaticCreateCapsule

Parameters

Returns VertexData

Deprecated

StaticCreateCylinder

Parameters

Returns VertexData

Deprecated

StaticCreateDashedLines

Parameters

Returns VertexData

Deprecated

`Static` `Readonly`BACKSIDE

`Static` `Readonly`DEFAULTSIDE

`Static` `Readonly`DOUBLESIDE

`Static` `Readonly`FRONTSIDE

`Static`ComputeNormals

`Static`CreateBox

`Static`CreateCapsule

`Static`CreateCylinder

`Static`CreateDashedLines

`Static`CreateDisc

`Static`CreateGround

`Static`CreateGroundFromHeightMap

`Static`CreateIcoSphere

`Static`CreateLineSystem

`Static`CreatePlane

`Static`CreatePolygon

`Static`CreatePolyhedron

`Static`CreateRibbon

`Static`CreateSphere

`Static`CreateTiledBox

`Static`CreateTiledGround

`Static`CreateTiledPlane

`Static`CreateTorus

`Static`CreateTorusKnot

`Static`ExtractFromGeometry

`Static`ExtractFromMesh

`Static`ImportVertexData

`Static`Parse