soonspacejs 2.13.6 → 2.13.7

package/dist/src/Shared/viewport.d.ts

@@ -0,0 +1,40 @@
+import { Vector3, Euler, Box3, Object3D, Vector2, Camera } from 'three';
+import { IVector3, AxisType, Rotation } from '../Interface';
+declare function IVector3ToVector3(val: IVector3 | Vector3): Vector3;
+declare function IVector3ToEuler(val: IVector3 | Euler): Euler;
+/**
+ * 获取 object box
+ * @param object
+ * @returns
+ */
+declare function getBoundingBox(object: Object3D, precise?: boolean): Box3;
+declare function rotationAxisFix(axis: AxisType, source: Euler, target: Euler): Euler;
+declare function rotationAFix(source: Euler, target: Euler): Euler;
+declare function deg2Euler(deg: number): number;
+declare function euler2Deg(euler: number): number;
+/**
+ * 从 object 获取 position、rotation、scale
+ * @param object
+ * @param isFromWorld
+ * @returns
+ */
+declare function getSpaceAttributeFromObject(object: Object3D, isFromWorld?: boolean): {
+    position: Vector3;
+    rotation: Euler;
+    scale: Vector3;
+};
+/**
+ * 同步 source 的 position、rotation、scale 到 target
+ * @param target
+ * @param source
+ * @param isFromWorld
+ */
+declare function syncSpaceAttributeToObject(target: Object3D, source: Object3D, isFromWorld?: boolean): void;
+declare function isObjectVisible(object: Object3D): boolean;
+declare const calculateScaleFactor: (point3: Vector3, radiusPx: number, camera: Camera, size: Vector2) => number;
+/**
+ * 计算 target
+ */
+declare function computeTargetByRotation(position: IVector3, rotation: Rotation, scalar?: number): Vector3;
+declare function absoluteAngle(targetAngle: number, sourceAngle: number): number;
+export { IVector3ToVector3, IVector3ToEuler, getBoundingBox, rotationAxisFix, rotationAFix, deg2Euler, euler2Deg, getSpaceAttributeFromObject, syncSpaceAttributeToObject, isObjectVisible, calculateScaleFactor, computeTargetByRotation, absoluteAngle, };

package/dist/src/Shared/xml.d.ts

@@ -0,0 +1,2 @@
+declare function xmlToJson<T>(url: string): Promise<T>;
+export { xmlToJson, };

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

@@ -0,0 +1,3 @@
+import { SignalsState } from '../Interface';
+declare const Signals: () => SignalsState;
+export default Signals;

package/dist/src/Viewport/Bvh/GenerateMeshBVHWorker.d.ts

@@ -0,0 +1,11 @@
+import { BufferGeometry } from 'three';
+import { WorkerPool } from 'three/examples/jsm/utils/WorkerPool.js';
+import { MeshBVH } from 'three-mesh-bvh';
+declare class GenerateMeshBVHWorker {
+    workerPool: WorkerPool;
+    constructor();
+    generate(geometry: BufferGeometry, options?: any): Promise<MeshBVH | undefined>;
+    dispose(): void;
+}
+declare const generateMeshBVHWorker: GenerateMeshBVHWorker;
+export { GenerateMeshBVHWorker, generateMeshBVHWorker, };

package/dist/src/Viewport/Bvh/generateBVH.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Viewport/Bvh/index.d.ts

@@ -0,0 +1,18 @@
+import Viewport from '..';
+export type ModelsBoundsTreeOptions = {
+    type?: 'block' | 'slice' | 'worker';
+    force?: boolean;
+    frameSliceCount?: number;
+    workerCreator?: () => Worker;
+};
+declare class Bvh {
+    readonly viewport: Viewport;
+    cameraChanging: boolean;
+    timer: number | null;
+    computedGeometriesUuid: Map<string, string>;
+    generateMeshBVHWorker: import("./GenerateMeshBVHWorker").GenerateMeshBVHWorker;
+    constructor(viewport: Viewport);
+    computeModelsBoundsTree(options?: ModelsBoundsTreeOptions): Promise<void>;
+    dispose(): void;
+}
+export default Bvh;

package/dist/src/Viewport/CameraManager.d.ts

@@ -0,0 +1,34 @@
+import { Box3, PerspectiveCamera, OrthographicCamera, Vector3, Euler, Object3D } from 'three';
+import { Rotation, Position, FlyToViewpoint, FlyToObjOptions, SurroundOptions, LabelOptions, CameraViewpointData, CameraViewpointDataLegacy, FlyToOptions, CameraType } from '../Interface';
+import Viewport from '.';
+declare class CameraManager {
+    viewport: Viewport;
+    /**
+     * the controls camera
+     */
+    mainCamera: PerspectiveCamera | OrthographicCamera;
+    /**
+     * 当前 renderer camera
+     */
+    currentCamera: PerspectiveCamera | OrthographicCamera;
+    cameras: {
+        [x: string]: PerspectiveCamera;
+    };
+    constructor(viewport: Viewport);
+    createCamera(key: string): PerspectiveCamera;
+    removeCamera(key: string): boolean;
+    setCurrentCamera(camera: PerspectiveCamera | OrthographicCamera): void;
+    /**
+     * set main camera
+     * @param camera
+     */
+    setCamera(cameraType: CameraType, viewpoint?: CameraViewpointData, enableTransition?: boolean): Promise<void>;
+    getCameraViewpoint(): CameraViewpointData;
+    setCameraViewpoint(data: CameraViewpointData | CameraViewpointDataLegacy, enableTransition?: boolean): Promise<void>;
+    flyTo(position: Position, rotation?: FlyToViewpoint | Rotation | Euler, options?: FlyToOptions): Promise<void>;
+    flyToObj(object: Object3D | Box3, viewpoint?: FlyToViewpoint, options?: FlyToObjOptions): Promise<void>;
+    surroundOnTarget(target: Position, options?: SurroundOptions): Promise<void>;
+    surroundOnObject(object: Object3D, options?: SurroundOptions): Promise<void>;
+    getObjectLabelPos(bbox: Box3 | Object3D, rotation?: FlyToViewpoint | Rotation | Euler, options?: LabelOptions): Vector3;
+}
+export default CameraManager;

package/dist/src/Viewport/EffectManager.d.ts

@@ -0,0 +1,45 @@
+import { Camera, Scene, WebGLRenderer } from 'three';
+import { EffectComposer, Pass, Effect } from 'postprocessing';
+export interface EffectState<T = Effect> {
+    enabled: boolean;
+    effect: T;
+}
+declare class EffectManager {
+    readonly renderer: WebGLRenderer;
+    readonly scene: Scene;
+    readonly camera: Camera;
+    static CONSTANTS: {
+        renderPass: string;
+        ssaoPass: string;
+        effectPass: string;
+        smaaEffect: string;
+        outlineEffect: string;
+        bloomEffect: string;
+        toneMappingEffect: string;
+    };
+    effectComposer: EffectComposer;
+    passesMap: Map<string, Pass>;
+    effectsMap: Map<string, EffectState>;
+    effectsNeedsUpdate: boolean;
+    constructor(renderer: WebGLRenderer, scene: Scene, camera: Camera);
+    /**
+     * 更新 Effect pass
+     */
+    updateEffectPass(): void;
+    /**
+     * 更新 camera
+     * @param camera
+     */
+    updateCamera(camera: Camera): void;
+    private _initEffectComposer;
+    private _initPasses;
+    private _initRenderPass;
+    private _initSSAOPass;
+    private _initEffectPass;
+    private _initEffects;
+    private _initSMAAEffect;
+    private _initToneMappingEffect;
+    private _initBloomEffect;
+    private _initOutlineEffect;
+}
+export default EffectManager;

package/dist/src/Viewport/EventHandler.d.ts

@@ -0,0 +1,50 @@
+import { Object3D } from 'three';
+import Viewport from '.';
+import { SceneEventType } from '../Interface';
+/**
+ * @todo 事件部分待重构。目前实现不来灵活，且部分对象不支持事件。
+ */
+declare class EventHandler {
+    readonly viewport: Viewport;
+    private dblClickMaxInterval;
+    /**
+     * PC
+     */
+    private mouseDownTimes;
+    private mouseDownEvent;
+    private container;
+    private options;
+    private signals;
+    private touchLongUpMaxInterval;
+    private isTouchLongPressAsTouchRightClick;
+    private timer;
+    private touchStartEvent;
+    private touchstartTimes;
+    private selectModel;
+    private selectPoi;
+    constructor(viewport: Viewport);
+    _getPoiAndModel(): Object3D<import("three").Object3DEventMap>[];
+    /**
+     * 触发场景交互事件
+     * @param {SceneEventType}          eventType 事件类型 hover | click | dblClick | rightClick
+     * @param {MouseEvent | TouchEvent} event     鼠标事件对象 或 触摸事件对象
+     */
+    _triggerSceneEventInAllObject(eventType: SceneEventType, event: MouseEvent | TouchEvent, objects?: Object3D[]): void;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleDblClick;
+    private handleMouseWheel;
+    private handleTouchStart;
+    private handleTouchEnd;
+    private handleContextmenu;
+    /**
+     * key event
+     */
+    private handleKeyDown;
+    private handleKeyUp;
+    addEventListeners(): void;
+    removeEventListeners(): void;
+    dispose(): void;
+}
+export default EventHandler;

package/dist/src/Viewport/Info.d.ts

@@ -0,0 +1,17 @@
+import { Scene } from 'three';
+import { SignalsState } from '../Interface';
+declare class Info {
+    readonly scene: Scene;
+    readonly signals: SignalsState;
+    container: HTMLDivElement;
+    state: {
+        objects: number;
+        meshes: number;
+        vertices: number;
+        triangles: number;
+        frametime: number;
+    };
+    constructor(scene: Scene, signals: SignalsState);
+    addListeners(): void;
+}
+export default Info;

package/dist/src/Viewport/RendererManager.d.ts

@@ -0,0 +1,26 @@
+import { WebGLRenderer } from 'three';
+import { CSS2DRenderer, CSS3DRenderer } from '../Renderer';
+import { InternalOptions } from '../Interface';
+import Viewport from '.';
+declare module 'three/src/renderers/WebGLRenderer' {
+    interface WebGLRenderer {
+        autoInstancing: boolean;
+    }
+}
+declare class RendererManager {
+    readonly viewport: Viewport;
+    internalOptions: InternalOptions;
+    renderer: WebGLRenderer;
+    container: HTMLElement;
+    interactiveContainer: HTMLElement;
+    rendererCSS2D: CSS2DRenderer;
+    rendererCSS3D: CSS3DRenderer;
+    constructor(viewport: Viewport);
+    setInternalState(name: keyof InternalOptions, state: boolean): void;
+    _initContainer(): HTMLElement;
+    _initRenderer(): WebGLRenderer;
+    _initRenderCSS2D(): CSS2DRenderer;
+    _initRenderCSS3D(): CSS3DRenderer;
+    _initInteractiveContainer(): HTMLDivElement;
+}
+export default RendererManager;

package/dist/src/Viewport/Scener.d.ts

@@ -0,0 +1,43 @@
+import { Scene, Mesh, Object3D } from 'three';
+import localforage from 'localforage';
+import { EdgeSelectOptions, StrokeSelectOptions, OpacitySelectOptions, HighlightSelectOptions, EmissiveSelectOptions, FogOptions, SignalsState, ViewportState } from '../Interface';
+declare class Scener {
+    readonly signals: SignalsState;
+    readonly viewportState: ViewportState;
+    scene: Scene;
+    selectedObjects: {
+        edge: Set<Object3D>;
+        stroke: Set<Object3D>;
+        opacity: Set<Object3D>;
+        highlight: Set<Object3D>;
+        emissive: Set<Object3D>;
+    };
+    intersectsList: {
+        meshOfModelList: Mesh[];
+        poiIconList: Object3D[];
+        otherObjList: Object3D[];
+        getAll: () => Object3D[];
+    };
+    /**
+     * 线框
+     */
+    strokeStore: typeof localforage;
+    constructor(signals: SignalsState, viewportState: ViewportState);
+    addObject(object: Object3D, parent?: Object3D | null): void;
+    attachObject(object: Object3D, parent?: Object3D | null): void;
+    removeObject(object: Object3D): void;
+    openSceneFog(options?: FogOptions): void;
+    closeSceneFog(): void;
+    edgeShow(object: Object3D | Object3D[], options?: EdgeSelectOptions): Promise<void>;
+    unEdgeShow(objects?: Object3D | Object3D[]): Promise<void | void[]>;
+    strokeShow(object: Object3D | Object3D[], options?: StrokeSelectOptions): Promise<void | void[]>;
+    unStrokeShow(objects?: Object3D | Object3D[]): Promise<void | void[]>;
+    opacityShow(object: Object3D | Object3D[], options?: OpacitySelectOptions): Promise<void | void[]>;
+    unOpacityShow(objects?: Object3D | Object3D[]): Promise<void | void[]>;
+    highlightShow(object: Object3D | Object3D[], options?: HighlightSelectOptions): Promise<void | void[]>;
+    unHighlightShow(objects?: Object3D | Object3D[]): Promise<void | void[]>;
+    emissiveShow(object: Object3D | Object3D[], options?: EmissiveSelectOptions): Promise<void | void[]>;
+    unEmissiveShow(objects?: Object3D | Object3D[]): Promise<void | void[]>;
+    _triggerObjectAdded(object: Object3D): void;
+}
+export default Scener;

package/dist/src/Viewport/ViewHelper.d.ts

@@ -0,0 +1,15 @@
+import { Camera, Object3D, WebGLRenderer } from 'three';
+import Controls from '../Controls';
+declare class ViewHelper extends Object3D {
+    camera: Camera;
+    controls: Controls;
+    setLabels: (labelX: string, labelY: string, labelZ: string) => void;
+    setLabelStyle: (font: string, color: string, radius: number) => void;
+    render: (renderer: WebGLRenderer) => void;
+    handleClick: (event: MouseEvent) => void;
+    dispose: () => void;
+    isViewHelper: boolean;
+    animating: boolean;
+    constructor(camera: Camera, domElement: HTMLElement, controls: Controls);
+}
+export { ViewHelper, };

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

@@ -0,0 +1,131 @@
+import { Mesh, Clock, Scene, PerspectiveCamera, WebGLRenderer, PMREMGenerator, Vector3, AnimationMixer, Raycaster, Intersection, AnimationClip, Texture, Material, OrthographicCamera } from 'three';
+import { EffectComposer } from 'postprocessing';
+import Stats from 'three/examples/jsm/libs/stats.module.js';
+import { Sky } from 'three/examples/jsm/objects/Sky.js';
+import { AnimationOperate } from '@three3d/animation';
+import Scener from './Scener';
+import { CSS2DRenderer, CSS3DRenderer } from '../Renderer';
+import RendererManager from './RendererManager';
+import CameraManager from './CameraManager';
+import EffectManager from './EffectManager';
+import Bvh from './Bvh';
+import Controls from '../Controls';
+import { Model } from '../Library';
+import { IColorSpace, SkyOptions, IColor, OffsetPoint, Position, ViewportOptions, ViewportState, ModelAnimationFindFunc, SignalsState, ToneMappingOptions, SSAOOptions, BloomOptions, IntersectsOptions, EnvironmentOptions } from '../Interface';
+import EventHandler from './EventHandler';
+import Info from './Info';
+import { ViewHelper } from './ViewHelper';
+import { ObjectsCache } from '../Cache';
+export declare const innerRenderState: {
+    needsUpdate: boolean;
+};
+declare class Viewport {
+    readonly options: ViewportOptions;
+    readonly signals: SignalsState;
+    readonly cache: ObjectsCache;
+    clock: Clock;
+    raycaster: Raycaster;
+    scene: Scene;
+    sky: Sky | null;
+    state: ViewportState;
+    scener: Scener;
+    rendererManager: RendererManager;
+    container: HTMLElement;
+    interactiveContainer: HTMLElement;
+    renderer: WebGLRenderer;
+    rendererCSS2D: CSS2DRenderer;
+    rendererCSS3D: CSS3DRenderer;
+    pmremGenerator: PMREMGenerator;
+    info: Info;
+    stats: Stats;
+    cameraManager: CameraManager;
+    camera: PerspectiveCamera | OrthographicCamera;
+    controls: Controls;
+    effectManager: EffectManager;
+    effectComposer: EffectComposer;
+    bvh: Bvh;
+    mixer: AnimationMixer;
+    clipsSet: Set<AnimationClip>;
+    viewHelper: ViewHelper;
+    eventHandler: EventHandler;
+    /**
+     * render 前回调（每帧执行）
+     */
+    postUpdate: Map<string | number, (time: number) => void>;
+    /**
+     * render 后回调
+     */
+    postRender: Map<string | number, () => void>;
+    private _loop;
+    resizeObserver: ResizeObserver;
+    constructor(options: ViewportOptions, signals: SignalsState, cache: ObjectsCache);
+    _initInfo(): void;
+    _initStats(): void;
+    setAutoInstancing(enabled: boolean): void;
+    /**
+     ***************************** post-processing ***************************
+     */
+    setBloom(options?: BloomOptions): void;
+    setSSAO(options?: SSAOOptions): void;
+    /**
+     ***************************** renderer ***************************
+     */
+    setColorSpace(colorSpace: IColorSpace): void;
+    setToneMapping(options?: ToneMappingOptions): void;
+    /**
+     ***************************** background ***************************
+     */
+    setSphereSkyBackground(imgUrl: string): Promise<void>;
+    setSkyBackground(dirPath: string, fileNames?: string[]): Promise<void>;
+    setBackgroundColor(color: IColor): void;
+    setBackgroundColorAlpha(color: IColor, alpha?: number): void;
+    setBackgroundImage(imgUrl: string): Promise<void>;
+    setSky(options?: SkyOptions): Sky | undefined;
+    closeSky(): boolean;
+    screenshot(): Promise<Blob | null>;
+    /**
+     ***************************** environment ***************************
+     */
+    setEnvironment(options?: EnvironmentOptions): Promise<Texture>;
+    /**
+     ***************************** modelAnimation ***************************
+     */
+    playModelAnimation(model: Model, animation: number | AnimationClip | ModelAnimationFindFunc): AnimationOperate | undefined;
+    stopModelAnimation(model: Model, animation: number | AnimationClip | ModelAnimationFindFunc): void;
+    /**
+     ***************************** render ***************************
+     */
+    render(fn?: () => unknown): Promise<number>;
+    /**
+     * 触发渲染（兼容 soongis）
+     * @param count
+     */
+    triggerRender(count?: number): void;
+    /**
+     * 暂停渲染
+     * @param pause
+     */
+    setPauseRender(pause?: boolean): Promise<number | undefined>;
+    /**
+     * effect passes
+     */
+    _passesObserver(): void;
+    /**
+     * 每帧都会被执行
+     * @param time
+     * @returns
+     */
+    autoRender(): void;
+    animate(time: number): void;
+    getOffsetByPosition(position: Position): {
+        left: number;
+        top: number;
+    };
+    getPositionByOffset(offset: OffsetPoint, z?: number, scalar?: number): Vector3;
+    getIntersects(event: MouseEvent | TouchEvent | OffsetPoint, objects?: import("three").Object3D<import("three").Object3DEventMap>[], options?: IntersectsOptions): Intersection<import("three").Object3D<import("three").Object3DEventMap>>[];
+    rayClash(startPoint?: Vector3, dir?: Vector3, objects?: Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, Material | Material[], import("three").Object3DEventMap>[]): Intersection<import("three").Object3D<import("three").Object3DEventMap>>[];
+    clearSignals(): void;
+    dispose(): void;
+    _signalsEventListenr(): void;
+}
+export default Viewport;

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

@@ -0,0 +1,6 @@
+import { Object3D } from 'three';
+import { GLTFExporterOptions } from 'three/examples/jsm/exporters/GLTFExporter.js';
+declare function exportGltf(object: Object3D | Object3D[], options?: GLTFExporterOptions): Promise<ArrayBuffer | {
+    [key: string]: any;
+}>;
+export { exportGltf, };