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

package/types/cinestation/VirtualCamera.d.ts

@@ -1,25 +1,25 @@
 import { Object3D, Quaternion, Vector3 } from "three";
 import { Component } from "../Component";
 import { CinestationBrain } from "./CinestationBrain";
+declare class Lens {
+    fov: number;
+    near: number;
+    far: number;
+}
 export declare class VirtualCamera extends Component<Object3D & {
     isCamera?: boolean;
 }> {
     private _finalPosition;
     private _finalRotation;
+    locked: boolean;
     priority: number;
-    lookAt: Object3D | null;
-    follow: Object3D | null;
-    fov: number;
-    near: number;
-    far: number;
+    lens: Lens;
     correctPosition: Vector3;
     correctRotation: Quaternion;
-    lookaheadPosition: Vector3;
-    trackedObjectOffset: Vector3;
     brain: CinestationBrain;
     get finalPosition(): Vector3;
     get finalRotation(): Quaternion;
     onLoad(): void;
     onDestroy(): void;
-    update(dt: number): void;
 }
+export {};

package/types/components/Animation.d.ts

@@ -0,0 +1,26 @@
+import { AnimationAction, AnimationActionLoopStyles, AnimationMixer } from "three";
+import { Component } from "../Component";
+export declare class Animation extends Component {
+    private _mixer;
+    private _action;
+    private _actions;
+    private _progress;
+    playing: boolean;
+    get mixer(): AnimationMixer;
+    get action(): AnimationAction;
+    get actions(): AnimationAction[];
+    get progress(): number;
+    set progress(v: number);
+    onLoad(): void;
+    onDestroy(): void;
+    update(dt: number): void;
+    play(animName?: string, state?: {
+        mode?: AnimationActionLoopStyles;
+        repetitions?: number;
+        duration?: number;
+        clampWhenFinished?: boolean;
+        zeroSlopeAtStart?: boolean;
+        zeroSlopeAtEnd?: boolean;
+    }): this;
+    stop(): this;
+}

package/types/components/PerformanceMonitor.d.ts

@@ -0,0 +1,48 @@
+import { Component } from "../Component";
+type PerformanceMonitorProps = {
+    /** How much time in milliseconds to collect an average fps, 250 */
+    ms?: number;
+    /** How many interations of averages to collect, 10 */
+    iterations?: number;
+    /** The percentage of iterations that are matched against the lower and upper bounds, 0.75 */
+    threshold?: number;
+    /** A function that receive the max device refreshrate to determine lower and upper bounds which create a margin where neither incline nor decline should happen, (refreshrate) => (refreshrate > 90 ? [50, 90] : [50, 60]) */
+    bounds?: (refreshrate: number) => [lower: number, upper: number];
+    /** How many times it can inline or decline before onFallback is called, Infinity */
+    flipflops?: number;
+    /** The factor increases and decreases between 0-1, this prop sets the starting value, 0.5 */
+    factor?: number;
+    /** The step that gets added or subtracted to or from the factor on each incline/decline, 0.1 */
+    step?: number;
+    /** When performance is higher than the upper bound (good!) */
+    onIncline?: (monitor: PerformanceMonitor) => void;
+    /** When performance is lower than the upper bound (bad!) */
+    onDecline?: (monitor: PerformanceMonitor) => void;
+    /** Incline and decline will change the factor, this will trigger when that happened */
+    onChange?: (monitor: PerformanceMonitor) => void;
+    /** Called after when the number of flipflops is reached, it indicates instability, use the function to set a fixed baseline */
+    onFallback?: (monitor: PerformanceMonitor) => void;
+};
+type PerformanceMonitorSubscriber = {
+    onIncline?: (monitor: PerformanceMonitor) => void;
+    /** When performance is lower than the upper bound (bad!) */
+    onDecline?: (monitor: PerformanceMonitor) => void;
+    /** Incline and decline will change the factor, this will trigger when that happened */
+    onChange?: (monitor: PerformanceMonitor) => void;
+    /** Called after when the number of flipflops is reached, it indicates instability, use the function to set a fixed baseline */
+    onFallback?: (monitor: PerformanceMonitor) => void;
+};
+export declare class PerformanceMonitor extends Component {
+    fps: number;
+    index: number;
+    factor: number;
+    flipped: number;
+    refreshrate: number;
+    fallback: boolean;
+    frames: any[];
+    averages: any[];
+    subscriptions: Map<any, any>;
+    subscribe(subscriber: PerformanceMonitorSubscriber): void;
+    constructor({ iterations, ms, threshold, step, factor: _factor, flipflops, bounds, onIncline, onDecline, onChange, onFallback, }: PerformanceMonitorProps);
+}
+export {};

package/types/components/Reflector.d.ts

@@ -0,0 +1,15 @@
+import { Matrix4, Vector3, WebGLRenderTarget } from "three";
+import { Component } from "../Component";
+export declare class Reflector extends Component {
+    constructor({ textureWidth, textureHeight, clipBias, multisample, layer, normal, mipmap, }?: {
+        textureWidth?: number;
+        textureHeight?: number;
+        clipBias?: number;
+        multisample?: number;
+        normal?: Vector3;
+        layer?: number;
+        mipmap?: boolean;
+    });
+    getTextureMatrix: () => Matrix4;
+    getRenderTarget: () => WebGLRenderTarget;
+}

package/types/components/index.d.ts

@@ -0,0 +1,2 @@
+export { Reflector } from "./Reflector";
+export { Animation } from "./Animation";

package/types/index.d.ts

@@ -1,12 +1,22 @@
 export * from "./types";
 export * from "./base";
 export * from "./tween";
-export * from "./loader";
+export * from "./loaders";
 export * from "./cinestation";
-export * from "./primitives";
+export * from "./primitive";
+export * from "./math";
+export * from "./components";
+export * from "./materials";
+export * from "./plugins";
+export * from "./Utils";
 export { Viewer } from "./Viewer";
 export { Component } from "./Component";
+export { Mount } from "./Mount";
 export { SystemInfo } from "./SystemInfo";
-export { Plugin } from "./Plugin";
 export { ObjectInstance } from "./ObjectInstance";
 export { property, PropertyManager } from "./PropertyManager";
+export { dependencies, DependentMode } from "./ComponentManager";
+export { DeviceInput } from "./DeviceInput";
+export { Orientation } from "./enums/Orientation";
+export { aLoader, type LoadProperties } from "./asset/aLoader";
+export { ResourceManager, type AssetProperties } from "./asset/ResourceManager";

package/types/{loader → loaders}/aEXRLoader.d.ts

@@ -1,5 +1,6 @@
 import { LoadProperties, aLoader } from "../asset/aLoader";
 export declare class aEXRLoader extends aLoader {
     extension: string[];
-    load({ url, onLoad, onProgress, onError, texSettings }: LoadProperties): void;
+    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError, }: LoadProperties): void;
+    private _loader;
 }

package/types/{loader → loaders}/aFBXLoader.d.ts

@@ -1,5 +1,6 @@
 import { LoadProperties, aLoader } from "../asset/aLoader";
 export declare class aFBXLoader extends aLoader {
     extension: string[];
-    load({ url, onLoad, onProgress, onError }: LoadProperties): void;
+    load({ url, buffer, path, resourcePath, manager, onLoad, onProgress, onError }: LoadProperties): void;
+    private _loader;
 }

package/types/loaders/aGLTFLoader.d.ts

@@ -0,0 +1,7 @@
+import { LoadProperties, aLoader } from "../asset/aLoader";
+export declare class aGLTFLoader extends aLoader {
+    extension: string[];
+    load({ url, buffer, path, resourcePath, dracoPath, manager, onLoad, onProgress, onError }: LoadProperties): void;
+    private _loader;
+    private _dracoLoader;
+}

package/types/{loader → loaders}/aHDRLoader.d.ts

@@ -1,5 +1,6 @@
 import { LoadProperties, aLoader } from "../asset/aLoader";
 export declare class aHDRLoader extends aLoader {
     extension: string[];
-    load({ url, onLoad, onProgress, onError, texSettings }: LoadProperties): void;
+    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError, }: LoadProperties): void;
+    private _loader;
 }

package/types/{loader → loaders}/aJSONLoader.d.ts

@@ -1,5 +1,6 @@
 import { LoadProperties, aLoader } from "../asset/aLoader";
 export declare class aJSONLoader extends aLoader {
     extension: string[];
-    load({ url, onLoad, onProgress, onError }: LoadProperties): void;
+    load({ url, path, resourcePath, manager, onLoad, onProgress, onError }: LoadProperties): void;
+    private _loader;
 }

package/types/{loader → loaders}/aTextureLoader.d.ts

@@ -1,5 +1,6 @@
 import { LoadProperties, aLoader } from "../asset/aLoader";
 export declare class aTextureLoader extends aLoader {
     extension: string[];
-    load({ url, onLoad, onProgress, onError, texSettings }: LoadProperties): void;
+    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }: LoadProperties): void;
+    private _loader;
 }

package/types/materials/ReflectorMaterial.d.ts

@@ -0,0 +1,44 @@
+import { Color, IUniform, ShaderMaterial, Texture, WebGLProgramParametersWithUniforms } from "three";
+import { Reflector } from "../components";
+export declare class ReflectorMaterial extends ShaderMaterial {
+    vertexShader: string;
+    fragmentShader: string;
+    defines: {
+        [key: string]: any;
+    };
+    uniforms: {
+        [uniform: string]: IUniform<any>;
+    };
+    constructor({ reflector, ...parameters }: {
+        reflector: Reflector;
+        name?: string;
+        opacity?: number;
+        transparent?: boolean;
+        depthWrite?: boolean;
+        roughness?: number;
+        metalness?: number;
+    });
+    onBeforeCompile(shader: WebGLProgramParametersWithUniforms): void;
+    get color(): Color;
+    set color(v: Color);
+    get metalness(): number;
+    set metalness(v: number);
+    get roughness(): number;
+    set roughness(v: number);
+    get map(): Texture;
+    set map(v: Texture);
+    get roughnessMap(): Texture;
+    set roughnessMap(v: Texture);
+    get normalMap(): Texture;
+    set normalMap(v: Texture);
+    get aoMap(): Texture;
+    set aoMap(v: Texture);
+    get lightMap(): Texture;
+    set lightMap(v: Texture);
+    get lightMapIntensity(): number;
+    set lightMapIntensity(v: number);
+    get reflectMap(): Texture;
+    set reflectMap(v: Texture);
+    get reflectIntensity(): number;
+    set reflectIntensity(v: number);
+}

package/types/{material → materials}/getShaderMaterial.d.ts

@@ -1,4 +1,4 @@
 import { Color, CubeTexture, Matrix3, Matrix4, Quaternion, ShaderMaterial, Texture, Vector2, Vector3, Vector4 } from "three";
-export declare function getShaderMaterial(uniforms: {
+export declare function getShaderMaterial<T extends {
     [name: string]: CubeTexture | Texture | Int32Array | Float32Array | Matrix4 | Matrix3 | Quaternion | Vector4 | Vector3 | Vector2 | Color | number | boolean | Array<any> | null;
-}, vertexShader: string, fragmentShader: string, onInit?: (material?: ShaderMaterial) => void): typeof ShaderMaterial;
+}>(uniforms: T, vertexShader: string, fragmentShader: string, onInit?: (material?: ShaderMaterial) => void): typeof ShaderMaterial & T & ShaderMaterial;

package/types/materials/glsl/index.d.ts

@@ -0,0 +1,3 @@
+export { vert_fullscreen } from "./fullscreen.glsl";
+export { frag_BoxfilterBlur } from "./boxfilterblur.glsl";
+export { frag_panoramaToCubeMap, frag_cubeMapToPanorama } from "./panorama.glsl";

package/types/materials/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./glsl";
+export { getShaderMaterial } from "./getShaderMaterial";
+export { ReflectorMaterial } from "./ReflectorMaterial";

package/types/math/Constant.d.ts

@@ -1,2 +1,9 @@
 import { Vector3 } from "three";
-export declare const Vector3_ZERO: Vector3;
+export declare const Vector3_UNIT_X: Readonly<Vector3>;
+export declare const Vector3_UNIT_Y: Readonly<Vector3>;
+export declare const Vector3_UNIT_Z: Readonly<Vector3>;
+export declare const Vector3_RIGHT: Readonly<Vector3>;
+export declare const Vector3_UP: Readonly<Vector3>;
+export declare const Vector3_ZERO: Readonly<Vector3>;
+export declare const Vector3_ONE: Readonly<Vector3>;
+export declare const Vector3_NEG_ONE: Readonly<Vector3>;

package/types/math/Interpolation.d.ts

@@ -1,9 +1,9 @@
-import { Quaternion } from "three";
-export declare function VInterpTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
-export declare function VInterpConstantTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
+import { Quaternion, Vector3 } from "three";
+export declare function VInterpTo(current: Vector3, target: Vector3, deltaTime: number, speed: number, out?: Vector3): Vector3;
+export declare function VInterpConstantTo(current: Vector3, target: Vector3, deltaTime: number, speed: number, out?: Vector3): Vector3;
 export declare function Quat_Equals(a: Quaternion, b: Quaternion, epsilon?: number): boolean;
 export declare function Quat_AngularDistance(a: Quaternion, b: Quaternion): number;
 export declare function QInterpTo(current: Quaternion, target: Quaternion, deltaTime: number, speed: number): Quaternion;
-export declare function QInterpConstantTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
-export declare function FInterpTo(current: any, target: any, deltaTime: any, speed: any): any;
-export declare function FInterpConstantTo(current: any, target: any, deltaTime: any, speed: any): any;
+export declare function QInterpConstantTo(current: Quaternion, target: Quaternion, deltaTime: number, speed: number, out?: Quaternion): Quaternion;
+export declare function FInterpTo(current: number, target: number, deltaTime: number, speed: number): number;
+export declare function FInterpConstantTo(current: number, target: number, deltaTime: number, speed: number): number;

package/types/math/Perlin.d.ts

@@ -0,0 +1,12 @@
+export declare class Perlin {
+    static Noise(x: number): number;
+    static Noise(x: number, y: number): number;
+    static Noise(x: number, y: number, z: number): number;
+    static Fbm(octave: number, x: number): number;
+    static Fbm(octave: number, x: number, y: number): number;
+    static Fbm(octave: number, x: number, y: number, z: number): number;
+    private static _Fade;
+    private static _Lerp;
+    private static _Grad;
+    private static _Permutation;
+}

package/types/math/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Damp";
+export * from "./Constant";
+export * from "./Interpolation";
+export { AnimationCurve } from "./AnimationCurve";
+export { Perlin } from "./Perlin";

package/types/passes/MipBlurPass.d.ts

@@ -0,0 +1,27 @@
+import { CubeTexture, Texture, WebGLCubeRenderTarget } from "three";
+import { Viewer } from "../Viewer";
+export declare class MipBlurPass {
+    private _viewer;
+    private _mipmapRenderTargets;
+    private _cubeRenderTarget;
+    private _blurMaterial;
+    private _blurIntensity;
+    private _sigma;
+    private _minLod;
+    private _maxLod;
+    private _onChanged?;
+    private _uniforms;
+    get exposure(): number;
+    set exposure(v: number);
+    get blurIntensity(): number;
+    set blurIntensity(v: number);
+    getBlurTexture(): CubeTexture;
+    constructor(props: {
+        viewer: Viewer;
+        cubeRenderTarget: WebGLCubeRenderTarget;
+        onChanged?: (tex: Texture) => void;
+    });
+    dispose(): void;
+    update(): void;
+    private _blur;
+}

package/types/passes/cubeuv/MergeBlurPass.d.ts

@@ -0,0 +1,22 @@
+import { CubeTexture, Texture, WebGLRenderTarget } from "three";
+import { Viewer } from "../../Viewer";
+import { MergeInfo } from "./MergeInfo";
+export declare class MergeMipBlurPass {
+    private _pmremGenerator;
+    private _sigma;
+    private _blurMinLod;
+    private _blurMaxLod;
+    private _blurIntensity;
+    private _envMapTarget;
+    private _reflectMap;
+    get envMapTarget(): WebGLRenderTarget<Texture>;
+    get envMap(): Texture;
+    constructor({ viewer, reflectMap, }: {
+        viewer: Viewer;
+        reflectMap: CubeTexture;
+    });
+    dispose(): void;
+    mergeMipBlur(info: MergeInfo): void;
+    private _setBlurIntensity;
+    private _getPMREMExtension;
+}

package/types/passes/cubeuv/MergeInfo.d.ts

@@ -0,0 +1,9 @@
+import { WebGLRenderTarget } from "three";
+export interface MergeInfo {
+    quality: number;
+    envMapTarget: WebGLRenderTarget;
+    envMapIntensity: number;
+    blurIntensity: number;
+    lodMax: number;
+    exposure: number;
+}

package/types/passes/cubeuv/MergeReflectPass.d.ts

@@ -0,0 +1,18 @@
+import { CubeTexture, Texture } from "three";
+import { Viewer } from "../../Viewer";
+import { MergeInfo } from "./MergeInfo";
+export declare class MergeRefectPass {
+    private _pmremGenerator;
+    private _reflectMap;
+    private _envMapTarget;
+    private _sourceTarget;
+    get envMap(): Texture;
+    constructor({ envMap, reflectMap, viewer, }: {
+        envMap?: Texture;
+        reflectMap: CubeTexture;
+        viewer: Viewer;
+    });
+    dispose(): void;
+    mergeReflect(info: MergeInfo): void;
+    private _getPMREMExtension;
+}

package/types/passes/cubeuv/utils.d.ts

@@ -0,0 +1,16 @@
+import { OrthographicCamera, ShaderMaterial, Vector3, WebGLRenderTarget } from "three";
+export declare const LOD_MIN = 4;
+export declare const _flatCamera: OrthographicCamera;
+export declare const _axisDirections: Vector3[];
+export declare const _Quality: {
+    LOW: number;
+    MEDIUM: number;
+    HIGH: number;
+    ULTRA: number;
+};
+export declare function _setViewport(target: WebGLRenderTarget, x: number, y: number, width: number, height: number): void;
+export declare function _getCommonVertexShader(): string;
+export declare function _getClearMaterial(): ShaderMaterial;
+export declare function _getCubeMapMaterial(): ShaderMaterial;
+export declare function _getMipCopyMaterial(lodMax: number, width: number, height: number): ShaderMaterial;
+export declare function _getMipBlurMaterial(lodMax: number, width: number, height: number): ShaderMaterial;

package/types/passes/mipGaussianBlendWeight.d.ts

@@ -0,0 +1 @@
+export declare function mipGaussianBlendWeight(sigma: number, lod: number): number;

package/types/plugins/BoxProjection.d.ts

@@ -0,0 +1,15 @@
+import { Vector3, Vector4, WebGLProgramParametersWithUniforms } from "three";
+import { Mount } from "../Mount";
+export declare class BoxProjection extends Mount {
+    private _center;
+    private _boxMin;
+    private _boxMax;
+    get center(): Vector4;
+    set center(v: Vector4);
+    get boxMin(): Vector3;
+    set boxMin(v: Vector3);
+    get boxMax(): Vector3;
+    set boxMax(v: Vector3);
+    onLoad(): void;
+    useBoxProjection(shader: WebGLProgramParametersWithUniforms): void;
+}

package/types/plugins/BoxProjectionPlugin.d.ts

@@ -0,0 +1,20 @@
+import { Vector3, Vector4, WebGLProgramParametersWithUniforms } from "three";
+import { Plugin } from "../Plugin";
+export declare class BoxProjectionPlugin extends Plugin {
+    private _center;
+    private _boxMin;
+    private _boxMax;
+    private _helper;
+    private _debug;
+    get debug(): boolean;
+    set debug(v: boolean);
+    get center(): Vector4;
+    set center(v: Vector4);
+    get boxMin(): Vector3;
+    set boxMin(v: Vector3);
+    get boxMax(): Vector3;
+    set boxMax(v: Vector3);
+    constructor();
+    onUpdate(dt: number): void;
+    useBoxProjection(shader: WebGLProgramParametersWithUniforms): void;
+}

package/types/plugins/DebugPlugin.d.ts

@@ -0,0 +1,10 @@
+import { Object3D, Scene } from "three";
+import { Plugin } from "../Plugin";
+import { Viewer } from "../Viewer";
+export declare class DebugPlugin extends Plugin {
+    static Instance(viewer: Viewer): any;
+    scene: Scene;
+    add(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    remove(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    onRender(dt: number): void;
+}

package/types/plugins/DebugScene.d.ts

@@ -0,0 +1,8 @@
+import { Object3D, Scene } from "three";
+import { Mount } from "../Mount";
+export declare class DebugScene extends Mount {
+    scene: Scene;
+    add(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    remove(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    update(dt: number): void;
+}

package/types/plugins/DropFile.d.ts

@@ -0,0 +1,18 @@
+import { Mount } from "../Mount";
+export declare class DropFile extends Mount {
+    private _onLoad;
+    private _onError;
+    private _extensions;
+    constructor({ onLoad, onError, extension, }?: {
+        onLoad?: Function;
+        onError?: Function;
+        extension?: string | string[];
+    });
+    onEnable(): void;
+    onDisable(): void;
+    private _onDrogOver;
+    private _onDrop;
+    private _loadItemList;
+    private _loadFiles;
+    private _loadFile;
+}

package/types/plugins/DropFilePlugin.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from "../Plugin";
+export declare class DropFilePlugin extends Plugin {
+    private _onLoad;
+    private _onError;
+    private _extensions;
+    constructor({ onLoad, onError, extension, }?: {
+        onLoad?: Function;
+        onError?: Function;
+        extension?: string | string[];
+    });
+    install(): void;
+    uninstall(): void;
+    private _onDrogOver;
+    private _onDrop;
+    private _loadItemList;
+    private _loadFiles;
+    private _loadFile;
+}

package/types/plugins/Environment.d.ts

@@ -0,0 +1,37 @@
+import { Object3D, Scene, Texture, TextureDataType, Vector3 } from "three";
+import { Mount } from "../Mount";
+export declare class Environment extends Mount {
+    static readonly Quality: {
+        LOW: number;
+        MEDIUM: number;
+        HIGH: number;
+        ULTRA: number;
+    };
+    private _elapsed;
+    private _scene;
+    private _cubeCamera;
+    private _reflectPass;
+    private _mipBlurPass;
+    private _mergeInfo;
+    quality: number;
+    envMapIntensity: number;
+    reflectExposure: number;
+    reflectBlurIntensity: number;
+    interval: number;
+    manual: boolean;
+    get envMap(): Texture;
+    constructor({ envMap, scene, near, far, layer, resolution, floatType, position, }?: {
+        envMap?: Texture;
+        scene?: Scene | Object3D;
+        performance?: number;
+        resolution?: number;
+        layer?: number;
+        near?: number;
+        far?: number;
+        floatType?: boolean | TextureDataType;
+        position?: Vector3;
+    });
+    update(dt: number): void;
+    manualFrame(): void;
+    private _renderFrame;
+}

package/types/plugins/EnvironmentPlugin.d.ts

@@ -0,0 +1,41 @@
+import { Object3D, Scene, Texture, TextureDataType, Vector3 } from "three";
+import { Plugin } from "../Plugin";
+export declare class EnvironmentPlugin extends Plugin {
+    static readonly Quality: {
+        LOW: number;
+        MEDIUM: number;
+        HIGH: number;
+        ULTRA: number;
+    };
+    private _scene;
+    private _cubeCamera;
+    private _reflectPass;
+    private _mipBlurPass;
+    private _mergeInfo;
+    private _debug;
+    private _debugNode;
+    private _elapsed;
+    get debug(): boolean;
+    set debug(v: boolean);
+    get envMap(): Texture;
+    quality: number;
+    envMapIntensity: number;
+    reflectExposure: number;
+    reflectBlurIntensity: number;
+    interval: number;
+    manual: boolean;
+    constructor({ envMap, scene, near, far, layer, resolution, floatType, position, }?: {
+        envMap?: Texture;
+        scene?: Scene | Object3D;
+        performance?: number;
+        resolution?: number;
+        layer?: number;
+        near?: number;
+        far?: number;
+        floatType?: boolean | TextureDataType;
+        position?: Vector3;
+    });
+    onRender(dt: number): void;
+    manualFrame(): void;
+    private _renderFrame;
+}