@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Meshes/mesh.vertexData.d.ts

@@ -0,0 +1,592 @@
+/**
+ * This class contains the various kinds of data on every vertex of a mesh used in determining its shape and appearance
+ */
+export class VertexData {
+    static _TransformVector3Coordinates(coordinates: any, transformation: any, offset?: number, length?: any): void;
+    static _TransformVector3Normals(normals: any, transformation: any, offset?: number, length?: any): void;
+    static _TransformVector4Normals(normals: any, transformation: any, offset?: number, length?: any): void;
+    static _FlipFaces(indices: any, offset?: number, length?: any): void;
+    static _MergeElement(kind: any, source: any, transform: any, others: any): any;
+    /**
+     * Extracts the vertexData from a mesh
+     * @param mesh the mesh from which to extract the VertexData
+     * @param copyWhenShared defines if the VertexData must be cloned when shared between multiple meshes, optional, default false
+     * @param forceCopy indicating that the VertexData must be cloned, optional, default false
+     * @returns the object VertexData associated to the passed mesh
+     */
+    static ExtractFromMesh(mesh: any, copyWhenShared: any, forceCopy: any): VertexData;
+    /**
+     * Extracts the vertexData from the geometry
+     * @param geometry the geometry from which to extract the VertexData
+     * @param copyWhenShared defines if the VertexData must be cloned when the geometry is shared between multiple meshes, optional, default false
+     * @param forceCopy indicating that the VertexData must be cloned, optional, default false
+     * @returns the object VertexData associated to the passed mesh
+     */
+    static ExtractFromGeometry(geometry: any, copyWhenShared: any, forceCopy: any): VertexData;
+    static _ExtractFrom(meshOrGeometry: any, copyWhenShared: any, forceCopy: any): VertexData;
+    /**
+     * Creates the VertexData for a Ribbon
+     * @param options 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
+     * @param options.pathArray
+     * @param options.closeArray
+     * @param options.closePath
+     * @param options.offset
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @param options.invertUV
+     * @param options.uvs
+     * @param options.colors
+     * @returns the VertexData of the ribbon
+     * @deprecated use CreateRibbonVertexData instead
+     */
+    static CreateRibbon(options: any): void;
+    /**
+     * Creates the VertexData for a box
+     * @param options 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)
+     * @param options.size
+     * @param options.width
+     * @param options.height
+     * @param options.depth
+     * @param options.faceUV
+     * @param options.faceColors
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the box
+     * @deprecated Please use CreateBoxVertexData from the BoxBuilder file instead
+     */
+    static CreateBox(options: any): void;
+    /**
+     * Creates the VertexData for a tiled box
+     * @param options an object used to set the following optional parameters for the box, required but can be empty
+     * * faceTiles sets the pattern, tile size and number of tiles for a face
+     * * 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
+     * @param options.pattern
+     * @param options.width
+     * @param options.height
+     * @param options.depth
+     * @param options.tileSize
+     * @param options.tileWidth
+     * @param options.tileHeight
+     * @param options.alignHorizontal
+     * @param options.alignVertical
+     * @param options.faceUV
+     * @param options.faceColors
+     * @param options.sideOrientation
+     * @returns the VertexData of the box
+     * @deprecated Please use CreateTiledBoxVertexData instead
+     */
+    static CreateTiledBox(options: any): void;
+    /**
+     * Creates the VertexData for a tiled plane
+     * @param options 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)
+     * @param options.pattern
+     * @param options.tileSize
+     * @param options.tileWidth
+     * @param options.tileHeight
+     * @param options.size
+     * @param options.width
+     * @param options.height
+     * @param options.alignHorizontal
+     * @param options.alignVertical
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the tiled plane
+     * @deprecated use CreateTiledPlaneVertexData instead
+     */
+    static CreateTiledPlane(options: any): void;
+    /**
+     * Creates the VertexData for an ellipsoid, defaults to a sphere
+     * @param options 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)
+     * @param options.segments
+     * @param options.diameter
+     * @param options.diameterX
+     * @param options.diameterY
+     * @param options.diameterZ
+     * @param options.arc
+     * @param options.slice
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the ellipsoid
+     * @deprecated use CreateSphereVertexData instead
+     */
+    static CreateSphere(options: any): void;
+    /**
+     * Creates the VertexData for a cylinder, cone or prism
+     * @param options 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)
+     * @param options.height
+     * @param options.diameterTop
+     * @param options.diameterBottom
+     * @param options.diameter
+     * @param options.tessellation
+     * @param options.subdivisions
+     * @param options.arc
+     * @param options.faceColors
+     * @param options.faceUV
+     * @param options.hasRings
+     * @param options.enclose
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the cylinder, cone or prism
+     * @deprecated please use CreateCylinderVertexData instead
+     */
+    static CreateCylinder(options: any): void;
+    /**
+     * Creates the VertexData for a torus
+     * @param options 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)
+     * @param options.diameter
+     * @param options.thickness
+     * @param options.tessellation
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the torus
+     * @deprecated use CreateTorusVertexData instead
+     */
+    static CreateTorus(options: any): void;
+    /**
+     * Creates the VertexData of the LineSystem
+     * @param options 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
+     * @param options.lines
+     * @param options.colors
+     * @returns the VertexData of the LineSystem
+     * @deprecated use CreateLineSystemVertexData instead
+     */
+    static CreateLineSystem(options: any): void;
+    /**
+     * Create the VertexData for a DashedLines
+     * @param options 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
+     * @param options.points
+     * @param options.dashSize
+     * @param options.gapSize
+     * @param options.dashNb
+     * @returns the VertexData for the DashedLines
+     * @deprecated use CreateDashedLinesVertexData instead
+     */
+    static CreateDashedLines(options: any): void;
+    /**
+     * Creates the VertexData for a Ground
+     * @param options 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
+     * @param options.width
+     * @param options.height
+     * @param options.subdivisions
+     * @param options.subdivisionsX
+     * @param options.subdivisionsY
+     * @returns the VertexData of the Ground
+     * @deprecated Please use CreateGroundVertexData instead
+     */
+    static CreateGround(options: any): void;
+    /**
+     * Creates the VertexData for a TiledGround by subdividing the ground into tiles
+     * @param options 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}
+     * @param options.xmin
+     * @param options.zmin
+     * @param options.xmax
+     * @param options.zmax
+     * @param options.subdivisions
+     * @param options.subdivisions.w
+     * @param options.subdivisions.h
+     * @param options.precision
+     * @param options.precision.w
+     * @param options.precision.h
+     * @returns the VertexData of the TiledGround
+     * @deprecated use CreateTiledGroundVertexData instead
+     */
+    static CreateTiledGround(options: any): void;
+    /**
+     * Creates the VertexData of the Ground designed from a heightmap
+     * @param options 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)
+     * @param options.width
+     * @param options.height
+     * @param options.subdivisions
+     * @param options.minHeight
+     * @param options.maxHeight
+     * @param options.colorFilter
+     * @param options.buffer
+     * @param options.bufferWidth
+     * @param options.bufferHeight
+     * @param options.alphaFilter
+     * @returns the VertexData of the Ground designed from a heightmap
+     * @deprecated use CreateGroundFromHeightMapVertexData instead
+     */
+    static CreateGroundFromHeightMap(options: any): void;
+    /**
+     * Creates the VertexData for a Plane
+     * @param options 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)
+     * @param options.size
+     * @param options.width
+     * @param options.height
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the box
+     * @deprecated use CreatePlaneVertexData instead
+     */
+    static CreatePlane(options: any): void;
+    /**
+     * Creates the VertexData of the Disc or regular Polygon
+     * @param options 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)
+     * @param options.radius
+     * @param options.tessellation
+     * @param options.arc
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the box
+     * @deprecated use CreateDiscVertexData instead
+     */
+    static CreateDisc(options: any): void;
+    /**
+     * 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
+     * @param polygon a mesh built from polygonTriangulation.build()
+     * @param sideOrientation takes the values Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+     * @param fUV an array of Vector4 elements used to set different images to the top, rings and bottom respectively
+     * @param fColors an array of Color3 elements used to set different colors to the top, rings and bottom respectively
+     * @param 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)
+     * @param 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)
+     * @param wrap a boolean, default false, when true and fUVs used texture is wrapped around all sides, when false texture is applied side
+     * @returns the VertexData of the Polygon
+     * @deprecated use CreatePolygonVertexData instead
+     */
+    static CreatePolygon(polygon: any, sideOrientation: any, fUV: any, fColors: any, frontUVs: any, backUVs: any, wrap: any): void;
+    /**
+     * Creates the VertexData of the IcoSphere
+     * @param options 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)
+     * @param options.radius
+     * @param options.radiusX
+     * @param options.radiusY
+     * @param options.radiusZ
+     * @param options.flat
+     * @param options.subdivisions
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the IcoSphere
+     * @deprecated use CreateIcoSphereVertexData instead
+     */
+    static CreateIcoSphere(options: any): void;
+    /**
+     * Creates the VertexData for a Polyhedron
+     * @param options 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)
+     * @param options.type
+     * @param options.size
+     * @param options.sizeX
+     * @param options.sizeY
+     * @param options.sizeZ
+     * @param options.custom
+     * @param options.faceUV
+     * @param options.faceColors
+     * @param options.flat
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the Polyhedron
+     * @deprecated use CreatePolyhedronVertexData instead
+     */
+    static CreatePolyhedron(options: any): void;
+    /**
+     * Creates the VertexData for a Capsule, inspired from https://github.com/maximeq/three-js-capsule-geometry/blob/master/src/CapsuleBufferGeometry.js
+     * @param options an object used to set the following optional parameters for the capsule, required but can be empty
+     * @returns the VertexData of the Capsule
+     * @deprecated Please use CreateCapsuleVertexData from the capsuleBuilder file instead
+     */
+    static CreateCapsule(options?: {
+        orientation: Vector3;
+        subdivisions: number;
+        tessellation: number;
+        height: number;
+        radius: number;
+        capSubdivisions: number;
+    }): void;
+    /**
+     * Creates the VertexData for a TorusKnot
+     * @param options 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)
+     * @param options.radius
+     * @param options.tube
+     * @param options.radialSegments
+     * @param options.tubularSegments
+     * @param options.p
+     * @param options.q
+     * @param options.sideOrientation
+     * @param options.frontUVs
+     * @param options.backUVs
+     * @returns the VertexData of the Torus Knot
+     * @deprecated use CreateTorusKnotVertexData instead
+     */
+    static CreateTorusKnot(options: any): void;
+    /**
+     * Compute normals for given positions and indices
+     * @param positions an array of vertex positions, [...., x, y, z, ......]
+     * @param indices an array of indices in groups of three for each triangular facet, [...., i, j, k, ......]
+     * @param normals an array of vertex normals, [...., x, y, z, ......]
+     * @param options 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
+     * @param options.facetNormals
+     * @param options.facetPositions
+     * @param options.facetPartitioning
+     * @param options.ratio
+     * @param options.bInfo
+     * @param options.bbSize
+     * @param options.subDiv
+     * @param options.useRightHandedSystem
+     * @param options.depthSort
+     * @param options.distanceTo
+     * @param options.depthSortedFacets
+     */
+    static ComputeNormals(positions: any, indices: any, normals: any, options: any): void;
+    /**
+     * @internal
+     */
+    static _ComputeSides(sideOrientation: any, positions: any, indices: any, normals: any, uvs: any, frontUVs: any, backUVs: any): void;
+    /**
+     * Applies VertexData created from the imported parameters to the geometry
+     * @param parsedVertexData the parsed data from an imported file
+     * @param geometry the geometry to apply the VertexData to
+     */
+    static ImportVertexData(parsedVertexData: any, geometry: any): void;
+    _applyTo: (meshOrGeometry?: any, updatable?: boolean | undefined, isAsync?: any) => VertexData;
+    /**
+     * Uses the passed data array to set the set the values for the specified kind of data
+     * @param data a linear array of floating numbers
+     * @param kind the type of data that is being set, eg positions, colors etc
+     */
+    set(data: any, kind: any): void;
+    positions: any;
+    normals: any;
+    tangents: any;
+    uvs: any;
+    uvs2: any;
+    uvs3: any;
+    uvs4: any;
+    uvs5: any;
+    uvs6: any;
+    colors: any;
+    matricesIndices: any;
+    matricesWeights: any;
+    matricesIndicesExtra: any;
+    matricesWeightsExtra: any;
+    /**
+     * Associates the vertexData to the passed Mesh.
+     * Sets it as updatable or not (default `false`)
+     * @param mesh the mesh the vertexData is applied to
+     * @param updatable when used and having the value true allows new data to update the vertexData
+     * @returns the VertexData
+     */
+    applyToMesh(mesh: any, updatable: any): VertexData;
+    /**
+     * Associates the vertexData to the passed Geometry.
+     * Sets it as updatable or not (default `false`)
+     * @param geometry the geometry the vertexData is applied to
+     * @param updatable when used and having the value true allows new data to update the vertexData
+     * @returns VertexData
+     */
+    applyToGeometry(geometry: any, updatable: any): VertexData;
+    /**
+     * Updates the associated mesh
+     * @param mesh the mesh to be updated
+     * @returns VertexData
+     */
+    updateMesh(mesh: any): VertexData;
+    /**
+     * Updates the associated geometry
+     * @param geometry the geometry to be updated
+     * @returns VertexData.
+     */
+    updateGeometry(geometry: any): VertexData;
+    /**
+     * @internal
+     */
+    _applyToCoroutine(meshOrGeometry: any, updatable: boolean | undefined, isAsync: any): Generator<undefined, VertexData, unknown>;
+    _update(meshOrGeometry: any, updateExtends: any, makeItUnique: any): VertexData;
+    /**
+     * Transforms each position and each normal of the vertexData according to the passed Matrix
+     * @param matrix the transforming matrix
+     * @returns the VertexData
+     */
+    transform(matrix: any): VertexData;
+    /**
+     * Merges the passed VertexData into the current one
+     * @param others the VertexData to be merged into the current one
+     * @param use32BitsIndices defines a boolean indicating if indices must be store in a 32 bits array
+     * @param forceCloneIndices defines a boolean indicating if indices are forced to be cloned
+     * @returns the modified VertexData
+     */
+    merge(others: any, use32BitsIndices?: boolean, forceCloneIndices?: boolean): VertexData;
+    /**
+     * @internal
+     */
+    _mergeCoroutine(transform: any, vertexDatas: any, use32BitsIndices: boolean | undefined, isAsync: any, forceCloneIndices: any): Generator<undefined, VertexData, unknown>;
+    indices: any;
+    _validate(): void;
+    /**
+     * Serializes the VertexData
+     * @returns a serialized object
+     */
+    serialize(): {
+        positions: any;
+        normals: any;
+        tangents: any;
+        uvs: any;
+        uvs2: any;
+        uvs3: any;
+        uvs4: any;
+        uvs5: any;
+        uvs6: any;
+        colors: any;
+        matricesIndices: any;
+        matricesWeights: any;
+        matricesIndicesExtra: any;
+        matricesWeightsExtra: any;
+        indices: any;
+    };
+}
+export namespace VertexData {
+    const FRONTSIDE: number;
+    const BACKSIDE: number;
+    const DOUBLESIDE: number;
+    const DEFAULTSIDE: number;
+}
+import { Vector3 } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/meshBuilder.d.ts

@@ -0,0 +1,58 @@
+export namespace MeshBuilder {
+    export { CreateBox };
+    export { CreateTiledBox };
+    export { CreateSphere };
+    export { CreateDisc };
+    export { CreateIcoSphere };
+    export { CreateRibbon };
+    export { CreateCylinder };
+    export { CreateTorus };
+    export { CreateTorusKnot };
+    export { CreateLineSystem };
+    export { CreateLines };
+    export { CreateDashedLines };
+    export { ExtrudeShape };
+    export { ExtrudeShapeCustom };
+    export { CreateLathe };
+    export { CreateTiledPlane };
+    export { CreatePlane };
+    export { CreateGround };
+    export { CreateTiledGround };
+    export { CreateGroundFromHeightMap };
+    export { CreatePolygon };
+    export { ExtrudePolygon };
+    export { CreateTube };
+    export { CreatePolyhedron };
+    export { CreateGeodesic };
+    export { CreateGoldberg };
+    export { CreateDecal };
+    export { CreateCapsule };
+}
+import { CreateBox } from "./Builders/boxBuilder.js";
+import { CreateTiledBox } from "./Builders/tiledBoxBuilder.js";
+import { CreateSphere } from "./Builders/sphereBuilder.js";
+import { CreateDisc } from "./Builders/discBuilder.js";
+import { CreateIcoSphere } from "./Builders/icoSphereBuilder.js";
+import { CreateRibbon } from "./Builders/ribbonBuilder.js";
+import { CreateCylinder } from "./Builders/cylinderBuilder.js";
+import { CreateTorus } from "./Builders/torusBuilder.js";
+import { CreateTorusKnot } from "./Builders/torusKnotBuilder.js";
+import { CreateLineSystem } from "./Builders/linesBuilder.js";
+import { CreateLines } from "./Builders/linesBuilder.js";
+import { CreateDashedLines } from "./Builders/linesBuilder.js";
+import { ExtrudeShape } from "./Builders/shapeBuilder.js";
+import { ExtrudeShapeCustom } from "./Builders/shapeBuilder.js";
+import { CreateLathe } from "./Builders/latheBuilder.js";
+import { CreateTiledPlane } from "./Builders/tiledPlaneBuilder.js";
+import { CreatePlane } from "./Builders/planeBuilder.js";
+import { CreateGround } from "./Builders/groundBuilder.js";
+import { CreateTiledGround } from "./Builders/groundBuilder.js";
+import { CreateGroundFromHeightMap } from "./Builders/groundBuilder.js";
+import { CreatePolygon } from "./Builders/polygonBuilder.js";
+import { ExtrudePolygon } from "./Builders/polygonBuilder.js";
+import { CreateTube } from "./Builders/tubeBuilder.js";
+import { CreatePolyhedron } from "./Builders/polyhedronBuilder.js";
+import { CreateGeodesic } from "./Builders/geodesicBuilder.js";
+import { CreateGoldberg } from "./Builders/goldbergBuilder.js";
+import { CreateDecal } from "./Builders/decalBuilder.js";
+import { CreateCapsule } from "./Builders/capsuleBuilder.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/meshLODLevel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Class used to represent a specific level of detail of a mesh
+ * @see https://doc.babylonjs.com/how_to/how_to_use_lod
+ */
+export class MeshLODLevel {
+    /**
+     * Creates a new LOD level
+     * @param distanceOrScreenCoverage defines either the distance or the screen coverage where this level should start being displayed
+     * @param mesh defines the mesh to use to render this level
+     */
+    constructor(distanceOrScreenCoverage: any, mesh: any);
+    distanceOrScreenCoverage: any;
+    mesh: any;
+}