@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,142 @@
+/**
+ * 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
+ */
+export function CreateGroundVertexData(options: any): VertexData;
+/**
+ * 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
+ */
+export function CreateTiledGroundVertexData(options: any): VertexData;
+/**
+ * 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
+ */
+export function CreateGroundFromHeightMapVertexData(options: any): VertexData;
+/**
+ * Creates a ground mesh
+ * * The parameters `width` and `height` (floats, default 1) set the width and height sizes of the ground
+ * * The parameter `subdivisions` (positive integer) sets the number of subdivisions per side
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.width
+ * @param options.height
+ * @param options.subdivisions
+ * @param options.subdivisionsX
+ * @param options.subdivisionsY
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the ground mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#ground
+ */
+export function CreateGround(name: any, options: {} | undefined, scene: any): GroundMesh;
+/**
+ * Creates a tiled ground mesh
+ * * The parameters `xmin` and `xmax` (floats, default -1 and 1) set the ground minimum and maximum X coordinates
+ * * The parameters `zmin` and `zmax` (floats, default -1 and 1) set the ground minimum and maximum Z coordinates
+ * * The parameter `subdivisions` is a javascript 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
+ * * The parameter `precision` is a javascript 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
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created.
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @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
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the tiled ground mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#tiled-ground
+ */
+export function CreateTiledGround(name: any, options: any, scene?: null): Mesh;
+/**
+ * Creates a ground mesh from a height map
+ * * The parameter `url` sets the URL of the height map image resource.
+ * * The parameters `width` and `height` (positive floats, default 10) set the ground width and height sizes.
+ * * The parameter `subdivisions` (positive integer, default 1) sets the number of subdivision per side.
+ * * The parameter `minHeight` (float, default 0) is the minimum altitude on the ground.
+ * * The parameter `maxHeight` (float, default 1) is the maximum altitude on the ground.
+ * * The parameter `colorFilter` (optional Color3, default (0.3, 0.59, 0.11) ) is the filter to apply to the image pixel colors to compute the height.
+ * * The parameter `onReady` is a javascript callback function that will be called  once the mesh is just built (the height map download can last some time).
+ * * The parameter `alphaFilter` will filter any data where the alpha channel is below this value, defaults 0 (all data visible)
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created.
+ * @param name defines the name of the mesh
+ * @param url defines the url to the height map
+ * @param options defines the options used to create the mesh
+ * @param options.width
+ * @param options.height
+ * @param options.subdivisions
+ * @param options.minHeight
+ * @param options.maxHeight
+ * @param options.colorFilter
+ * @param options.alphaFilter
+ * @param options.updatable
+ * @param options.onReady
+ * @param scene defines the hosting scene
+ * @returns the ground mesh
+ * @see https://doc.babylonjs.com/babylon101/height_map
+ * @see https://doc.babylonjs.com/how_to/set_shapes#ground-from-a-height-map
+ */
+export function CreateGroundFromHeightMap(name: any, url: any, options?: {}, scene?: null): GroundMesh;
+export namespace GroundBuilder {
+    export { CreateGround };
+    export { CreateGroundFromHeightMap };
+    export { CreateTiledGround };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { GroundMesh } from "../groundMesh.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,15 @@
+/**
+ * Creates a hemisphere mesh
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.segments
+ * @param options.diameter
+ * @param options.sideOrientation
+ * @param scene defines the hosting scene
+ * @returns the hemisphere mesh
+ */
+export function CreateHemisphere(name: any, options: {} | undefined, scene: any): import("@babylonjs/core").Nullable<Mesh>;
+export namespace HemisphereBuilder {
+    export { CreateHemisphere };
+}
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,55 @@
+/**
+ * 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
+ */
+export function CreateIcoSphereVertexData(options: any): VertexData;
+/**
+ * Creates a sphere based upon an icosahedron with 20 triangular faces which can be subdivided
+ * * The parameter `radius` sets the radius size (float) of the icosphere (default 1)
+ * * You can set some different icosphere dimensions, for instance to build an ellipsoid, by using the parameters `radiusX`, `radiusY` and `radiusZ` (all by default have the same value of `radius`)
+ * * The parameter `subdivisions` sets the number of subdivisions (positive integer, default 4). The more subdivisions, the more faces on the icosphere whatever its size
+ * * The parameter `flat` (boolean, default true) gives each side its own normals. Set it to false to get a smooth continuous light reflection on the surface
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @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
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the icosahedron mesh
+ * @see https://doc.babylonjs.com/how_to/polyhedra_shapes#icosphere
+ */
+export function CreateIcoSphere(name: any, options?: {}, scene?: null): Mesh;
+export namespace IcoSphereBuilder {
+    export { CreateIcoSphere };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,23 @@
+export * from "./boxBuilder.js";
+export * from "./tiledBoxBuilder.js";
+export * from "./discBuilder.js";
+export * from "./ribbonBuilder.js";
+export * from "./sphereBuilder.js";
+export * from "./hemisphereBuilder.js";
+export * from "./cylinderBuilder.js";
+export * from "./torusBuilder.js";
+export * from "./torusKnotBuilder.js";
+export * from "./linesBuilder.js";
+export * from "./polygonBuilder.js";
+export * from "./shapeBuilder.js";
+export * from "./latheBuilder.js";
+export * from "./planeBuilder.js";
+export * from "./tiledPlaneBuilder.js";
+export * from "./groundBuilder.js";
+export * from "./tubeBuilder.js";
+export * from "./polyhedronBuilder.js";
+export * from "./geodesicBuilder.js";
+export * from "./goldbergBuilder.js";
+export * from "./decalBuilder.js";
+export * from "./icoSphereBuilder.js";
+export * from "./capsuleBuilder.js";

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

@@ -0,0 +1,37 @@
+/**
+ * Creates lathe mesh.
+ * The lathe is a shape with a symmetry axis : a 2D model shape is rotated around this axis to design the lathe
+ * * The parameter `shape` 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
+ * * The parameter `radius` (positive float, default 1) is the radius value of the lathe
+ * * The parameter `tessellation` (positive integer, default 64) is the side number of the lathe
+ * * The parameter `clip` (positive integer, default 0) is the number of sides to not create without effecting the general shape of the sides
+ * * The parameter `arc` (positive float, default 1) is the ratio of the lathe. 0.5 builds for instance half a lathe, so an opened shape
+ * * The parameter `closed` (boolean, default true) opens/closes the lathe circumference. This should be set to false when used with the parameter "arc"
+ * * The parameter `cap` sets the way the extruded shape is capped. Possible values : BABYLON.Mesh.NO_CAP (default), BABYLON.Mesh.CAP_START, BABYLON.Mesh.CAP_END, BABYLON.Mesh.CAP_ALL
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The optional parameter `invertUV` (boolean, default false) swaps in the geometry the U and V coordinates to apply a texture
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.shape
+ * @param options.radius
+ * @param options.tessellation
+ * @param options.clip
+ * @param options.arc
+ * @param options.closed
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.cap
+ * @param options.invertUV
+ * @param scene defines the hosting scene
+ * @returns the lathe mesh
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#lathe
+ */
+export function CreateLathe(name: any, options: any, scene?: null): Mesh;
+export namespace LatheBuilder {
+    export { CreateLathe };
+}
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,107 @@
+/**
+ * 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
+ */
+export function CreateLineSystemVertexData(options: any): VertexData;
+/**
+ * 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
+ */
+export function CreateDashedLinesVertexData(options: any): VertexData;
+/**
+ * Creates a line system mesh. A line system is a pool of many lines gathered in a single mesh
+ * * A line system mesh is considered as a parametric shape since it has no predefined original shape. Its shape is determined by the passed array of lines as an input parameter
+ * * Like every other parametric shape, it is dynamically updatable by passing an existing instance of LineSystem to this static function
+ * * The parameter `lines` is an array of lines, each line being an array of successive Vector3
+ * * The optional parameter `instance` is an instance of an existing LineSystem object to be updated with the passed `lines` parameter
+ * * The optional parameter `colors` is an array of line colors, each line colors being an array of successive Color4, one per line point
+ * * The optional parameter `useVertexAlpha` is to be set to `false` (default `true`) when you don't need the alpha blending (faster)
+ * * The optional parameter `material` is the material to use to draw the lines if provided. If not, a default material will be created
+ * * Updating a simple Line mesh, you just need to update every line in the `lines` array : https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh#lines-and-dashedlines
+ * * When updating an instance, remember that only line point positions can change, not the number of points, neither the number of lines
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#line-system
+ * @param name defines the name of the new line system
+ * @param options defines the options used to create the line system
+ * @param options.lines
+ * @param options.updatable
+ * @param options.instance
+ * @param options.colors
+ * @param options.useVertexAlpha
+ * @param options.material
+ * @param scene defines the hosting scene
+ * @returns a new line system mesh
+ */
+export function CreateLineSystem(name: any, options: any, scene: any): any;
+/**
+ * Creates a line mesh
+ * A line mesh is considered as a parametric shape since it has no predefined original shape. Its shape is determined by the passed array of points as an input parameter
+ * * Like every other parametric shape, it is dynamically updatable by passing an existing instance of LineMesh to this static function
+ * * The parameter `points` is an array successive Vector3
+ * * The optional parameter `instance` 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
+ * * The optional parameter `colors` is an array of successive Color4, one per line point
+ * * The optional parameter `useVertexAlpha` is to be set to `false` (default `true`) when you don't need alpha blending (faster)
+ * * The optional parameter `material` is the material to use to draw the lines if provided. If not, a default material will be created
+ * * When updating an instance, remember that only point positions can change, not the number of points
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#lines
+ * @param name defines the name of the new line system
+ * @param options defines the options used to create the line system
+ * @param options.points
+ * @param options.updatable
+ * @param options.instance
+ * @param options.colors
+ * @param options.useVertexAlpha
+ * @param options.material
+ * @param scene defines the hosting scene
+ * @returns a new line mesh
+ */
+export function CreateLines(name: any, options: any, scene?: null): any;
+/**
+ * Creates a dashed line mesh
+ * * A dashed line mesh is considered as a parametric shape since it has no predefined original shape. Its shape is determined by the passed array of points as an input parameter
+ * * Like every other parametric shape, it is dynamically updatable by passing an existing instance of LineMesh to this static function
+ * * The parameter `points` is an array successive Vector3
+ * * The parameter `dashNb` is the intended total number of dashes (positive integer, default 200)
+ * * The parameter `dashSize` is the size of the dashes relatively the dash number (positive float, default 3)
+ * * The parameter `gapSize` is the size of the gap between two successive dashes relatively the dash number (positive float, default 1)
+ * * The optional parameter `instance` 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
+ * * The optional parameter `useVertexAlpha` is to be set to `false` (default `true`) when you don't need the alpha blending (faster)
+ * * The optional parameter `material` is the material to use to draw the lines if provided. If not, a default material will be created
+ * * When updating an instance, remember that only point positions can change, not the number of points
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.points
+ * @param options.dashSize
+ * @param options.gapSize
+ * @param options.dashNb
+ * @param options.updatable
+ * @param options.instance
+ * @param options.useVertexAlpha
+ * @param options.material
+ * @param scene defines the hosting scene
+ * @returns the dashed line mesh
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#dashed-lines
+ */
+export function CreateDashedLines(name: any, options: any, scene?: null): any;
+export namespace LinesBuilder {
+    export { CreateDashedLines };
+    export { CreateLineSystem };
+    export { CreateLines };
+}
+import { VertexData } from "../mesh.vertexData.js";

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

@@ -0,0 +1,46 @@
+/**
+ * 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
+ */
+export function CreatePlaneVertexData(options: any): VertexData;
+/**
+ * Creates a plane mesh
+ * * The parameter `size` sets the size (float) of both sides of the plane at once (default 1)
+ * * You can set some different plane dimensions by using the parameters `width` and `height` (both by default have the same value of `size`)
+ * * The parameter `sourcePlane` is a Plane instance. It builds a mesh plane from a Math plane
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.size
+ * @param options.width
+ * @param options.height
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.updatable
+ * @param options.sourcePlane
+ * @param scene defines the hosting scene
+ * @returns the plane mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#plane
+ */
+export function CreatePlane(name: any, options?: {}, scene?: null): Mesh;
+export namespace PlaneBuilder {
+    export { CreatePlane };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,66 @@
+/**
+ * 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 wrp 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
+ */
+export function CreatePolygonVertexData(polygon: any, sideOrientation: any, fUV: any, fColors: any, frontUVs: any, backUVs: any, wrp: any): VertexData;
+/**
+ * Creates a polygon mesh
+ * 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
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4)
+ * * Remember you can only change the shape positions, not their number when updating a polygon
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.shape
+ * @param options.holes
+ * @param options.depth
+ * @param options.smoothingThreshold
+ * @param options.faceUV
+ * @param options.faceColors
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.wrap
+ * @param scene defines the hosting scene
+ * @param earcutInjection can be used to inject your own earcut reference
+ * @returns the polygon mesh
+ */
+export function CreatePolygon(name: any, options: any, scene?: null, earcutInjection?: any): Mesh;
+/**
+ * Creates an extruded polygon mesh, with depth in the Y direction.
+ * * You can set different colors and different images to the top, bottom and extruded side by using the parameters `faceColors` (an array of 3 Color3 elements) and `faceUV` (an array of 3 Vector4 elements)
+ * @see https://doc.babylonjs.com/how_to/createbox_per_face_textures_and_colors
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.shape
+ * @param options.holes
+ * @param options.depth
+ * @param options.faceUV
+ * @param options.faceColors
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.wrap
+ * @param scene defines the hosting scene
+ * @param earcutInjection can be used to inject your own earcut reference
+ * @returns the polygon mesh
+ */
+export function ExtrudePolygon(name: any, options: any, scene?: null, earcutInjection?: any): Mesh;
+export namespace PolygonBuilder {
+    export { ExtrudePolygon };
+    export { CreatePolygon };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,71 @@
+/**
+ * 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
+ */
+export function CreatePolyhedronVertexData(options: any): VertexData;
+/**
+ * Creates a polyhedron mesh
+ * * The parameter `type` (positive integer, max 14, default 0) sets the polyhedron type to build among the 15 embbeded types. Please refer to the type sheet in the tutorial to choose the wanted type
+ * * The parameter `size` (positive float, default 1) sets the polygon size
+ * * You can overwrite the `size` on each dimension bu using the parameters `sizeX`, `sizeY` or `sizeZ` (positive floats, default to `size` value)
+ * * You can build other polyhedron types than the 15 embbeded ones by setting the parameter `custom` (`polyhedronObject`, default null). If you set the parameter `custom`, this overrides the parameter `type`
+ * * A `polyhedronObject` is a formatted javascript object. You'll find a full file with pre-set polyhedra here : https://github.com/BabylonJS/Extensions/tree/master/Polyhedron
+ * * You can set the color and the UV of each side of the polyhedron with the parameters `faceColors` (Color4, default `(1, 1, 1, 1)`) and faceUV (Vector4, default `(0, 0, 1, 1)`)
+ * * To understand how to set `faceUV` or `faceColors`, please read this by considering the right number of faces of your polyhedron, instead of only 6 for the box : https://doc.babylonjs.com/how_to/createbox_per_face_textures_and_colors
+ * * The parameter `flat` (boolean, default true). If set to false, it gives the polyhedron a single global face, so less vertices and shared normals. In this case, `faceColors` and `faceUV` are ignored
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @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.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param scene defines the hosting scene
+ * @returns the polyhedron mesh
+ * @see https://doc.babylonjs.com/how_to/polyhedra_shapes
+ */
+export function CreatePolyhedron(name: any, options?: {}, scene?: null): Mesh;
+export namespace PolyhedronBuilder {
+    export { CreatePolyhedron };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,66 @@
+/**
+ * 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
+ */
+export function CreateRibbonVertexData(options: any): VertexData;
+/**
+ * Creates a ribbon mesh. The ribbon is a parametric shape.  It has no predefined shape. Its final shape will depend on the input parameters
+ * * The parameter `pathArray` is a required array of paths, what are each an array of successive Vector3. The pathArray parameter depicts the ribbon geometry
+ * * The parameter `closeArray` (boolean, default false) creates a seam between the first and the last paths of the path array
+ * * The parameter `closePath` (boolean, default false) creates a seam between the first and the last points of each path of the path array
+ * * The parameter `offset` (positive integer, default : rounded half size of the pathArray length), is taken in account only if the `pathArray` is containing a single path
+ * * It's the offset to join the points from the same path. Ex : offset = 10 means the point 1 is joined to the point 11
+ * * The optional parameter `instance` is 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
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The optional parameter `invertUV` (boolean, default false) swaps in the geometry the U and V coordinates to apply a texture
+ * * The parameter `uvs` is an optional flat array of `Vector2` to update/set each ribbon vertex with its own custom UV values instead of the computed ones
+ * * The parameters `colors` is an optional flat array of `Color4` to set/update each ribbon vertex with its own custom color values
+ * * Note that if you use the parameters `uvs` or `colors`, the passed arrays must be populated with the right number of elements, it is to say the number of ribbon vertices. Remember that if you set `closePath` to `true`, there's one extra vertex per path in the geometry
+ * * Moreover, you can use the parameter `color` with `instance` (to update the ribbon), only if you previously used it at creation time
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.pathArray
+ * @param options.closeArray
+ * @param options.closePath
+ * @param options.offset
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.instance
+ * @param options.invertUV
+ * @param options.uvs
+ * @param options.colors
+ * @param scene defines the hosting scene
+ * @returns the ribbon mesh
+ * @see https://doc.babylonjs.com/how_to/ribbon_tutorial
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes
+ */
+export function CreateRibbon(name: any, options: any, scene?: null): any;
+export namespace RibbonBuilder {
+    export { CreateRibbon };
+}
+import { VertexData } from "../mesh.vertexData.js";