explain how rebuildNormals in CSG2.toVertexData works.

Deep

How `rebuildNormals` Works in `CSG2.toVertexData`

The rebuildNormals option in CSG2.toVertexData() is a boolean parameter that controls whether the Manifold library recalculates surface normals for the resulting geometry.

Configuration

The rebuildNormals parameter is defined in the IVertexDataRebuildOptions interface and defaults to false when not specified. csg2.ts:78-83 csg2.ts:176-179

Mechanism

When rebuildNormals is enabled, the method checks if a normal component exists in the vertex structure. If both conditions are met, it passes the array [3, 4, 5] to the Manifold library's getMesh() method: csg2.ts:181-182

These indices [3, 4, 5] specify the positions in the vertex property array where the normals should be stored. This is based on the vertex structure layout where:

Indices 0, 1, 2 contain position data (x, y, z)
Indices 3, 4, 5 contain normal data (nx, ny, nz) csg2.ts:341-342 csg2.ts:357-359

Data Extraction

After the Manifold library processes the mesh, the method extracts the vertex data (including the recalculated normals if requested) from the returned manifoldMesh.vertProperties array and distributes it to the appropriate vertex buffers: csg2.ts:195-207

Notes

The rebuildNormals option only takes effect if the source geometry already has normals in its vertex structure. If no normal component exists, passing [3, 4, 5] would be meaningless, so the method passes undefined instead.
This same option is also available in the CSG2.toMesh() method, which internally calls toVertexData().
The recalculation is performed by the Manifold library (a WebAssembly-based geometry processing library), not by Babylon.js itself.

BabylonJS/Babylon.js packages/dev/core/src/Meshes/csg2.ts

75/**
76 * Interface to customize the vertex data rebuild options
77 */

78export interface IVertexDataRebuildOptions {
79    /**
80     * Rebuild normals
81     */
82    rebuildNormals?: boolean;
83}

84
85interface IManifoldMesh {
86    numProp: number;

173     * @returns a new vertex data
174     */
175    public toVertexData(options?: Partial<IVertexDataRebuildOptions>): VertexData {

176        const localOptions = {
177            rebuildNormals: false,
178            ...options,
179        };

180        const vertexData = new VertexData();

181        const normalComponent = this._vertexStructure.find((c) => c.kind === VertexBuffer.NormalKind);
182        const manifoldMesh: IManifoldMesh = this._manifold.getMesh(localOptions.rebuildNormals && normalComponent ? [3, 4, 5] : undefined);

183
184        vertexData.indices = manifoldMesh.triVerts.length > 65535 ? new Uint32Array(manifoldMesh.triVerts) : new Uint16Array(manifoldMesh.triVerts);
185

192        const vertexCount = manifoldMesh.vertProperties.length / manifoldMesh.numProp;
193
194        // Attributes

195        let offset = 0;
196        for (let componentIndex = 0; componentIndex < this._vertexStructure.length; componentIndex++) {
197            const component = this._vertexStructure[componentIndex];
198
199            const data = new Float32Array(vertexCount * component.stride);
200            for (let i = 0; i < vertexCount; i++) {
201                for (let strideIndex = 0; strideIndex < component.stride; strideIndex++) {
202                    data[i * component.stride + strideIndex] = manifoldMesh.vertProperties[i * manifoldMesh.numProp + offset + strideIndex];
203                }
204            }
205            vertexData.set(data, component.kind);
206            offset += component.stride;
207        }

208
209        // Rebuild mesh from vertex data
210        return vertexData;

338        }
339
340        const tempVector3 = new Vector3();

341        let numProp = 3;
342        const structure: IManifoldVertexComponent[] = [{ stride: 3, kind: VertexBuffer.PositionKind }];

343
344        if (!worldMatrix) {
345            structure[0].data = data.positions!;

354
355        // Normals
356        const sourceNormals = data.normals!;

357        if (sourceNormals) {
358            numProp += 3;
359            structure.push({ stride: 3, kind: VertexBuffer.NormalKind });

360            if (!worldMatrix) {
361                structure[1].data = sourceNormals;
362            } else {

BabylonJS/Babylon.js

explain how rebuildNormals in CSG2.toVertexData works.

Codemap

CSG2.toVertexData rebuildNormals Flow

This codemap traces the rebuildNormals functionality in CSG2.toVertexData(), showing how the option triggers normal recalculation in the Manifold library when conditions are met. Key flow includes option processing , normal component detection , and the critical Manifold library call that receives the normal indices [3,4,5] for rebuilding.

AI generated guide

Motivation

When performing boolean operations (union, subtraction, intersection) on 3D meshes using the Manifold library, the resulting geometry often has incorrect or missing surface normals. Normals are crucial for proper lighting and shading. The rebuildNormals option provides a way to automatically recalculate these normals after operations, ensuring the final mesh renders correctly with proper lighting.

Details

The toVertexData() method accepts an optional rebuildNormals parameter that defaults to false . Before triggering the rebuild, the system first checks if the source geometry actually contains normals by searching for a normal component in the vertex structure . If both conditions are met (rebuildNormals is true AND normals exist), the method passes the array [3, 4, 5] to the Manifold library's getMesh() method . These indices specify that normals should be stored at positions 3, 4, and 5 in each vertex's property array (following the 3 position values at indices 0, 1, 2). The Manifold library then performs the actual normal recalculation using its WebAssembly-based geometry processing engine.

Process rebuildNormals option

Call Manifold library

packagesdevcoresrcMeshescsg2.ts

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

import { Mesh } from "./mesh";
import type { IDisposable, Scene } from "core/scene";
import type { IVertexDataLike } from "./mesh.vertexData";
import { VertexData } from "./mesh.vertexData";
import { VertexBuffer } from "../Buffers/buffer";
import { Logger } from "core/Misc/logger";
import { MultiMaterial } from "core/Materials/multiMaterial";
import { SubMesh } from "./subMesh";
import type { Material } from "core/Materials/material";
import { _LoadScriptModuleAsync } from "core/Misc/tools.internals";
import type { FloatArray, Nullable } from "core/types";
import type { Matrix } from "core/Maths/math.vector";
import { Vector3 } from "core/Maths/math.vector";
/**
 * Main manifold library
 */
// eslint-disable-next-line @typescript-eslint/naming-convention
let Manifold: any;
/**
 * Promise to wait for the manifold library to be ready
 */
// eslint-disable-next-line @typescript-eslint/naming-convention
let ManifoldPromise: Promise<{ Manifold: any; Mesh: any }>;
/**
 * Manifold mesh
 */
// eslint-disable-next-line @typescript-eslint/naming-convention
let ManifoldMesh: any;
/**
 * First ID to use for materials indexing
 */
// eslint-disable-next-line @typescript-eslint/naming-convention
let FirstID: number;
/**
 * Interface to customize the Manifold library import
 */
export interface ICSG2Options {
    /**
     * Custom manifold URL
     */
    manifoldUrl?: string;
    /**
     * Custom manifold instance
     */
    manifoldInstance: any;
    /**
     * Custom manifold mesh instance
     */
    manifoldMeshInstance: any;
}
/**
 * Interface to customize the mesh rebuild options
 */
export interface IMeshRebuildOptions {
    /**
     * Rebuild normals
     */
    rebuildNormals?: boolean;
    /**
     * True to center the mesh on 0,0,0
     */
    centerMesh?: boolean;
    /**
     * Defines a material to use for that mesh. When not defined the system will either 
     reuse the one from the source or create a multimaterial if several materials were 
     involved
     */
    materialToUse?: Material;
}
/**
 * Interface to customize the vertex data rebuild options
 */
export interface IVertexDataRebuildOptions {
    /**
     * Rebuild normals
     */
    rebuildNormals?: boolean;
}
interface IManifoldMesh {
    numProp: number;
    vertProperties: Float32Array;
    triVerts: Uint32Array;
    runIndex: Uint32Array;
    // eslint-disable-next-line @typescript-eslint/naming-convention
    runOriginalID: Uint32Array;
    numRun: number;
}
interface IManifoldVertexComponent {
    stride: number;
    kind: string;
    data?: FloatArray;
}
/**
 * Wrapper around the Manifold library
 * https://manifoldcad.org/
 * Use this class to perform fast boolean operations on meshes
 * @see [basic operations](https://playground.babylonjs.com/#IW43EB#15)
 * @see [skull vs box](https://playground.babylonjs.com/#JUKXQD#6218)
 * @see [skull vs vertex data](https://playground.babylonjs.com/#JUKXQD#6219)
 */
export class CSG2 implements IDisposable {
    private _manifold: any;
    private _numProp: number;
    private _vertexStructure: IManifoldVertexComponent[];
    /**
     * Return the size of a vertex (at least 3 for the position)
     */
    public get numProp() {
        return this._numProp;
    }
    private constructor(manifold: any, numProp: number, vertexStructure: 
    IManifoldVertexComponent[]) {
        this._manifold = manifold;
        this._numProp = numProp;
        this._vertexStructure = vertexStructure;
    }
    private _process(operation: "difference" | "intersection" | "union", csg: CSG2) {
        if (this.numProp !== csg.numProp) {
            throw new Error("CSG must be used with geometries having the same number of 
            properties");
        }
        return new CSG2(Manifold[operation](this._manifold, csg._manifold), this.numProp, 
        this._vertexStructure);
    }
    /**
     * Run a difference operation between two CSG
     * @param csg defines the CSG to use to create the difference
     * @returns a new csg
     */
    public subtract(csg: CSG2) {
        return this._process("difference", csg);
    }
    /**
     * Run an intersection operation between two CSG
     * @param csg defines the CSG to use to create the intersection
     * @returns a new csg
     */
    public intersect(csg: CSG2) {
        return this._process("intersection", csg);
    }
    /**
     * Run an union operation between two CSG
     * @param csg defines the CSG to use to create the union
     * @returns a new csg
     */
    public add(csg: CSG2) {
        return this._process("union", csg);
    }
    /**
     * Print debug information about the CSG
     */
    public printDebug() {
        Logger.Log("Genus:" + this._manifold.genus());
        Logger.Log("Volume:" + this._manifold.volume());
        Logger.Log("surface area:" + this._manifold.surfaceArea());
    }
    /**
     * Generate a vertex data from the CSG
     * @param options defines the options to use to rebuild the vertex data
     * @returns a new vertex data
     */
    public toVertexData(options?: Partial<IVertexDataRebuildOptions>): VertexData {
        const localOptions = {
            rebuildNormals: false,
            ...options,
        };
        const vertexData = new VertexData();
        const normalComponent = this._vertexStructure.find((c) => c.kind === VertexBuffer.
        NormalKind);
        const manifoldMesh: IManifoldMesh = this._manifold.getMesh(localOptions.
        rebuildNormals && normalComponent ? [3, 4, 5] : undefined);
        vertexData.indices = manifoldMesh.triVerts.length > 65535 ? new Uint32Array
        (manifoldMesh.triVerts) : new Uint16Array(manifoldMesh.triVerts);
        for (let i = 0; i < manifoldMesh.triVerts.length; i += 3) {
            vertexData.indices[i] = manifoldMesh.triVerts[i + 2];
            vertexData.indices[i + 1] = manifoldMesh.triVerts[i + 1];
            vertexData.indices[i + 2] = manifoldMesh.triVerts[i];
        }
        const vertexCount = manifoldMesh.vertProperties.length / manifoldMesh.numProp;
        // Attributes
        let offset = 0;
        for (let componentIndex = 0; componentIndex < this._vertexStructure.length; 
        componentIndex++) {
            const component = this._vertexStructure[componentIndex];
            const data = new Float32Array(vertexCount * component.stride);
            for (let i = 0; i < vertexCount; i++) {
                for (let strideIndex = 0; strideIndex < component.stride; strideIndex++) {
                    data[i * component.stride + strideIndex] = manifoldMesh.vertProperties
                    [i * manifoldMesh.numProp + offset + strideIndex];
                }
            }
            vertexData.set(data, component.kind);
            offset += component.stride;
        }
        // Rebuild mesh from vertex data
        return vertexData;
    }
    /**
     * Generate a mesh from the CSG

BabylonJS/Babylon.js

explain how normals are recalculated when rebuildNormals = true

Codemap

CSG2 Normal Recalculation Flow

This codemap traces the complete flow of normal recalculation in CSG2 when rebuildNormals = true, from option processing through Manifold WebAssembly processing to final vertex data extraction. Key locations include the critical Manifold library call , the data extraction loop , and comparison with traditional Babylon.js normal computation .

AI generated guide

Motivation

When performing boolean operations (union, subtraction, intersection) on 3D meshes using the Manifold library, the resulting geometry often has incorrect or missing surface normals. Normals are crucial for proper lighting and shading - without them, meshes appear flat or have distorted lighting. The rebuildNormals option provides a way to automatically recalculate these normals after operations, ensuring the final mesh renders correctly with proper lighting.

Details

If both conditions are met (rebuildNormals is true AND normals exist), the method passes the array [3, 4, 5] to the Manifold library's getMesh() method . These indices specify that normals should be stored at positions 3, 4, and 5 in each vertex's property array (following the 3 position values at indices 0, 1, 2).

The Manifold library is loaded as a WebAssembly module from an external CDN , providing high-performance geometry processing. This external library performs the actual normal recalculation using sophisticated algorithms that are more robust than Babylon.js's built-in normal computation, especially for complex geometries resulting from boolean operations.

toVertexData() method entry

Library Initialization

Load WebAssembly module

Setup Manifold instance

AI generated guide

Motivation

When you perform boolean operations (union, subtraction, intersection) on 3D meshes, the resulting geometry often has incorrect or missing surface normals. Normals are crucial for proper lighting and shading - without correct normals, your mesh will look dark, shiny in wrong places, or have completely broken lighting. The CSG2 system solves this by automatically recalculating normals using the sophisticated Manifold WebAssembly library when you set rebuildNormals = true.

Details

The extraction process starts by calculating how many vertices exist from Manifold's internal vertex property array . Then it systematically extracts each type of vertex data (positions, normals, UVs, etc.) from Manifold's flat property array and organizes them into separate Babylon.js vertex buffers .

For normals specifically, the system knows they occupy 3 slots (x,y,z) in the vertex structure and extracts the recalculated normal values accordingly. The extraction loop creates properly sized arrays for each vertex component, copies the data from Manifold's format into Babylon.js format, and sets the data on the VertexData object . Finally, the complete VertexData object containing positions, recalculated normals, and other attributes is returned for use in creating meshes .

This approach leverages Manifold's advanced geometry processing algorithms which are specifically designed to handle the complex topology changes that occur during boolean operations, producing much more reliable normals than traditional face-based computation methods.

Extract data from Manifold

Loop through vertex components

Create data arrays for each component

Set data in vertexData object

AI generated guide

Motivation

When 3D meshes undergo complex geometric operations like boolean unions or subtractions, their surface normals often become incorrect or inconsistent. Normals are crucial for proper lighting and shading - incorrect normals make meshes appear dark, flat, or lit from wrong angles. Babylon.js provides a traditional normal computation method that works well for simple meshes but can produce artifacts on complex geometries resulting from boolean operations.

Details

Babylon.js computes surface normals using a classic geometric approach . The process systematically processes each triangle face in the mesh:

Edge Vector Calculation: For each triangle, two edge vectors are computed by subtracting vertex positions . These vectors define the plane orientation of the face.
Face Normal Computation: The cross product of these edge vectors yields a perpendicular vector - the face normal . This vector is then normalized to unit length.
Normal Accumulation: Each face normal is accumulated to its three constituent vertices . This averaging process creates smooth transitions across adjacent faces.
Final Normalization: All accumulated vertex normals are normalized to ensure consistent lighting behavior .

While this algorithm is mathematically sound and efficient for simple geometries, it struggles with the complex topology changes that occur during boolean operations. This is why CSG2 delegates normal recalculation to the specialized Manifold library when rebuildNormals = true, which uses more sophisticated algorithms better suited for post-boolean geometry.

Reset normals array to zeros

For each triangle face

p1p2 = v1 - v2

p3p2 = v3 - v2

Normalize face normal

Add to vertex 1 normal

Add to vertex 2 normal

Add to vertex 3 normal

For each vertex

Calculate magnitude

Divide by magnitude

Return normalized normals

packagesdevcoresrcMeshesmesh.vertexData.ts

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

/* eslint-disable jsdoc/require-returns-check */
/* eslint-disable @typescript-eslint/no-unused-vars */
import type { Nullable, FloatArray, IndicesArray, DeepImmutable } from "../types";
import type { Matrix, Vector2 } from "../Maths/math.vector";
import { Vector3, Vector4, TmpVectors } from "../Maths/math.vector";
import { VertexBuffer } from "../Buffers/buffer";
import { _WarnImport } from "../Misc/devTools";
import type { Color3 } from "../Maths/math.color";
import { Color4 } from "../Maths/math.color";
import { Logger } from "../Misc/logger";
import { nativeOverride } from "../Misc/decorators";
import type { Coroutine } from "../Misc/coroutine";
import { makeSyncFunction, runCoroutineSync } from "../Misc/coroutine";
import type { ICreateCapsuleOptions } from "./Builders/capsuleBuilder";
import { RuntimeError, ErrorCodes } from "../Misc/error";
import type { Geometry } from "../Meshes/geometry";
import type { Mesh } from "../Meshes/mesh";
import { SubMesh } from "./subMesh";
/**
 * Define an interface for all classes that will get and set the data on vertices
 */
export interface IGetSetVerticesData {
    /**
     * Gets a boolean indicating if specific vertex data is present
     * @param kind defines the vertex data kind to use
     * @returns true is data kind is present
     */
    isVerticesDataPresent(kind: string): boolean;
    /**
     * Gets a specific vertex data attached to this geometry. Float data is constructed 
     if the vertex buffer data cannot be returned directly.
     * @param kind defines the data kind (Position, normal, etc...)
     * @param copyWhenShared defines if the returned array must be cloned upon returning 
     it if the current geometry is shared between multiple meshes
     * @param forceCopy defines a boolean indicating that the returned array must be 
     cloned upon returning it
     * @returns a float array containing vertex data
     */
    getVerticesData(kind: string, copyWhenShared?: boolean, forceCopy?: boolean): 
    Nullable<FloatArray>;
    /**
     * Returns an array of integers or a typed array (Int32Array, Uint32Array, 
     Uint16Array) populated with the mesh indices.
     * @param copyWhenShared If true (default false) and and if the mesh geometry is 
     shared among some other meshes, the returned array is a copy of the internal one.
     * @param forceCopy defines a boolean indicating that the returned array must be 
     cloned upon returning it
     * @returns the indices array or an empty array if the mesh has no geometry
     */
    getIndices(copyWhenShared?: boolean, forceCopy?: boolean): Nullable<IndicesArray>;
    /**
     * Set specific vertex data
     * @param kind defines the data kind (Position, normal, etc...)
     * @param data defines the vertex data to use
     * @param updatable defines if the vertex must be flagged as updatable (false as 
     default)
     * @param stride defines the stride to use (0 by default). This value is deduced from 
     the kind value if not specified
     */
    setVerticesData(kind: string, data: FloatArray, updatable: boolean, stride?: number): 
    void;
    /**
     * Update a specific associated vertex buffer
     * @param kind defines which buffer to write to (positions, indices, normals, etc). 
     Possible `kind` values :
     * - VertexBuffer.PositionKind
     * - VertexBuffer.UVKind
     * - VertexBuffer.UV2Kind
     * - VertexBuffer.UV3Kind
     * - VertexBuffer.UV4Kind
     * - VertexBuffer.UV5Kind
     * - VertexBuffer.UV6Kind
     * - VertexBuffer.ColorKind
     * - VertexBuffer.MatricesIndicesKind
     * - VertexBuffer.MatricesIndicesExtraKind
     * - VertexBuffer.MatricesWeightsKind
     * - VertexBuffer.MatricesWeightsExtraKind
     * @param data defines the data source
     * @param updateExtends defines if extends info of the mesh must be updated (can be 
     null). This is mostly useful for "position" kind
     * @param makeItUnique defines if the geometry associated with the mesh must be 
     cloned to make the change only for this mesh (and not all meshes associated with the 
     same geometry)
     */
    updateVerticesData(kind: string, data: FloatArray, updateExtends?: boolean, 
    makeItUnique?: boolean): void;
    /**
     * Creates a new index buffer
     * @param indices defines the indices to store in the index buffer
     * @param totalVertices defines the total number of vertices (could be null)
     * @param updatable defines if the index buffer must be flagged as updatable (false 
     by default)
     */
    setIndices(indices: IndicesArray, totalVertices: Nullable<number>, updatable?: 
    boolean): void;
}
/** Class used to attach material info to sub section of a vertex data class */
export class VertexDataMaterialInfo {
    /** Defines the material index to use */
    public materialIndex: number;
    /** Defines vertex index start*/
    public verticesStart: number;
    /** Defines vertices count */
    public verticesCount: number;
    /** Defines index start */
    public indexStart: number;
    /** Defines indices count */
    public indexCount: number;
}
/**
 * Interface used to define a object like a vertex data structure
 */
export interface IVertexDataLike {
    /**
     * An array of the x, y, z position of each vertex  [...., x, y, z, .....]
     */
    positions: Nullable<FloatArray>;
    /**
     * An array of the x, y, z normal vector of each vertex  [...., x, y, z, .....]
     */
    normals?: Nullable<FloatArray>;
    /**
     * An array of the x, y, z, w tangent vector of each vertex  [...., x, y, z, w, .....]
     */
    tangents?: Nullable<FloatArray>;
    /**
     * An array of u,v which maps a texture image onto each vertex  [...., u, v, .....]
     */
    uvs?: Nullable<FloatArray>;
    /**
     * A second array of u,v which maps a texture image onto each vertex  [...., u, 
     v, .....]
     */
    uvs2?: Nullable<FloatArray>;
    /**
     * A third array of u,v which maps a texture image onto each vertex  [...., u, 
     v, .....]
     */
    uvs3?: Nullable<FloatArray>;
    /**
     * A fourth array of u,v which maps a texture image onto each vertex  [...., u, 
     v, .....]
     */
    uvs4?: Nullable<FloatArray>;
    /**
     * A fifth array of u,v which maps a texture image onto each vertex  [...., u, 
     v, .....]
     */
    uvs5?: Nullable<FloatArray>;
    /**
     * A sixth array of u,v which maps a texture image onto each vertex  [...., u, 
     v, .....]
     */
    uvs6?: Nullable<FloatArray>;
    /**
     * An array of the r, g, b, a, color of each vertex  [...., r, g, b, a, .....]
     */
    colors?: Nullable<FloatArray>;
    /**
     * An array containing the list of indices to the array of matrices produced by 
     bones, each vertex have up to 4 indices (8 if the matricesIndicesExtra is set).
     */
    matricesIndices?: Nullable<FloatArray>;
    /**
     * An array containing the list of weights defining the weight of each indexed matrix 
     in the final computation
     */
    matricesWeights?: Nullable<FloatArray>;
    /**
     * An array extending the number of possible indices
     */
    matricesIndicesExtra?: Nullable<FloatArray>;
    /**
     * An array extending the number of possible weights when the number of indices is 
     extended
     */
    matricesWeightsExtra?: Nullable<FloatArray>;
    /**
     * An array of i, j, k the three vertex indices required for each triangular facet  
     [...., i, j, k .....]
     */
    indices?: Nullable<IndicesArray>;
}
/**
 * This class contains the various kinds of data on every vertex of a mesh used in 
 determining its shape and appearance
 */
export class VertexData implements IVertexDataLike {
    /**
     * Mesh side orientation : usually the external or front surface
     */
    public static readonly FRONTSIDE = 0;
    /**
     * Mesh side orientation : usually the internal or back surface
     */
    public static readonly BACKSIDE = 1;
    /**
     * Mesh side orientation : both internal and external or front and back surfaces
     */
    public static readonly DOUBLESIDE = 2;
    /**
     * Mesh side orientation : by default, `FRONTSIDE`
     */
    public static readonly DEFAULTSIDE = 0;

(cache)Search | DeepWiki

How rebuildNormals Works in CSG2.toVertexData

Configuration

Mechanism

Data Extraction

Notes

Motivation

Details

Motivation

Details

Motivation

Details

Motivation

Details

How `rebuildNormals` Works in `CSG2.toVertexData`