brep-io-kernel 1.0.0

package/src/features/plane/PlaneFeature.js

@@ -0,0 +1,154 @@
+import { BREP } from "../../BREP/BREP.js";
+const THREE = BREP.THREE;
+import { CADmaterials } from '../../UI/CADmaterials.js';
+
+export function createPlaneBaseMesh() {
+    const material = CADmaterials.PLANE.BASE;
+    const mesh = new THREE.Mesh(new THREE.PlaneGeometry(5, 5), material);
+    mesh.type = 'PLANE';
+    mesh.renderOrder = 1;
+    return mesh;
+}
+
+const inputParamsSchema = {
+    id: {
+        type: "string",
+        default_value: null,
+        hint: "unique identifier for the plane feature",
+    },
+    datum: {
+        type: "reference_selection",
+        selectionFilter: ["PLANE", "FACE"],
+        multiple: false,
+        default_value: null,
+        hint: "Optional reference plane or face",
+
+    },
+    orientation: {
+        type: "options",
+        options: ["XY", "XZ", "YZ"],
+        default_value: "XY",
+        hint: "Plane orientation",
+    },
+    offset_distance: {
+        type: "number",
+        default_value: 0,
+        hint: "Plane offset distance",
+    },
+};
+
+
+
+
+
+
+export class PlaneFeature {
+    static shortName = "P";
+    static longName = "Plane";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        
+        this.persistentData = {};
+    }
+    async run() {
+        const planeMesh = await this.createPlaneMesh();
+        if (!planeMesh) return { added: [], removed: [] };
+
+        const group = new THREE.Group();
+        group.renderOrder = 1;
+        const featureID = this.inputParams.featureID || null;
+        const label = planeMesh.name || featureID || 'Plane';
+        group.name = `D:${label}`;
+        group.type = 'DATUM';
+        group.add(planeMesh);
+
+        if (featureID != null) {
+            planeMesh.owningFeatureID = String(featureID);
+        }
+
+        return { added: [group], removed: [] };
+    }
+
+    async createPlaneMesh() {
+        // When sanitized, reference_selection becomes an array; treat empty as no datum
+        const datum = Array.isArray(this.inputParams.datum) ? this.inputParams.datum[0] : this.inputParams.datum;
+        const basis = datum ? this.#basisFromReference(datum) : this.#basisFromOrientation(this.inputParams.orientation);
+        if (!basis) return null;
+
+        const planeMesh = createPlaneBaseMesh();
+
+        const basisMatrix = new THREE.Matrix4().makeBasis(basis.x, basis.y, basis.z);
+        planeMesh.setRotationFromMatrix(basisMatrix);
+        planeMesh.position.copy(basis.origin);
+
+        const offset = Number(this.inputParams.offset_distance) || 0;
+        if (offset) planeMesh.position.addScaledVector(basis.z, offset);
+
+        //planeMesh.uuid = this.inputParams.featureID; // Assign the featureID to the mesh's uuid
+        planeMesh.name = this.inputParams.featureID; // Ensure selectable by name
+        return planeMesh;
+    }
+
+    #basisFromOrientation(orientation) {
+        const rotX = orientation === "XZ" ? Math.PI / 2 : 0;
+        const rotY = orientation === "YZ" ? Math.PI / 2 : 0;
+        const rot = new THREE.Euler(rotX, rotY, 0);
+        const origin = new THREE.Vector3(0, 0, 0);
+        const x = new THREE.Vector3(1, 0, 0).applyEuler(rot).normalize();
+        const y = new THREE.Vector3(0, 1, 0).applyEuler(rot).normalize();
+        const z = new THREE.Vector3(0, 0, 1).applyEuler(rot).normalize();
+        return { origin, x, y, z };
+    }
+
+    #basisFromReference(refObj) {
+        if (!refObj) return null;
+        const origin = new THREE.Vector3();
+        try { refObj.updateWorldMatrix(true, true); } catch { }
+
+        try {
+            const g = refObj.geometry;
+            if (g) {
+                const bs = g.boundingSphere || (g.computeBoundingSphere(), g.boundingSphere);
+                if (bs) origin.copy(refObj.localToWorld(bs.center.clone()));
+                else origin.copy(refObj.getWorldPosition(new THREE.Vector3()));
+            } else {
+                origin.copy(refObj.getWorldPosition(new THREE.Vector3()));
+            }
+        } catch {
+            origin.copy(refObj.getWorldPosition(new THREE.Vector3()));
+        }
+
+        if (refObj.type === 'FACE') {
+            let n = null;
+            try {
+                if (typeof refObj.getAverageNormal === 'function') n = refObj.getAverageNormal().clone();
+            } catch { n = null; }
+            if (!n || n.lengthSq() < 1e-12) {
+                const q = new THREE.Quaternion();
+                try { refObj.getWorldQuaternion(q); } catch { }
+                n = new THREE.Vector3(0, 0, 1).applyQuaternion(q);
+            }
+            n.normalize();
+
+            const worldUp = new THREE.Vector3(0, 1, 0);
+            const refUp = Math.abs(n.dot(worldUp)) > 0.9 ? new THREE.Vector3(1, 0, 0) : worldUp;
+            const x = new THREE.Vector3().crossVectors(refUp, n).normalize();
+            const y = new THREE.Vector3().crossVectors(n, x).normalize();
+            return { origin, x, y, z: n };
+        }
+
+        try {
+            const q = new THREE.Quaternion();
+            refObj.getWorldQuaternion(q);
+            const x = new THREE.Vector3(1, 0, 0).applyQuaternion(q).normalize();
+            const y = new THREE.Vector3(0, 1, 0).applyQuaternion(q).normalize();
+            const z = new THREE.Vector3(0, 0, 1).applyQuaternion(q).normalize();
+            return { origin, x, y, z };
+        } catch {
+            return this.#basisFromOrientation(this.inputParams.orientation);
+        }
+    }
+
+}

package/src/features/primitiveCone/primitiveConeFeature.js

@@ -0,0 +1,99 @@
+// primitiveConeFeature.js
+// Creates a primitive cone/frustum as separate meshes per surface: lateral (side) and caps.
+// Aligned along the Y axis with base at y=0 and top at y=height (not centered).
+
+import { BREP } from '../../BREP/BREP.js'
+// no extra imports needed for centerline metadata
+
+const inputParamsSchema = {
+  id: {
+    type: 'string',
+    default_value: null,
+    hint: 'Unique identifier for the feature'
+  },
+  radiusTop: {
+    type: 'number',
+    default_value: 5,
+    hint: 'Top radius of the cone (tip if 0)'
+  },
+  radiusBottom: {
+    type: 'number',
+    default_value: 10,
+    hint: 'Base radius of the cone'
+  },
+  height: {
+    type: 'number',
+    default_value: 10,
+    hint: 'Height of the cone along Y-axis'
+  },
+  resolution: {
+    type: 'number',
+    default_value: 32,
+    hint: 'Number of segments around the circumference'
+  },
+  transform: {
+    type: 'transform',
+    default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+    hint: 'Position, rotation, and scale'
+  },
+  boolean: {
+    type: 'boolean_operation',
+    default_value: { targets: [], operation: 'NONE' },
+    hint: 'Optional boolean operation with selected solids'
+  }
+};
+
+export class PrimitiveConeFeature {
+    static shortName = "P.CO";
+    static longName = "Primitive Cone";
+    static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  async run(partHistory) {
+    const { radiusTop, radiusBottom, height, resolution } = this.inputParams;
+
+    const cone = await new BREP.Cone({
+      r1: radiusTop,
+      r2: radiusBottom,
+      h: height,
+      resolution,
+      name: this.inputParams.featureID
+    });
+    try {
+      if (this.inputParams.transform) {
+        cone.bakeTRS(this.inputParams.transform);
+      }
+    } catch (_) { }
+
+    // Add a world-space centerline along Y from base to top and store on the solid
+    const THREE = BREP.THREE;
+    try {
+      const p = Array.isArray(this.inputParams?.transform?.position) ? this.inputParams.transform.position : [0, 0, 0];
+      const r = Array.isArray(this.inputParams?.transform?.rotationEuler) ? this.inputParams.transform.rotationEuler : [0, 0, 0];
+      const s = Array.isArray(this.inputParams?.transform?.scale) ? this.inputParams.transform.scale : [1, 1, 1];
+      const pos = new THREE.Vector3(p[0] || 0, p[1] || 0, p[2] || 0);
+      const eul = new THREE.Euler(
+        THREE.MathUtils.degToRad(r[0] || 0),
+        THREE.MathUtils.degToRad(r[1] || 0),
+        THREE.MathUtils.degToRad(r[2] || 0),
+        'XYZ'
+      );
+      const quat = new THREE.Quaternion().setFromEuler(eul);
+      const scl = new THREE.Vector3(s[0] || 1, s[1] || 1, s[2] || 1);
+      const M = new THREE.Matrix4().compose(pos, quat, scl);
+      const a0 = new THREE.Vector3(0, 0, 0).applyMatrix4(M);
+      const a1 = new THREE.Vector3(0, Number(height) || 0, 0).applyMatrix4(M);
+      if (a0.distanceToSquared(a1) >= 1e-16) {
+        const featureID = this.inputParams.featureID;
+        cone.addCenterline([a0.x, a0.y, a0.z], [a1.x, a1.y, a1.z], (featureID ? `${featureID}_AXIS` : 'AXIS'), { materialKey: 'OVERLAY' });
+      }
+    } catch (_) { }
+
+    cone.visualize();
+    return await BREP.applyBooleanOperation(partHistory || {}, cone, this.inputParams.boolean, this.inputParams.featureID);
+  }
+}

package/src/features/primitiveCube/primitiveCubeFeature.js

@@ -0,0 +1,70 @@
+// primitiveCubeFeature.js
+// Creates a primitive axis-aligned rectangular prism (cube) composed of six Face objects.
+// Positioned with its minimum corner at the origin (0,0,0). Dimensions extend +sizeX, +sizeY, +sizeZ along X/Y/Z.
+
+import { BREP } from '../../BREP/BREP.js'
+
+const inputParamsSchema = {
+    id: {
+        type: 'string',
+        default_value: null,
+        hint: 'Unique identifier for the feature'
+    },
+    sizeX: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Width along X'
+    },
+    sizeY: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Height along Y'
+    },
+    sizeZ: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Depth along Z'
+    },
+    transform: {
+        type: 'transform',
+        default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+        hint: 'Position, rotation, and scale'
+    },
+    boolean: {
+        type: 'boolean_operation',
+        default_value: { targets: [], operation: 'NONE' },
+        hint: 'Optional boolean operation with selected solids'
+    }
+};
+
+export class PrimitiveCubeFeature {
+    static shortName = "P.CU";
+    static longName = "Primitive Cube";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+    async run(partHistory) {
+        const { sizeX, sizeY, sizeZ, featureID } = this.inputParams;
+
+        const cube = await new BREP.Cube({
+            x: sizeX,
+            y: sizeY,
+            z: sizeZ,
+            name: featureID,
+        });
+        // Apply transform before visualization so it bakes into geometry arrays
+        try {
+            if (this.inputParams.transform) {
+                cube.bakeTRS(this.inputParams.transform);
+            }
+        } catch (_) { alert("Error applying transform"); }
+        cube.visualize();
+
+        // Apply optional boolean operation
+        return await BREP.applyBooleanOperation(partHistory || {}, cube, this.inputParams.boolean, featureID);
+    }
+}

package/src/features/primitiveCylinder/primitiveCylinderFeature.js

@@ -0,0 +1,91 @@
+// primitiveCylinderFeature.js
+// Creates a primitive cylinder as separate faces: lateral (side) and two caps.
+// Aligned along the Y axis with base at y=0 and top at y=height (not centered).
+
+import { BREP } from '../../BREP/BREP.js'
+// no extra imports needed for centerline metadata
+
+const inputParamsSchema = {
+    id: {
+        type: 'string',
+        default_value: null,
+        hint: 'Unique identifier for the feature'
+    },
+    radius: {
+        type: 'number',
+        default_value: 5,
+        hint: 'Radius of the cylinder'
+    },
+    height: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Height of the cylinder along Y-axis'
+    },
+    resolution: {
+        type: 'number',
+        default_value: 64,
+        hint: 'Number of segments around the circumference'
+    },
+    transform: {
+        type: 'transform',
+        default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+        hint: 'Position, rotation, and scale'
+    },
+    boolean: {
+        type: 'boolean_operation',
+        default_value: { targets: [], operation: 'NONE' },
+        hint: 'Optional boolean operation with selected solids'
+    }
+};
+
+export class PrimitiveCylinderFeature {
+    static shortName = "P.CY";
+    static longName = "Primitive Cylinder";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+  async run(partHistory) {
+        const { radius, height, resolution, featureID } = this.inputParams;
+
+        const cyl = await new BREP.Cylinder({
+            radius,
+            height,
+            resolution,
+            name: featureID,
+        });
+        try {
+            if (this.inputParams.transform) {
+                cyl.bakeTRS(this.inputParams.transform);
+            }
+        } catch (_) { }
+        // Build world-space centerline along cylinder axis and store on the solid.
+        const THREE = BREP.THREE;
+        try {
+            const p = Array.isArray(this.inputParams?.transform?.position) ? this.inputParams.transform.position : [0, 0, 0];
+            const r = Array.isArray(this.inputParams?.transform?.rotationEuler) ? this.inputParams.transform.rotationEuler : [0, 0, 0];
+            const s = Array.isArray(this.inputParams?.transform?.scale) ? this.inputParams.transform.scale : [1, 1, 1];
+            const pos = new THREE.Vector3(p[0] || 0, p[1] || 0, p[2] || 0);
+            const eul = new THREE.Euler(
+                THREE.MathUtils.degToRad(r[0] || 0),
+                THREE.MathUtils.degToRad(r[1] || 0),
+                THREE.MathUtils.degToRad(r[2] || 0),
+                'XYZ'
+            );
+            const quat = new THREE.Quaternion().setFromEuler(eul);
+            const scl = new THREE.Vector3(s[0] || 1, s[1] || 1, s[2] || 1);
+            const M = new THREE.Matrix4().compose(pos, quat, scl);
+            const a0 = new THREE.Vector3(0, 0, 0).applyMatrix4(M);
+            const a1 = new THREE.Vector3(0, Number(height) || 0, 0).applyMatrix4(M);
+            if (a0.distanceToSquared(a1) >= 1e-16) {
+                cyl.addCenterline([a0.x, a0.y, a0.z], [a1.x, a1.y, a1.z], (featureID ? `${featureID}_AXIS` : 'AXIS'), { materialKey: 'OVERLAY' });
+            }
+        } catch (_) { }
+
+        cyl.visualize();
+        return await BREP.applyBooleanOperation(partHistory || {}, cyl, this.inputParams.boolean, featureID);
+  }
+}

package/src/features/primitivePyramid/primitivePyramidFeature.js

@@ -0,0 +1,72 @@
+// primitivePyramidFeature.js
+// Creates a primitive right pyramid as a Solid composed of Face objects:
+// - One triangular Face per lateral side
+// - One polygonal base Face (triangulated fan, combined into a single geometry)
+// Aligned along the Y axis, centered at the origin,
+// with the apex at +height/2 and the base plane at -height/2.
+
+import { BREP } from '../../BREP/BREP.js'
+
+const inputParamsSchema = {
+    id: {
+        type: 'string',
+        default_value: null,
+        hint: 'Unique identifier for the feature'
+    },
+    baseSideLength: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Side length of the regular base polygon'
+    },
+    sides: {
+        type: 'number',
+        default_value: 4,
+        hint: 'Number of sides for the base polygon (min 3)'
+    },
+    height: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Height of the pyramid along Y-axis'
+    },
+    transform: {
+        type: 'transform',
+        default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+        hint: 'Position, rotation, and scale'
+    },
+    boolean: {
+        type: 'boolean_operation',
+        default_value: { targets: [], operation: 'NONE' },
+        hint: 'Optional boolean operation with selected solids'
+    }
+};
+
+export class PrimitivePyramidFeature {
+    static shortName = "P.PY";
+    static longName = "Primitive Pyramid";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        
+        this.persistentData = {};
+    }
+
+    async run(partHistory) {
+        const { baseSideLength, sides, height, featureID } = this.inputParams;
+
+        const pyramid = await new BREP.Pyramid({
+            bL: baseSideLength,
+            s: sides,
+            h: height,
+            name: featureID,
+        });
+        try {
+            if (this.inputParams.transform) {
+                pyramid.bakeTRS(this.inputParams.transform);
+            }
+        } catch (_) { }
+        pyramid.visualize();
+
+        return await BREP.applyBooleanOperation(partHistory || {}, pyramid, this.inputParams.boolean, featureID);
+    }
+}

package/src/features/primitiveSphere/primitiveSphereFeature.js

@@ -0,0 +1,62 @@
+// primitiveSphereFeature.js
+// Creates a primitive sphere as a Solid containing a single Face (one analytic surface).
+// Centered at the origin, aligned with the Y axis (poles at ±radius along Y).
+
+import { BREP } from '../../BREP/BREP.js'
+
+const inputParamsSchema = {
+    id: {
+        type: 'string',
+        default_value: null,
+        hint: 'Unique identifier for the feature'
+    },
+    radius: {
+        type: 'number',
+        default_value: 5,
+        hint: 'Radius of the sphere'
+    },
+    resolution: {
+        type: 'number',
+        default_value: 32,
+        hint: 'Base segment count (longitude). Latitude segments are derived from this.'
+    },
+    transform: {
+        type: 'transform',
+        default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+        hint: 'Position, rotation, and scale'
+    },
+    boolean: {
+        type: 'boolean_operation',
+        default_value: { targets: [], operation: 'NONE' },
+        hint: 'Optional boolean operation with selected solids'
+    }
+};
+
+export class PrimitiveSphereFeature {
+    static shortName = "P.S";
+    static longName = "Primitive Sphere";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+    async run(partHistory) {
+        const { radius, resolution, featureID } = this.inputParams;
+
+        const sphere = await new BREP.Sphere({
+            r: radius,
+            resolution,
+            name: featureID,
+        });
+        try {
+            if (this.inputParams.transform) {
+                sphere.bakeTRS(this.inputParams.transform);
+            }
+        } catch (_) { }
+        sphere.visualize();
+
+        return await BREP.applyBooleanOperation(partHistory || {}, sphere, this.inputParams.boolean, featureID);
+    }
+}

package/src/features/primitiveTorus/primitiveTorusFeature.js

@@ -0,0 +1,109 @@
+// primitiveTorusFeature.js
+// Creates a primitive torus as a Solid composed of Face objects.
+// If arc < 360°, adds end-cap Faces to close the open torus, matching
+// the original orientation (start cap built at θ=0 with normal (0,-1,0),
+// end cap is a rotated clone about +Z by the sweep arc).
+
+import { BREP } from '../../BREP/BREP.js'
+// no extra imports needed for centerline metadata
+
+const inputParamsSchema = {
+    id: {
+        type: 'string',
+        default_value: null,
+        hint: 'Unique identifier for the feature'
+    },
+    majorRadius: {
+        type: 'number',
+        default_value: 10,
+        hint: 'Distance from center to the centerline of the tube (R)'
+    },
+    tubeRadius: {
+        type: 'number',
+        default_value: 2,
+        hint: 'Radius of the tube (r)'
+    },
+    resolution: {
+        type: 'number',
+        default_value: 64,
+        hint: 'Quality resolution (base setting for segments)'
+    },
+    arc: {
+        type: 'number',
+        default_value: 360,
+        hint: 'Sweep angle of the torus in degrees (0, 360]'
+    },
+    transform: {
+        type: 'transform',
+        default_value: { position: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1] },
+        hint: 'Position, rotation, and scale'
+    },
+    boolean: {
+        type: 'boolean_operation',
+        default_value: { targets: [], operation: 'NONE' },
+        hint: 'Optional boolean operation with selected solids'
+    }
+};
+
+export class PrimitiveTorusFeature {
+    static shortName = "P.T";
+    static longName = "Primitive Torus";
+    static inputParamsSchema = inputParamsSchema;
+
+    constructor() {
+        this.inputParams = {};
+        this.persistentData = {};
+    }
+
+    async run(partHistory) {
+        let {
+            majorRadius,
+            tubeRadius,
+            resolution,
+            arc,
+            featureID
+        } = this.inputParams;
+
+        const torus = await new BREP.Torus({
+            mR: majorRadius,
+            tR: tubeRadius,
+            resolution,
+            arcDegrees: arc,
+            name: featureID,
+        });
+        try {
+            if (this.inputParams.transform) {
+                torus.bakeTRS(this.inputParams.transform);
+            }
+        } catch (_) { }
+
+        // Add a world-space centerline edge along the torus revolve axis (Y).
+        // Choose a length that spans the torus extents and store on the solid.
+        const THREE = BREP.THREE;
+        try {
+            const p = Array.isArray(this.inputParams?.transform?.position) ? this.inputParams.transform.position : [0, 0, 0];
+            const r = Array.isArray(this.inputParams?.transform?.rotationEuler) ? this.inputParams.transform.rotationEuler : [0, 0, 0];
+            const s = Array.isArray(this.inputParams?.transform?.scale) ? this.inputParams.transform.scale : [1, 1, 1];
+            const pos = new THREE.Vector3(p[0] || 0, p[1] || 0, p[2] || 0);
+            const eul = new THREE.Euler(
+                THREE.MathUtils.degToRad(r[0] || 0),
+                THREE.MathUtils.degToRad(r[1] || 0),
+                THREE.MathUtils.degToRad(r[2] || 0),
+                'XYZ'
+            );
+            const quat = new THREE.Quaternion().setFromEuler(eul);
+            const scl = new THREE.Vector3(s[0] || 1, s[1] || 1, s[2] || 1);
+            const M = new THREE.Matrix4().compose(pos, quat, scl);
+
+            const L = 2 * (Math.abs(Number(majorRadius) || 0) + Math.abs(Number(tubeRadius) || 0));
+            const a0 = new THREE.Vector3(0, -0.5 * L, 0).applyMatrix4(M);
+            const a1 = new THREE.Vector3(0, +0.5 * L, 0).applyMatrix4(M);
+            if (a0.distanceToSquared(a1) >= 1e-16) {
+                torus.addCenterline([a0.x, a0.y, a0.z], [a1.x, a1.y, a1.z], (featureID ? `${featureID}_AXIS` : 'AXIS'), { materialKey: 'OVERLAY' });
+            }
+        } catch (_) { }
+
+        torus.visualize();
+        return await BREP.applyBooleanOperation(partHistory || {}, torus, this.inputParams.boolean, featureID);
+    }
+}