opengeometry 2.0.13 → 2.0.15

package/src/primitives/elliptical_arc.d.ts

@@ -1,66 +1,38 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-/**
- * Construction options for an elliptical arc primitive.
- */
+import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
+import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
+import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
 export interface IEllipticalArcOptions {
+    ogid?: string;
+    center?: Vector3;
+    majorRadius?: number;
+    minorRadius?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+export type EllipticalArcConfigUpdate = Partial<Omit<IEllipticalArcOptions, "ogid">>;
+interface NormalizedEllipticalArcOptions {
     ogid?: string;
     center: Vector3;
-    radiusX: number;
-    radiusZ: number;
+    majorRadius: number;
+    minorRadius: number;
     startAngle: number;
-    endAngle: number;
-    segments: number;
-    color: number;
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `EllipticalArc`.
- */
-export interface EllipticalArcPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
 }
-/**
- * Partial config payload accepted by `EllipticalArc.setConfig(...)`.
- */
-export type EllipticalArcConfigUpdate = Partial<Omit<IEllipticalArcOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `EllipticalArc` placement updates.
- */
-export type EllipticalArcPlacementUpdate = EllipticalArcPlacementOptions;
-/**
- * EllipticalArc wrapper backed by the kernel OGEllipticalArc primitive.
- */
-export declare class EllipticalArc extends THREE.Line {
-    ogid: string;
-    options: IEllipticalArcOptions;
-    private ellipticalArc;
-    private fatLine;
-    set color(color: number);
+/** Authoritative elliptical edge with transient deflection tessellation. */
+export declare class EllipticalArc extends AnalyticCurve {
+    options: Readonly<NormalizedEllipticalArcOptions>;
     constructor(options?: IEllipticalArcOptions);
-    validateOptions(): void;
-    setConfig(options: EllipticalArcConfigUpdate): void;
     getAnchor(): Vector3;
-    setPlacement(placement: EllipticalArcPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getConfig(): IEllipticalArcOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getBrep(): any;
-    discardGeometry(): void;
-    private writePositionsToGeometry;
+    getConfig(): Readonly<NormalizedEllipticalArcOptions>;
+    setConfig(update: EllipticalArcConfigUpdate): AnalyticCurveStats;
+    getBrep(): Record<string, unknown>;
+    retessellate(deflection: number): AnalyticCurveStats;
 }
+export {};

package/src/rendering/analytic-lod.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from "three";
+import type { AnalyticSolid, AnalyticTessellationStats } from "../shapes/analytic-solid.js";
+import { AnalyticTessellationWorker } from "./analytic-tessellation.js";
+export declare function deflectionBucket(target: number, previous?: number): number;
+export declare function worldUnitsPerPixel(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, depth: number, physicalHeight: number): number;
+export interface AnalyticLodOptions {
+    fixedDeflection?: number;
+    onUpdate?: (solid: AnalyticSolid, statistics: AnalyticTessellationStats) => void;
+    onError?: (solid: AnalyticSolid, error: Error) => void;
+}
+/** Register authored changes explicitly; camera meshes never refresh a scene's authored BRep snapshots. */
+export declare class AnalyticLodController {
+    private readonly worker;
+    private readonly options;
+    private readonly entries;
+    private readonly cameraState;
+    private lastMotion;
+    private lastSchedule;
+    private initialized;
+    private closed;
+    private refining;
+    private fixedDeflection?;
+    constructor(worker: AnalyticTessellationWorker, options?: AnalyticLodOptions);
+    setDeflection(deflection?: number): void;
+    register(solid: AnalyticSolid): Promise<void>;
+    unregister(solid: AnalyticSolid): Promise<void>;
+    update(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, physicalHeight: number, now?: number, motion?: boolean): void;
+    /** Explicit export refinement; a resource or precision failure rejects and retains each body's prior mesh. */
+    refine(deflection: number): Promise<void>;
+    dispose(): void;
+}
+export declare function uniformScale(matrix: THREE.Matrix4): number;

package/src/rendering/analytic-tessellation.d.ts

@@ -0,0 +1,32 @@
+export interface AnalyticTessellationData {
+    positions: Float64Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    triangleFaceIds: Uint32Array;
+    outlinePositions: Float64Array;
+    outlineEdgeIds: Uint32Array;
+    revision: bigint;
+    achievedDeflection: number;
+}
+export declare const GEOMETRY_DEFLECTION_SHARE = 0.75;
+export interface AnalyticWorkerOptions {
+    workerURL: string | URL;
+    kernelURL: string | URL;
+    wasmURL: string | URL;
+}
+export declare class AnalyticTessellationWorker {
+    private readonly worker;
+    private readonly pending;
+    private readonly generations;
+    private readonly ready;
+    private serial;
+    private closed;
+    constructor(options: AnalyticWorkerOptions);
+    setModel(handle: string, serialized: string): Promise<void>;
+    tessellate(handle: string, deflection: number): Promise<AnalyticTessellationData>;
+    cancel(handle: string): number;
+    removeModel(handle: string): Promise<void>;
+    dispose(): void;
+    private send;
+    private fail;
+}

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

@@ -0,0 +1,36 @@
+import * as THREE from "three";
+import { AnalyticSolid } from "./analytic-solid.js";
+export interface AnalyticPatternInstance {
+    id?: string;
+    matrix: THREE.Matrix4;
+}
+export interface AnalyticPatternHit {
+    pattern: AnalyticPattern;
+    instanceIndex: number;
+    instanceId: string;
+    source: AnalyticSolid;
+    faceId?: number;
+}
+/**
+ * Renders many rigid placements of one authoritative analytic body. The source
+ * owns the BRep; instances own only identity and placement matrices.
+ */
+export declare class AnalyticPattern extends THREE.Group {
+    readonly source: AnalyticSolid;
+    readonly surface: THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material>;
+    readonly instanceIds: readonly string[];
+    private disposed;
+    constructor(source: AnalyticSolid, instances: readonly AnalyticPatternInstance[]);
+    get count(): number;
+    setInstanceMatrix(index: number, matrix: THREE.Matrix4): void;
+    resolveIntersection(intersection: THREE.Intersection): AnalyticPatternHit | undefined;
+    dispose(): void;
+    private checkActive;
+}
+export declare function linearPattern(source: AnalyticSolid, count: number, spacing: THREE.Vector3): AnalyticPattern;
+export declare function rectangularPattern(source: AnalyticSolid, counts: readonly [number, number], spacing: readonly [THREE.Vector3, THREE.Vector3]): AnalyticPattern;
+export declare function circularPattern(source: AnalyticSolid, count: number, radius: number, options?: {
+    startAngle?: number;
+    sweepAngle?: number;
+    rotateInstances?: boolean;
+}): AnalyticPattern;

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

@@ -0,0 +1,304 @@
+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 AnalyticAnnularSectorOpening {
+    id: string;
+    angle: number;
+    width: number;
+    bottom: number;
+    height: number;
+}
+export type AnalyticProfileEdge = {
+    kind: "line";
+    from: [number, number];
+    to: [number, number];
+} | {
+    kind: "arc";
+    center: [number, number];
+    radius: number;
+    startAngle: number;
+    sweepAngle: 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: "arcEdgedExtrusion";
+    outer: AnalyticProfileEdge[];
+    holes?: AnalyticProfileEdge[][];
+    height: number;
+} | {
+    kind: "polygonLoft";
+    lower: [number, number, number][];
+    upper: [number, number, number][];
+    alignment?: AnalyticPolygonLoftAlignment;
+} | {
+    kind: "boxWithArchedOpening";
+    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: "annularSectorExtrusion";
+    radius: number;
+    thickness: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+} | {
+    kind: "annularSectorExtrusionWithOpenings";
+    radius: number;
+    thickness: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+    openings: AnalyticAnnularSectorOpening[];
+} | {
+    kind: "annularSectorExtrusionWithArchedOpening";
+    radius: number;
+    thickness: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+    opening: AnalyticAnnularSectorOpening;
+} | {
+    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 {};