@xviewer.js/core 1.0.0-alpha.6 → 1.0.0-alpha.61

package/package.json

@@ -1,23 +1,21 @@
 {
-    "name": "@xviewer.js/core",
-    "version": "1.0.0-alpha.6",
-    "publishConfig": {
-        "access": "public",
-        "registry": "https://registry.npmjs.org"
-    },
-    "license": "MIT",
-    "main": "dist/main.js",
-    "module": "dist/module.js",
-    "types": "types/index.d.ts",
-    "debug": "src/index.ts",
-    "scripts": {
-        "b:types": "tsc"
-    },
-    "files": [
-        "dist/**/*",
-        "types/**/*"
-    ],
-    "peerDependencies": {
-		"three": ">= 0.164.0 < 0.165.0"
-	}
+  "name": "@xviewer.js/core",
+  "version": "1.0.0-alpha.61",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/main.js",
+  "module": "dist/module.js",
+  "types": "types/index.d.ts",
+  "debug": "src/index.ts",
+  "files": [
+    "dist/**/*",
+    "types/**/*"
+  ],
+  "peerDependencies": {
+    "three": ">= 0.164.0"
+  },
+  "scripts": {
+    "b:types": "tsc"
+  }
 }

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/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/Viewer.d.ts

@@ -1,24 +1,41 @@
-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 } from "./asset/ResourceManager";
-import { __C, __Comp, __P } from "./types";
+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 { Task } from "./Task";
 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 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: Material, lod?: number, face?: number): void;
+    static createFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes>;
+    static findChild<T extends Object3D>(node: T, path: string): T;
+    static getChildByName<T extends Object3D>(node: T, name: string): T;
+    static getObject<T extends Object3D>(node: T, filter: (value: T) => any, group?: boolean): any;
+    static __emtpyObject: {};
+    static _getObjectValue<T extends Object & {
+        name: string;
+    }>(object: any, name?: string, group?: boolean): T | T[];
+    static getMaterial<T extends Material>(node: Object3D): T[];
+    static getMaterial<T extends Material>(node: Object3D, name: string): T;
+    static getTexture<T extends Texture>(node: Object3D): T[];
+    static getTexture<T extends Texture>(node: Object3D, name: string): T;
+    static getMesh<T extends Mesh>(node: Object3D): T[];
+    static getMesh<T extends Mesh>(node: Object3D, name: string): T;
     static fullscreenMesh: Mesh;
     static fullscreenCamera: OrthographicCamera;
+    static _instanceCount: number;
+    private _instanceId;
     private _root;
     private _canvas;
     private _gl;
@@ -33,17 +50,21 @@ 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;
     get root(): HTMLElement;
     get time(): number;
     get scene(): Scene;
@@ -62,10 +83,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 +105,7 @@ export declare class Viewer extends EventEmitter {
         path?: string;
         resourcePath?: string;
         dracoPath?: string;
+        orientation?: Orientation;
         camera?: {
             fov?: number;
             aspect?: number;
@@ -96,6 +126,7 @@ export declare class Viewer extends EventEmitter {
         };
     } & WebGLRendererParameters);
     destroy(): void;
+    private _addDefaultLoaders;
     private _frame;
     loop(dt: number): void;
     update(dt: number): void;
@@ -105,9 +136,9 @@ export declare class Viewer extends EventEmitter {
     start(): this;
     stop(): this;
     resize(width?: number, height?: number): void;
-    loadAsset(props: AssetProperties & TextureSettings): Promise<any>;
-    load({ url, ext, onProgress, castShadow, receiveShadow, ...props }: AssetProperties & __P<Object3D, typeof Object3D>): Promise<any>;
-    tween(target: Object): import("./tween").Tween<Object>;
+    loadAsset(props: AssetProperties): Promise<any>;
+    getLoader(ext: string): import(".").aLoader;
+    addLoader(Loader: LoaderConstructor): void;
     timeline(target: Object): import("./tween").TweenChain;
     killTweensOf(target: Object): void;
     traverseMaterials(callback: (mat: Material) => void): void;
@@ -124,12 +155,12 @@ export declare class Viewer extends EventEmitter {
         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;
+    addTask(task: Task): void;
+    addNode<T extends Object3D | Component, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
     removeNode(node: Object3D): void;
-    activeNode(node: Object3D, active: boolean): void;
-    createComponent<T extends Component, K extends __C<T>>(comp: T | K & __C<T>, props?: __Comp<T, K>): any;
-    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;
+    activeNode(node: Object3D, active: boolean): Object3D<import("three").Object3DEventMap>;
+    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: BufferSource, width: number, height: number, floatType?: boolean, nearest?: boolean): DataTexture;
     /**
      * 传送门，得到一个全新的场景
@@ -137,6 +168,7 @@ export declare class Viewer extends EventEmitter {
      * @returns
      */
     portal<T = any>(callback: () => T): 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,42 +1,28 @@
 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;
 export declare class ResourceManager {
     static extension(path: string): string;
     static dirname(path: string): string;
     static basename(path: string, ext?: string): string;
-    static _loaders: Map<string, aLoader>;
-    static _addLoader(extNames: string[], Loader: new () => aLoader): void;
-    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;
-    constructor(props: {
-        path: string;
-        resourcePath: string;
-        dracoPath: string;
-        loadingManager: LoadingManager;
-    });
+    private _loaders;
     destroy(): void;
-    loadAsset<T = any>({ url, ext, onProgress, ...props }: AssetProperties & TextureSettings): Promise<T>;
+    getLoader(ext: string): aLoader;
+    addLoader(Loader: LoaderConstructor): void;
+    loadAsset<T = any>({ url, buffer, ext, path, resourcePath, dracoPath, manager, onProgress, ...props }: AssetProperties): Promise<T>;
 }
-export declare function resourceLoader(extNames: string[]): <T extends aLoader>(Loader: new () => T) => void;

package/types/asset/aLoader.d.ts

@@ -3,14 +3,21 @@ 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 {
-    static _setMeshData(node: Object3D): Object3D<import("three").Object3DEventMap>;
     manager: ResourceManager;
-    loadingManager: LoadingManager;
+    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,54 +1,60 @@
-import { Object3D, Quaternion, Spherical, Vector2, Vector3 } from "three";
+import { Quaternion, Vector2, Vector3 } from "three";
 import { VirtualCamera } from "./VirtualCamera";
-export declare enum VCamFreeLookMode {
-    FREE = 0,
-    TRANSLATE = 1
-}
+import { EasingFunction } from "../tween";
 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;
@@ -56,7 +62,20 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _onTouchStart;
     private _onTouchMove;
     private _calculateDistanceScale;
-    private _calculateRotateDelta;
+    private _calculateRotatelDelta;
     private _calculatePanDelta;
+    private _calculateTargetLookAt;
+    private _calculateTargetSpringArm;
+    gotoPOI({ duration, easing, springLength, theta, phi, lookAt, fov, smoothing, rotateSmoothing }: {
+        duration?: number;
+        easing?: EasingFunction;
+        springLength?: number;
+        theta?: number;
+        phi?: number;
+        lookAt?: Vector3;
+        fov?: number;
+        smoothing?: number;
+        rotateSmoothing?: number;
+    }): void;
     update(dt: number): void;
 }

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";