opengeometry 2.0.11 → 2.0.14

package/src/shapes/analytic-solid.d.ts

@@ -0,0 +1,288 @@
+import * as THREE from "three";
+import { type AnalyticTessellationData } from "../rendering/analytic-tessellation.js";
+import { AnalyticExchangeBodyV2 } from "../export/analytic-ifc.js";
+export interface AnalyticFrame {
+    origin: [number, number, number];
+    x: [number, number, number];
+    y: [number, number, number];
+    z: [number, number, number];
+}
+export interface AnalyticAccuracy {
+    geometric: number;
+    intersection: number;
+    tessellation: number;
+    exchange: number;
+}
+export interface AnalyticCircularWallOpening {
+    id: string;
+    angle: number;
+    width: number;
+    bottom: number;
+    height: number;
+}
+export type AnalyticPolygonLoftAlignment = "auto" | {
+    upperStartIndex: number;
+    reverseUpper?: boolean;
+};
+export interface AnalyticProjectionCamera {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    target: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    up: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    near: number;
+    projection_mode: "Orthographic" | "Perspective";
+}
+export interface AnalyticProjectionHlr {
+    hide_hidden_edges: boolean;
+}
+interface AnalyticOptions {
+    ogid?: string;
+    frame?: AnalyticFrame;
+    accuracy?: AnalyticAccuracy;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+}
+export type AnalyticPrimitiveOptions = AnalyticOptions & ({
+    kind: "cuboid";
+    width: number;
+    depth: number;
+    height: number;
+} | {
+    kind: "linearExtrusion";
+    outer: [number, number][];
+    holes: [number, number][][];
+    height: number;
+} | {
+    kind: "polygonLoft";
+    lower: [number, number, number][];
+    upper: [number, number, number][];
+    alignment?: AnalyticPolygonLoftAlignment;
+} | {
+    kind: "straightWallWithArchedOpening";
+    width: number;
+    depth: number;
+    height: number;
+    opening: {
+        id: string;
+        station: number;
+        width: number;
+        bottom: number;
+        height: number;
+    };
+} | {
+    kind: "planarPolyhedron";
+    vertices: [number, number, number][];
+    faces: number[][];
+} | {
+    kind: "cylinder" | "cone";
+    radius: number;
+    height: number;
+} | {
+    kind: "cylinderSector";
+    radius: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+} | {
+    kind: "sphere";
+    radius: number;
+} | {
+    kind: "frustum";
+    lowerRadius: number;
+    upperRadius: number;
+    height: number;
+} | {
+    kind: "torus";
+    majorRadius: number;
+    minorRadius: number;
+} | {
+    kind: "circularWall";
+    radius: number;
+    thickness: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+} | {
+    kind: "circularWallWithOpenings";
+    radius: number;
+    thickness: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+    openings: AnalyticCircularWallOpening[];
+} | {
+    kind: "circularWallWithArchedOpening";
+    radius: number;
+    thickness: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+    opening: AnalyticCircularWallOpening;
+} | {
+    kind: "coaxialCircleLoft";
+    lowerRadius: number;
+    upperRadius: number;
+    height: number;
+} | {
+    kind: "revolvedRectangle";
+    innerRadius: number;
+    outerRadius: number;
+    height: number;
+} | {
+    kind: "chamferedCuboid";
+    width: number;
+    depth: number;
+    height: number;
+    chamfer: number;
+} | {
+    kind: "filletedCylinder";
+    radius: number;
+    height: number;
+    filletRadius: number;
+});
+export type AnalyticBooleanOp = "union" | "intersection" | "subtraction";
+export type AnalyticPointClassification = "inside" | "outside" | "boundary" | "unknown";
+export interface AnalyticBooleanReport {
+    operation: AnalyticBooleanOp;
+    quality: {
+        kind: "Analytic";
+    };
+    contacts: [number, number, number][];
+    coincident: boolean;
+    face_mappings: {
+        source: {
+            entity: string;
+            body: string;
+            key: string;
+            face: number;
+        };
+        result_faces: number[];
+    }[];
+}
+export interface AnalyticBrepOptions extends Omit<AnalyticOptions, "ogid" | "frame" | "accuracy"> {
+    kind: "brep";
+    serialized: string;
+}
+export interface AnalyticTessellationStats {
+    requestedDeflection: number;
+    achievedDeflection: number;
+    triangleCount: number;
+    faceCount: number;
+    revision: bigint;
+}
+export interface AnalyticTessellationOptions {
+    maxTriangles?: number;
+}
+export interface AnalyticStepExport {
+    text: string;
+    report: {
+        schema_version: 2;
+        revision: string;
+        length_unit: "metre" | "millimetre";
+        quality: {
+            kind: string;
+        };
+        faces: number;
+        edges: number;
+        solids: number;
+        cavity_shells: number;
+        collapsed_chart_uses: number;
+        geometric_tolerance: number;
+        exchange_error_bound: number;
+        validation_level: string;
+    };
+}
+export interface AnalyticStlExport {
+    bytes: Uint8Array;
+    report: {
+        schema_version: 2;
+        revision: string;
+        triangle_count: number;
+        requested_deflection: number;
+        achieved_deflection: number;
+        float32_encoding_error: number;
+        quality: "tessellated_from_analytic_brep";
+    };
+}
+export declare class AnalyticSolid extends THREE.Group {
+    readonly ogid: string;
+    readonly surface: THREE.Mesh<THREE.BufferGeometry, THREE.MeshStandardMaterial>;
+    readonly featureOutline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    private kernel;
+    private triangleFaces;
+    private outlineEdges;
+    private disposed;
+    private lastDeflection;
+    private booleanReport?;
+    get report(): AnalyticBooleanReport | undefined;
+    get isDisposed(): boolean;
+    get modelRevision(): bigint;
+    get deflection(): number;
+    get color(): THREE.Color;
+    set color(value: THREE.ColorRepresentation);
+    get outline(): boolean;
+    set outline(value: boolean);
+    constructor(options: AnalyticPrimitiveOptions | AnalyticBrepOptions);
+    static fromBrep(serialized: string, options?: Omit<AnalyticBrepOptions, "kind" | "serialized">): AnalyticSolid;
+    boolean(other: AnalyticSolid, operation: AnalyticBooleanOp, options?: {
+        deflection?: number;
+        color?: THREE.ColorRepresentation;
+    }): AnalyticSolid;
+    union(other: AnalyticSolid, options?: {
+        deflection?: number;
+        color?: THREE.ColorRepresentation;
+    }): AnalyticSolid;
+    intersection(other: AnalyticSolid, options?: {
+        deflection?: number;
+        color?: THREE.ColorRepresentation;
+    }): AnalyticSolid;
+    subtract(cutters: AnalyticSolid[], options?: {
+        deflection?: number;
+        color?: THREE.ColorRepresentation;
+    }): AnalyticSolid;
+    shell(thickness: number, options?: {
+        deflection?: number;
+        color?: THREE.ColorRepresentation;
+    }): AnalyticSolid;
+    getBrepSerialized(): string;
+    getBrepData(): Record<string, unknown>;
+    /** Rebuilds authored analytic geometry while preserving the wrapper and placement. */
+    protected replaceDefinition(options: AnalyticPrimitiveOptions): AnalyticTessellationStats;
+    getWorldBrepSerialized(): string;
+    prepareIfcExchange(): AnalyticExchangeBodyV2;
+    exportIfc(): {
+        text: string;
+        report: AnalyticExchangeBodyV2;
+    };
+    /** Exports world placement and authored metre geometry, converted once to the selected STEP unit. */
+    exportStep(lengthUnit?: "metre" | "millimetre"): AnalyticStepExport;
+    /** Exports a binary STL tessellated from the placed analytic BRep at an explicit error budget. */
+    exportStl(deflection?: number): AnalyticStlExport;
+    faceIdForTriangle(triangle: number): number | undefined;
+    edgeIdForOutlineSegment(segment: number): number | undefined;
+    /** Evaluates the oriented support normal at a projected model-space point; this does not classify trim membership. */
+    normalAtFace(faceId: number, modelPoint: THREE.Vector3): THREE.Vector3;
+    /** Classifies a world-space point against the regularized material represented by this solid. */
+    classifyPoint(worldPoint: THREE.Vector3): AnalyticPointClassification;
+    projectTo2DLines(camera: AnalyticProjectionCamera, hlr: AnalyticProjectionHlr, deflection?: number): string;
+    getModelBounds(): THREE.Box3;
+    retessellate(deflection: number): AnalyticTessellationStats;
+    tessellate(deflection: number, options?: AnalyticTessellationOptions): AnalyticTessellationData;
+    /** Applies a transient worker mesh only when it still matches this authored model revision. */
+    applyTessellation(result: AnalyticTessellationData, deflection: number): AnalyticTessellationStats;
+    dispose(): void;
+    private checkActive;
+    private worldKernel;
+}
+export {};

package/src/shapes/cuboid.d.ts

@@ -1,76 +1,62 @@
 import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-import { ShapeOutlineMesh } from "./outline-utils.js";
-import type { ShapeSubtractOperands, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract.js";
-/**
- * Placement updates accepted by `Cuboid`.
- */
+import { AnalyticSolid, type AnalyticAccuracy } from "./analytic-solid.js";
 export interface CuboidPlacementOptions {
     translation?: Vector3;
     rotation?: Vector3;
     scale?: Vector3;
 }
-/**
- * Construction options for a cuboid shape.
- */
 export interface ICuboidOptions extends CuboidPlacementOptions {
+    ogid?: string;
+    center?: Vector3;
+    width?: number;
+    height?: number;
+    depth?: number;
+    color?: THREE.ColorRepresentation;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+}
+export type CuboidConfigUpdate = Partial<Omit<ICuboidOptions, "ogid" | "translation" | "rotation" | "scale">>;
+export type CuboidPlacementUpdate = CuboidPlacementOptions;
+interface NormalizedCuboidOptions {
     ogid?: string;
     center: Vector3;
     width: number;
     height: number;
     depth: number;
-    color: number;
-    fatOutlines?: boolean;
-    outlineWidth?: number;
+    color: THREE.ColorRepresentation;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    translation: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
 }
-/**
- * Partial config payload accepted by `Cuboid.setConfig(...)`.
- */
-export type CuboidConfigUpdate = Partial<Omit<ICuboidOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Cuboid` placement updates.
- */
-export type CuboidPlacementUpdate = CuboidPlacementOptions;
-/**
- * Box-shaped solid wrapper backed by the kernel cuboid primitive.
- */
-export declare class Cuboid extends THREE.Mesh {
-    #private;
-    ogid: string;
-    options: ICuboidOptions;
-    private cuboid;
-    private _outlineEnabled;
-    private _fatOutlines;
-    private _outlineWidth;
-    set width(value: number);
-    set color(color: number);
+/** Authoritative six-plane BRep with transient tessellation. */
+export declare class Cuboid extends AnalyticSolid {
+    options: NormalizedCuboidOptions;
     constructor(options?: ICuboidOptions);
-    getConfig(): ICuboidOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    setConfig(options: CuboidConfigUpdate): void;
-    generateGeometry(): void;
-    getBrepData(): any;
-    /**
-     * Subtracts one or more boolean operands, such as Opening volumes, from this cuboid.
-     */
-    subtract(operands: ShapeSubtractOperands, 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;
-    getAnchor(): Vector3;
-    setPlacement(placement: CuboidPlacementUpdate): void;
+    set width(value: number);
+    get width(): number;
+    set height(value: number);
+    get height(): number;
+    set depth(value: number);
+    get depth(): number;
+    set color(value: THREE.ColorRepresentation);
+    get color(): THREE.Color;
+    setConfig(update: CuboidConfigUpdate): void;
+    getConfig(): Readonly<NormalizedCuboidOptions>;
+    setPlacement(update: CuboidPlacementUpdate): void;
     setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
     setTranslation(translation: Vector3): void;
     setRotation(rotation: Vector3): void;
     setScale(scale: Vector3): void;
+    getPlacement(): Required<CuboidPlacementOptions>;
+    getAnchor(): Vector3;
     getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private clearOutlineMesh;
+    canConvertToFreeform(): false;
+    toFreeform(): never;
+    cleanGeometry(): void;
     discardGeometry(): void;
-    private writePositionsToGeometry;
+    private applyPlacement;
 }
+export {};

package/src/shapes/cylinder.d.ts

@@ -1,80 +1,36 @@
 import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-import type { ShapeSubtractOperands, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract.js";
-/**
- * Construction options for a cylinder shape.
- */
+import { AnalyticSolid, type AnalyticAccuracy } from "./analytic-solid.js";
 export interface ICylinderOptions {
+    ogid?: string;
+    center?: Vector3;
+    radius?: number;
+    height?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+interface NormalizedCylinderOptions {
     ogid?: string;
     center: Vector3;
     radius: number;
     height: number;
-    segments: number;
-    angle: number;
-    color: number;
-    fatOutlines?: boolean;
-    outlineWidth?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Cylinder`.
- */
-export interface CylinderPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    startAngle: number;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
 }
-/**
- * Partial config payload accepted by `Cylinder.setConfig(...)`.
- */
-export type CylinderConfigUpdate = Partial<Omit<ICylinderOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Cylinder` placement updates.
- */
-export type CylinderPlacementUpdate = CylinderPlacementOptions;
-/**
- * Cylinder wrapper backed by the kernel cylindrical primitive.
- */
-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);
+/** Authoritative Plane/Cylinder BRep with transient deflection tessellation. */
+export declare class Cylinder extends AnalyticSolid {
+    readonly options: Readonly<NormalizedCylinderOptions>;
     constructor(options?: ICylinderOptions);
-    validateOptions(): void;
-    setConfig(options: CylinderConfigUpdate): void;
-    getConfig(): ICylinderOptions;
-    getAnchor(): Vector3;
-    setPlacement(placement: CylinderPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    cleanGeometry(): void;
-    generateGeometry(): void;
-    getBrep(): any;
-    /**
-     * Subtracts one or more boolean operands, such as Opening volumes, from this cylinder.
-     */
-    subtract(operands: ShapeSubtractOperands, 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;
-    private writePositionsToGeometry;
+    get radius(): number;
+    get height(): number;
+    get startAngle(): number;
+    get sweepAngle(): number;
+    getAnchor(): THREE.Vector3;
 }
+export {};

package/src/shapes/opening.d.ts

@@ -1,94 +1,31 @@
 import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-import { ShapeOutlineMesh } from "./outline-utils.js";
-import type { ShapeSubtractOperand, ShapeSubtractOperands, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract.js";
-/**
- * Construction options for an architectural opening volume.
- */
-export interface IOpeningOptions {
+import { AnalyticSolid, type AnalyticAccuracy } from "./analytic-solid.js";
+import { Cuboid, type CuboidConfigUpdate, type CuboidPlacementOptions } from "./cuboid.js";
+export interface IOpeningOptions extends CuboidPlacementOptions {
     ogid?: string;
-    center: Vector3;
-    width: number;
-    height: number;
-    depth: number;
-    color: number;
-    fatOutlines?: boolean;
-    outlineWidth?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    center?: Vector3;
+    width?: number;
+    height?: number;
+    depth?: number;
+    color?: THREE.ColorRepresentation;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
 }
-/**
- * Placement updates accepted by `Opening`.
- */
-export interface OpeningPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Partial config payload accepted by `Opening.setConfig(...)`.
- */
-export type OpeningConfigUpdate = Partial<Omit<IOpeningOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Opening` placement updates.
- */
+export type OpeningPlacementOptions = CuboidPlacementOptions;
+export type OpeningConfigUpdate = CuboidConfigUpdate;
 export type OpeningPlacementUpdate = OpeningPlacementOptions;
-/**
- * Opening wrapper used as a subtractive solid in architectural workflows.
- */
-export declare class Opening extends THREE.Mesh {
-    #private;
-    ogid: string;
-    options: IOpeningOptions;
-    private opening;
-    private _outlineEnabled;
-    private _fatOutlines;
-    private _outlineWidth;
-    set width(value: number);
-    set height(value: number);
-    set depth(value: number);
+/** Strict BRep v2 subtractive box. */
+export declare class Opening extends Cuboid {
+    constructor(options?: IOpeningOptions);
     get dimensions(): {
         width: number;
         height: number;
         depth: number;
     };
-    constructor(options?: IOpeningOptions);
-    validateOptions(): void;
-    setConfig(options: OpeningConfigUpdate): void;
-    getConfig(): IOpeningOptions;
-    getAnchor(): Vector3;
-    setPlacement(placement: OpeningPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getPlacement(): import("../editor.js").ParametricPlacement;
     getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    cleanGeometry(): void;
-    generateGeometry(): void;
-    getBrepData(): any;
-    /**
-     * Subtracts one or more boolean operands from this opening volume.
-     */
-    subtract(operands: ShapeSubtractOperands, options?: ShapeSubtractOptions): ShapeSubtractResult;
-    /**
-     * Uses this opening volume to cut a host shape.
-     *
-     * Prefer this helper for wall, slab, and other host-cutting workflows in
-     * browser-based AEC/BIM tools.
-     */
-    subtractFrom(host: 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;
-    private writePositionsToGeometry;
+    subtractFrom(host: AnalyticSolid, options?: {
+        deflection?: number;
+        color?: THREE.ColorRepresentation;
+    }): AnalyticSolid;
 }

package/src/shapes/polygon.d.ts

@@ -1,7 +1,7 @@
 import * as THREE from "three";
 import { OGPolygon, Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import { Solid } from "./solid.js";
-import type { ShapeSubtractOperands, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract.js";
+import { type PolygonLoftOptions } from "../operations/loft.js";
 /**
  * Construction options for a planar polygon.
  */
@@ -79,14 +79,13 @@ export declare class Polygon extends THREE.Mesh {
      * starts from a planar profile and needs a boolean-ready solid.
      */
     extrude(height: number): Solid;
+    /** Builds a capped analytic ruled loft from this profile to `other`. */
+    loftTo(other: Polygon, options?: PolygonLoftOptions): import("./analytic-solid.js").AnalyticSolid;
     /**
      * Returns the serialized BRep payload for this polygon.
      */
     getBrepData(): string | null;
-    /**
-     * Subtracts one or more boolean operands from this polygon.
-     */
-    subtract(operands: ShapeSubtractOperands, options?: ShapeSubtractOptions): ShapeSubtractResult;
+    private worldProfilePoints;
     set outlineColor(color: number);
     get outlineColor(): number;
     set outline(enable: boolean);

package/src/shapes/solid.d.ts

@@ -2,7 +2,6 @@ import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
 import { type FreeformGeometry } from "../freeform.js";
 import type { FreeformSource } from "../freeform/types.js";
-import type { ShapeSubtractOperands, ShapeSubtractOptions, ShapeSubtractResult } from "./boolean-subtract.js";
 /**
  * Construction options for a generic BRep-backed solid.
  */
@@ -91,13 +90,6 @@ export declare class Solid extends THREE.Mesh {
      * Returns the parsed world-space BRep object for this solid.
      */
     getBrepData(): any;
-    /**
-     * Subtracts one or more boolean operands from this solid.
-     *
-     * This is the main shape-level boolean workflow after operations like
-     * `polygon.extrude(height)` or `Solid.extrude(...)`.
-     */
-    subtract(operands: ShapeSubtractOperands, options?: ShapeSubtractOptions): ShapeSubtractResult;
     /**
      * Rebuilds the visible mesh and outline from the current freeform geometry.
      */