@babylonjs/core 6.22.0 → 6.23.0

package/Meshes/csg.d.ts

@@ -1,8 +1,163 @@
 import type { Nullable } from "../types";
 import type { Scene } from "../scene";
-import { Quaternion, Matrix, Vector3 } from "../Maths/math.vector";
+import { Quaternion, Matrix, Vector3, Vector2 } from "../Maths/math.vector";
 import { Mesh } from "../Meshes/mesh";
 import type { Material } from "../Materials/material";
+import { Color4 } from "../Maths/math.color";
+import { VertexData } from "./mesh.vertexData";
+/**
+ * Represents a vertex of a polygon. Use your own vertex class instead of this
+ * one to provide additional features like texture coordinates and vertex
+ * colors. Custom vertex classes need to provide a `pos` property and `clone()`,
+ * `flip()`, and `interpolate()` methods that behave analogous to the ones
+ * defined by `BABYLON.CSG.Vertex`. This class provides `normal` so convenience
+ * functions like `BABYLON.CSG.sphere()` can return a smooth vertex normal, but `normal`
+ * is not used anywhere else.
+ * Same goes for uv, it allows to keep the original vertex uv coordinates of the 2 meshes
+ */
+declare class Vertex {
+    /**
+     * The position of the vertex
+     */
+    pos: Vector3;
+    /**
+     * The normal of the vertex
+     */
+    normal: Vector3;
+    /**
+     * The texture coordinate of the vertex
+     */
+    uv?: Vector2 | undefined;
+    /**
+     * The texture coordinate of the vertex
+     */
+    vertColor?: Color4 | undefined;
+    /**
+     * Initializes the vertex
+     * @param pos The position of the vertex
+     * @param normal The normal of the vertex
+     * @param uv The texture coordinate of the vertex
+     * @param vertColor The RGBA color of the vertex
+     */
+    constructor(
+    /**
+     * The position of the vertex
+     */
+    pos: Vector3, 
+    /**
+     * The normal of the vertex
+     */
+    normal: Vector3, 
+    /**
+     * The texture coordinate of the vertex
+     */
+    uv?: Vector2 | undefined, 
+    /**
+     * The texture coordinate of the vertex
+     */
+    vertColor?: Color4 | undefined);
+    /**
+     * Make a clone, or deep copy, of the vertex
+     * @returns A new Vertex
+     */
+    clone(): Vertex;
+    /**
+     * Invert all orientation-specific data (e.g. vertex normal). Called when the
+     * orientation of a polygon is flipped.
+     */
+    flip(): void;
+    /**
+     * Create a new vertex between this vertex and `other` by linearly
+     * interpolating all properties using a parameter of `t`. Subclasses should
+     * override this to interpolate additional properties.
+     * @param other the vertex to interpolate against
+     * @param t The factor used to linearly interpolate between the vertices
+     */
+    interpolate(other: Vertex, t: number): Vertex;
+}
+/**
+ * Represents a plane in 3D space.
+ */
+declare class Plane {
+    normal: Vector3;
+    w: number;
+    /**
+     * Initializes the plane
+     * @param normal The normal for the plane
+     * @param w
+     */
+    constructor(normal: Vector3, w: number);
+    /**
+     * `CSG.Plane.EPSILON` is the tolerance used by `splitPolygon()` to decide if a
+     * point is on the plane
+     */
+    static EPSILON: number;
+    /**
+     * Construct a plane from three points
+     * @param a Point a
+     * @param b Point b
+     * @param c Point c
+     */
+    static FromPoints(a: Vector3, b: Vector3, c: Vector3): Nullable<Plane>;
+    /**
+     * Clone, or make a deep copy of the plane
+     * @returns a new Plane
+     */
+    clone(): Plane;
+    /**
+     * Flip the face of the plane
+     */
+    flip(): void;
+    /**
+     * Split `polygon` by this plane if needed, then put the polygon or polygon
+     * fragments in the appropriate lists. Coplanar polygons go into either
+    `* coplanarFront` or `coplanarBack` depending on their orientation with
+     * respect to this plane. Polygons in front or in back of this plane go into
+     * either `front` or `back`
+     * @param polygon The polygon to be split
+     * @param coplanarFront Will contain polygons coplanar with the plane that are oriented to the front of the plane
+     * @param coplanarBack Will contain polygons coplanar with the plane that are oriented to the back of the plane
+     * @param front Will contain the polygons in front of the plane
+     * @param back Will contain the polygons begind the plane
+     */
+    splitPolygon(polygon: Polygon, coplanarFront: Polygon[], coplanarBack: Polygon[], front: Polygon[], back: Polygon[]): void;
+}
+/**
+ * Represents a convex polygon. The vertices used to initialize a polygon must
+ * be coplanar and form a convex loop.
+ *
+ * Each convex polygon has a `shared` property, which is shared between all
+ * polygons that are clones of each other or were split from the same polygon.
+ * This can be used to define per-polygon properties (such as surface color)
+ */
+declare class Polygon {
+    /**
+     * Vertices of the polygon
+     */
+    vertices: Vertex[];
+    /**
+     * Properties that are shared across all polygons
+     */
+    shared: any;
+    /**
+     * A plane formed from the vertices of the polygon
+     */
+    plane: Plane;
+    /**
+     * Initializes the polygon
+     * @param vertices The vertices of the polygon
+     * @param shared The properties shared across all polygons
+     */
+    constructor(vertices: Vertex[], shared: any);
+    /**
+     * Clones, or makes a deep copy, or the polygon
+     */
+    clone(): Polygon;
+    /**
+     * Flips the faces of the polygon
+     */
+    flip(): void;
+}
 /**
  * Class for building Constructive Solid Geometry
  */
@@ -28,6 +183,12 @@ export declare class CSG {
      * Stores the scaling vector
      */
     scaling: Vector3;
+    /**
+     * Convert a VertexData to CSG
+     * @param mesh defines the VertexData to convert to CSG
+     * @returns the new CSG
+     */
+    static FromVertexData(data: VertexData): CSG;
     /**
      * Convert the Mesh to CSG
      * @param mesh The Mesh to convert to CSG
@@ -96,6 +257,12 @@ export declare class CSG {
      * @returns This CSG
      */
     copyTransformAttributes(csg: CSG): CSG;
+    /**
+     * Build vertex data from CSG
+     * Coordinates here are in world space
+     * @returns the final vertex data
+     */
+    toVertexData(onBeforePolygonProcessing?: Nullable<(polygon: Polygon) => void>, onAfterPolygonProcessing?: Nullable<() => void>): VertexData;
     /**
      * Build Raw mesh from CSG
      * Coordinates here are in world space
@@ -115,3 +282,4 @@ export declare class CSG {
      */
     toMesh(name: string, material?: Nullable<Material>, scene?: Scene, keepSubMeshes?: boolean): Mesh;
 }
+export {};

package/Meshes/csg.js

@@ -4,6 +4,7 @@ import { SubMesh } from "../Meshes/subMesh.js";
 import { Mesh } from "../Meshes/mesh.js";
 import { Color4 } from "../Maths/math.color.js";
 
+import { VertexData } from "./mesh.vertexData.js";
 /**
  * Unique ID when we import meshes from Babylon to CSG
  */
@@ -379,6 +380,50 @@ export class CSG {
     constructor() {
         this._polygons = new Array();
     }
+    /**
+     * Convert a VertexData to CSG
+     * @param mesh defines the VertexData to convert to CSG
+     * @returns the new CSG
+     */
+    static FromVertexData(data) {
+        let vertex, polygon, vertices;
+        const polygons = new Array();
+        const indices = data.indices;
+        const positions = data.positions;
+        const normals = data.normals;
+        const uvs = data.uvs;
+        const vertColors = data.colors;
+        if (!indices || !positions) {
+            throw "BABYLON.CSG: VertexData must at least contain positions and indices";
+        }
+        for (let i = 0; i < indices.length; i += 3) {
+            vertices = [];
+            for (let j = 0; j < 3; j++) {
+                const indexIndices = i + j;
+                const offset = indices[indexIndices];
+                const normal = normals ? Vector3.FromArray(normals, offset * 3) : Vector3.Zero();
+                const uv = uvs ? Vector2.FromArray(uvs, offset * 2) : undefined;
+                const vertColor = vertColors ? Color4.FromArray(vertColors, offset * 4) : undefined;
+                const position = Vector3.FromArray(positions, offset * 3);
+                vertex = new Vertex(position, normal, uv, vertColor);
+                vertices.push(vertex);
+            }
+            polygon = new Polygon(vertices, { subMeshId: 0, meshId: currentCSGMeshId, materialIndex: 0 });
+            // To handle the case of degenerated triangle
+            // polygon.plane == null <=> the polygon does not represent 1 single plane <=> the triangle is degenerated
+            if (polygon.plane) {
+                polygons.push(polygon);
+            }
+        }
+        const csg = CSG._FromPolygons(polygons);
+        csg.matrix = Matrix.Identity();
+        csg.position = Vector3.Zero();
+        csg.rotation = Vector3.Zero();
+        csg.scaling = Vector3.One();
+        csg.rotationQuaternion = Quaternion.Identity();
+        currentCSGMeshId++;
+        return csg;
+    }
     /**
      * Convert the Mesh to CSG
      * @param mesh The Mesh to convert to CSG
@@ -595,17 +640,14 @@ export class CSG {
         return this;
     }
     /**
-     * Build Raw mesh from CSG
+     * Build vertex data from CSG
      * Coordinates here are in world space
-     * @param name The name of the mesh geometry
-     * @param scene The Scene
-     * @param keepSubMeshes Specifies if the submeshes should be kept
-     * @returns A new Mesh
+     * @returns the final vertex data
      */
-    buildMeshGeometry(name, scene, keepSubMeshes) {
+    toVertexData(onBeforePolygonProcessing = null, onAfterPolygonProcessing = null) {
         const matrix = this.matrix.clone();
         matrix.invert();
-        const mesh = new Mesh(name, scene);
+        const polygons = this._polygons;
         const vertices = [];
         const indices = [];
         const normals = [];
@@ -615,39 +657,14 @@ export class CSG {
         const normal = Vector3.Zero();
         const uv = Vector2.Zero();
         const vertColor = new Color4(0, 0, 0, 0);
-        const polygons = this._polygons;
         const polygonIndices = [0, 0, 0];
-        let polygon;
         const vertice_dict = {};
         let vertex_idx;
-        let currentIndex = 0;
-        const subMeshDict = {};
-        let subMeshObj;
-        if (keepSubMeshes) {
-            // Sort Polygons, since subMeshes are indices range
-            polygons.sort((a, b) => {
-                if (a.shared.meshId === b.shared.meshId) {
-                    return a.shared.subMeshId - b.shared.subMeshId;
-                }
-                else {
-                    return a.shared.meshId - b.shared.meshId;
-                }
-            });
-        }
         for (let i = 0, il = polygons.length; i < il; i++) {
-            polygon = polygons[i];
-            // Building SubMeshes
-            if (!subMeshDict[polygon.shared.meshId]) {
-                subMeshDict[polygon.shared.meshId] = {};
+            const polygon = polygons[i];
+            if (onBeforePolygonProcessing) {
+                onBeforePolygonProcessing(polygon);
             }
-            if (!subMeshDict[polygon.shared.meshId][polygon.shared.subMeshId]) {
-                subMeshDict[polygon.shared.meshId][polygon.shared.subMeshId] = {
-                    indexStart: +Infinity,
-                    indexEnd: -Infinity,
-                    materialIndex: polygon.shared.materialIndex,
-                };
-            }
-            subMeshObj = subMeshDict[polygon.shared.meshId][polygon.shared.subMeshId];
             for (let j = 2, jl = polygon.vertices.length; j < jl; j++) {
                 polygonIndices[0] = 0;
                 polygonIndices[1] = j - 1;
@@ -700,21 +717,68 @@ export class CSG {
                         vertex_idx = vertice_dict[localVertex.x + "," + localVertex.y + "," + localVertex.z] = vertices.length / 3 - 1;
                     }
                     indices.push(vertex_idx);
-                    subMeshObj.indexStart = Math.min(currentIndex, subMeshObj.indexStart);
-                    subMeshObj.indexEnd = Math.max(currentIndex, subMeshObj.indexEnd);
-                    currentIndex++;
+                    if (onAfterPolygonProcessing) {
+                        onAfterPolygonProcessing();
+                    }
                 }
             }
         }
-        mesh.setVerticesData(VertexBuffer.PositionKind, vertices);
-        mesh.setVerticesData(VertexBuffer.NormalKind, normals);
+        const result = new VertexData();
+        result.positions = vertices;
+        result.normals = normals;
         if (uvs) {
-            mesh.setVerticesData(VertexBuffer.UVKind, uvs);
+            result.uvs = uvs;
         }
         if (vertColors) {
-            mesh.setVerticesData(VertexBuffer.ColorKind, vertColors);
+            result.colors = vertColors;
+        }
+        result.indices = indices;
+        return result;
+    }
+    /**
+     * Build Raw mesh from CSG
+     * Coordinates here are in world space
+     * @param name The name of the mesh geometry
+     * @param scene The Scene
+     * @param keepSubMeshes Specifies if the submeshes should be kept
+     * @returns A new Mesh
+     */
+    buildMeshGeometry(name, scene, keepSubMeshes) {
+        const mesh = new Mesh(name, scene);
+        const polygons = this._polygons;
+        let currentIndex = 0;
+        const subMeshDict = {};
+        let subMeshObj;
+        if (keepSubMeshes) {
+            // Sort Polygons, since subMeshes are indices range
+            polygons.sort((a, b) => {
+                if (a.shared.meshId === b.shared.meshId) {
+                    return a.shared.subMeshId - b.shared.subMeshId;
+                }
+                else {
+                    return a.shared.meshId - b.shared.meshId;
+                }
+            });
         }
-        mesh.setIndices(indices, null);
+        const vertexData = this.toVertexData((polygon) => {
+            // Building SubMeshes
+            if (!subMeshDict[polygon.shared.meshId]) {
+                subMeshDict[polygon.shared.meshId] = {};
+            }
+            if (!subMeshDict[polygon.shared.meshId][polygon.shared.subMeshId]) {
+                subMeshDict[polygon.shared.meshId][polygon.shared.subMeshId] = {
+                    indexStart: +Infinity,
+                    indexEnd: -Infinity,
+                    materialIndex: polygon.shared.materialIndex,
+                };
+            }
+            subMeshObj = subMeshDict[polygon.shared.meshId][polygon.shared.subMeshId];
+        }, () => {
+            subMeshObj.indexStart = Math.min(currentIndex, subMeshObj.indexStart);
+            subMeshObj.indexEnd = Math.max(currentIndex, subMeshObj.indexEnd);
+            currentIndex++;
+        });
+        vertexData.applyToMesh(mesh);
         if (keepSubMeshes) {
             // We offset the materialIndex by the previous number of materials in the CSG mixed meshes
             let materialIndexOffset = 0, materialMaxIndex;