@thatopen/components 3.4.6 → 3.4.8

package/dist/index.d.ts

@@ -390,6 +390,15 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
      * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
      */
     clippingPlanes: THREE.Plane[];
+    /**
+     * The default `isLocal` value used by {@link setPlane} when the caller
+     * doesn't pass one. When `true`, planes added without an explicit
+     * `isLocal` stay out of the global `three.clippingPlanes` list and are
+     * clipped per-material instead. The {@link Clipper} sets this to mirror
+     * its own `localClippingPlanes` flag, so consumers like `Views` that add
+     * their own planes automatically inherit the active clipping mode.
+     */
+    localClippingPlanes: boolean;
     /**
      * Updates the clipping planes and triggers the `onClippingPlanesUpdated` event.
      *
@@ -1437,8 +1446,15 @@ export declare class Clipper extends Component implements Createable, Disposable
      * Default `false` to preserve existing behavior. Set this once
      * before creating planes; toggling at runtime won't reclassify
      * planes already on the renderer.
+     *
+     * Setting this also mirrors the value onto every world's
+     * `renderer.localClippingPlanes`, so planes added by other
+     * components (e.g. the {@link Views} cut planes) default to the
+     * same mode without each call site having to pass `isLocal`.
      */
-    localClippingPlanes: boolean;
+    private _localClippingPlanes;
+    get localClippingPlanes(): boolean;
+    set localClippingPlanes(value: boolean);
     /**
      * The type of clipping plane to be created.
      * Default is {@link SimplePlane}.
@@ -2995,6 +3011,19 @@ export declare class FastModelPicker implements Disposable_2 {
      * restored after.
      */
     private _hiddenLods;
+    /**
+     * The meshes each model owns, i.e. excluding those belonging to a
+     * model nested inside it. A delta model's object is parented under
+     * its parent model's object (see the fragments EditHelper), while
+     * both are listed as separate models, so subtree membership alone
+     * does not determine ownership.
+     *
+     * Populated in {@link applyIdMaterial}, consumed by
+     * {@link renderPickPass} to isolate one model per render without
+     * relying on root visibility. A nested model can't be isolated by
+     * its root, since hiding the parent's root culls the child too.
+     */
+    private _ownMeshes;
     constructor(components: Components, world: World);
     /**
      * Returns the model id under the given screen position, or `null` if
@@ -3112,6 +3141,18 @@ export declare class FastModelPicker implements Disposable_2 {
      * disambiguate models.
      */
     private applyIdMaterial;
+    /**
+     * The object roots of every loaded model.
+     */
+    private getModelRoots;
+    /**
+     * Like `Object3D.traverse`, but prunes the subtree of any nested model
+     * root, so each mesh is visited exactly once, by the model that owns
+     * it. A delta model's object hangs under its parent model's object
+     * while being a model in its own right; a plain `traverse` from the
+     * parent would walk into it.
+     */
+    private traverseOwn;
     /**
      * Renders the world scene to the id target one model at a time,
      * flipping the `modelByte` uniform between renders. The depth buffer
@@ -3695,6 +3736,8 @@ export declare interface IDSLengthParameter {
 
 export declare class IDSMaterial extends IDSFacet {
     private _ifcMaterialEntities;
+    private _materialParentAttributes;
+    private _materialRelations;
     facetType: "Material";
     value?: IDSFacetParameter;
     uri?: string;
@@ -5595,6 +5638,7 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
      */
     enabled: boolean;
     private _dynamicAnchor;
+    private _anchorRequestId;
     set dynamicAnchor(value: boolean);
     get dynamicAnchor(): boolean;
     /**
@@ -5609,6 +5653,19 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     private _camera?;
     private _renderer;
     private onPointerDown;
+    /**
+     * The pointer position in normalized device coordinates, derived from the
+     * event rather than the raycaster's mouse: that one only tracks pointermove
+     * and touchstart, so on a bare pointerdown it would still report the center of
+     * the viewport.
+     */
+    private getPointerPosition;
+    /**
+     * The point where the pointer ray crosses the plane that contains the current
+     * orbit target and faces the camera. Used as the anchor when the pointer
+     * doesn't land on any geometry.
+     */
+    private getPlaneAnchor;
     private _defaultCamera?;
     get defaultCamera(): U;
     set defaultCamera(value: U);
@@ -5730,6 +5787,12 @@ export declare enum SnapClass {
     FACE = 2
 }
 
+/** Typed arrays used to store snap geometry payloads. */
+export declare type SnapFloatArray = Float32Array | Float64Array;
+
+/** Numeric typed-array precision used by SnapResolver geometry caches. */
+export declare type SnapPrecision = "half" | "full";
+
 /**
  * Main-thread snap resolver: takes a world-space pick point + the
  * picked item, returns the closest face / line / point of that item
@@ -5762,7 +5825,20 @@ export declare class SnapResolver implements Disposable_2 {
      * that revisit thousands of distinct items in a single session.
      */
     maxCacheSize: number;
+    /**
+     * Numeric precision for cached face/edge/vertex buffers.
+     *
+     * `"half"` uses Float32Array for lower memory footprint.
+     * `"full"` uses Float64Array for higher numeric precision.
+     * Use `"full"` for workflows that require higher geometric fidelity.
+     *
+     * Changing this value clears the snap cache so subsequent requests
+     * are rebuilt with the new precision.
+     */
+    get precision(): SnapPrecision;
+    set precision(value: SnapPrecision);
     private readonly components;
+    private _precision;
     private readonly cache;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
@@ -5812,6 +5888,13 @@ export declare class SnapResolver implements Disposable_2 {
     private snapToPoint;
     private snapToLine;
     private snapToFace;
+    private signedDistance;
+    private projectOntoPlane;
+    /**
+     * Even-odd point-in-polygon test, run on the polygon projected onto its
+     * dominant plane. `point` is assumed to already lie on the face's plane.
+     */
+    private containsPoint;
 }
 
 /**
@@ -5852,7 +5935,7 @@ export declare type SnapResult = {
     snappingClass: SnapClass;
     /** Polygon vertices of the snapped face (FACE only). Flat array of
      *  `[x, y, z, x, y, z, ...]`. */
-    facePoints?: Float32Array;
+    facePoints?: SnapFloatArray;
     /** Triangulation indices into `facePoints` (FACE only). For convex
      *  polygons we emit a fan; for concave the consumer can re-tessellate. */
     faceIndices?: Uint32Array;