u-space 0.0.7 → 0.0.9

package/dist/src/effects/MaterialEffects.d.ts

@@ -3,15 +3,38 @@ export interface HighlightColorOptions {
     opacity?: number;
     color?: ColorRepresentation;
     overwrite?: boolean;
+    depthWrite?: boolean;
 }
 export interface BreatheColorOptions {
     color?: ColorRepresentation;
     speed?: number;
     intensity?: number;
 }
+export interface FadeOptions {
+    duration?: number;
+}
 export declare class MaterialEffects {
     static highlightColor(object: Object3D | Object3D[], options?: HighlightColorOptions): void;
     static removeHighlightColor(object: Object3D | Object3D[]): void;
     static breatheColor(object: Object3D | Object3D[], options?: BreatheColorOptions): void;
     static removeBreatheColor(object: Object3D | Object3D[]): void;
+    /**
+     * Enable wireframe mode on object(s).
+     */
+    static wireframe(object: Object3D | Object3D[], enabled?: boolean): void;
+    /**
+     * Remove wireframe mode.
+     */
+    static removeWireframe(object: Object3D | Object3D[]): void;
+    /**
+     * Fade in object(s) from fully transparent to original opacity.
+     * Returns a promise that resolves when animation is complete.
+     */
+    static fadeIn(object: Object3D | Object3D[], options?: FadeOptions): Promise<void>;
+    /**
+     * Fade out object(s) to fully transparent.
+     * Returns a promise that resolves when animation is complete.
+     */
+    static fadeOut(object: Object3D | Object3D[], options?: FadeOptions): Promise<void>;
+    private static _fade;
 }

package/dist/src/index.d.ts

@@ -5,6 +5,7 @@ export * from './managers';
 export * from './objects';
 export * from './effects';
 export * from './animations';
+export * from './tools';
 export * from './interfaces';
 export * from './types';
 export declare const version: string;

package/dist/src/interactions/InteractionManager.d.ts

@@ -25,11 +25,42 @@ export declare class InteractionManager {
      * Disabled by default for performance optimization.
      */
     pointerMoveEventsEnabled: boolean;
+    /**
+     * Whether interaction is enabled globally.
+     */
+    private _enabled;
+    /**
+     * Objects excluded from raycasting (via addIgnore or setInteractable(false)).
+     */
+    private _excludeSet;
     constructor(domElement: HTMLElement, scene: Scene, camera: Camera);
     /**
      * Updates the camera reference (useful when switching cameras).
      */
     setCamera(camera: Camera): void;
+    /**
+     * Enable all interactions.
+     */
+    enable(): void;
+    /**
+     * Disable all interactions.
+     */
+    disable(): void;
+    /**
+     * Set whether a specific object is interactable.
+     * When set to false, the object and its children are excluded from raycasting.
+     */
+    setInteractable(object: Object3D, interactable: boolean): void;
+    /**
+     * Add an object to the exclude list (will not receive any events).
+     * Alias for `setInteractable(object, false)`.
+     */
+    addIgnore(object: Object3D): void;
+    /**
+     * Remove an object from the exclude list.
+     * Alias for `setInteractable(object, true)`.
+     */
+    removeIgnore(object: Object3D): void;
     private _bindEvents;
     private _updatePointer;
     private _getIntersects;

package/dist/src/interactions/Selection.d.ts

@@ -0,0 +1,77 @@
+import { type Scene, type Camera, type Object3D, EventDispatcher } from 'three/webgpu';
+export interface SelectionEventMap {
+    select: {
+        objects: Object3D[];
+    };
+    deselect: {
+        objects: Object3D[];
+    };
+    change: {
+        selected: Set<Object3D>;
+    };
+}
+export interface BoxSelectionOptions {
+    /** CSS class for the selection box overlay */
+    className?: string;
+    /** Deep traversal into children for selection */
+    deep?: boolean;
+}
+/**
+ * Manages object selection: single, multi, and box (rubber-band) selection.
+ */
+export declare class Selection extends EventDispatcher<SelectionEventMap> {
+    private scene;
+    private camera;
+    private domElement;
+    /** The container element for the selection box overlay (domElement's parent). */
+    private _container;
+    private _selected;
+    private _boxSelectionEnabled;
+    private _isSelecting;
+    private _startPoint;
+    private _endPoint;
+    private _selectionBox;
+    private _deep;
+    /**
+     * Objects available for selection (defaults to scene.children).
+     */
+    targetObjects: Object3D[] | null;
+    constructor(domElement: HTMLElement, scene: Scene, camera: Camera);
+    get selected(): Set<Object3D>;
+    get selectedArray(): Object3D[];
+    /**
+     * Select one or more objects.
+     */
+    select(objects: Object3D | Object3D[]): void;
+    /**
+     * Deselect one or more objects.
+     */
+    deselect(objects: Object3D | Object3D[]): void;
+    /**
+     * Toggle selection of an object.
+     */
+    toggle(object: Object3D): void;
+    /**
+     * Clear all selections.
+     */
+    clear(): void;
+    /**
+     * Check if an object is selected.
+     */
+    isSelected(object: Object3D): boolean;
+    /**
+     * Enable rubber-band box selection mode.
+     */
+    enableBoxSelection(options?: BoxSelectionOptions): void;
+    /**
+     * Disable box selection mode.
+     */
+    disableBoxSelection(): void;
+    setCamera(camera: Camera): void;
+    private _onBoxPointerDown;
+    private _onBoxPointerMove;
+    private _onBoxPointerUp;
+    private _updateBoxElement;
+    private _getObjectsInBox;
+    dispose(): void;
+}

package/dist/src/interactions/index.d.ts

@@ -1,2 +1,3 @@
 export * from './InteractionEvent';
 export * from './InteractionManager';
+export * from './Selection';

package/dist/src/managers/LightManager.d.ts

@@ -0,0 +1,101 @@
+import { type Scene, AmbientLight, DirectionalLight, PointLight, SpotLight, HemisphereLight, type ColorRepresentation, type Light } from 'three/webgpu';
+export interface AmbientLightOptions {
+    color?: ColorRepresentation;
+    intensity?: number;
+}
+export interface DirectionalLightOptions {
+    color?: ColorRepresentation;
+    intensity?: number;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    castShadow?: boolean;
+    shadowMapSize?: number;
+}
+export interface PointLightOptions {
+    color?: ColorRepresentation;
+    intensity?: number;
+    distance?: number;
+    decay?: number;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    castShadow?: boolean;
+}
+export interface SpotLightOptions {
+    color?: ColorRepresentation;
+    intensity?: number;
+    distance?: number;
+    angle?: number;
+    penumbra?: number;
+    decay?: number;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    target?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    castShadow?: boolean;
+}
+export interface HemisphereLightOptions {
+    skyColor?: ColorRepresentation;
+    groundColor?: ColorRepresentation;
+    intensity?: number;
+}
+export type LightPreset = 'indoor' | 'outdoor' | 'studio' | 'warehouse';
+/**
+ * Manages lights in the scene with convenient creation and preset support.
+ */
+export declare class LightManager {
+    private scene;
+    private lights;
+    private helpers;
+    constructor(scene: Scene);
+    addAmbient(id: string, options?: AmbientLightOptions): AmbientLight;
+    addDirectional(id: string, options?: DirectionalLightOptions): DirectionalLight;
+    addPoint(id: string, options?: PointLightOptions): PointLight;
+    addSpot(id: string, options?: SpotLightOptions): SpotLight;
+    addHemisphere(id: string, options?: HemisphereLightOptions): HemisphereLight;
+    /**
+     * Apply a lighting preset to the scene.
+     */
+    applyPreset(preset: LightPreset): void;
+    /**
+     * Get a light by id.
+     */
+    get(id: string): Light | undefined;
+    /**
+     * Remove a light by id.
+     */
+    remove(id: string): void;
+    /**
+     * Remove all lights managed by this manager.
+     */
+    removeAll(): void;
+    /**
+     * Show a visual helper for a light.
+     */
+    showHelper(id: string): void;
+    /**
+     * Hide (remove) the helper for a light.
+     */
+    hideHelper(id: string): void;
+    /**
+     * Show helpers for all lights.
+     */
+    showAllHelpers(): void;
+    /**
+     * Hide all helpers.
+     */
+    hideAllHelpers(): void;
+    private _register;
+    dispose(): void;
+}

package/dist/src/managers/ObjectManager.d.ts

@@ -1,4 +1,4 @@
-import type { Object3D } from 'three/webgpu';
+import { Box3, type Object3D } from 'three/webgpu';
 /**
  * Manages 3D objects with custom id and name caching for quick retrieval.
  */
@@ -57,4 +57,36 @@ export declare class ObjectManager {
      * Get the number of unique cached objects.
      */
     get size(): number;
+    /**
+     * Show an object by id.
+     */
+    show(id: string): void;
+    /**
+     * Hide an object by id.
+     */
+    hide(id: string): void;
+    /**
+     * Show only the specified objects, hide all others.
+     */
+    isolate(ids: string[]): void;
+    /**
+     * Set the opacity of an object's materials.
+     */
+    setOpacity(id: string, opacity: number): void;
+    /**
+     * Get the bounding box of an object by id, or all objects if no id provided.
+     */
+    getBoundingBox(id?: string): Box3;
+    /**
+     * Iterate over all managed objects.
+     */
+    forEach(callback: (object: Object3D, ids: Set<string>) => void): void;
+    /**
+     * Filter objects by a predicate.
+     */
+    filter<T extends Object3D>(predicate: (object: Object3D) => boolean): T[];
+    /**
+     * Show all managed objects.
+     */
+    showAll(): void;
 }

package/dist/src/managers/SceneManager.d.ts

@@ -0,0 +1,57 @@
+import { Scene, type ColorRepresentation } from 'three/webgpu';
+export interface SceneSnapshot {
+    name: string;
+    background: ColorRepresentation | null;
+    environmentRotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    children: string[];
+}
+/**
+ * Manages multiple scenes and provides scene-level utilities.
+ */
+export declare class SceneManager {
+    private scenes;
+    private _activeSceneKey;
+    /**
+     * Add a scene with a key.
+     */
+    add(key: string, scene: Scene): void;
+    /**
+     * Create and register a new scene.
+     */
+    create(key: string, options?: {
+        background?: ColorRepresentation;
+    }): Scene;
+    /**
+     * Get a scene by key.
+     */
+    get(key: string): Scene | undefined;
+    /**
+     * Remove a scene by key.
+     */
+    remove(key: string): void;
+    /**
+     * Get the currently active scene key.
+     */
+    get activeKey(): string | null;
+    /**
+     * Set the active scene key (for external use to track which scene is active).
+     */
+    set activeKey(key: string | null);
+    /**
+     * List all registered scene keys.
+     */
+    keys(): string[];
+    /**
+     * Serialize scene metadata to JSON (children names/ids, background, etc.).
+     */
+    serialize(key: string): SceneSnapshot | null;
+    /**
+     * Clear all scenes.
+     */
+    clear(): void;
+    get size(): number;
+}

package/dist/src/managers/index.d.ts

@@ -1 +1,3 @@
 export * from './ObjectManager';
+export * from './SceneManager';
+export * from './LightManager';

package/dist/src/objects/Model.d.ts

@@ -1,4 +1,4 @@
-import { type Object3D, AnimationMixer, type AnimationAction, type AnimationClip } from 'three/webgpu';
+import { type Object3D, AnimationMixer, type AnimationAction, type AnimationClip, Box3, Vector3, type Material } from 'three/webgpu';
 import { type InteractionEventMap } from '../interactions';
 import { BaseGroup } from './BaseGroup';
 export interface ModelParameters {
@@ -25,6 +25,18 @@ export declare class Model extends BaseGroup<InteractionEventMap> {
     playAllAnimations(options?: PlayAnimationOptions): AnimationAction[];
     stopAnimation(nameOrIndex?: string | number): void;
     updateAnimation(delta: number): void;
+    /**
+     * Get the axis-aligned bounding box of this model.
+     */
+    getBoundingBox(): Box3;
+    /**
+     * Get the center point of this model's bounding box.
+     */
+    getCenter(): Vector3;
+    /**
+     * Set the material for all meshes in this model.
+     */
+    setMaterial(material: Material): void;
     static clearMemoryCache(): void;
     static clearPersistentCache(): Promise<void>;
 }

package/dist/src/tools/AnnotationManager.d.ts

@@ -0,0 +1,104 @@
+import { Line, type Scene, type ColorRepresentation, Group } from 'three/webgpu';
+export interface AnnotationOptions {
+    /** Position of the annotation anchor in 3D space */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** HTML content or text for the label */
+    content: string;
+    /** Offset from anchor position for the label (in 3D space) */
+    labelOffset?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Whether to draw a leader line from anchor to label */
+    showLeaderLine?: boolean;
+    /** Leader line color */
+    lineColor?: ColorRepresentation;
+    /** CSS styles for the label element */
+    labelStyle?: Partial<CSSStyleDeclaration>;
+}
+export interface Annotation {
+    id: string;
+    options: AnnotationOptions;
+    group: Group;
+    labelElement: HTMLDivElement;
+    line: Line | null;
+}
+/**
+ * Manages 3D annotations with leader lines and HTML labels.
+ * Works with CSSRenderer for HTML overlay rendering.
+ */
+export declare class AnnotationManager {
+    private scene;
+    private annotations;
+    private _idCounter;
+    private _createCSSObject;
+    constructor(scene: Scene);
+    /**
+     * Set the CSS object factory function (from CSSRenderer).
+     * This allows annotations to be rendered as CSS2D/CSS2.5D objects.
+     */
+    setCSSObjectFactory(factory: (element: HTMLElement) => any): void;
+    /**
+     * Add an annotation.
+     */
+    add(id: string, options: AnnotationOptions): Annotation;
+    /**
+     * Quick-add a text annotation.
+     */
+    addText(text: string, position: {
+        x: number;
+        y: number;
+        z: number;
+    }, options?: Partial<AnnotationOptions>): Annotation;
+    /**
+     * Update an annotation's content.
+     */
+    updateContent(id: string, content: string): void;
+    /**
+     * Update an annotation's position.
+     */
+    updatePosition(id: string, position: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Show an annotation.
+     */
+    show(id: string): void;
+    /**
+     * Hide an annotation.
+     */
+    hide(id: string): void;
+    /**
+     * Get an annotation by id.
+     */
+    get(id: string): Annotation | undefined;
+    /**
+     * Remove an annotation.
+     */
+    remove(id: string): void;
+    /**
+     * Remove all annotations.
+     */
+    removeAll(): void;
+    /**
+     * Show all annotations.
+     */
+    showAll(): void;
+    /**
+     * Hide all annotations.
+     */
+    hideAll(): void;
+    /**
+     * Get all annotation ids.
+     */
+    keys(): string[];
+    get size(): number;
+    dispose(): void;
+}

package/dist/src/tools/ClippingTool.d.ts

@@ -0,0 +1,96 @@
+import { Plane, type Scene, type Object3D, Box3, ClippingGroup, type ColorRepresentation } from 'three/webgpu';
+export interface ClippingPlaneOptions {
+    normal?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    constant?: number;
+    showHelper?: boolean;
+    helperSize?: number;
+    helperColor?: ColorRepresentation;
+}
+export interface ClippingBoxOptions {
+    showHelpers?: boolean;
+    helperColor?: ColorRepresentation;
+}
+/**
+ * Provides clipping plane and clipping box functionality using ClippingGroup (WebGPU).
+ *
+ * Objects must be children of the ClippingGroup to be clipped.
+ * Use `clippingTool.group` to access the ClippingGroup and add objects to it,
+ * or call `clippingTool.attach(scene)` to reparent all scene children under the group.
+ */
+export declare class ClippingTool {
+    private scene;
+    private planes;
+    private helpers;
+    /**
+     * The ClippingGroup node. Objects must be descendants of this group to be clipped.
+     */
+    readonly group: ClippingGroup;
+    constructor(scene: Scene);
+    /**
+     * Move all current scene children (except the clipping group itself) into the ClippingGroup,
+     * so they are all subject to clipping.
+     */
+    attach(): void;
+    /**
+     * Move all children out of the ClippingGroup back to the scene root.
+     */
+    detach(): void;
+    /**
+     * Enable clipping.
+     */
+    enable(): void;
+    /**
+     * Disable clipping.
+     */
+    disable(): void;
+    /**
+     * Add a clipping plane.
+     */
+    addPlane(id: string, options?: ClippingPlaneOptions): Plane;
+    /**
+     * Add six clipping planes that form a box around a Box3.
+     * Returns the six plane ids: `${id}_+x`, `${id}_-x`, etc.
+     */
+    addBox(id: string, box: Box3, options?: ClippingBoxOptions): string[];
+    /**
+     * Add a clipping box from an object's bounding box with optional padding.
+     */
+    addBoxFromObject(id: string, object: Object3D, padding?: number, options?: ClippingBoxOptions): string[];
+    /**
+     * Update a plane's constant (distance from origin).
+     */
+    setPlaneConstant(id: string, constant: number): void;
+    /**
+     * Remove a clipping plane.
+     */
+    removePlane(id: string): void;
+    /**
+     * Remove a clipping box (all 6 associated planes).
+     */
+    removeBox(id: string): void;
+    /**
+     * Remove all clipping planes.
+     */
+    removeAll(): void;
+    /**
+     * Show a helper visualization for a clipping plane.
+     */
+    showHelper(id: string, size?: number, color?: ColorRepresentation): void;
+    /**
+     * Hide a plane helper.
+     */
+    hideHelper(id: string): void;
+    /**
+     * Get a plane by id.
+     */
+    get(id: string): Plane | undefined;
+    /**
+     * Sync the planes map into the ClippingGroup's clippingPlanes array.
+     */
+    private _syncPlanes;
+    dispose(): void;
+}

package/dist/src/tools/MeasureTool.d.ts

@@ -0,0 +1,80 @@
+import { Vector3, type Scene, type ColorRepresentation, Group } from 'three/webgpu';
+export interface MeasureStyleOptions {
+    lineColor?: ColorRepresentation;
+    /** @deprecated lineWidth is not supported in WebGPU renderer */
+    lineWidth?: number;
+}
+export interface MeasureResult {
+    id: string;
+    type: 'distance' | 'area' | 'angle';
+    value: number;
+    unit: string;
+    points: Vector3[];
+    object: Group;
+}
+/**
+ * Provides measurement utilities for 3D scenes.
+ */
+export declare class MeasureTool {
+    private scene;
+    private measurements;
+    private _idCounter;
+    constructor(scene: Scene);
+    /**
+     * Measure distance between two points.
+     */
+    measureDistance(pointA: {
+        x: number;
+        y: number;
+        z: number;
+    }, pointB: {
+        x: number;
+        y: number;
+        z: number;
+    }, options?: MeasureStyleOptions): MeasureResult;
+    /**
+     * Measure the area of a polygon defined by 3+ coplanar points.
+     */
+    measureArea(points: {
+        x: number;
+        y: number;
+        z: number;
+    }[], options?: MeasureStyleOptions): MeasureResult;
+    /**
+     * Measure the angle between three points (vertex at the middle point).
+     */
+    measureAngle(pointA: {
+        x: number;
+        y: number;
+        z: number;
+    }, vertex: {
+        x: number;
+        y: number;
+        z: number;
+    }, pointC: {
+        x: number;
+        y: number;
+        z: number;
+    }, options?: MeasureStyleOptions): MeasureResult;
+    /**
+     * Get a measurement result by id.
+     */
+    get(id: string): MeasureResult | undefined;
+    /**
+     * Remove a measurement by id.
+     */
+    remove(id: string): void;
+    /**
+     * Remove all measurements.
+     */
+    removeAll(): void;
+    /**
+     * Get all measurement results.
+     */
+    getAll(): MeasureResult[];
+    /**
+     * Calculate polygon area using cross product method (Newell's method).
+     */
+    private _calculatePolygonArea;
+    dispose(): void;
+}

package/dist/src/tools/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ClippingTool';
+export * from './MeasureTool';
+export * from './AnnotationManager';