import { BabylonMesh } from "./babylon-mesh-inputs"; import type { Base } from "./base-inputs"; /** * Parameters for the engine's own mesh primitives - boxes, spheres, cylinders, planes, tubes, ribbons * and the rest. These build display geometry directly, without going through a CAD kernel, which is * the right choice for scene furniture that never has to be manufactured. */ export declare namespace BabylonMeshBuilder { /** * Feeds `babylon.meshBuilder.createBox`: the three sizes of a box centered on the origin, plus * the side orientation and shadow flag every builder takes. */ class CreateBoxDto { constructor(width?: number, depth?: number, height?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Full size along X, in scene units * @default 1 */ width?: number | undefined; /** * Full size along Z, in scene units * @default 1 */ depth?: number | undefined; /** * Full size along Y, in scene units * @default 1 */ height?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createCube` with the edge length of a cube centered on the origin. */ class CreateCubeDto { constructor(size?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Length of every edge, in scene units * @default 1 */ size?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createSquarePlane` with the side of a flat square in the XY plane. */ class CreateSquarePlaneDto { constructor(size?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Length of each side, in scene units * @default 1 */ size?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createSphere` with the diameter of a sphere centered on the origin * and how finely it is divided. */ class CreateSphereDto { constructor(diameter?: number, segments?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Full width of the sphere, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ diameter?: number | undefined; /** * Number of divisions around and over the sphere; more is rounder and heavier * @default 32 * @minimum 0 * @maximum Infinity * @step 1 */ segments?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createIcoSphere`: the radius of a triangle-based sphere, optional * per-axis radii, flat shading and how often it is subdivided. */ class CreateIcoSphereDto { constructor(radius?: number, radiusX?: number, radiusY?: number, radiusZ?: number, flat?: boolean, subdivisions?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Radius on every axis, in scene units, unless a per-axis radius overrides it * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ radius?: number | undefined; /** * Radius along X, in scene units; 0 falls back to `radius` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ radiusX?: number | undefined; /** * Radius along Y, in scene units; 0 falls back to `radius` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ radiusY?: number | undefined; /** * Radius along Z, in scene units; 0 falls back to `radius` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ radiusZ?: number | undefined; /** * When true, each triangle is shaded flat, showing facets instead of a smooth surface * @default false */ flat?: boolean | undefined; /** * How many times the starting icosahedron is subdivided; more is rounder and heavier * @default 4 * @minimum 0 * @maximum Infinity * @step 1 */ subdivisions?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createDisc`: the radius of a flat disc in the XY plane, how many * sides approximate it and how much of the full circle it covers. */ class CreateDiscDto { constructor(radius?: number, tessellation?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Distance from the center to the rim, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ radius?: number | undefined; /** * Number of straight sides around the rim; more is rounder * @default 32 * @minimum 3 * @maximum Infinity * @step 1 */ tessellation?: number | undefined; /** * How much of the full circle is drawn, from 0 to 1; 0.5 gives a half disc * @default 1 * @minimum 0 * @maximum 1 * @step 0.1 */ arc?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createRibbon`: the paths a surface is stretched over, how they * close and pair up, and whether the mesh can be updated later. */ class CreateRibbonDto { constructor(pathArray?: Base.Vector3[][], closeArray?: boolean, closePath?: boolean, offset?: number, updatable?: boolean, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The paths, each a list of points; neighboring paths are joined with triangles */ pathArray: Base.Vector3[][]; /** * When true, the last path is joined back to the first, closing the surface around * @default false */ closeArray?: boolean | undefined; /** * When true, each path is joined end to start, closing the surface along * @default false */ closePath?: boolean | undefined; /** * When only one path is given, how many points apart the pairs that form triangles are * taken * @default 0 */ offset?: number | undefined; /** * When true, the vertices of the mesh can be changed later without rebuilding it * @default false */ updatable?: boolean | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createTorus`: the overall diameter of a ring in the XZ plane, the * diameter of its tube and how finely it is divided. */ class CreateTorusDto { constructor(diameter?: number, thickness?: number, tessellation?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Full width of the ring, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ diameter?: number | undefined; /** * Diameter of the tube, in scene units * @default 0.5 * @minimum 0 * @maximum Infinity * @step 0.1 */ thickness?: number | undefined; /** * Number of divisions around the ring and the tube; more is rounder * @default 32 * @minimum 3 * @maximum Infinity * @step 1 */ tessellation?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createTorusKnot`: the size of a knotted tube, its segment counts * and the two winding numbers that shape the knot. */ class CreateTorusKnotDto { constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, p?: number, q?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Overall radius of the knot, in scene units * @default 2 * @minimum 0 * @maximum Infinity * @step 0.1 */ radius?: number | undefined; /** * Radius of the tube, in scene units * @default 0.5 * @minimum 0 * @maximum Infinity * @step 0.1 */ tube?: number | undefined; /** * Number of segments along the length of the tube; more is smoother * @default 128 * @minimum 3 * @maximum Infinity * @step 1 */ radialSegments?: number | undefined; /** * Number of segments around the tube; more is rounder * @default 32 * @minimum 3 * @maximum Infinity * @step 1 */ tubularSegments?: number | undefined; /** * How many times the tube winds around the axis of the ring; 2 with `q` 3 gives a trefoil * @default 2 * @minimum 0 * @maximum Infinity * @step 1 */ p?: number | undefined; /** * How many times the tube winds through the hole of the ring; 3 with `p` 2 gives a trefoil * @default 3 * @minimum 0 * @maximum Infinity * @step 1 */ q?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createPolygon`: the outline of a flat polygon in the XZ plane, its * holes, an optional thickness and how it is shaded and wrapped. */ class CreatePolygonDto { constructor(shape?: Base.Vector3[], holes?: Base.Vector3[][], depth?: number, smoothingThreshold?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, wrap?: boolean, enableShadows?: boolean); /** * The outline points in order, only X and Z used; the outline must not cross itself */ shape: Base.Vector3[]; /** * Lists of points, one outline per hole cut out of the polygon * @optional true */ holes?: Base.Vector3[][] | undefined; /** * Thickness the polygon is given downward along Y, in scene units; 0 keeps it flat * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ depth?: number | undefined; /** * How close two face normals must be for the edge between them to be shaded smooth * @default 0.01 * @minimum 0 * @maximum 1 * @step 0.01 */ smoothingThreshold?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the sides of an extruded polygon get texture coordinates that wrap around it * @default false */ wrap?: boolean | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.extrudePolygon`: the outline of a flat polygon in the XZ plane, * its holes, and how far it is extruded downward. */ class ExtrudePolygonDto { constructor(shape?: Base.Vector3[], holes?: Base.Vector3[][], depth?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, wrap?: boolean, enableShadows?: boolean); /** * The outline points in order, only X and Z used; the outline must not cross itself */ shape: Base.Vector3[]; /** * Lists of points, one outline per hole through the extrusion * @optional true */ holes?: Base.Vector3[][] | undefined; /** * How far the polygon is extruded downward along Y, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ depth?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the sides get texture coordinates that wrap around the extrusion * @default false */ wrap?: boolean | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createPolyhedron`: which of the built-in polyhedra to build or * custom data for your own, its size per axis and its shading. */ class CreatePolyhedronDto { constructor(size?: number, type?: number, sizeX?: number, sizeY?: number, sizeZ?: number, custom?: number[], flat?: boolean, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Size on every axis, in scene units, unless a per-axis size overrides it * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ size?: number | undefined; /** * Which built-in shape, 0 to 14: 0 tetrahedron, 1 octahedron, 2 dodecahedron, 3 * icosahedron, 4 rhombicuboctahedron, then prisms, pyramids, dipyramids and a cupola * @default 0 * @minimum 0 * @maximum Infinity * @step 1 */ type?: number | undefined; /** * Size along X, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeX?: number | undefined; /** * Size along Y, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeY?: number | undefined; /** * Size along Z, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeZ?: number | undefined; /** * Your own polyhedron as the data the engine expects, used instead of `type` when given * @optional true */ custom?: number[] | undefined; /** * When true, each face is shaded flat, showing facets instead of a smooth surface * @default false */ flat?: boolean | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createGeodesic`: how finely the twenty faces of the sphere are * subdivided, its size per axis and its shading. */ class CreateGeodesicDto { constructor(m?: number, n?: number, size?: number, sizeX?: number, sizeY?: number, sizeZ?: number, flat?: boolean, subdivisions?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The first subdivision number; with `n` it sets how many triangles each face is split into * @default 4 * @minimum 0 * @maximum Infinity * @step 1 */ m?: number | undefined; /** * The second subdivision number; with `m` it sets how many triangles each face is split * into * @default 4 * @minimum 0 * @maximum Infinity * @step 1 */ n?: number | undefined; /** * Size on every axis, in scene units, unless a per-axis size overrides it * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ size?: number | undefined; /** * Size along X, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeX?: number | undefined; /** * Size along Y, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeY?: number | undefined; /** * Size along Z, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeZ?: number | undefined; /** * When true, each triangle is shaded flat, showing facets instead of a smooth surface * @default false */ flat?: boolean | undefined; /** * Kept for compatibility; the geodesic is built from `m` and `n` * @default 4 * @minimum 0 * @maximum Infinity * @step 1 */ subdivisions?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default frontside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createCapsule`: the axis, length and radii of a cylinder with * rounded ends, and how finely each part is divided. */ class CreateCapsuleDto { constructor(orientation?: Base.Vector3, subdivisions?: number, tessellation?: number, height?: number, radius?: number, capSubdivisions?: number, radiusTop?: number, radiusBottom?: number, topCapSubdivisions?: number, bottomCapSubdivisions?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The direction the length of the capsule runs along, as `[x, y, z]`; `[0, 1, 0]` stands it * upright */ orientation: Base.Vector3; /** * Number of divisions along the straight middle part * @default 2 * @minimum 0 * @maximum Infinity * @step 1 */ subdivisions?: number | undefined; /** * Number of divisions around the capsule; more is rounder * @default 16 * @minimum 3 * @maximum Infinity * @step 1 */ tessellation?: number | undefined; /** * Full length from end to end, rounded caps included, in scene units * @default 2 * @minimum 0 * @maximum Infinity * @step 0.1 */ height?: number | undefined; /** * Radius of the middle part, in scene units, unless the cap radii override it * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ radius?: number | undefined; /** * Number of divisions over each rounded end; more is smoother * @default 6 * @minimum 0 * @maximum Infinity * @step 1 */ capSubdivisions?: number | undefined; /** * Radius of the top end, in scene units * @default 0.5 * @minimum 0 * @maximum Infinity * @step 0.1 */ radiusTop?: number | undefined; /** * Radius of the bottom end, in scene units * @default 0.5 * @minimum 0 * @maximum Infinity * @step 0.1 */ radiusBottom?: number | undefined; /** * Number of divisions over the top end, overriding `capSubdivisions` * @default 6 * @minimum 0 * @maximum Infinity * @step 1 */ topCapSubdivisions?: number | undefined; /** * Number of divisions over the bottom end, overriding `capSubdivisions` * @default 6 * @minimum 0 * @maximum Infinity * @step 1 */ bottomCapSubdivisions?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createGoldberg`: how many hexagons the ball is made of and its * size per axis. */ class CreateGoldbergDto { constructor(m?: number, n?: number, size?: number, sizeX?: number, sizeY?: number, sizeZ?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The first subdivision number; with `n` it sets how many hexagons surround the twelve * pentagons * @default 4 * @minimum 0 * @maximum Infinity * @step 1 */ m?: number | undefined; /** * The second subdivision number; with `m` it sets how many hexagons surround the twelve * pentagons * @default 4 * @minimum 0 * @maximum Infinity * @step 1 */ n?: number | undefined; /** * Size on every axis, in scene units, unless a per-axis size overrides it * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ size?: number | undefined; /** * Size along X, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeX?: number | undefined; /** * Size along Y, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeY?: number | undefined; /** * Size along Z, in scene units; 0 falls back to `size` * @default 0 * @minimum 0 * @maximum Infinity * @step 0.1 */ sizeZ?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createTube`: the path a tube follows, its radius, how round it is, * which ends are capped and how much of its circumference is drawn. */ class CreateTubeDto { constructor(path?: Base.Vector3[], radius?: number, tessellation?: number, cap?: number, arc?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The points the center line of the tube passes through, in order * @default undefined */ path: Base.Vector3[]; /** * Radius of the tube, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ radius?: number | undefined; /** * Number of sides around the tube; more is rounder * @default 32 * @minimum 3 * @maximum Infinity * @step 1 */ tessellation?: number | undefined; /** * Which ends are closed: 0 none, 1 the start, 2 the end, 3 both * @default 0 * @minimum 0 * @maximum 3 * @step 1 */ cap?: number | undefined; /** * How much of the circumference is drawn, from 0 to 1; below 1 the tube is open along its * length * @default 1 * @minimum 0 * @maximum 1 * @step 0.1 */ arc?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createExtrudedSahpe`: the profile to sweep, the path to sweep it * along, and how it scales, turns and closes on the way. */ class CreateExtrudedShapeDto { constructor(shape?: Base.Vector3[], path?: Base.Vector3[], scale?: number, rotation?: number, cap?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The profile as points in the XY plane, swept along the path */ shape: Base.Vector3[]; /** * The points the profile travels through, in order */ path: Base.Vector3[]; /** * Factor the profile is scaled by along the path; 1 keeps its size * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ scale?: number | undefined; /** * How far the profile turns around the path at each step, in radians; 0 keeps it straight * @default 0 * @minimum -Infinity * @maximum Infinity * @step 0.1 */ rotation?: number | undefined; /** * When true, the last point of the profile is joined back to its first * @default false */ closeShape?: boolean | undefined; /** * When true, the last point of the path is joined back to its first * @default false */ closePath?: boolean | undefined; /** * Which ends are closed: 0 none, 1 the start, 2 the end, 3 both * @default 0 * @minimum 0 * @maximum 3 * @step 1 */ cap?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createCylinder`: the height of a cylinder standing along Y, its * top and bottom diameters and how finely it is divided. */ class CreateCylinderDto { constructor(height?: number, diameterTop?: number, diameterBottom?: number, tessellation?: number, subdivisions?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Full length along Y, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ height?: number | undefined; /** * Diameter of the top end, in scene units; 0 closes it to a point * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ diameterTop?: number | undefined; /** * Diameter of the bottom end, in scene units; 0 closes it to a point * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ diameterBottom?: number | undefined; /** * Number of sides around the cylinder; more is rounder * @default 64 * @minimum 3 * @maximum Infinity * @step 1 */ tessellation?: number | undefined; /** * Number of rings along the height; more than 1 only matters for deforming or shading * @default 1 * @minimum 0 * @maximum Infinity * @step 1 */ subdivisions?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createLathe`: the profile to revolve around the Y axis, an outward * offset, how finely and how far it is revolved and whether the ends close. */ class CreateLatheDto { constructor(shape?: Base.Vector3[], radius?: number, tessellation?: number, arc?: number, closed?: boolean, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * The profile as points in the XY plane, X being the distance from the axis, revolved * around Y */ shape: Base.Vector3[]; /** * Extra distance the profile is pushed away from the axis, in scene units * @default 1 * @minimum 0 * @maximum Infinity * @step 0.1 */ radius?: number | undefined; /** * Number of steps in a full turn; more is rounder * @default 64 * @minimum 3 * @maximum Infinity * @step 1 */ tessellation?: number | undefined; /** * How much of a full turn is revolved, from 0 to 1; below 1 the shape is open * @default 1 * @minimum 0 * @maximum 1 * @step 0.1 */ arc?: number | undefined; /** * When true and the arc is full, the seam is closed so the surface has no gap * @default true */ closed?: boolean | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createGround`: the size of a flat ground in the XZ plane and how * many cells it is divided into. */ class CreateGroundDto { constructor(width?: number, height?: number, subdivisionsX?: number, subdivisionsY?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Full size along X, in scene units * @default 10 * @minimum 0 * @maximum Infinity * @step 1 */ width?: number | undefined; /** * Full size along Z, in scene units * @default 10 * @minimum 0 * @maximum Infinity * @step 1 */ height?: number | undefined; /** * Number of cells along X; more matters only for deforming or lighting * @default 1 * @minimum 0 * @maximum Infinity * @step 1 */ subdivisionsX?: number | undefined; /** * Number of cells along Z; more matters only for deforming or lighting * @default 1 * @minimum 0 * @maximum Infinity * @step 1 */ subdivisionsY?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } /** * Feeds `babylon.meshBuilder.createRectanglePlane` with the sizes of a flat rectangle in the XY * plane. */ class CreateRectanglePlaneDto { constructor(width?: number, height?: number, sideOrientation?: BabylonMesh.sideOrientationEnum, enableShadows?: boolean); /** * Full size along X, in scene units * @default 1 */ width?: number | undefined; /** * Full size along Y, in scene units * @default 1 */ height?: number | undefined; /** * Which side of each face is drawn: the front, the back or both; single-sided meshes are * invisible from behind * @default doubleside */ sideOrientation?: BabylonMesh.sideOrientationEnum | undefined; /** * When true, the mesh casts and receives shadows from the lights that have them enabled * @default true */ enableShadows?: boolean | undefined; } }