threedviewer 0.10.0 → 2.0.0

package/dist/SimpleViewer.d.ts

@@ -1,4 +1,20 @@
 import { default as React } from 'react';
+import { MapControls } from '../node_modules/three/examples/jsm/controls/MapControls';
+import { OrbitControls } from '../node_modules/three/examples/jsm/controls/OrbitControls';
 import { SimpleViewerProps } from './types';
-declare const SimpleViewer: React.FC<SimpleViewerProps>;
+import { TypedEventEmitter, ViewerEventMap } from './events';
+import * as THREE from 'three';
+export interface SimpleViewerHandle {
+    scene: THREE.Scene | null;
+    camera: THREE.Camera | null;
+    renderer: THREE.WebGLRenderer | null;
+    controls: OrbitControls | MapControls | null;
+    events: TypedEventEmitter<ViewerEventMap>;
+    loadModel: (url: string) => Promise<void>;
+    startRendering: () => void;
+    stopRendering: () => void;
+    captureScreenshot: () => Promise<string>;
+    dispose: () => void;
+}
+declare const SimpleViewer: React.ForwardRefExoticComponent<SimpleViewerProps & React.RefAttributes<SimpleViewerHandle>>;
 export default SimpleViewer;

package/dist/ThreeSceneSetup/HexGrid/HexTile.d.ts

@@ -3,6 +3,8 @@ declare class HexTile {
     position: THREE.Vector3;
     size: number;
     color: string;
+    readonly height: number;
+    bevel: number;
     constructor(position: THREE.Vector3, size: number, color: string);
     createMesh(): THREE.Object3D;
 }

package/dist/ThreeSceneSetup/SceneInitializer.d.ts

@@ -1,15 +1,18 @@
 import { MapControls } from '../../node_modules/three/examples/jsm/controls/MapControls';
 import { OrbitControls } from '../../node_modules/three/examples/jsm/controls/OrbitControls';
 import { SimpleViewerOptions } from '../types';
+import { Result } from '../utils/Result';
 import * as THREE from 'three';
 export declare class SceneInitializer {
-    scene: THREE.Scene;
+    scene: THREE.Scene | null;
     private object;
     private camera;
     private controls;
     private options;
     private mountRef;
     constructor(object: THREE.Object3D | null, camera: THREE.Camera, controls: OrbitControls | MapControls, options: SimpleViewerOptions, mountRef: React.RefObject<HTMLDivElement>);
+    setup(): Result<THREE.Scene>;
     private setupScene;
     private setupObjectInScene;
+    dispose(): void;
 }

package/dist/ThreeSceneSetup/cleanupScene.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
 import * as THREE from 'three';
-export declare const cleanupScene: (mountRef: React.RefObject<HTMLDivElement>, renderer: THREE.WebGLRenderer, resizeHandler: () => void) => void;
+export declare const cleanupScene: (mountRef: React.RefObject<HTMLDivElement>, renderer: THREE.WebGLRenderer | null, resizeHandler: () => void) => void;

package/dist/ThreeSceneSetup/constants.d.ts

@@ -1,4 +1 @@
-export declare const BACKGROUND_COLOR = 15790327;
-export declare const UNITS_PER_INCH = 1;
-export declare const UNITS_PER_FOOT: number;
 export declare const TIME_PER_FRAME: number;

package/dist/ThreeSceneSetup/setupScene/AnimationManager.d.ts

@@ -2,6 +2,7 @@ import { OrbitControls } from '../../../node_modules/three/examples/jsm/controls
 import { MapControls } from '../../../node_modules/three/examples/jsm/controls/MapControls';
 import { SimpleViewerOptions } from '../../types';
 import { PathTracingManager } from './PathTracingManager';
+import { Result } from '../../utils/Result';
 import * as THREE from 'three';
 export declare class AnimationManager {
     private renderer;
@@ -11,10 +12,13 @@ export declare class AnimationManager {
     private options;
     private isSceneActive;
     private pathTracingManager;
-    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, controls: OrbitControls | MapControls, options: SimpleViewerOptions, pathTracingManager: PathTracingManager | null);
+    private animationFrameId;
+    constructor(renderer: THREE.WebGLRenderer | null, scene: THREE.Scene | null, camera: THREE.Camera | null, controls: OrbitControls | MapControls | null, options: SimpleViewerOptions, pathTracingManager: PathTracingManager | null);
+    setup(): Result<void>;
     private throttledRender;
     private animate;
-    private handleRendering;
-    startRendering(): void;
-    stopRendering(): void;
+    startInitialRendering(): void;
+    startRendering(): Result<void>;
+    stopRendering(): Result<void>;
+    dispose(): void;
 }

package/dist/ThreeSceneSetup/setupScene/ControlsManager.d.ts

@@ -1,12 +1,14 @@
 import { OrbitControls } from '../../../node_modules/three/examples/jsm/controls/OrbitControls';
 import { MapControls } from '../../../node_modules/three/examples/jsm/controls/MapControls';
 import { SimpleViewerOptions } from '../../types';
+import { Result } from '../../utils/Result';
 import * as THREE from 'three';
 export declare class ControlsManager {
-    controls: OrbitControls | MapControls;
+    controls: OrbitControls | MapControls | null;
     private camera;
     private rendererDomElement;
     private options;
     constructor(camera: THREE.Camera, rendererDomElement: HTMLCanvasElement, options: SimpleViewerOptions);
-    private setupControls;
+    setup(): Result<OrbitControls | MapControls>;
+    dispose(): void;
 }

package/dist/ThreeSceneSetup/setupScene/EnvironmentMapManager.d.ts

@@ -0,0 +1,32 @@
+import { PathTracingManager } from './PathTracingManager';
+import { Result } from '../../utils/Result';
+import * as THREE from 'three';
+interface EnvironmentMapManagerParams {
+    renderer: THREE.WebGLRenderer | null;
+    scene: THREE.Scene | null;
+    camera: THREE.Camera | null;
+    envMapUrl?: string;
+    usePathTracing: boolean;
+    pathTracingManager: PathTracingManager | null;
+    backgroundBlurriness?: number;
+    blurStrengthPathTracing?: number;
+}
+export declare class EnvironmentMapManager {
+    private renderer;
+    private scene;
+    private camera;
+    private envMapUrl?;
+    private usePathTracing;
+    private pathTracingManager;
+    private backgroundBlurriness;
+    private blurStrengthPathTracing;
+    private loadedTexture;
+    private pmremGenerator;
+    constructor(params: EnvironmentMapManagerParams);
+    setup(): Result<void>;
+    load(): Promise<Result<THREE.Texture>>;
+    private processPathTracingEnvironment;
+    updateEnvironment(): Result<void>;
+    dispose(): void;
+}
+export {};

package/dist/ThreeSceneSetup/setupScene/PathTracingManager.d.ts

@@ -1,17 +1,19 @@
 import { SimpleViewerOptions } from '../../types';
+import { WebGLPathTracer } from '../importRaytracer';
+import { Result } from '../../utils/Result';
 import * as THREE from 'three';
 export declare class PathTracingManager {
     private renderer;
     private scene;
     private camera;
     private isPathTracing;
-    ptRenderer: any;
+    ptRenderer: WebGLPathTracer | null;
     private renderCount;
     private maxSamples;
     private _onComplete;
     constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, options: SimpleViewerOptions, onComplete: (image: string) => void);
-    setupPathTracer(): void;
-    updatePathTracerRenderer(): void;
+    setup(): Result<WebGLPathTracer>;
+    updatePathTracerRenderer(): Result<void>;
     set onComplete(value: (image: string) => void);
     get onComplete(): (image: string) => void;
     startPathTracing(): void;
@@ -19,4 +21,5 @@ export declare class PathTracingManager {
     private animatePathTracing;
     saveScreenshot(): void;
     resetForStandardRender(): void;
+    dispose(): void;
 }

package/dist/ThreeSceneSetup/setupScene/RendererManager.d.ts

@@ -1,7 +1,11 @@
 import { SimpleViewerOptions } from '../../types';
+import { Result } from '../../utils/Result';
 import * as THREE from 'three';
 export declare class RendererManager {
-    renderer: THREE.WebGLRenderer;
+    renderer: THREE.WebGLRenderer | null;
     private options;
     constructor(options: SimpleViewerOptions);
+    setup(): Result<THREE.WebGLRenderer>;
+    private isWebGLSupported;
+    dispose(): void;
 }

package/dist/ThreeSceneSetup/setupScene/SceneManager.d.ts

@@ -15,9 +15,9 @@ export declare class SceneManager {
     private sceneInitializer;
     readonly pathTracingManager: PathTracingManager | null;
     private animationManager;
+    private environmentMapManager;
     constructor(threeBase: THREEBase, object: THREE.Object3D | null, options: SimpleViewerOptions, setRenderCompleteImage: (image: string | null) => void);
     onStartRendering(): void;
-    private loadEnvironmentMap;
     getSceneElements(): {
         scene: THREE.Scene;
         camera: THREE.Camera;

package/dist/ThreeSceneSetup/updateSize.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
 import * as THREE from 'three';
-export declare const updateSize: (renderer: THREE.WebGLRenderer, camera: THREE.PerspectiveCamera, mountRef: React.RefObject<HTMLDivElement>, scene: THREE.Scene) => void;
+export declare const updateSize: (renderer: THREE.WebGLRenderer, camera: THREE.Camera, mountRef: React.RefObject<HTMLDivElement>, scene: THREE.Scene) => void;

package/dist/errors/ErrorCode.d.ts

@@ -0,0 +1,13 @@
+export declare enum ErrorCode {
+    SCENE_INIT_FAILED = "SCENE_INIT_FAILED",
+    RENDERER_INIT_FAILED = "RENDERER_INIT_FAILED",
+    CAMERA_INIT_FAILED = "CAMERA_INIT_FAILED",
+    WEBGL_NOT_SUPPORTED = "WEBGL_NOT_SUPPORTED",
+    MODEL_LOAD_FAILED = "MODEL_LOAD_FAILED",
+    TEXTURE_LOAD_FAILED = "TEXTURE_LOAD_FAILED",
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
+    INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
+    RENDER_ERROR = "RENDER_ERROR",
+    COMPONENT_NOT_MOUNTED = "COMPONENT_NOT_MOUNTED",
+    UNKNOWN = "UNKNOWN"
+}

package/dist/errors/ThreeViewerError.d.ts

@@ -0,0 +1,11 @@
+import { ErrorCode } from './ErrorCode';
+export interface ErrorContext {
+    [key: string]: any;
+}
+export declare class ThreeViewerError extends Error {
+    readonly code: ErrorCode;
+    readonly context?: ErrorContext | undefined;
+    readonly timestamp: Date;
+    constructor(message: string, code: ErrorCode, context?: ErrorContext | undefined);
+    static fromError(error: unknown, code: ErrorCode, context?: ErrorContext): ThreeViewerError;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { ThreeViewerError, type ErrorContext } from './ThreeViewerError';
+export { ErrorCode } from './ErrorCode';

package/dist/events/EventEmitter.d.ts

@@ -0,0 +1,8 @@
+export declare class TypedEventEmitter<T extends Record<string, any>> {
+    private listeners;
+    on<K extends keyof T>(event: K, listener: (data: T[K]) => void): () => void;
+    emit<K extends keyof T>(event: K, data: T[K]): void;
+    once<K extends keyof T>(event: K, listener: (data: T[K]) => void): () => void;
+    removeAllListeners(event?: keyof T): void;
+    listenerCount(event: keyof T): number;
+}

package/dist/events/ViewerEvents.d.ts

@@ -0,0 +1,42 @@
+import { ThreeViewerError } from '../errors';
+import { SimpleViewerHandle } from '../SimpleViewer';
+import * as THREE from 'three';
+export interface ViewerEventMap {
+    'initialized': {
+        viewer: SimpleViewerHandle;
+    };
+    'disposed': {
+        viewer: SimpleViewerHandle;
+    };
+    'model:loading': {
+        url: string;
+    };
+    'model:loaded': {
+        model: THREE.Object3D;
+        loadTime: number;
+    };
+    'model:error': {
+        error: ThreeViewerError;
+        url: string;
+    };
+    'render:start': {
+        frame: number;
+    };
+    'render:complete': {
+        frame: number;
+        renderTime: number;
+    };
+    'screenshot:captured': {
+        dataUrl: string;
+    };
+    'controls:change': {
+        type: string;
+        camera: THREE.Camera;
+    };
+    'object:selected': {
+        object: THREE.Object3D;
+    };
+    'error': {
+        error: ThreeViewerError;
+    };
+}

package/dist/events/index.d.ts

@@ -0,0 +1,2 @@
+export { TypedEventEmitter } from './EventEmitter';
+export type { ViewerEventMap } from './ViewerEvents';

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export { default as SimpleViewer } from './SimpleViewer';
+export { default as SimpleViewer, type SimpleViewerHandle } from './SimpleViewer';
 export { type SimpleViewerProps } from './types';
 export { type SimpleViewerOptions } from './types';
 export { default as defaultOptions } from './defaultOptions';
+export { TypedEventEmitter } from './events';
+export type { ViewerEventMap } from './events';