opengeometry 0.0.6 → 1.0.9

package/src/primitives/polyline.d.ts

@@ -4,23 +4,34 @@ export interface IPolylineOptions {
     ogid?: string;
     color: number;
     points: Vector3[];
+    fatLines?: boolean;
+    width?: number;
+}
+export type PolylineConfigUpdate = Partial<IPolylineOptions>;
+export interface IOffsetResult {
+    points: Vector3[];
+    beveledVertexIndices: number[];
+    isClosed: boolean;
 }
 export declare class Polyline extends THREE.Line {
-    #private;
     ogid: string;
     options: IPolylineOptions;
     isClosed: boolean;
     private polyline;
+    private fatLine;
     transformationMatrix: THREE.Matrix4;
     set color(color: number);
     constructor(options?: IPolylineOptions);
     validateOptions(): void;
-    setConfig(options: IPolylineOptions): void;
+    setConfig(options: PolylineConfigUpdate): void;
     addPoint(point: Vector3): void;
     /**
      * Every time there are property changes, geometry needs to be discarded and regenerated.
      * This is to ensure that the geometry is always up-to-date with the current state.
      */
     discardGeometry(): void;
+    private getCurrentPositions;
+    private updateRenderStyle;
     private generateGeometry;
+    getOffset(distance: number, acuteThresholdDegrees?: number, bevel?: boolean): IOffsetResult;
 }

package/src/primitives/rectangle.d.ts

@@ -6,17 +6,29 @@ export interface IRectangleOptions {
     width: number;
     breadth: number;
     color: number;
+    fatLines?: boolean;
+    lineWidth?: number;
+}
+export type RectangleConfigUpdate = Partial<IRectangleOptions>;
+export interface IRectangleOffsetResult {
+    points: Vector3[];
+    beveledVertexIndices: number[];
+    isClosed: boolean;
 }
 export declare class Rectangle extends THREE.Line {
     ogid: string;
     options: IRectangleOptions;
     private polyLineRectangle;
+    private fatLine;
     set color(color: number);
     constructor(options?: IRectangleOptions);
     validateOptions(): void;
-    setConfig(options: IRectangleOptions): void;
+    setConfig(options: RectangleConfigUpdate): void;
     getConfig(): IRectangleOptions;
+    private getCurrentPositions;
+    private updateRenderStyle;
     private generateGeometry;
     getBrep(): any;
+    getOffset(distance: number, acuteThresholdDegrees?: number, bevel?: boolean): IRectangleOffsetResult;
     discardGeometry(): void;
 }

package/src/shapes/boolean-subtract.d.ts

@@ -0,0 +1,8 @@
+import type { BooleanExecutionOptions, BooleanOperand, BooleanResult } from "../operations/boolean";
+export type ShapeSubtractOperand = BooleanOperand;
+export type ShapeSubtractOptions = BooleanExecutionOptions;
+export type ShapeSubtractResult = BooleanResult;
+/**
+ * Executes a kernel-backed subtraction for a shape wrapper against another boolean operand.
+ */
+export declare function subtractShapeOperand(host: ShapeSubtractOperand, operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;

package/src/shapes/cuboid.d.ts

@@ -1,5 +1,7 @@
 import { Vector3 } from "../../../opengeometry/pkg/opengeometry";
 import * as THREE from "three";
+import { ShapeOutlineMesh } from "./outline-utils";
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
 export interface ICuboidOptions {
     ogid?: string;
     center: Vector3;
@@ -7,22 +9,39 @@ export interface ICuboidOptions {
     height: number;
     depth: number;
     color: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
 }
+export type CuboidConfigUpdate = Partial<ICuboidOptions>;
 export declare class Cuboid extends THREE.Mesh {
     #private;
     ogid: string;
     options: ICuboidOptions;
     private cuboid;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
     private _geometryCenterOffset;
     set width(value: number);
     set color(color: number);
     constructor(options?: ICuboidOptions);
     validateOptions(): void;
-    setConfig(options: ICuboidOptions): void;
+    getConfig(): ICuboidOptions;
+    setConfig(options: CuboidConfigUpdate): void;
     cleanGeometry(): void;
     generateGeometry(): void;
     getBrepData(): any;
+    /**
+     * Subtracts another boolean operand, such as an Opening, from this cuboid.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
     set outline(enable: boolean);
-    get outlineMesh(): THREE.Line<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | null;
+    get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
+    get outlineMesh(): ShapeOutlineMesh | null;
+    private clearOutlineMesh;
     discardGeometry(): void;
 }

package/src/shapes/cylinder.d.ts

@@ -1,5 +1,6 @@
 import { Vector3 } from "../../../opengeometry/pkg/opengeometry";
 import * as THREE from "three";
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
 export interface ICylinderOptions {
     ogid?: string;
     center: Vector3;
@@ -8,20 +9,36 @@ export interface ICylinderOptions {
     segments: number;
     angle: number;
     color: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
 }
+export type CylinderConfigUpdate = Partial<ICylinderOptions>;
 export declare class Cylinder extends THREE.Mesh {
     #private;
     ogid: string;
     options: ICylinderOptions;
     private cylinder;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
     set radius(value: number);
     set color(color: number);
     constructor(options?: ICylinderOptions);
     validateOptions(): void;
-    setConfig(options: ICylinderOptions): void;
+    setConfig(options: CylinderConfigUpdate): void;
     cleanGeometry(): void;
     generateGeometry(): void;
     getBrep(): any;
+    /**
+     * Subtracts another boolean operand, such as an Opening, from this cylinder.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
     set outline(enable: boolean);
+    get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
+    private clearOutlineMesh;
     discardGeometry(): void;
 }

package/src/shapes/index.d.ts

@@ -1,4 +1,10 @@
+/**
+ * High-level 3D shape wrappers backed by the OpenGeometry kernel.
+ */
 export * from './polygon';
 export * from './cylinder';
 export * from './cuboid';
 export * from './opening';
+export * from './sphere';
+export * from './wedge';
+export * from './sweep';

package/src/shapes/opening.d.ts

@@ -1,18 +1,26 @@
 import { Vector3 } from "./../../../opengeometry/pkg/opengeometry";
 import * as THREE from "three";
-interface IOpeningOptions {
+import { ShapeOutlineMesh } from "./outline-utils";
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
+export interface IOpeningOptions {
     ogid?: string;
     center: Vector3;
     width: number;
     height: number;
     depth: number;
     color: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
 }
+export type OpeningConfigUpdate = Partial<IOpeningOptions>;
 export declare class Opening extends THREE.Mesh {
     #private;
     ogid: string;
     options: IOpeningOptions;
     private opening;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
     private _geometryCenterOffset;
     set width(value: number);
     set height(value: number);
@@ -24,12 +32,25 @@ export declare class Opening extends THREE.Mesh {
     };
     constructor(options?: IOpeningOptions);
     validateOptions(): void;
-    setConfig(options: IOpeningOptions): void;
+    setConfig(options: OpeningConfigUpdate): void;
     cleanGeometry(): void;
     generateGeometry(): void;
     getBrepData(): any;
+    /**
+     * Subtracts another boolean operand from this opening volume.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
+    /**
+     * Uses this opening volume to cut a host shape.
+     */
+    subtractFrom(host: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
     set outline(enable: boolean);
-    get outlineMesh(): THREE.Line<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | null;
+    get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
+    get outlineMesh(): ShapeOutlineMesh | null;
+    private clearOutlineMesh;
     discardGeometry(): void;
 }
-export {};

package/src/shapes/outline-utils.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
+export type ShapeOutlineMesh = THREE.LineSegments | LineSegments2;
+export interface ShapeOutlineMeshOptions {
+    positions: number[];
+    color?: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
+}
+export declare function sanitizeOutlineWidth(width?: number): number;
+export declare function createShapeOutlineMesh({ positions, color, fatOutlines, outlineWidth, }: ShapeOutlineMeshOptions): ShapeOutlineMesh;
+export declare function disposeShapeOutlineMesh(mesh: ShapeOutlineMesh | null): void;
+export declare function setShapeOutlineColor(mesh: ShapeOutlineMesh | null, color: number): void;
+export declare function getShapeOutlineColor(mesh: ShapeOutlineMesh | null, fallback?: number): number;

package/src/shapes/polygon.d.ts

@@ -1,29 +1,50 @@
 import * as THREE from "three";
 import { OGPolygon, Vector3 } from "../../../opengeometry/pkg/opengeometry";
-interface IPolygonOptions {
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
+export interface IPolygonOptions {
+    ogid?: string;
     vertices: Vector3[];
+    holes?: Vector3[][];
+    color: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
 }
+export type PolygonConfigUpdate = Partial<IPolygonOptions>;
 export declare class Polygon extends THREE.Mesh {
     #private;
     ogid: string;
     options: IPolygonOptions;
     polygon: OGPolygon;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
+    private _outlineColor;
     transformationMatrix: THREE.Matrix4;
     set color(color: number);
+    get color(): number;
     private _geometryCenterOffset;
     constructor(options?: IPolygonOptions);
     validateOptions(): void;
-    setConfig(): void;
+    setConfig(options: PolygonConfigUpdate): void;
+    cleanGeometry(): void;
     generateGeometry(): void;
     addVertices(vertices: Vector3[]): void;
     saveTransformationToBREP(): void;
     addHole(holeVertices: Vector3[]): void;
     getBrepData(): string | null;
+    /**
+     * Subtracts another boolean operand from this polygon.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
     set outlineColor(color: number);
     get outlineColor(): number;
     set outline(enable: boolean);
     get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
     disposeGeometryMaterial(): void;
+    private clearOutlineMesh;
     dispose(): void;
 }
-export {};

package/src/shapes/sphere.d.ts

@@ -0,0 +1,45 @@
+import { Vector3 } from "../../../opengeometry/pkg/opengeometry";
+import * as THREE from "three";
+import { ShapeOutlineMesh } from "./outline-utils";
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
+export interface ISphereOptions {
+    ogid?: string;
+    center: Vector3;
+    radius: number;
+    widthSegments: number;
+    heightSegments: number;
+    color: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
+}
+export type SphereConfigUpdate = Partial<ISphereOptions>;
+export declare class Sphere extends THREE.Mesh {
+    #private;
+    ogid: string;
+    options: ISphereOptions;
+    private sphere;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
+    set radius(value: number);
+    set color(color: number);
+    constructor(options?: ISphereOptions);
+    validateOptions(): void;
+    setConfig(options: SphereConfigUpdate): void;
+    cleanGeometry(): void;
+    generateGeometry(): void;
+    getBrep(): any;
+    /**
+     * Subtracts another boolean operand, such as an Opening, from this sphere.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
+    set outline(enable: boolean);
+    get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
+    get outlineMesh(): ShapeOutlineMesh | null;
+    private clearOutlineMesh;
+    discardGeometry(): void;
+}

package/src/shapes/sweep.d.ts

@@ -0,0 +1,42 @@
+import { Vector3 } from "../../../opengeometry/pkg/opengeometry";
+import * as THREE from "three";
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
+export interface ISweepOptions {
+    ogid?: string;
+    path: Vector3[];
+    profile: Vector3[];
+    color: number;
+    capStart?: boolean;
+    capEnd?: boolean;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
+}
+export type SweepConfigUpdate = Partial<ISweepOptions>;
+export declare class Sweep extends THREE.Mesh {
+    #private;
+    ogid: string;
+    options: ISweepOptions;
+    private sweep;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
+    set color(color: number);
+    constructor(options?: ISweepOptions);
+    validateOptions(): void;
+    setConfig(options: SweepConfigUpdate): void;
+    cleanGeometry(): void;
+    generateGeometry(): void;
+    getBrep(): any;
+    /**
+     * Subtracts another boolean operand, such as an Opening, from this sweep.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
+    set outline(enable: boolean);
+    get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
+    private clearOutlineMesh;
+    discardGeometry(): void;
+}

package/src/shapes/swept-shape.d.ts

@@ -0,0 +1,63 @@
+import * as THREE from "three";
+import { OGSweptShape, Vector3 } from "../../../opengeometry/pkg/opengeometry";
+interface ISweptShapeOptions {
+    ogid?: string;
+    color?: number;
+    profileVertices?: Vector3[];
+    pathPoints?: Vector3[];
+}
+/**
+ * SweptShape class that extends THREE.Mesh
+ * Creates a 3D shape by sweeping a 2D profile along a 3D path
+ */
+export declare class SweptShape extends THREE.Mesh {
+    #private;
+    ogid: string;
+    options: ISweptShapeOptions;
+    sweptShape: OGSweptShape;
+    transformationMatrix: THREE.Matrix4;
+    get color(): number;
+    set color(color: number);
+    constructor(options?: ISweptShapeOptions);
+    validateOptions(): void;
+    setConfig(options?: ISweptShapeOptions): void;
+    /**
+     * Generate geometry from the swept shape
+     */
+    generateGeometry(): void;
+    /**
+     * Set the profile vertices for the sweep operation
+     */
+    setProfileVertices(vertices: Vector3[]): void;
+    /**
+     * Set the path points for the sweep operation
+     */
+    setPathPoints(points: Vector3[]): void;
+    /**
+     * Create a swept shape from a profile and path
+     */
+    sweepAlongPath(profileVertices: Vector3[], pathPoints: Vector3[]): void;
+    /**
+     * Get the B-Rep data from the swept shape
+     */
+    getBrepData(): string | null;
+    /**
+     * Clear the swept shape data
+     */
+    clearSweptShape(): void;
+    /**
+     * Dispose of geometry and material resources
+     */
+    disposeGeometry(): void;
+    /**
+     * Enable/disable outline rendering
+     */
+    set outline(enable: boolean);
+    get outline(): boolean;
+    get outlineMesh(): THREE.Line | null;
+    /**
+     * Dispose of all resources when the object is destroyed
+     */
+    dispose(): void;
+}
+export {};

package/src/shapes/wedge.d.ts

@@ -0,0 +1,44 @@
+import { Vector3 } from "../../../opengeometry/pkg/opengeometry";
+import * as THREE from "three";
+import { ShapeOutlineMesh } from "./outline-utils";
+import type { ShapeSubtractOperand, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract";
+export interface IWedgeOptions {
+    ogid?: string;
+    center: Vector3;
+    width: number;
+    height: number;
+    depth: number;
+    color: number;
+    fatOutlines?: boolean;
+    outlineWidth?: number;
+}
+export type WedgeConfigUpdate = Partial<IWedgeOptions>;
+export declare class Wedge extends THREE.Mesh {
+    #private;
+    ogid: string;
+    options: IWedgeOptions;
+    private wedge;
+    private _outlineEnabled;
+    private _fatOutlines;
+    private _outlineWidth;
+    set color(color: number);
+    constructor(options?: IWedgeOptions);
+    validateOptions(): void;
+    setConfig(options: WedgeConfigUpdate): void;
+    cleanGeometry(): void;
+    generateGeometry(): void;
+    getBrepData(): any;
+    /**
+     * Subtracts another boolean operand, such as an Opening, from this wedge.
+     */
+    subtract(operand: ShapeSubtractOperand, options?: ShapeSubtractOptions): ShapeSubtractResult;
+    set outline(enable: boolean);
+    get outline(): boolean;
+    set fatOutlines(value: boolean);
+    get fatOutlines(): boolean;
+    set outlineWidth(value: number);
+    get outlineWidth(): number;
+    get outlineMesh(): ShapeOutlineMesh | null;
+    private clearOutlineMesh;
+    discardGeometry(): void;
+}