threedviewer 2.2.0 → 2.4.0

package/dist/core/ViewerCore.d.ts

@@ -1,5 +1,4 @@
 import { IRenderer, IRendererOptions, IScene, IModelLoader, ICamera, IControls, IObject3D, Result } from './interfaces';
-import { ViewerState } from './entities/ViewerState';
 import { TypedEventEmitter } from '../events/EventEmitter';
 import { ViewerEventMap } from './events/ViewerEvents';
 import { SimpleViewerOptions } from '../types/SimpleViewerOptions';
@@ -7,6 +6,7 @@ import { IPathTracingService } from './services/IPathTracingService';
 import { IEnvironmentService } from './services/IEnvironmentService';
 import { ISceneSetupService } from './services/ISceneSetupService';
 import { IFloorAlignmentService } from './services/IFloorAlignmentService';
+import { ViewerState } from './entities/ViewerState';
 export interface ViewerDependencies {
     renderer: IRenderer;
     scene: IScene;
@@ -25,31 +25,26 @@ export interface ViewerDependencies {
  * Independent of UI framework and rendering engine
  */
 export declare class ViewerCore {
-    private state;
     private readonly events;
     private readonly renderLoopManager;
     private lastFrameTime;
     private frameCount;
-    private stateChangeCallback?;
     private pathTracingStartTime?;
-    private screenshotElement;
-    private isShowingScreenshot;
-    private screenshotResizeHandler?;
-    private serializedSceneState?;
-    private lastModelUrl?;
     private pathTracingCompleteHandled;
     private disposed;
+    private readonly stateManager;
+    private readonly screenshotManager;
+    private readonly modelManager;
+    private readonly resourceManager;
     private readonly renderer;
     private readonly scene;
     private readonly camera;
     private readonly controls;
-    private readonly modelLoader;
     private readonly options;
     private readonly rendererOptions?;
     private readonly sceneSetupService?;
     private environmentService?;
     private pathTracingService?;
-    private readonly floorAlignmentService?;
     constructor(dependencies: ViewerDependencies);
     /**
      * Initialize the viewer
@@ -99,14 +94,6 @@ export declare class ViewerCore {
      * Restore the 3D scene from screenshot
      */
     private restoreFromScreenshot;
-    /**
-     * Dispose scene resources while keeping the screenshot
-     */
-    private disposeSceneResources;
-    /**
-     * Recursively dispose of an object and its children
-     */
-    private disposeObject;
     /**
      * Dispose of all resources
      */

package/dist/core/managers/ModelManager.d.ts

@@ -0,0 +1,53 @@
+import { IModelLoader, IObject3D, IScene, ICamera, IControls, Result } from '../interfaces';
+import { IFloorAlignmentService } from '../services/IFloorAlignmentService';
+import { ISceneSetupService } from '../services/ISceneSetupService';
+import { TypedEventEmitter } from '../../events/EventEmitter';
+import { ViewerEventMap } from '../events/ViewerEvents';
+export interface ModelManagerDependencies {
+    modelLoader: IModelLoader;
+    scene: IScene;
+    camera: ICamera;
+    controls: IControls;
+    floorAlignmentService?: IFloorAlignmentService;
+    sceneSetupService?: ISceneSetupService;
+    autoFitToObject?: boolean;
+}
+/**
+ * Manages model loading, disposal, and scene setup
+ */
+export declare class ModelManager {
+    private currentModel;
+    private lastModelUrl?;
+    private readonly modelLoader;
+    private readonly scene;
+    private readonly camera;
+    private readonly controls;
+    private readonly floorAlignmentService?;
+    private readonly sceneSetupService?;
+    private readonly autoFitToObject;
+    constructor(dependencies: ModelManagerDependencies);
+    /**
+     * Get current model
+     */
+    getCurrentModel(): IObject3D | null;
+    /**
+     * Get last loaded model URL
+     */
+    getLastModelUrl(): string | undefined;
+    /**
+     * Load a 3D model
+     */
+    loadModel(source: string | IObject3D, events: TypedEventEmitter<ViewerEventMap>): Promise<Result<IObject3D>>;
+    /**
+     * Dispose current model
+     */
+    disposeCurrentModel(): void;
+    /**
+     * Recursively dispose of an object and its children
+     */
+    private disposeObject;
+    /**
+     * Dispose all resources
+     */
+    dispose(): void;
+}

package/dist/core/managers/ResourceManager.d.ts

@@ -0,0 +1,40 @@
+import { IScene } from '../interfaces';
+import { IPathTracingService } from '../services/IPathTracingService';
+import { IEnvironmentService } from '../services/IEnvironmentService';
+export interface ResourceManagerDependencies {
+    scene: IScene;
+    pathTracingService?: IPathTracingService;
+    environmentService?: IEnvironmentService;
+}
+/**
+ * Manages resource disposal and cleanup
+ */
+export declare class ResourceManager {
+    private readonly scene;
+    private pathTracingService?;
+    private environmentService?;
+    constructor(dependencies: ResourceManagerDependencies);
+    /**
+     * Update services (needed after screenshot restoration)
+     */
+    updateServices(services: {
+        pathTracingService?: IPathTracingService;
+        environmentService?: IEnvironmentService;
+    }): void;
+    /**
+     * Dispose scene resources (for screenshot mode)
+     */
+    disposeSceneResources(preservePathTracing?: boolean): void;
+    /**
+     * Dispose all services
+     */
+    disposeServices(): void;
+    /**
+     * Complete disposal of all resources
+     */
+    dispose(): void;
+    /**
+     * Trigger garbage collection hint
+     */
+    private triggerGarbageCollection;
+}

package/dist/core/managers/ScreenshotManager.d.ts

@@ -0,0 +1,38 @@
+import { IRenderer, ICamera, IControls } from '../interfaces';
+import { SerializedSceneState } from '../utils/SceneSerializer';
+export interface ScreenshotManagerDependencies {
+    renderer: IRenderer;
+    onRestore?: () => Promise<void>;
+}
+/**
+ * Manages screenshot capture and restoration functionality
+ */
+export declare class ScreenshotManager {
+    private screenshotElement;
+    private isShowingScreenshot;
+    private screenshotResizeHandler?;
+    private serializedSceneState?;
+    private readonly renderer;
+    private readonly onRestore?;
+    constructor(dependencies: ScreenshotManagerDependencies);
+    /**
+     * Check if currently showing a screenshot
+     */
+    isActive(): boolean;
+    /**
+     * Capture current frame and replace canvas with screenshot
+     */
+    captureAndReplace(camera: ICamera, controls: IControls, lastModelUrl?: string, onResourcesDisposed?: () => void): void;
+    /**
+     * Restore the 3D scene from screenshot
+     */
+    restore(): Promise<void>;
+    /**
+     * Get serialized scene state for restoration
+     */
+    getSerializedState(): SerializedSceneState | undefined;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}

package/dist/core/managers/StateManager.d.ts

@@ -0,0 +1,78 @@
+import { ViewerState } from '../entities/ViewerState';
+import { ThreeViewerError } from '../../errors';
+import { IObject3D } from '../interfaces';
+export interface StateChangeCallback {
+    (state: ViewerState): void;
+}
+/**
+ * Manages viewer state transitions and notifications
+ */
+export declare class StateManager {
+    private state;
+    private readonly stateChangeCallbacks;
+    constructor();
+    /**
+     * Get current state
+     */
+    getState(): ViewerState;
+    /**
+     * Set initialized state
+     */
+    setInitialized(): void;
+    /**
+     * Start loading state
+     */
+    startLoading(): void;
+    /**
+     * Set loaded state with model
+     */
+    setLoaded(model: IObject3D): void;
+    /**
+     * Set error state
+     */
+    setError(error: ThreeViewerError): void;
+    /**
+     * Start rendering state
+     */
+    startRendering(): void;
+    /**
+     * Update render info
+     */
+    updateRenderInfo(info: {
+        frameCount: number;
+        fps: number;
+        lastRenderTime: number;
+    }): void;
+    /**
+     * Set disposed state
+     */
+    setDisposed(): void;
+    /**
+     * Check if can load model in current state
+     */
+    canLoad(): boolean;
+    /**
+     * Check if viewer is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current status
+     */
+    getStatus(): 'idle' | 'loading' | 'loaded' | 'rendering' | 'error' | 'disposed';
+    /**
+     * Get current model
+     */
+    getCurrentModel(): IObject3D | null;
+    /**
+     * Subscribe to state changes
+     */
+    onStateChange(callback: StateChangeCallback): () => void;
+    /**
+     * Clear all callbacks
+     */
+    clearCallbacks(): void;
+    /**
+     * Update state and notify listeners
+     */
+    private updateState;
+}

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

@@ -0,0 +1,4 @@
+export { StateManager } from './StateManager';
+export { ScreenshotManager } from './ScreenshotManager';
+export { ModelManager } from './ModelManager';
+export { ResourceManager } from './ResourceManager';

package/dist/core/services/IEnvironmentService.d.ts

@@ -13,7 +13,7 @@ export interface IEnvironmentService {
     /**
      * Apply environment to scene
      */
-    applyToScene(scene: IScene, texture: ITexture): Result<void>;
+    applyToScene(scene: IScene, texture: ITexture, options?: IEnvironmentApplyOptions): Result<void>;
     /**
      * Create studio environment
      */
@@ -32,3 +32,8 @@ export interface IStudioEnvironmentOptions {
     groundColor?: string;
     skyColor?: string;
 }
+export interface IEnvironmentApplyOptions {
+    backgroundBlurriness?: number;
+    backgroundIntensity?: number;
+    environmentIntensity?: number;
+}

package/dist/core/services/ISceneSetupService.d.ts

@@ -3,6 +3,7 @@ import { IScene } from '../interfaces/IScene';
 import { IObject3D } from '../interfaces/IObject3D';
 import { ICamera } from '../interfaces/ICamera';
 import { IControls } from '../interfaces/IControls';
+import { GridHelperOptions, AxesHelperOptions } from '../../types/options/HelperOptions';
 /**
  * Service for setting up scene elements like helpers, lighting, and backgrounds
  */
@@ -29,12 +30,12 @@ export interface ISceneSetupService {
     addDynamicGrid(scene: IScene, object: IObject3D, scaleFactor?: number): Result<void>;
 }
 export interface IHelperOptions {
-    grid?: boolean;
+    grid?: boolean | GridHelperOptions;
     gridSize?: number;
     gridDivisions?: number;
     gridColor?: string;
     gridCenterLineColor?: string;
-    axes?: boolean;
+    axes?: boolean | AxesHelperOptions;
     axesSize?: number;
     object3DHelper?: boolean;
 }

package/dist/infrastructure/three/ThreeEnvironmentService.d.ts

@@ -1,4 +1,4 @@
-import { IEnvironmentService, IEnvironmentOptions, IStudioEnvironmentOptions } from '../../core/services/IEnvironmentService';
+import { IEnvironmentService, IEnvironmentOptions, IStudioEnvironmentOptions, IEnvironmentApplyOptions } from '../../core/services/IEnvironmentService';
 import { IScene, ITexture } from '../../core/interfaces/IScene';
 import { Result } from '../../utils/Result';
 export declare class ThreeEnvironmentService implements IEnvironmentService {
@@ -7,7 +7,7 @@ export declare class ThreeEnvironmentService implements IEnvironmentService {
     constructor();
     initialize(options: IEnvironmentOptions): Promise<Result<void>>;
     loadEnvironmentMap(url: string): Promise<Result<ITexture>>;
-    applyToScene(scene: IScene, texture: ITexture): Result<void>;
+    applyToScene(scene: IScene, texture: ITexture, options?: IEnvironmentApplyOptions): Result<void>;
     /**
      * Get the original environment texture (for path tracing)
      */

package/dist/infrastructure/three/grids/GridFactory.d.ts

@@ -0,0 +1,21 @@
+import { IGridStyle, IGridOptions, GridType } from './IGridStyle';
+import * as THREE from 'three';
+export declare class GridFactory {
+    private static gridStyles;
+    /**
+     * Create a grid of the specified type
+     */
+    static createGrid(type: GridType, options: IGridOptions): THREE.Object3D;
+    /**
+     * Register a custom grid style
+     */
+    static registerGridStyle(type: GridType | string, style: IGridStyle): void;
+    /**
+     * Get available grid types
+     */
+    static getAvailableTypes(): string[];
+    /**
+     * Dispose of a specific grid style's resources
+     */
+    static disposeGridStyle(type: GridType): void;
+}

package/dist/infrastructure/three/grids/HexagonalGlassGrid.d.ts

@@ -0,0 +1,7 @@
+import { IGridStyle, IGridOptions } from './IGridStyle';
+import * as THREE from 'three';
+export declare class HexagonalGlassGrid implements IGridStyle {
+    name: string;
+    createGrid(options: IGridOptions): THREE.Object3D;
+    dispose(): void;
+}

package/dist/infrastructure/three/grids/HexagonalWireGrid.d.ts

@@ -0,0 +1,7 @@
+import { IGridStyle, IGridOptions } from './IGridStyle';
+import * as THREE from 'three';
+export declare class HexagonalWireGrid implements IGridStyle {
+    name: string;
+    createGrid(options: IGridOptions): THREE.Object3D;
+    dispose(): void;
+}

package/dist/infrastructure/three/grids/IGridStyle.d.ts

@@ -0,0 +1,45 @@
+import * as THREE from 'three';
+export interface IGridStyle {
+    /**
+     * Name of the grid style
+     */
+    name: string;
+    /**
+     * Create the grid geometry and materials
+     */
+    createGrid(options: IGridOptions): THREE.Object3D;
+    /**
+     * Dispose of any resources used by this grid style
+     */
+    dispose?(): void;
+}
+export interface IGridOptions {
+    size: number;
+    divisions: number;
+    color?: string | number;
+    centerLineColor?: string | number;
+    opacity?: number;
+    styleOptions?: {
+        hexRadius?: number;
+        tileSize?: number;
+        texture?: string;
+        normalMap?: string;
+        roughnessMap?: string;
+        metalness?: number;
+        roughness?: number;
+        transmission?: number;
+        thickness?: number;
+        ior?: number;
+        height?: number;
+        bevelSize?: number;
+        randomHeight?: boolean;
+        randomRotation?: boolean;
+    };
+}
+export declare enum GridType {
+    SQUARE_WIRE = "square_wire",
+    HEXAGONAL_WIRE = "hexagonal_wire",
+    HEXAGONAL_GLASS = "hexagonal_glass",
+    STONE_TILES = "stone_tiles",
+    CUSTOM = "custom"
+}

package/dist/infrastructure/three/grids/SquareWireGrid.d.ts

@@ -0,0 +1,7 @@
+import { IGridStyle, IGridOptions } from './IGridStyle';
+import * as THREE from 'three';
+export declare class SquareWireGrid implements IGridStyle {
+    name: string;
+    createGrid(options: IGridOptions): THREE.Object3D;
+    dispose(): void;
+}

package/dist/infrastructure/three/grids/StoneTileGrid.d.ts

@@ -0,0 +1,11 @@
+import { IGridStyle, IGridOptions } from './IGridStyle';
+import * as THREE from 'three';
+export declare class StoneTileGrid implements IGridStyle {
+    name: string;
+    private textureLoader;
+    private loadedTextures;
+    createGrid(options: IGridOptions): THREE.Object3D;
+    private createStoneMaterial;
+    private loadTexture;
+    dispose(): void;
+}

package/dist/infrastructure/three/grids/index.d.ts

@@ -0,0 +1,6 @@
+export * from './IGridStyle';
+export * from './GridFactory';
+export * from './SquareWireGrid';
+export * from './HexagonalWireGrid';
+export * from './HexagonalGlassGrid';
+export * from './StoneTileGrid';