@xviewer.js/core 1.0.0-beta.2 → 1.0.0

package/package.json

@@ -1,10 +1,6 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.0-beta.2",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
+  "version": "1.0.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -17,7 +13,7 @@
     "types/**/*"
   ],
   "peerDependencies": {
-    "three": ">= 0.164.0 < 0.165.0"
+    "three": ">= 0.164.0"
   },
   "scripts": {
     "b:types": "tsc"

package/types/Component.d.ts

@@ -3,12 +3,11 @@ import { Viewer } from "./Viewer";
 import { ComponentManager } from "./ComponentManager";
 import { ObjectInstance } from "./ObjectInstance";
 export declare class Component<T extends Object3D = Object3D> extends ObjectInstance {
-    get enabled(): boolean;
-    set enabled(v: boolean);
     private _enabled;
     node: T;
     viewer: Viewer;
     manager: ComponentManager;
+    isComponent: boolean;
     type: string;
     onLoad?(): void;
     onEnable?(): void;
@@ -17,6 +16,8 @@ export declare class Component<T extends Object3D = Object3D> extends ObjectInst
     start?(): void;
     update?(dt: number): void;
     lastUpdate?(dt: number): void;
+    render?(dt: number): void;
+    resize?(width: number, height: number): void;
     flags: {
         Destroyed?: boolean;
         OnLoadCalled?: boolean;
@@ -25,6 +26,8 @@ export declare class Component<T extends Object3D = Object3D> extends ObjectInst
         Deactivating?: boolean;
         IsStartCalled?: boolean;
     };
+    get enabled(): boolean;
+    set enabled(v: boolean);
     protected _onPreDestroy(): void;
     schedule(callback: Function, interval: number, repeat?: number): void;
     unshedule(callback: Function): void;

package/types/ComponentManager.d.ts

@@ -3,7 +3,7 @@ import { Scheduler } from "./Scheduler";
 import { Component } from "./Component";
 import { ComponentScheduler } from "./ComponentScheduler";
 import { Viewer } from "./Viewer";
-type ComponentConstructor = new () => Component;
+type ComponentConstructor = new (...args: any[]) => Component;
 interface DependentInfo {
     mode: DependentMode;
     components: ComponentConstructor[];
@@ -16,7 +16,7 @@ export declare enum DependentMode {
 }
 export declare function dependencies(componentOrComponents: ComponentConstructor | ComponentConstructor[], mode?: DependentMode): <T extends ComponentConstructor>(target: T) => void;
 export declare class ComponentManager {
-    static _dependenciesMap: Map<ComponentConstructor, DependentInfo>;
+    static _infoMap: Map<ComponentConstructor, DependentInfo>;
     private _viewer;
     private _scheduler;
     private _componentScheduler;
@@ -27,6 +27,8 @@ export declare class ComponentManager {
     constructor(viewer: Viewer);
     destroy(): void;
     update(dt: number): void;
+    render(dt: number): void;
+    resize(width: number, height: number): void;
     destroyComponents(node: Object3D): void;
     activeComponents(node: Object3D): void;
     addComponent<T extends Component>(node: Object3D | Component, instance: T): T;
@@ -35,7 +37,7 @@ export declare class ComponentManager {
     }): T;
     removeComponent(node: Object3D, component: Component): this;
     getComponent<T extends Component>(node: Object3D, constructor: {
-        new (): T;
+        new (...args: any[]): T;
     }, autoAdd?: boolean): T;
     getComponentsInChidren<T extends Component>(node: Object3D, constructor: {
         new (): T;

package/types/ComponentScheduler.d.ts

@@ -1,19 +1,23 @@
 import { Component } from "./Component";
 declare class Invoker<T> {
     protected _targets: T[];
-    protected _callback: (target: T, dt: number) => any;
-    constructor(callback: (target: T, dt: number) => any);
+    protected _callback: (target: T, ...args: any[]) => any;
+    constructor(callback: (target: T, ...args: any[]) => any);
     add(target: any): void;
     remove(target: any): void;
-    invoke(dt: number): void;
+    invoke(...args: any[]): void;
 }
 export declare class ComponentScheduler {
     startInvoker: Invoker<Component>;
     updateInvoker: Invoker<Component>;
     lastUpdateInvoker: Invoker<Component>;
+    renderInvoker: Invoker<Component>;
+    resizeInvoker: Invoker<Component>;
     start(): void;
     update(dt: number): void;
     lastUpdate(dt: number): void;
+    render(dt: number): void;
+    resize(width: number, height: number): void;
     enableComponent(comp: Component, enable: boolean): void;
 }
 export {};

package/types/DeviceInput.d.ts

@@ -16,7 +16,6 @@ export declare class DeviceInput {
     static readonly KEYDOWN = "keydown";
     static readonly KEYPRESS = "keypress";
     static readonly KEYUP = "keyup";
-    static readonly RESIZE = "resize";
     private _listeners;
     private _mouseWheel;
     private _touches;

package/types/Mount.d.ts

@@ -0,0 +1,4 @@
+import { Component } from "./Component";
+export declare class Mount extends Component {
+    isMount: boolean;
+}

package/types/ObjectInstance.d.ts

@@ -1,7 +1,7 @@
 export declare class ObjectInstance {
     static _instanceCount: number;
-    instanceId: number;
-    uuid: string;
+    readonly instanceId: number;
+    readonly uuid: string;
     name: string;
     type: string;
 }

package/types/Plugin.d.ts

@@ -1,10 +1,4 @@
-import { ObjectInstance } from "./ObjectInstance";
-import { Viewer } from "./Viewer";
-export declare class Plugin extends ObjectInstance {
-    viewer: Viewer;
-    type: string;
-    install?(): void;
-    uninstall?(): void;
-    onUpdate?(dt: number): void;
-    onRender?(dt: number): void;
+import { Component } from "./Component";
+export declare class Plugin extends Component {
+    isPlugin: boolean;
 }

package/types/PropertyManager.d.ts

@@ -1,8 +1,18 @@
+declare class ClassProperties {
+    clsName: string;
+    private _properties;
+    constructor(clsName: string);
+    property(propertyKey: string, options?: Object): this;
+    applyProperties(target: object): object;
+}
 export declare class PropertyManager {
-    static _propertiesMap: Map<Object, Object>;
-    static _getProperties(target: object): Object;
-    static _hasProperties(target: object): boolean;
-    static _getMergedProperties(target: Object): any;
+    static _classMap: Map<String, ClassProperties>;
+    static _propertyMap: Map<Object, Object>;
+    static _hasProperties(constructor: Function): boolean;
+    static _getProperties(constructor: Function, autoAdd?: boolean): Object;
+    static _getMergedProperties(constructor: Function): any;
+    static _getClassProperties(clsName: string, autoAdd?: boolean): ClassProperties;
+    static _applyClassProperties(clsName: string, constructor: Function): object;
 }
 export interface IPropertyOptions {
     dir?: string;

package/types/SystemInfo.d.ts

@@ -1,4 +1,5 @@
 export declare class SystemInfo {
+    static isTablet: boolean;
     static isMobile: boolean;
     static isDesktop: boolean;
     static device: string;

package/types/Task.d.ts

@@ -1,5 +1,7 @@
 export declare class Task {
     excute: () => void;
     name: string;
+    static _instanceCount: number;
     constructor(excute: () => void, name?: string);
+    instanceId: number;
 }

package/types/TextureSettings.d.ts

@@ -1,4 +1,4 @@
-import { Mapping, PixelFormat, TextureDataType, TextureFilter, Vector2, Wrapping } from "three";
+import { ColorSpace, Mapping, PixelFormat, TextureDataType, TextureFilter, Vector2, Wrapping } from "three";
 export interface TextureSettings {
     flipY?: boolean;
     mapping?: Mapping;
@@ -10,4 +10,6 @@ export interface TextureSettings {
     dataType?: TextureDataType;
     anisotropy?: number;
     repeat?: Vector2;
+    colorSpace?: ColorSpace;
+    channel?: number;
 }

package/types/Utils.d.ts

@@ -1,6 +1,16 @@
+import { Object3D } from "three";
 import { __C, __P } from "./types";
 export declare function applyProps<T, K extends __C<T>>(target: T & {
     copy?: Function;
 }, props: __P<T, K>): T & {
     copy?: Function;
 };
+export declare function find<T extends Object3D>(node: T, path: string): T;
+export declare function getChidren<T extends Object3D>(node: T, filter: (value: T) => any, group?: boolean): any;
+export declare function getChildByName<T extends Object3D>(node: T, name: string): T;
+export declare function queryValues<T extends Object & {
+    name: string;
+}>(object: any): T[];
+export declare function queryValues<T extends Object & {
+    name: string;
+}>(object: any, name: string): T;

package/types/Viewer.d.ts

@@ -1,24 +1,28 @@
-import { BufferGeometry, Camera, ColorSpace, DataTexture, DirectionalLightShadow, Euler, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, ShaderMaterial, ShadowMapType, Texture, TextureDataType, ToneMapping, Vector3, WebGLCubeRenderTarget, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget } from "three";
+import { BufferGeometry, Camera, ColorSpace, DataTexture, DirectionalLightShadow, Euler, LoadingManager, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, ShadowMapType, Texture, TextureDataType, ToneMapping, Vector3, WebGLCubeRenderTarget, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget } from "three";
 import { EventEmitter } from "./base";
-import { ComponentManager } from "./ComponentManager";
-import { AssetProperties, LoaderConstructor } from "./asset/ResourceManager";
+import { TaskManager } from "./TaskManager";
+import { DeviceInput } from "./DeviceInput";
+import { Orientation } from "./enums/Orientation";
+import { AssetProperties, LoaderConstructor, ResourceManager } from "./asset/ResourceManager";
 import { __C, __P } from "./types";
 import { Component } from "./Component";
-import { TextureSettings } from "./TextureSettings";
-import { Plugin } from "./Plugin";
+import { TweenManager } from "./tween";
+import { Task } from "./Task";
+import { Mount } from "./Mount";
 export declare class Viewer extends EventEmitter {
     static __target: Vector3;
     static __worldPos: Vector3;
-    static _getClassInstance(constructor: any, args?: any[]): any;
     static _shadowCameraKeys: string[];
     static _setDirectLightShadow(shadow: DirectionalLightShadow, props: number[]): DirectionalLightShadow;
     static CompileMaterial(renderer: WebGLRenderer, scene: Scene, camera: Camera, target: Material | Material[]): void;
     static CompileObject3D(renderer: WebGLRenderer, scene: Scene, camera: Camera, target: Object3D): void;
     static CompileTexture(renderer: WebGLRenderer, target: Texture | Texture[]): void;
-    static Blit(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget, material: ShaderMaterial, lod?: number, face?: number): void;
-    static GetFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes>;
+    static Blit(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, material: Material, lod?: number, face?: number): void;
+    static CreateFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes>;
     static fullscreenMesh: Mesh;
     static fullscreenCamera: OrthographicCamera;
+    static instanceCount: number;
+    private _instanceId;
     private _root;
     private _canvas;
     private _gl;
@@ -26,6 +30,7 @@ export declare class Viewer extends EventEmitter {
     private _DATA_FLOAT_TYPE;
     private _scene;
     private _camera;
+    private _mount;
     private _renderer;
     private _input;
     private _dpr;
@@ -33,17 +38,20 @@ export declare class Viewer extends EventEmitter {
     private _height;
     private _viewport;
     private _orientation;
+    private _defaultProps;
     private _running;
     private _rootRotated;
     private _time;
     private _lastTime;
+    private _lastFrameTime;
     private _targetFrameRate;
+    private _fixedFrameTime;
     private _autoResize;
     private _taskManager;
     private _resourceManager;
     private _componentManager;
-    private _pluginManager;
-    private _tweenManager;
+    private _loadingManager;
+    private _tweens;
     get root(): HTMLElement;
     get time(): number;
     get scene(): Scene;
@@ -62,10 +70,18 @@ export declare class Viewer extends EventEmitter {
         factor: number;
     };
     get rootRotated(): boolean;
-    constructor({ root, canvas, autoStart, autoResize, shadows, camera, targetFrameRate, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, loader, tasker, ...webglOpts }?: {
+    get input(): DeviceInput;
+    get targetFrameRate(): number;
+    set targetFrameRate(v: number);
+    get instanceId(): number;
+    get loadingManager(): LoadingManager;
+    get resourceManager(): ResourceManager;
+    get taskManager(): TaskManager;
+    constructor({ root, canvas, autoStart, autoResize, shadows, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, orientation, loader, tasker, ...webglOpts }?: {
         root?: HTMLElement;
         canvas?: HTMLCanvasElement;
         targetFrameRate?: number;
+        fixedFrameTime?: boolean;
         autoStart?: boolean;
         autoResize?: boolean;
         shadows?: boolean | ShadowMapType;
@@ -76,6 +92,7 @@ export declare class Viewer extends EventEmitter {
         path?: string;
         resourcePath?: string;
         dracoPath?: string;
+        orientation?: Orientation;
         camera?: {
             fov?: number;
             aspect?: number;
@@ -101,43 +118,33 @@ export declare class Viewer extends EventEmitter {
     loop(dt: number): void;
     update(dt: number): void;
     render(dt: number): void;
-    _onRender(dt: number): void;
-    _onResize(width: number, height: number): void;
+    _rendering(dt: number): void;
+    _resizing(width: number, height: number): void;
     start(): this;
     stop(): this;
     resize(width?: number, height?: number): void;
-    loadAsset(props: AssetProperties & TextureSettings): Promise<any>;
+    loadAsset(props: AssetProperties): Promise<any>;
+    getLoader(ext: string): import(".").aLoader;
     addLoader(Loader: LoaderConstructor): void;
-    load({ url, ext, onProgress, castShadow, receiveShadow, ...props }: AssetProperties & __P<Object3D, typeof Object3D>): Promise<any>;
-    tween(target: Object): import("./tween").Tween<Object>;
-    timeline(target: Object): import("./tween").TweenChain;
-    killTweensOf(target: Object): void;
     traverseMaterials(callback: (mat: Material) => void): void;
-    traversePlugins(callback: (plugin: Plugin) => void): void;
-    getPlugin<T extends Plugin>(plugin: new (...args: any[]) => T, autoAdd?: boolean): T;
-    addPlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>, props?: __P<T, K>): T;
-    removePlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>): void;
-    getComponent<T extends Component>(node: Object3D, constructor: {
-        new (): T;
-    }, autoAdd?: boolean): T;
     traverseComponents(callback: (comp: Component) => void): void;
-    addComponent<T extends Component>(node: Object3D | Component, instance: T): T;
-    addComponent<T extends Component>(node: Object3D | Component, constructor: {
-        new (): T;
-    }): T;
-    removeComponent(node: Object3D, component: Component): ComponentManager;
-    addNode<T, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
-    removeNode(node: Object3D): void;
-    activeNode(node: Object3D, active: boolean): Object3D<import("three").Object3DEventMap>;
-    createRenderTarget(width: number, height: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean): WebGLRenderTarget<Texture>;
-    createCubeRenderTarget(size: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean): WebGLCubeRenderTarget;
-    createDataTexture(data: BufferSource, width: number, height: number, floatType?: boolean, nearest?: boolean): DataTexture;
+    mount<T extends Mount>(constructor: {
+        new (...args: any[]): T;
+    }, autoAdd?: boolean): T;
+    tween(): TweenManager;
+    task(task: Task): void;
+    add<T extends Object3D | Component, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
+    remove<T extends Object3D | Component>(ins: T): T;
+    createRenderTarget(width: number, height: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean, depth?: boolean): WebGLRenderTarget<Texture>;
+    createCubeRenderTarget(size: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean, depth?: boolean): WebGLCubeRenderTarget;
+    createDataTexture(data: ArrayBufferView, width: number, height: number, floatType?: boolean, nearest?: boolean): DataTexture;
     /**
      * 传送门，得到一个全新的场景
      * @param callback 禁止使用异步函数，会导致状态错误
      * @returns
      */
-    portal<T = any>(callback: () => T): T;
+    portal<T = any>(callback: () => T, sceneNew?: Scene): T;
+    blit(renderTarget: WebGLRenderTarget, material: Material, lod?: number, face?: number): void;
     compile(target?: Object3D | Scene | Material | Texture): void;
     compile(target?: Material[]): void;
 }

package/types/asset/ResourceManager.d.ts

@@ -1,12 +1,14 @@
 import { LoadingManager } from "three";
 import { TextureSettings } from "../TextureSettings";
 import { aLoader } from "./aLoader";
-export interface AssetProperties {
+export interface AssetProperties extends TextureSettings {
+    url?: string;
     ext?: string;
-    url?: string | File | {
-        mainFile: File;
-        additionalFiles: File[];
-    };
+    buffer?: string | ArrayBuffer;
+    path?: string;
+    resourcePath?: string;
+    dracoPath?: string;
+    manager?: LoadingManager;
     onProgress?: (event: ProgressEvent) => void;
 }
 export type LoaderConstructor = new (manager: ResourceManager) => aLoader;
@@ -14,29 +16,13 @@ export declare class ResourceManager {
     static extension(path: string): string;
     static dirname(path: string): string;
     static basename(path: string, ext?: string): string;
-    static _parseURL(uri: any): {
-        url: string;
-        file: any;
-        ext: string;
-    };
-    static _getTextureKey(url: string, settings: TextureSettings): string;
     static _texSettingKeys: string[];
     static _splitTextureSettings(props: TextureSettings & {
         [k: string]: any;
     }): {};
-    path: string;
-    resourcePath: string;
-    dracoPath: string;
-    loadingManager: LoadingManager;
-    private _caches;
     private _loaders;
-    constructor(props: {
-        path: string;
-        resourcePath: string;
-        dracoPath: string;
-        loadingManager: LoadingManager;
-    });
     destroy(): void;
+    getLoader(ext: string): aLoader;
     addLoader(Loader: LoaderConstructor): void;
-    loadAsset<T = any>({ url, ext, onProgress, ...props }: AssetProperties & TextureSettings): Promise<T>;
+    loadAsset<T = any>({ url, buffer, ext, path, resourcePath, dracoPath, manager, onProgress, ...props }: AssetProperties): Promise<T>;
 }

package/types/asset/aLoader.d.ts

@@ -1,16 +1,22 @@
-import { Object3D } from "three";
+import { LoadingManager, Object3D } from "three";
 import { ResourceManager } from "./ResourceManager";
 import { TextureSettings } from "../TextureSettings";
 export interface LoadProperties {
     url: string;
+    buffer?: string | ArrayBuffer;
     texSettings?: TextureSettings;
+    path?: string;
+    resourcePath?: string;
+    dracoPath?: string;
+    manager?: LoadingManager;
     onLoad: (asset: any) => void;
     onProgress?: (event: ProgressEvent) => void;
     onError?: (event: ErrorEvent) => void;
 }
 export declare abstract class aLoader {
     manager: ResourceManager;
-    static _setMeshData(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    static _texKeys: string[];
+    static _setUserData(node: Object3D): Object3D<import("three").Object3DEventMap>;
     constructor(manager: ResourceManager);
     abstract extension: string[];
     abstract load(props: LoadProperties): void;

package/types/base/EventEmitter.d.ts

@@ -4,26 +4,26 @@ interface EventHandler {
     target?: Object;
     once?: boolean;
 }
-interface Listener {
-    name: string;
+interface Listener<T> {
+    name: T;
     callback: (...args: any[]) => any;
 }
-export declare class EventEmitter {
+export declare class EventEmitter<T extends string = string> {
     protected _events: {
         [k: string]: EventHandler[];
     };
     protected _removeEvent(list: EventHandler[], index: number, name: string): this;
     clear(): this;
-    has(name: string): boolean;
-    on(name: string, callback: (...args: any[]) => any, target?: Object, once?: boolean): this;
-    off(name: string, callback: (...args: any[]) => any, target?: Object): this;
-    onof(name: string, callback: (...args: any[]) => any, container: Object & {
-        _listeners?: Listener[];
+    has(name: T): boolean;
+    on(name: T, callback: (...args: any[]) => any, target?: Object, once?: boolean): this;
+    off(name: T, callback: (...args: any[]) => any, target?: Object): this;
+    onof(name: T, callback: (...args: any[]) => any, container: Object & {
+        _listeners?: Listener<T>[];
     }): this;
     offof(container: Object & {
-        _listeners?: Listener[];
+        _listeners?: Listener<T>[];
     }): this;
     targetOff(target: Object): this;
-    emit(name: string, ...args: any[]): this;
+    emit(name: T, ...args: any[]): this;
 }
 export {};

package/types/base/getClassInstance.d.ts

@@ -0,0 +1 @@
+export declare function getClassInstance(constructor: any, args?: any[]): any;

package/types/base/index.d.ts

@@ -1,3 +1,4 @@
 export { EventEmitter } from "./EventEmitter";
 export { Logger } from "./Logger";
 export { mixin } from "./mixin";
+export { getClassInstance } from "./getClassInstance";

package/types/cinestation/CinestationBlendDefinition.d.ts

@@ -1,8 +1,8 @@
 export declare const CinestationBlendStyle: {
-    Linear: (amount: number) => number;
-    QuadraticIn: (amount: number) => number;
-    QuadraticOut: (amount: number) => number;
-    QuadraticInOut: (amount: number) => number;
+    Linear: import("../tween").EasingFunction;
+    QuadraticIn: import("../tween").EasingFunction;
+    QuadraticOut: import("../tween").EasingFunction;
+    QuadraticInOut: import("../tween").EasingFunction;
 };
 export type CinestationBlendStyle = typeof CinestationBlendStyle[keyof typeof CinestationBlendStyle];
 export declare class CinestationBlendDefinition {

package/types/cinestation/CinestationBrain.d.ts

@@ -7,9 +7,7 @@ export declare class CinestationBrain extends Component<PerspectiveCamera> {
     private _vcamSolo;
     private _vcams;
     private _lerpTime;
-    private _isChanged;
     brainBlend: CinestationBlendDefinition;
-    onChanged: (v: boolean) => void;
     get vcam(): VirtualCamera;
     get vcams(): VirtualCamera[];
     lastUpdate(dt: number): void;

package/types/cinestation/FreelookVirtualCamera.d.ts

@@ -1,55 +1,59 @@
-import { Object3D, Quaternion, Spherical, Vector2, Vector3 } from "three";
+import { Quaternion, Vector2, Vector3 } from "three";
 import { VirtualCamera } from "./VirtualCamera";
-export declare const VCamFreeLookMode: {
-    FREE: number;
-    TRANSLATE: number;
-};
-export type VCamFreeLookMode = typeof VCamFreeLookMode[keyof typeof VCamFreeLookMode];
 export declare class FreelookVirtualCamera extends VirtualCamera {
     static __loc0: Vector2;
     static __loc1: Vector2;
     static __center: Vector2;
     static __preCenter: Vector2;
-    static __moveDelta: Vector2;
-    static __worldPos: Vector3;
+    static __panDelta: Vector2;
+    static __panTarget: Vector2;
+    static __rotateDelta: Vector2;
     static __posDelta: Vector3;
-    static __posOffset: Vector3;
     static __xAxis: Vector3;
     static __yAxis: Vector3;
     static __quat: Quaternion;
-    static __spherical: Spherical;
     private _button;
     private _touchID;
-    private _distanceDelta;
     private _preLoc0;
     private _preLoc1;
-    private _rotateDelta;
-    private _panDelta;
-    mode: VCamFreeLookMode;
+    private _spherical;
+    private _lookAt;
+    private _tempSmoothing;
+    private _tempRotateSmoothing;
+    private _targetTheta;
+    private _targetPhi;
+    private _targetSpringLength;
+    private _targetFov;
+    private _targetLookAt;
     forbidX: boolean;
     forbidY: boolean;
     forbidZ: boolean;
     forbidPanX: boolean;
     forbidPanY: boolean;
     forbitPanOffsetY: boolean;
+    panSpeed: number;
     rotateSpeed: number;
+    smoothing: number;
     rotateSmoothing: number;
-    panSpeed: number;
-    panSmoothing: number;
-    panScale: Vector3;
     phiMin: number;
     phiMax: number;
     thetaMin: number;
     thetaMax: number;
     distanceMin: number;
     distanceMax: number;
-    rotateTouchID: number;
-    lookAt: Object3D<import("three").Object3DEventMap>;
+    get lookAt(): Vector3;
+    set lookAt(v: Vector3);
+    get springLength(): number;
+    set springLength(v: number);
+    get theta(): number;
+    set theta(v: number);
+    get phi(): number;
+    set phi(v: number);
+    get fov(): number;
+    set fov(v: number);
     onEnable(): void;
     onDisable(): void;
     reset(): void;
-    private _tweenPOI;
-    gotoPOI(position: Vector3, lookAt: Vector3, duration?: number, easing?: (amount: number) => number): void;
     private _onPointerDown;
     private _onPointerUp;
     private _onPointerMove;
@@ -57,7 +61,20 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _onTouchStart;
     private _onTouchMove;
     private _calculateDistanceScale;
-    private _calculateRotateDelta;
+    private _calculateRotatelDelta;
     private _calculatePanDelta;
+    private _setTargetLookAt;
+    private _setTargetRotation;
+    private _setTargetSpringLength;
+    goto({ springLength, theta, phi, lookAt, fov, smoothing, rotateSmoothing, }: {
+        duration?: number;
+        springLength?: number;
+        theta?: number;
+        phi?: number;
+        lookAt?: Vector3;
+        fov?: number;
+        smoothing?: number;
+        rotateSmoothing?: number;
+    }): void;
     update(dt: number): void;
 }