@xviewer.js/core 1.0.0-alpha.5 → 1.0.0-alpha.50

package/package.json

@@ -1,23 +1,21 @@
 {
-    "name": "@xviewer.js/core",
-    "version": "1.0.0-alpha.5",
-    "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.50",
+  "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 < 0.165.0"
+  },
+  "scripts": {
+    "b:types": "tsc"
+  }
 }

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/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,22 +1,36 @@
-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, 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 { DeviceInput } from "./DeviceInput";
+import { Orientation } from "./enums/Orientation";
+import { AssetProperties, LoaderConstructor } from "./asset/ResourceManager";
+import { __C, __P } from "./types";
 import { Component } from "./Component";
 import { TextureSettings } from "./TextureSettings";
 import { Plugin } from "./Plugin";
 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;
     private _root;
@@ -37,7 +51,9 @@ export declare class Viewer extends EventEmitter {
     private _rootRotated;
     private _time;
     private _lastTime;
+    private _lastFrameTime;
     private _targetFrameRate;
+    private _fixedFrameTime;
     private _autoResize;
     private _taskManager;
     private _resourceManager;
@@ -62,10 +78,14 @@ 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);
+    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 +96,7 @@ export declare class Viewer extends EventEmitter {
         path?: string;
         resourcePath?: string;
         dracoPath?: string;
+        orientation?: Orientation;
         camera?: {
             fov?: number;
             aspect?: number;
@@ -96,6 +117,7 @@ export declare class Viewer extends EventEmitter {
         };
     } & WebGLRendererParameters);
     destroy(): void;
+    private _addDefaultLoaders;
     private _frame;
     loop(dt: number): void;
     update(dt: number): void;
@@ -106,8 +128,8 @@ export declare class Viewer extends EventEmitter {
     stop(): this;
     resize(width?: number, height?: number): void;
     loadAsset(props: AssetProperties & TextureSettings): Promise<any>;
+    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;
@@ -126,10 +148,9 @@ export declare class Viewer extends EventEmitter {
     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): 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 +158,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

@@ -9,12 +9,11 @@ export interface AssetProperties {
     };
     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;
@@ -30,6 +29,7 @@ export declare class ResourceManager {
     dracoPath: string;
     loadingManager: LoadingManager;
     private _caches;
+    private _loaders;
     constructor(props: {
         path: string;
         resourcePath: string;
@@ -37,6 +37,6 @@ export declare class ResourceManager {
         loadingManager: LoadingManager;
     });
     destroy(): void;
+    addLoader(Loader: LoaderConstructor): void;
     loadAsset<T = any>({ url, ext, onProgress, ...props }: AssetProperties & TextureSettings): Promise<T>;
 }
-export declare function resourceLoader(extNames: string[]): <T extends aLoader>(Loader: new () => T) => void;

package/types/asset/aLoader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, Object3D } from "three";
+import { Object3D } from "three";
 import { ResourceManager } from "./ResourceManager";
 import { TextureSettings } from "../TextureSettings";
 export interface LoadProperties {
@@ -9,8 +9,10 @@ export interface LoadProperties {
     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/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/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 @@
+export { Reflector } from "./Reflector";

package/types/index.d.ts

@@ -1,12 +1,19 @@
 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 { Viewer } from "./Viewer";
 export { Component } from "./Component";
 export { SystemInfo } from "./SystemInfo";
 export { Plugin } from "./Plugin";
 export { ObjectInstance } from "./ObjectInstance";
 export { property, PropertyManager } from "./PropertyManager";
+export { DeviceInput } from "./DeviceInput";
+export { Orientation } from "./enums/Orientation";
+export * from "./asset/aLoader";

package/types/loaders/aEXRLoader.d.ts

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

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

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

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

@@ -1,4 +1,5 @@
 import { LoadProperties, aLoader } from "../asset/aLoader";
 export declare class aGLTFLoader extends aLoader {
+    extension: string[];
     load({ url, onLoad, onProgress, onError }: LoadProperties): void;
 }

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

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

package/types/loaders/aJSONLoader.d.ts

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

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

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

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

@@ -1,8 +1,6 @@
-import "./aGLTFLoader";
-import "./aFBXLoader";
-import "./aHDRLoader";
-import "./aTextureLoader";
-export { aGLTFLoader } from "./aGLTFLoader";
+export { aEXRLoader } from "./aEXRLoader";
 export { aFBXLoader } from "./aFBXLoader";
+export { aGLTFLoader } from "./aGLTFLoader";
 export { aHDRLoader } from "./aHDRLoader";
+export { aJSONLoader } from "./aJSONLoader";
 export { aTextureLoader } from "./aTextureLoader";

package/types/materials/ReflectorMaterial.d.ts

@@ -0,0 +1,28 @@
+import { IUniform, ShaderMaterial, Texture, WebGLProgramParametersWithUniforms } from "three";
+export declare class ReflectorMaterial extends ShaderMaterial {
+    vertexShader: string;
+    fragmentShader: string;
+    defines: {
+        [key: string]: any;
+    };
+    uniforms: {
+        [uniform: string]: IUniform<any>;
+    };
+    onBeforeCompile(shader: WebGLProgramParametersWithUniforms): void;
+    get alpha(): number;
+    set alpha(v: number);
+    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);
+}

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