@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Maths/math.vertexFormat.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Contains position and normal vectors for a vertex
+ */
+export class PositionNormalVertex {
+    /**
+     * Creates a PositionNormalVertex
+     * @param position the position of the vertex (defaut: 0,0,0)
+     * @param normal the normal of the vertex (defaut: 0,1,0)
+     */
+    constructor(position?: Vector3, normal?: Vector3);
+    position: Vector3;
+    normal: Vector3;
+    /**
+     * Clones the PositionNormalVertex
+     * @returns the cloned PositionNormalVertex
+     */
+    clone(): PositionNormalVertex;
+}
+/**
+ * Contains position, normal and uv vectors for a vertex
+ */
+export class PositionNormalTextureVertex {
+    /**
+     * Creates a PositionNormalTextureVertex
+     * @param position the position of the vertex (defaut: 0,0,0)
+     * @param normal the normal of the vertex (defaut: 0,1,0)
+     * @param uv the uv of the vertex (default: 0,0)
+     */
+    constructor(position?: Vector3, normal?: Vector3, uv?: Vector2);
+    position: Vector3;
+    normal: Vector3;
+    uv: Vector2;
+    /**
+     * Clones the PositionNormalTextureVertex
+     * @returns the cloned PositionNormalTextureVertex
+     */
+    clone(): PositionNormalTextureVertex;
+}
+import { Vector3 } from "./math.vector.js";
+import { Vector2 } from "./math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Maths/math.viewport.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Class used to represent a viewport on screen
+ */
+export class Viewport {
+    /**
+     * Creates a Viewport object located at (x, y) and sized (width, height)
+     * @param x defines viewport left coordinate
+     * @param y defines viewport top coordinate
+     * @param width defines the viewport width
+     * @param height defines the viewport height
+     */
+    constructor(x: any, y: any, width: any, height: any);
+    x: any;
+    y: any;
+    width: any;
+    height: any;
+    /**
+     * Creates a new viewport using absolute sizing (from 0-> width, 0-> height instead of 0->1)
+     * @param renderWidth defines the rendering width
+     * @param renderHeight defines the rendering height
+     * @returns a new Viewport
+     */
+    toGlobal(renderWidth: any, renderHeight: any): Viewport;
+    /**
+     * Stores absolute viewport value into a target viewport (from 0-> width, 0-> height instead of 0->1)
+     * @param renderWidth defines the rendering width
+     * @param renderHeight defines the rendering height
+     * @param ref defines the target viewport
+     * @returns the current viewport
+     */
+    toGlobalToRef(renderWidth: any, renderHeight: any, ref: any): Viewport;
+    /**
+     * Returns a new Viewport copied from the current one
+     * @returns a new Viewport
+     */
+    clone(): Viewport;
+}

package/dist/types/node_modules/@babylonjs/core/Maths/sphericalPolynomial.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Class representing spherical harmonics coefficients to the 3rd degree
+ */
+export class SphericalHarmonics {
+    /**
+     * Constructs a spherical harmonics from an array.
+     * @param data defines the 9x3 coefficients (l00, l1-1, l10, l11, l2-2, l2-1, l20, l21, l22)
+     * @returns the spherical harmonics
+     */
+    static FromArray(data: any): SphericalHarmonics;
+    /**
+     * Gets the spherical harmonics from polynomial
+     * @param polynomial the spherical polynomial
+     * @returns the spherical harmonics
+     */
+    static FromPolynomial(polynomial: any): SphericalHarmonics;
+    /**
+     * Defines whether or not the harmonics have been prescaled for rendering.
+     */
+    preScaled: boolean;
+    /**
+     * The l0,0 coefficients of the spherical harmonics
+     */
+    l00: Vector3;
+    /**
+     * The l1,-1 coefficients of the spherical harmonics
+     */
+    l1_1: Vector3;
+    /**
+     * The l1,0 coefficients of the spherical harmonics
+     */
+    l10: Vector3;
+    /**
+     * The l1,1 coefficients of the spherical harmonics
+     */
+    l11: Vector3;
+    /**
+     * The l2,-2 coefficients of the spherical harmonics
+     */
+    l2_2: Vector3;
+    /**
+     * The l2,-1 coefficients of the spherical harmonics
+     */
+    l2_1: Vector3;
+    /**
+     * The l2,0 coefficients of the spherical harmonics
+     */
+    l20: Vector3;
+    /**
+     * The l2,1 coefficients of the spherical harmonics
+     */
+    l21: Vector3;
+    /**
+     * The l2,2 coefficients of the spherical harmonics
+     */
+    l22: Vector3;
+    /**
+     * Adds a light to the spherical harmonics
+     * @param direction the direction of the light
+     * @param color the color of the light
+     * @param deltaSolidAngle the delta solid angle of the light
+     */
+    addLight(direction: any, color: any, deltaSolidAngle: any): void;
+    /**
+     * Scales the spherical harmonics by the given amount
+     * @param scale the amount to scale
+     */
+    scaleInPlace(scale: any): void;
+    /**
+     * Convert from incident radiance (Li) to irradiance (E) by applying convolution with the cosine-weighted hemisphere.
+     *
+     * ```
+     * E_lm = A_l * L_lm
+     * ```
+     *
+     * In spherical harmonics this convolution amounts to scaling factors for each frequency band.
+     * This corresponds to equation 5 in "An Efficient Representation for Irradiance Environment Maps", where
+     * the scaling factors are given in equation 9.
+     */
+    convertIncidentRadianceToIrradiance(): void;
+    /**
+     * Convert from irradiance to outgoing radiance for Lambertian BDRF, suitable for efficient shader evaluation.
+     *
+     * ```
+     * L = (1/pi) * E * rho
+     * ```
+     *
+     * This is done by an additional scale by 1/pi, so is a fairly trivial operation but important conceptually.
+     */
+    convertIrradianceToLambertianRadiance(): void;
+    /**
+     * Integrates the reconstruction coefficients directly in to the SH preventing further
+     * required operations at run time.
+     *
+     * This is simply done by scaling back the SH with Ylm constants parameter.
+     * The trigonometric part being applied by the shader at run time.
+     */
+    preScaleForRendering(): void;
+    /**
+     * update the spherical harmonics coefficients from the given array
+     * @param data defines the 9x3 coefficients (l00, l1-1, l10, l11, l2-2, l2-1, l20, l21, l22)
+     * @returns the spherical harmonics (this)
+     */
+    updateFromArray(data: any): SphericalHarmonics;
+    /**
+     * update the spherical harmonics coefficients from the given floats array
+     * @param data defines the 9x3 coefficients (l00, l1-1, l10, l11, l2-2, l2-1, l20, l21, l22)
+     * @returns the spherical harmonics (this)
+     */
+    updateFromFloatsArray(data: any): SphericalHarmonics;
+}
+/**
+ * Class representing spherical polynomial coefficients to the 3rd degree
+ */
+export class SphericalPolynomial {
+    /**
+     * Gets the spherical polynomial from harmonics
+     * @param harmonics the spherical harmonics
+     * @returns the spherical polynomial
+     */
+    static FromHarmonics(harmonics: any): SphericalPolynomial;
+    /**
+     * Constructs a spherical polynomial from an array.
+     * @param data defines the 9x3 coefficients (x, y, z, xx, yy, zz, yz, zx, xy)
+     * @returns the spherical polynomial
+     */
+    static FromArray(data: any): SphericalPolynomial;
+    /**
+     * The x coefficients of the spherical polynomial
+     */
+    x: Vector3;
+    /**
+     * The y coefficients of the spherical polynomial
+     */
+    y: Vector3;
+    /**
+     * The z coefficients of the spherical polynomial
+     */
+    z: Vector3;
+    /**
+     * The xx coefficients of the spherical polynomial
+     */
+    xx: Vector3;
+    /**
+     * The yy coefficients of the spherical polynomial
+     */
+    yy: Vector3;
+    /**
+     * The zz coefficients of the spherical polynomial
+     */
+    zz: Vector3;
+    /**
+     * The xy coefficients of the spherical polynomial
+     */
+    xy: Vector3;
+    /**
+     * The yz coefficients of the spherical polynomial
+     */
+    yz: Vector3;
+    /**
+     * The zx coefficients of the spherical polynomial
+     */
+    zx: Vector3;
+    /**
+     * The spherical harmonics used to create the polynomials.
+     */
+    get preScaledHarmonics(): any;
+    _harmonics: any;
+    /**
+     * Adds an ambient color to the spherical polynomial
+     * @param color the color to add
+     */
+    addAmbient(color: any): void;
+    /**
+     * Scales the spherical polynomial by the given amount
+     * @param scale the amount to scale
+     */
+    scaleInPlace(scale: any): void;
+    /**
+     * Updates the spherical polynomial from harmonics
+     * @param harmonics the spherical harmonics
+     * @returns the spherical polynomial
+     */
+    updateFromHarmonics(harmonics: any): SphericalPolynomial;
+}
+import { Vector3 } from "../Maths/math.vector.js";

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

@@ -0,0 +1,61 @@
+/**
+ * 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
+ * @param options.wrap
+ * @param options.topBaseAt
+ * @param options.bottomBaseAt
+ * @returns the VertexData of the box
+ */
+export function CreateBoxVertexData(options: any): VertexData;
+/**
+ * Creates a box mesh
+ * * The parameter `size` sets the size (float) of each box side (default 1)
+ * * You can set some different box dimensions by using the parameters `width`, `height` and `depth` (all by default have the same value of `size`)
+ * * You can set different colors and different images to each box side by using the parameters `faceColors` (an array of 6 Color3 elements) and `faceUV` (an array of 6 Vector4 elements)
+ * * Please read this tutorial : https://doc.babylonjs.com/how_to/createbox_per_face_textures_and_colors
+ * * 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
+ * @see https://doc.babylonjs.com/how_to/set_shapes#box
+ * @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.depth
+ * @param options.faceUV
+ * @param options.faceColors
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.wrap
+ * @param options.topBaseAt
+ * @param options.bottomBaseAt
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the box mesh
+ */
+export function CreateBox(name: any, options?: {}, scene?: null): Mesh;
+export namespace BoxBuilder {
+    export { CreateBox };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,35 @@
+/**
+ * Scripts based off of https://github.com/maximeq/three-js-capsule-geometry/blob/master/src/CapsuleBufferGeometry.js
+ * @param options the constructors options used to shape the mesh.
+ * @returns the capsule VertexData
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/set/capsule
+ */
+export function CreateCapsuleVertexData(options?: {
+    subdivisions: number;
+    tessellation: number;
+    height: number;
+    radius: number;
+    capSubdivisions: number;
+}): VertexData;
+/**
+ * Creates a capsule or a pill mesh
+ * @param name defines the name of the mesh
+ * @param options The constructors options.
+ * @param scene The scene the mesh is scoped to.
+ * @returns Capsule Mesh
+ */
+export function CreateCapsule(name: any, options?: {
+    orientation: Vector3;
+    subdivisions: number;
+    tessellation: number;
+    height: number;
+    radius: number;
+    capSubdivisions: number;
+    updatable: boolean;
+}, scene?: null): Mesh;
+export namespace CapsuleBuilder {
+    export { CreateCapsule };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Vector3 } from "../../Maths/math.vector.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,85 @@
+/**
+ * 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.cap
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @returns the VertexData of the cylinder, cone or prism
+ */
+export function CreateCylinderVertexData(options: any): VertexData;
+/**
+ * Creates a cylinder or a cone mesh
+ * * The parameter `height` sets the height size (float) of the cylinder/cone (float, default 2).
+ * * The parameter `diameter` sets the diameter of the top and bottom cap at once (float, default 1).
+ * * The parameters `diameterTop` and `diameterBottom` overwrite the parameter `diameter` and set respectively the top cap and bottom cap diameter (floats, default 1). The parameter "diameterBottom" can't be zero.
+ * * The parameter `tessellation` sets the number of cylinder sides (positive integer, default 24). Set it to 3 to get a prism for instance.
+ * * The parameter `subdivisions` sets the number of rings along the cylinder height (positive integer, default 1).
+ * * The parameter `hasRings` (boolean, default false) makes the subdivisions independent from each other, so they become different faces.
+ * * The parameter `enclose`  (boolean, default false) adds two extra faces per subdivision to a sliced cylinder to close it around its height axis.
+ * * The parameter `cap` sets the way the cylinder is capped. Possible values : BABYLON.Mesh.NO_CAP, BABYLON.Mesh.CAP_START, BABYLON.Mesh.CAP_END, BABYLON.Mesh.CAP_ALL (default).
+ * * The parameter `arc` (float, default 1) is the ratio (max 1) to apply to the circumference to slice the cylinder.
+ * * You can set different colors and different images to each box side by using the parameters `faceColors` (an array of n Color3 elements) and `faceUV` (an array of n Vector4 elements).
+ * * The value of n is the number of cylinder faces. If the cylinder has only 1 subdivisions, n equals : top face + cylinder surface + bottom face = 3
+ * * Now, if the cylinder has 5 independent subdivisions (hasRings = true), n equals : top face + 5 stripe surfaces + bottom face = 2 + 5 = 7
+ * * Finally, if the cylinder has 5 independent subdivisions and is enclose, n equals : top face + 5 x (stripe surface + 2 closing faces) + bottom face = 2 + 5 * 3 = 17
+ * * Each array (color or UVs) is always ordered the same way : the first element is the bottom cap, the last element is the top cap. The other elements are each a ring surface.
+ * * If `enclose` is false, a ring surface is one element.
+ * * If `enclose` is true, a ring surface is 3 successive elements in the array : the tubular surface, then the two closing faces.
+ * * Example how to set colors and textures on a sliced cylinder : https://www.html5gamedevs.com/topic/17945-creating-a-closed-slice-of-a-cylinder/#comment-106379
+ * * 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.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.updatable
+ * @param options.hasRings
+ * @param options.enclose
+ * @param options.cap
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param scene defines the hosting scene
+ * @returns the cylinder mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#cylinder-or-cone
+ */
+export function CreateCylinder(name: any, options: {} | undefined, scene: any): Mesh;
+export namespace CylinderBuilder {
+    export { CreateCylinder };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,24 @@
+/**
+ * Creates a decal mesh.
+ * A decal is a mesh usually applied as a model onto the surface of another mesh. So don't forget the parameter `sourceMesh` depicting the decal
+ * * The parameter `position` (Vector3, default `(0, 0, 0)`) sets the position of the decal in World coordinates
+ * * The parameter `normal` (Vector3, default `Vector3.Up`) sets the normal of the mesh where the decal is applied onto in World coordinates
+ * * The parameter `size` (Vector3, default `(1, 1, 1)`) sets the decal scaling
+ * * The parameter `angle` (float in radian, default 0) sets the angle to rotate the decal
+ * * The parameter `captureUVS` defines if we need to capture the uvs or compute them
+ * @param name defines the name of the mesh
+ * @param sourceMesh defines the mesh where the decal must be applied
+ * @param options defines the options used to create the mesh
+ * @param options.position
+ * @param options.normal
+ * @param options.size
+ * @param options.angle
+ * @param options.captureUVS
+ * @returns the decal mesh
+ * @see https://doc.babylonjs.com/how_to/decals
+ */
+export function CreateDecal(name: any, sourceMesh: any, options: any): Mesh;
+export namespace DecalBuilder {
+    export { CreateDecal };
+}
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,45 @@
+/**
+ * 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
+ */
+export function CreateDiscVertexData(options: any): VertexData;
+/**
+ * Creates a plane polygonal mesh.  By default, this is a disc
+ * * The parameter `radius` sets the radius size (float) of the polygon (default 0.5)
+ * * The parameter `tessellation` sets the number of polygon sides (positive integer, default 64). So a tessellation valued to 3 will build a triangle, to 4 a square, etc
+ * * You can create an unclosed polygon with the parameter `arc` (positive float, default 1), valued between 0 and 1, what is the ratio of the circumference : 2 x PI x ratio
+ * * 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.tessellation
+ * @param options.arc
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param scene defines the hosting scene
+ * @returns the plane polygonal mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#disc-or-regular-polygon
+ */
+export function CreateDisc(name: any, options?: {}, scene?: null): Mesh;
+export namespace DiscBuilder {
+    export { CreateDisc };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,36 @@
+/**
+ * Creates the Mesh for a Geodesic Polyhedron
+ * @see https://en.wikipedia.org/wiki/Geodesic_polyhedron
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/polyhedra/geodesic_poly
+ * @param name defines the name of the mesh
+ * @param options an object used to set the following optional parameters for the polyhedron, required but can be empty
+ * * m number of horizontal steps along an isogrid
+ * * n number of angled steps along an isogrid
+ * * size the size of the Geodesic, 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
+ * * 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.n
+ * @param options.size
+ * @param options.sizeX
+ * @param options.sizeY
+ * @param options.sizeZ
+ * @param options.faceUV
+ * @param options.faceColors
+ * @param options.flat
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.m
+ * @param scene defines the hosting scene
+ * @returns Geodesic mesh
+ */
+export function CreateGeodesic(name: any, options: any, scene?: null): import("@babylonjs/core").Mesh;

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

@@ -0,0 +1,19 @@
+/**
+ * Creates the Mesh for a Goldberg Polyhedron
+ * @param options an object used to set the following optional parameters for the polyhedron, required but can be empty
+ * @param goldbergData polyhedronData defining the Goldberg polyhedron
+ * @returns GoldbergSphere mesh
+ */
+export function CreateGoldbergVertexData(options: any, goldbergData: any): VertexData;
+/**
+ * Creates the Mesh for a Goldberg Polyhedron which is made from 12 pentagonal and the rest hexagonal faces
+ * @see https://en.wikipedia.org/wiki/Goldberg_polyhedron
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/polyhedra/goldberg_poly
+ * @param name defines the name of the mesh
+ * @param options an object used to set the following optional parameters for the polyhedron, required but can be empty
+ * @param scene defines the hosting scene
+ * @returns Goldberg mesh
+ */
+export function CreateGoldberg(name: any, options: any, scene?: null): GoldbergMesh;
+import { VertexData } from "../mesh.vertexData.js";
+import { GoldbergMesh } from "../goldbergMesh.js";