@xviewer.js/core 1.0.0 → 1.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
-  "main": "dist/main.js",
+  "main": "dist/main.cjs",
   "module": "dist/module.js",
-  "types": "types/index.d.ts",
   "debug": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
     "dist/**/*",
     "types/**/*"

package/types/Component.d.ts

@@ -2,6 +2,7 @@ import { Object3D } from "three";
 import { Viewer } from "./Viewer";
 import { ComponentManager } from "./ComponentManager";
 import { ObjectInstance } from "./ObjectInstance";
+import { __C, __P } from "./types";
 export declare class Component<T extends Object3D = Object3D> extends ObjectInstance {
     private _enabled;
     node: T;
@@ -34,4 +35,7 @@ export declare class Component<T extends Object3D = Object3D> extends ObjectInst
     unscheduleAll(): void;
     destroy(): boolean;
     destroyImmediate(): void;
+    apply<K extends __C<this>>(props: __P<this, K>): this & {
+        copy?: Function;
+    };
 }

package/types/DeviceInput.d.ts

@@ -43,6 +43,7 @@ export declare class DeviceInput {
     connect(target: ConnTarget, event: string): void;
     disconnect(target: ConnTarget): void;
     private _addEventListener;
+    private _onResize;
     private _remapPointer;
     private _remapTouch;
     private _computePointer;

package/types/Mount.d.ts

@@ -1,4 +1,5 @@
+import { Object3D } from "three";
 import { Component } from "./Component";
-export declare class Mount extends Component {
+export declare class Mount<T extends Object3D = Object3D> extends Component<T> {
     isMount: boolean;
 }

package/types/SystemInfo.d.ts

@@ -16,10 +16,7 @@ export declare class SystemInfo {
     static isOpera: boolean;
     static isSafari: boolean;
     static isSupportMSAA: boolean;
-    static isSupportOgg: boolean;
-    static isRetina: boolean;
-    static devicePixelRatio: number;
     static cpuCoreCount: number;
-    static baseUrl: string;
+    static isRetina: boolean;
     static isIFrame: boolean;
 }

package/types/Utils.d.ts

@@ -1,13 +1,13 @@
-import { Object3D } from "three";
+import * as THREE 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 find<T extends THREE.Object3D>(node: T, path: string): T;
+export declare function getChildren<T extends THREE.Object3D>(node: T, filter: (value: T) => any, group?: boolean): any;
+export declare function getChildByName<T extends THREE.Object3D>(node: T, name: string): T;
 export declare function queryValues<T extends Object & {
     name: string;
 }>(object: any): T[];

package/types/Viewer.d.ts

@@ -6,9 +6,13 @@ import { Orientation } from "./enums/Orientation";
 import { AssetProperties, LoaderConstructor, ResourceManager } from "./asset/ResourceManager";
 import { __C, __P } from "./types";
 import { Component } from "./Component";
-import { TweenManager } from "./tween";
 import { Task } from "./Task";
 import { Mount } from "./Mount";
+declare module 'three' {
+    interface Object3D {
+        apply<K extends __C<this>>(props: __P<this, K>): this;
+    }
+}
 export declare class Viewer extends EventEmitter {
     static __target: Vector3;
     static __worldPos: Vector3;
@@ -25,6 +29,7 @@ export declare class Viewer extends EventEmitter {
     private _instanceId;
     private _root;
     private _canvas;
+    private _container;
     private _gl;
     private _RENDER_TARGET_FLOAT_TYPE;
     private _DATA_FLOAT_TYPE;
@@ -51,8 +56,8 @@ export declare class Viewer extends EventEmitter {
     private _resourceManager;
     private _componentManager;
     private _loadingManager;
-    private _tweens;
     get root(): HTMLElement;
+    get container(): HTMLElement;
     get time(): number;
     get scene(): Scene;
     get camera(): PerspectiveCamera;
@@ -77,9 +82,10 @@ export declare class Viewer extends EventEmitter {
     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 }?: {
+    constructor({ root, canvas, container, autoStart, autoResize, shadows, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, orientation, loader, tasker, ...webglOpts }?: {
         root?: HTMLElement;
         canvas?: HTMLCanvasElement;
+        container?: HTMLDivElement;
         targetFrameRate?: number;
         fixedFrameTime?: boolean;
         autoStart?: boolean;
@@ -122,16 +128,16 @@ export declare class Viewer extends EventEmitter {
     _resizing(width: number, height: number): void;
     start(): this;
     stop(): this;
+    rotate(): void;
     resize(width?: number, height?: number): void;
     loadAsset(props: AssetProperties): Promise<any>;
-    getLoader(ext: string): import(".").aLoader;
-    addLoader(Loader: LoaderConstructor): void;
+    getLoader(ext: string): import(".").Loader;
+    addLoader(Loader: LoaderConstructor): import(".").Loader;
     traverseMaterials(callback: (mat: Material) => void): void;
     traverseComponents(callback: (comp: Component) => void): void;
     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;

package/types/asset/{aLoader.d.ts → Loader.d.ts}

@@ -13,7 +13,7 @@ export interface LoadProperties {
     onProgress?: (event: ProgressEvent) => void;
     onError?: (event: ErrorEvent) => void;
 }
-export declare abstract class aLoader {
+export declare abstract class Loader {
     manager: ResourceManager;
     static _texKeys: string[];
     static _setUserData(node: Object3D): Object3D<import("three").Object3DEventMap>;

package/types/asset/ResourceManager.d.ts

@@ -1,6 +1,6 @@
 import { LoadingManager } from "three";
 import { TextureSettings } from "../TextureSettings";
-import { aLoader } from "./aLoader";
+import { Loader } from "./Loader";
 export interface AssetProperties extends TextureSettings {
     url?: string;
     ext?: string;
@@ -11,7 +11,7 @@ export interface AssetProperties extends TextureSettings {
     manager?: LoadingManager;
     onProgress?: (event: ProgressEvent) => void;
 }
-export type LoaderConstructor = new (manager: ResourceManager) => aLoader;
+export type LoaderConstructor = new (manager: ResourceManager) => Loader;
 export declare class ResourceManager {
     static extension(path: string): string;
     static dirname(path: string): string;
@@ -22,7 +22,7 @@ export declare class ResourceManager {
     }): {};
     private _loaders;
     destroy(): void;
-    getLoader(ext: string): aLoader;
-    addLoader(Loader: LoaderConstructor): void;
+    getLoader(ext: string): Loader;
+    addLoader(Loader: LoaderConstructor): Loader;
     loadAsset<T = any>({ url, buffer, ext, path, resourcePath, dracoPath, manager, onProgress, ...props }: AssetProperties): Promise<T>;
 }

package/types/cinestation/CinestationBlendDefinition.d.ts

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

package/types/cinestation/FreelookVirtualCamera.d.ts

@@ -9,6 +9,7 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     static __panTarget: Vector2;
     static __rotateDelta: Vector2;
     static __posDelta: Vector3;
+    static __lookAtOffset: Vector3;
     static __xAxis: Vector3;
     static __yAxis: Vector3;
     static __quat: Quaternion;
@@ -18,6 +19,7 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _preLoc1;
     private _spherical;
     private _lookAt;
+    private _offset;
     private _tempSmoothing;
     private _tempRotateSmoothing;
     private _targetTheta;
@@ -25,6 +27,7 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _targetSpringLength;
     private _targetFov;
     private _targetLookAt;
+    private _targetOffset;
     forbidX: boolean;
     forbidY: boolean;
     forbidZ: boolean;
@@ -43,6 +46,8 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     distanceMax: number;
     get lookAt(): Vector3;
     set lookAt(v: Vector3);
+    get offset(): Vector2;
+    set offset(v: Vector2);
     get springLength(): number;
     set springLength(v: number);
     get theta(): number;
@@ -63,18 +68,21 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _calculateDistanceScale;
     private _calculateRotatelDelta;
     private _calculatePanDelta;
+    private _calculateLookAtOffset;
     private _setTargetLookAt;
     private _setTargetRotation;
     private _setTargetSpringLength;
-    goto({ springLength, theta, phi, lookAt, fov, smoothing, rotateSmoothing, }: {
+    goto({ springLength, theta, phi, lookAt, offset, fov, smoothing, rotateSmoothing, }: {
         duration?: number;
         springLength?: number;
         theta?: number;
         phi?: number;
         lookAt?: Vector3;
+        offset?: Vector2;
         fov?: number;
         smoothing?: number;
         rotateSmoothing?: number;
     }): void;
+    private _finalLookAt;
     update(dt: number): void;
 }

package/types/components/AccumulativeShadows.d.ts

@@ -0,0 +1,68 @@
+import * as THREE from "three";
+import { Component } from "../Component";
+import { __E } from "../types";
+export type AccumulativeShadowsProps = {
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    frames?: number;
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    blend?: number;
+    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
+    limit?: number;
+    /** Scale of the plane,  */
+    scale?: number;
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    temporal?: boolean;
+    /** Opacity of the plane, 1 */
+    opacity?: number;
+    /** Discards alpha pixels, 0.65 */
+    alphaTest?: number;
+    /** Shadow color, black */
+    color?: string;
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    colorBlend?: number;
+    /** Buffer resolution, 1024 */
+    resolution?: number;
+    /** Texture tonemapping */
+    toneMapped?: boolean;
+    randomLights?: RandomizedLight[];
+};
+export declare class AccumulativeShadows extends Component {
+    temporal: boolean;
+    frames: number;
+    count: number;
+    limit: number;
+    blend: number;
+    constructor({ temporal, frames, limit, blend, scale, opacity, alphaTest, color, colorBlend, resolution, toneMapped, randomLights, ...props }?: AccumulativeShadowsProps);
+    reset?(): void;
+}
+export type RandomizedLightProps = __E & {
+    /** How many frames it will jiggle the lights, 1.
+     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
+    frames?: number;
+    /** Light position, [0, 0, 0] */
+    position?: THREE.Vector3;
+    /** Radius of the jiggle, higher values make softer light, 5 */
+    radius?: number;
+    /** Amount of lights, 8 */
+    amount?: number;
+    /** Light intensity, 1 */
+    intensity?: number;
+    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
+    ambient?: number;
+    /** If the lights cast shadows, this is true by default */
+    castShadow?: boolean;
+    /** Default shadow bias, 0 */
+    bias?: number;
+    /** Default map size, 512 */
+    mapSize?: number;
+    /** Default size of the shadow camera, 10 */
+    size?: number;
+    /** Default shadow camera near, 0.5 */
+    near?: number;
+    /** Default shadow camera far, 500 */
+    far?: number;
+};
+export declare class RandomizedLight extends THREE.Group {
+    constructor({ castShadow, bias, mapSize, size, near, far, frames, position, radius, amount, intensity, ambient, ...props }?: RandomizedLightProps);
+    update?(): void;
+}

package/types/components/Center.d.ts

@@ -0,0 +1,44 @@
+import { Box3, Group, Object3D, Vector3, Sphere } from "three";
+import { Component } from "../Component";
+import { __E } from "../types";
+export type OnCenterCallbackProps = {
+    /** The next parent above <Center> */
+    parent: Object3D;
+    /** The outmost container group of the <Center> component */
+    container: Object3D;
+    width: number;
+    height: number;
+    depth: number;
+    boundingBox: Box3;
+    boundingSphere: Sphere;
+    center: Vector3;
+    verticalAlignment: number;
+    horizontalAlignment: number;
+    depthAlignment: number;
+};
+export type CenterProps = __E & {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    front?: boolean;
+    back?: boolean;
+    /** Disable all axes */
+    disable?: boolean;
+    /** Disable x-axis centering */
+    disableX?: boolean;
+    /** Disable y-axis centering */
+    disableY?: boolean;
+    /** Disable z-axis centering */
+    disableZ?: boolean;
+    /** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */
+    precise?: boolean;
+    /** Callback, fires in the useLayoutEffect phase, after measurement */
+    onCentered?: (props: OnCenterCallbackProps) => void;
+    /** Optional cacheKey to keep the component from recalculating on every render */
+    cacheKey?: any;
+    children?: Object3D[];
+};
+export declare class Center extends Component<Group> {
+    constructor({ disable, disableX, disableY, disableZ, left, right, top, bottom, front, back, onCentered, precise, cacheKey, children, ...props }?: CenterProps);
+}

package/types/components/ContactShadows.d.ts

@@ -0,0 +1,28 @@
+import { Matrix4, Color, Euler, Vector3, WebGLRenderTarget } from "three";
+import { Component } from "../Component";
+export declare class ContactShadows extends Component {
+    layerMask: number;
+    get visible(): boolean;
+    set visible(v: boolean);
+    color: Color;
+    blur: number;
+    constructor({ scale, frames, width, height, intensity, blur, near, far, resolution, smooth, color, renderOrder, layerMask, ...props }?: {
+        scale?: number;
+        frames?: number;
+        width?: number;
+        height?: number;
+        intensity?: number;
+        blur?: number;
+        near?: number;
+        far?: number;
+        resolution?: number;
+        smooth?: boolean;
+        color?: Color;
+        renderOrder?: number;
+        position?: Vector3;
+        rotation?: Euler;
+        layerMask?: number;
+    });
+    getRenderTarget: () => WebGLRenderTarget;
+    getTextureMatrix: () => Matrix4;
+}

package/types/components/index.d.ts

@@ -1,2 +1,5 @@
 export { Reflector } from "./Reflector";
 export { Animation } from "./Animation";
+export { ContactShadows } from "./ContactShadows";
+export { AccumulativeShadows, RandomizedLight } from "../components/AccumulativeShadows";
+export { Center } from "./Center";

package/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const version: number;

package/types/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./types";
 export * from "./base";
-export * from "./tween";
 export * from "./loaders";
 export * from "./cinestation";
 export * from "./primitive";
@@ -18,5 +17,5 @@ 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 { Loader, type LoadProperties } from "./asset/Loader";
 export { ResourceManager, type AssetProperties } from "./asset/ResourceManager";

package/types/loaders/BINLoader.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

package/types/loaders/index.d.ts

@@ -1,6 +1,7 @@
-export { aEXRLoader } from "./aEXRLoader";
-export { aFBXLoader } from "./aFBXLoader";
-export { aGLTFLoader } from "./aGLTFLoader";
-export { aHDRLoader } from "./aHDRLoader";
-export { aJSONLoader } from "./aJSONLoader";
-export { aTextureLoader } from "./aTextureLoader";
+export { EXRLoader } from "./EXRLoader";
+export { FBXLoader } from "./FBXLoader";
+export { GLTFLoader } from "./GLTFLoader";
+export { HDRLoader } from "./HDRLoader";
+export { JSONLoader } from "./JSONLoader";
+export { TextureLoader } from "./TextureLoader";
+export { BINLoader } from "./BINLoader";

package/types/materials/DiscardMaterial.d.ts

@@ -0,0 +1,5 @@
+import { ShaderMaterial } from "three";
+export declare class DiscardMaterial extends ShaderMaterial {
+    vertexShader: string;
+    fragmentShader: string;
+}

package/types/materials/ShadowMaterial.d.ts

@@ -0,0 +1,17 @@
+import { Color, IUniform, ShaderMaterial } from "three";
+import { ContactShadows } from "../components";
+export declare class ShadowMaterial extends ShaderMaterial {
+    vertexShader: string;
+    fragmentShader: string;
+    uniforms: {
+        [uniform: string]: IUniform<any>;
+    };
+    constructor({ shadows, ...props }: {
+        shadows: ContactShadows;
+        opacity?: number;
+        transparent?: boolean;
+        depthWrite?: boolean;
+    });
+    get color(): Color;
+    set color(v: Color);
+}

package/types/materials/index.d.ts

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

package/types/math/Interpolation.d.ts

@@ -1,9 +1,10 @@
-import { Quaternion, Vector3 } from "three";
-export declare function VInterpTo(current: Vector3, target: Vector3, deltaTime: number, speed: number, out?: Vector3): Vector3;
+import { Quaternion, Vector2, Vector3 } from "three";
+export declare function VInterpTo(current: Vector2, target: Vector2, deltaTime: number, speed: number, out?: Vector2, epsilon?: number): Vector2;
+export declare function VInterpTo(current: Vector3, target: Vector3, deltaTime: number, speed: number, out?: Vector3, epsilon?: number): 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 QInterpTo(current: Quaternion, target: Quaternion, deltaTime: number, speed: number, epsilon?: number): Quaternion;
 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;
+export declare function FInterpTo(current: number, target: number, deltaTime: number, speed: number, epsilon?: number): number;
+export declare function FInterpConstantTo(current: number, target: number, deltaTime: number, speed: number, epsilon?: number): number;

package/types/math/index.d.ts

@@ -3,3 +3,4 @@ export * from "./Constant";
 export * from "./Interpolation";
 export { AnimationCurve } from "./AnimationCurve";
 export { Perlin } from "./Perlin";
+export { Easing } from "./Easing";

package/types/plugins/DropFile.d.ts

@@ -3,10 +3,12 @@ export declare class DropFile extends Mount {
     private _onLoad;
     private _onError;
     private _extensions;
-    constructor({ onLoad, onError, extension, }?: {
+    private _raw;
+    constructor({ onLoad, onError, extension, raw, }?: {
         onLoad?: Function;
         onError?: Function;
         extension?: string | string[];
+        raw?: boolean;
     });
     onEnable(): void;
     onDisable(): void;

package/types/plugins/UI.d.ts

@@ -0,0 +1,30 @@
+import { Vector2 } from "three";
+import { Mount } from "../Mount";
+export declare class UI extends Mount {
+    static __loc0: Vector2;
+    static __loc1: Vector2;
+    static __panOffset: Vector2;
+    private _camera;
+    private _zoom;
+    private _targetZoom;
+    private _targetPosition;
+    private _button;
+    private _touchID;
+    private _preLoc0;
+    private _preLoc1;
+    get layerMask(): number;
+    set layerMask(v: number);
+    onLoad(): void;
+    onDestroy(): void;
+    private _onPointerDown;
+    private _onPointerUp;
+    private _onPointerMove;
+    private _onMouseWheel;
+    private _onTouchStart;
+    private _onTouchMove;
+    private _setTargetPosition;
+    private _calculatePanDelta;
+    update(dt: number): void;
+    resize(width: number, height: number): void;
+    render(dt: number): void;
+}

package/types/plugins/index.d.ts

@@ -1,3 +1,4 @@
+export { UI } from "./UI";
 export { Environment } from "./Environment";
 export { BoxProjection } from "./BoxProjection";
 export { PerformanceMonitor } from "./PerformanceMonitor";

package/types/shaderMaterial.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+import { ConstructorRepresentation } from "./types";
+type UniformValue = THREE.Texture | THREE.TypedArray | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | THREE.Color | number | boolean | null;
+type Uniforms = Record<string, UniformValue | Record<string, UniformValue> | Array<UniformValue>>;
+export declare function shaderMaterial<U extends Uniforms, M extends THREE.ShaderMaterial & U>(uniforms: U, vertexShader: string, fragmentShader: string): ConstructorRepresentation<M> & {
+    key: string;
+};
+export {};