@xviewer.js/core 1.0.4-alpha.0 → 1.0.4-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.4-alpha.0",
+  "version": "1.0.4-alpha.1",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -13,7 +13,7 @@
     "types/**/*"
   ],
   "peerDependencies": {
-    "three": ">= 0.164.0"
+    "three": ">= 0.179.0"
   },
   "scripts": {
     "b:types": "tsc"

package/types/Component.d.ts

@@ -1,14 +1,18 @@
 import { Object3D } from "three";
 import { Viewer } from "./Viewer";
+import { Context } from "./Context";
 import { ComponentManager } from "./ComponentManager";
 import { ObjectInstance } from "./ObjectInstance";
 export declare class Component<T extends Object3D = Object3D> extends ObjectInstance {
     private _enabled;
+    name: string;
+    type: string;
+    isComponent: boolean;
+    order: number;
     node: T;
     viewer: Viewer;
+    context: Context;
     manager: ComponentManager;
-    isComponent: boolean;
-    type: string;
     onLoad?(): void;
     onEnable?(): void;
     onDisable?(): void;
@@ -19,12 +23,12 @@ export declare class Component<T extends Object3D = Object3D> extends ObjectInst
     render?(dt: number): void;
     resize?(width: number, height: number): void;
     flags: {
-        Destroyed?: boolean;
-        OnLoadCalled?: boolean;
-        OnEnableCalled?: boolean;
-        StartCalled?: boolean;
-        Deactivating?: boolean;
-        IsStartCalled?: boolean;
+        destroyed?: boolean;
+        onLoadCalled?: boolean;
+        onEnableCalled?: boolean;
+        startCalled?: boolean;
+        deActivating?: boolean;
+        isStartCalled?: boolean;
     };
     get enabled(): boolean;
     set enabled(v: boolean);

package/types/ComponentManager.d.ts

@@ -4,9 +4,10 @@ import { Component } from "./Component";
 import { ComponentScheduler } from "./ComponentScheduler";
 import { Viewer } from "./Viewer";
 type ComponentConstructor = new (...args: any[]) => Component;
-interface DependentInfo {
-    mode: DependentMode;
-    components: ComponentConstructor[];
+interface ComponentInfo {
+    mode?: DependentMode;
+    components?: ComponentConstructor[];
+    single?: boolean;
 }
 export declare enum DependentMode {
     /** Check only, throw error if dependent components do not exist. */
@@ -15,8 +16,9 @@ export declare enum DependentMode {
     AutoAdd = 1
 }
 export declare function dependencies(componentOrComponents: ComponentConstructor | ComponentConstructor[], mode?: DependentMode): <T extends ComponentConstructor>(target: T) => void;
+export declare function single(): <T extends ComponentConstructor>(target: T) => void;
 export declare class ComponentManager {
-    static _infoMap: Map<ComponentConstructor, DependentInfo>;
+    static _infoMap: Map<ComponentConstructor, ComponentInfo>;
     private _viewer;
     private _scheduler;
     private _componentScheduler;
@@ -38,7 +40,10 @@ export declare class ComponentManager {
     removeComponent(node: Object3D, component: Component): this;
     getComponent<T extends Component>(node: Object3D, constructor: {
         new (...args: any[]): T;
-    }, autoAdd?: boolean): T;
+    }): T;
+    getComponentInChildren<T extends Component>(node: Object3D, constructor: {
+        new (): T;
+    }): Component<Object3D<import("three").Object3DEventMap>>;
     getComponentsInChidren<T extends Component>(node: Object3D, constructor: {
         new (): T;
     }, out?: T[]): T[];

package/types/ComponentScheduler.d.ts

@@ -1,10 +1,10 @@
 import { Component } from "./Component";
-declare class Invoker<T> {
+declare class Invoker<T extends Component> {
     protected _targets: T[];
     protected _callback: (target: T, ...args: any[]) => any;
     constructor(callback: (target: T, ...args: any[]) => any);
-    add(target: any): void;
-    remove(target: any): void;
+    add(target: T): void;
+    remove(target: T): void;
     invoke(...args: any[]): void;
 }
 export declare class ComponentScheduler {

package/types/Context.d.ts

@@ -0,0 +1,6 @@
+import { Camera, Scene, WebGLRenderer } from "three";
+export interface Context {
+    scene: Scene;
+    camera: Camera;
+    renderer: WebGLRenderer;
+}

package/types/DeviceInput.d.ts

@@ -1,8 +1,13 @@
 import { Vector2 } from "three";
 import { ConnTarget } from "./Pressability";
-import { Viewer } from "./Viewer";
-export declare class DeviceInput {
-    viewer: Viewer;
+import { Component } from "./Component";
+export interface InputTarget {
+    on?(event: string, cb: (...args: any[]) => void, target: Object, once?: boolean): any;
+    off?(event: string, cb: (...args: any[]) => void, target: Object): any;
+    removeEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    addEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+export declare class DeviceInput extends Component {
     static readonly CLICK = "click";
     static readonly MOUSE_WHEEL = "mousewheel";
     static readonly TOUCH_START = "touchstart";
@@ -16,18 +21,23 @@ export declare class DeviceInput {
     static readonly KEYDOWN = "keydown";
     static readonly KEYPRESS = "keypress";
     static readonly KEYUP = "keyup";
+    private _target;
     private _listeners;
-    private _mouseWheel;
     private _touches;
     private _touchCount;
-    private _pointerButton;
-    private _pointerPosition;
     private _pointer;
+    private _pointerPixel;
+    private _pointerButton;
+    private _prePointer;
+    private _prePointerPixel;
+    private _mouseWheel;
     private _keys;
     private _pressability;
-    get pointerButton(): number;
     get pointer(): Vector2;
-    get pointerPosition(): Vector2;
+    get pointerPixel(): Vector2;
+    get pointerButton(): number;
+    get prePointer(): Vector2;
+    get prePointerPixel(): Vector2;
     get mouseWheel(): number;
     get touchCount(): number;
     get touches(): {
@@ -37,9 +47,10 @@ export declare class DeviceInput {
     get keys(): {
         [k: string]: boolean;
     };
-    constructor(viewer: Viewer);
-    addEventListeners(): void;
-    removeAllListeners(): void;
+    constructor(target: HTMLElement | Document);
+    onEnable(): void;
+    onDisable(): void;
+    lastUpdate(dt: number): void;
     connect(target: ConnTarget, event: string): void;
     disconnect(target: ConnTarget): void;
     private _addEventListener;

package/types/PropertyManager.d.ts

@@ -1,18 +1,10 @@
-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 _classMap: Map<String, ClassProperties>;
+    static _classMap: Map<String, Object>;
     static _propertyMap: Map<Object, Object>;
     static _hasProperties(constructor: Function): boolean;
-    static _getProperties(constructor: Function, autoAdd?: boolean): Object;
+    static _getProperties(constructor: Function, initProps?: Object): Object;
     static _getMergedProperties(constructor: Function): any;
-    static _getClassProperties(clsName: string, autoAdd?: boolean): ClassProperties;
-    static _applyClassProperties(clsName: string, constructor: Function): object;
+    static _getClassProperties(clsName: string, initProps?: Object): Object;
 }
 export interface IPropertyOptions {
     dir?: string;

package/types/TaskManager.d.ts

@@ -1,13 +1,13 @@
 import { Task } from "./Task";
-import { EventEmitter } from "./base";
-export declare class TaskManager extends EventEmitter {
+export declare class TaskManager {
     onComplete?: () => void;
     onProgress?: (task: Task, loaded: number, total: number) => void;
     onError?: (task: Task) => void;
     private _tasks;
     private _taskIndex;
-    private _percent;
-    get percent(): number;
+    private _interval;
+    private _onstartCalled;
+    onStart?: () => void;
     constructor(onComplete?: () => void, onProgress?: (task: Task, loaded: number, total: number) => void, onError?: (task: Task) => void);
     destroy(): void;
     add(task: Task): void;

package/types/Viewer.d.ts

@@ -1,44 +1,35 @@
-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 { BufferGeometry, Camera, Color, ColorRepresentation, ColorSpace, DataTexture, LoadingManager, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, ShaderMaterial, ShadowMapType, Texture, TextureDataType, ToneMapping, Vector3, WebGLCubeRenderTarget, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget } from "three";
 import { EventEmitter } from "./base";
-import { TaskManager } from "./TaskManager";
+import { ComponentManager } from "./ComponentManager";
 import { DeviceInput } from "./DeviceInput";
-import { Orientation } from "./enums/Orientation";
-import { AssetProperties, LoaderConstructor, ResourceManager } from "./asset/ResourceManager";
-import { __C, __P } from "./types";
+import { Orientation, ResizeMode } from "./enums";
+import { AssetProperties, LoaderConstructor } from "./asset/ResourceManager";
+import { __C, __P, __Properties } from "./types";
 import { Component } from "./Component";
 import { Task } from "./Task";
-import { Mount } from "./Mount";
+import { Context } from "./Context";
+type SizeFunction = () => number[];
 export declare class Viewer extends EventEmitter {
-    static __target: Vector3;
-    static __worldPos: Vector3;
-    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 | null, material: Material, lod?: number, face?: number): void;
-    static CreateFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes>;
-    static fullscreenMesh: Mesh;
-    static fullscreenCamera: OrthographicCamera;
     static instanceCount: number;
+    static target: Vector3;
+    static worldPos: Vector3;
+    static clearColor: Color;
     private _instanceId;
     private _root;
     private _canvas;
-    private _container;
     private _gl;
     private _RENDER_TARGET_FLOAT_TYPE;
     private _DATA_FLOAT_TYPE;
-    private _scene;
-    private _camera;
     private _mount;
-    private _renderer;
     private _input;
     private _dpr;
     private _width;
     private _height;
     private _viewport;
-    private _orientation;
-    private _defaultProps;
+    private _resourceOptions;
+    private _scene;
+    private _camera;
+    private _renderer;
     private _running;
     private _rootRotated;
     private _time;
@@ -46,17 +37,14 @@ export declare class Viewer extends EventEmitter {
     private _lastFrameTime;
     private _targetFrameRate;
     private _fixedFrameTime;
-    private _autoResize;
+    private _windowSize;
+    private _orientation;
     private _taskManager;
     private _resourceManager;
     private _componentManager;
     private _loadingManager;
     get root(): HTMLElement;
-    get container(): HTMLElement;
     get time(): number;
-    get scene(): Scene;
-    get camera(): PerspectiveCamera;
-    get renderer(): WebGLRenderer;
     get canvas(): HTMLCanvasElement;
     get gl(): WebGL2RenderingContext | WebGLRenderingContext;
     get RENDER_TARGET_FLOAT_TYPE(): TextureDataType;
@@ -74,78 +62,104 @@ export declare class Viewer extends EventEmitter {
     get targetFrameRate(): number;
     set targetFrameRate(v: number);
     get instanceId(): number;
-    get loadingManager(): LoadingManager;
-    get resourceManager(): ResourceManager;
-    get taskManager(): TaskManager;
-    constructor({ root, canvas, container, autoStart, autoResize, shadows, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, orientation, loader, tasker, ...webglOpts }?: {
+    get componentManager(): ComponentManager;
+    get scene(): Scene;
+    get camera(): Camera;
+    get renderer(): WebGLRenderer;
+    constructor({ root, canvas, input, shadows, sortObjects, resize, orthographic, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, orientation, loader, tasker, ...webglOpts }?: {
+        /** 根节点，用于屏幕旋转 */
         root?: HTMLElement;
+        /** 渲染用的 canvas 元素，如果不提供，默认获取 id 为 "canvas" 的元素 */
         canvas?: HTMLCanvasElement;
-        container?: HTMLDivElement;
+        /** 设备输入容器，默认使用canvas */
+        input?: HTMLElement | Document;
+        /** 是否开启阴影或阴影类型，true/false 表示默认 PCFSoftShadowMap */
+        shadows?: boolean | ShadowMapType;
+        /** 渲染是否开启排序，默认 True */
+        sortObjects?: boolean;
+        /** 渲染目标帧率 (FPS)，-1 表示无限制帧率 */
         targetFrameRate?: number;
+        /** 是否固定帧时间，true 使用固定 delta 时间 */
         fixedFrameTime?: boolean;
-        autoStart?: boolean;
-        autoResize?: boolean;
-        shadows?: boolean | ShadowMapType;
+        /** 调整大小模式，AUTO: 自动 resize，MUNUAL: 手动控制 */
+        resize?: ResizeMode | SizeFunction;
+        /** 渲染器输出的色彩空间，默认 SRGBColorSpace */
         colorSpace?: ColorSpace;
+        /** 渲染器的色调映射类型，默认 LinearToneMapping */
         toneMapping?: ToneMapping;
+        /** 色调映射曝光值，默认 1 */
         toneMappingExposure?: number;
+        /** 最大设备像素比，用于控制高分屏渲染精度 */
         maxDPR?: number;
+        /** 模型路径，通常用于加载主模型文件（如 glTF、FBX 等）的基础路径 */
         path?: string;
+        /** 资源路径，模型引用的其他资源（如贴图、材质等）的路径 */
         resourcePath?: string;
+        /** Draco 压缩解码器路径，默认 Google CDN 地址 */
         dracoPath?: string;
+        /** 页面方向，AUTO: 自动，LANDSCAPE: 横屏，PORTRAIT: 竖屏 */
         orientation?: Orientation;
-        camera?: {
-            fov?: number;
-            aspect?: number;
-            near?: number;
-            far?: number;
-            position?: Vector3;
-            rotation?: Euler;
-        };
+        /** Creates an orthographic camera */
+        orthographic?: boolean;
+        /** A `THREE.Camera` instance or props that go into the default camera */
+        camera?: (Camera | __Properties<PerspectiveCamera & OrthographicCamera>);
+        /** 加载管理器 */
         loader?: {
-            onLoad?: () => void;
+            onComplete?: () => void;
             onProgress?: (url: string, loaded: number, total: number) => void;
             onError?: (url: string) => void;
         };
+        /** 任务管理器 */
         tasker?: {
             onComplete?: () => void;
-            onProgress?: (target: Object, loaded: number, total: number) => void;
-            onError?: (target: Object) => void;
+            onProgress?: (task: Task, loaded: number, total: number) => void;
+            onError?: (task: Task) => void;
         };
     } & WebGLRendererParameters);
     destroy(): void;
-    private _addDefaultLoaders;
+    context(context?: Context): Context;
     private _frame;
     loop(dt: number): void;
-    update(dt: number): void;
-    render(dt: number): void;
-    _rendering(dt: number): void;
-    _resizing(width: number, height: number): void;
     start(): this;
     stop(): this;
     rotate(): void;
     resize(width?: number, height?: number): void;
+    setURLModifier(callback?: (url: string) => string): LoadingManager;
     loadAsset(props: AssetProperties): Promise<any>;
     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: {
+    getComponent<T extends Component>(constructor: {
         new (...args: any[]): T;
-    }, autoAdd?: boolean): T;
-    task(task: Task): void;
+    }, node?: Object3D): T;
+    task<T extends Object3D | Scene | Material | Texture | Function>(target?: T): T;
+    task<T extends Material[]>(target?: Material[]): T;
     add<T extends Object3D | Component, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
     remove<T extends Object3D | Component>(ins: T): T;
     createRenderTarget(width: number, height: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean, depth?: boolean): WebGLRenderTarget<Texture>;
     createCubeRenderTarget(size: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean, depth?: boolean): WebGLCubeRenderTarget;
     createDataTexture(data: ArrayBufferView, width: number, height: number, floatType?: boolean, nearest?: boolean): DataTexture;
-    /**
-     * 传送门，得到一个全新的场景
-     * @param callback 禁止使用异步函数，会导致状态错误
-     * @returns
-     */
-    portal<T = any>(callback: () => T, sceneNew?: Scene): T;
     blit(renderTarget: WebGLRenderTarget, material: Material, lod?: number, face?: number): void;
+    copy(src: WebGLRenderTarget | Texture, dest: WebGLRenderTarget): void;
+    clearColor(renderTarget: WebGLRenderTarget, color: ColorRepresentation, alpha?: number): void;
+    blur(blurLevel: number, shadingScale: number, inputBuffer: WebGLRenderTarget, tempBuffer: WebGLRenderTarget, outputBuffer?: WebGLRenderTarget, fixedOutput?: boolean): void;
+    render(renderTarget: WebGLRenderTarget | null, node: Object3D, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number): void;
     compile(target?: Object3D | Scene | Material | Texture): void;
     compile(target?: Material[]): void;
+    static fullscreenMesh: Mesh;
+    static fullscreenCamera: OrthographicCamera;
+    static copyMaterial: ShaderMaterial;
+    static clearMaterial: ShaderMaterial;
+    static blur9Material: ShaderMaterial;
+    static blur9VaryingMaterial: ShaderMaterial;
+    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 Blur(renderer: WebGLRenderer, blurLevel: number, shadingScale: number, inputBuffer: WebGLRenderTarget, tempBuffer: WebGLRenderTarget, outputBuffer?: WebGLRenderTarget, fixedOutput?: boolean): void;
+    static Blit(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, material: Material, lod?: number, face?: number): void;
+    static Copy(renderer: WebGLRenderer, src: WebGLRenderTarget | Texture, dest: WebGLRenderTarget): void;
+    static ClearColor(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, clearColor: ColorRepresentation, clearAlpha?: number): void;
+    static Render(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, node: Object3D, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    static Stash(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, callback: () => void, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    static CreateFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
 }
+export {};

package/types/WebGL.d.ts

@@ -1,5 +1,5 @@
 import { WebGLRendererParameters } from "three";
-export declare function parepareWebGL(canvas: HTMLCanvasElement, props: WebGLRendererParameters): {
+export declare function checkWebGL(canvas: HTMLCanvasElement, props: WebGLRendererParameters): {
     gl: WebGL2RenderingContext;
     RENDER_TARGET_FLOAT_TYPE: 1016;
     DATA_FLOAT_TYPE: 1015;

package/types/asset/Loader.d.ts

@@ -1,6 +1,6 @@
 import { LoadingManager, Object3D } from "three";
-import { ResourceManager } from "./ResourceManager";
 import { TextureSettings } from "../TextureSettings";
+import type { Viewer } from "../Viewer";
 export interface LoadProperties {
     url: string;
     buffer?: string | ArrayBuffer;
@@ -14,10 +14,10 @@ export interface LoadProperties {
     onError?: (event: ErrorEvent) => void;
 }
 export declare abstract class Loader {
-    manager: ResourceManager;
+    viewer: Viewer;
     static _texKeys: string[];
     static _setUserData(node: Object3D): Object3D<import("three").Object3DEventMap>;
-    constructor(manager: ResourceManager);
+    constructor(viewer: Viewer);
     abstract extension: string[];
     abstract load(props: LoadProperties): void;
 }

package/types/asset/ResourceManager.d.ts

@@ -1,6 +1,8 @@
 import { LoadingManager } from "three";
 import { TextureSettings } from "../TextureSettings";
 import { Loader } from "./Loader";
+import type { Viewer } from "../Viewer";
+export type LoaderConstructor = new (viewer: Viewer) => Loader;
 export interface AssetProperties extends TextureSettings {
     url?: string;
     ext?: string;
@@ -11,7 +13,6 @@ export interface AssetProperties extends TextureSettings {
     manager?: LoadingManager;
     onProgress?: (event: ProgressEvent) => void;
 }
-export type LoaderConstructor = new (manager: ResourceManager) => Loader;
 export declare class ResourceManager {
     static extension(path: string): string;
     static dirname(path: string): string;
@@ -20,7 +21,9 @@ export declare class ResourceManager {
     static _splitTextureSettings(props: TextureSettings & {
         [k: string]: any;
     }): {};
+    private _viewer;
     private _loaders;
+    constructor(viewer: Viewer);
     destroy(): void;
     getLoader(ext: string): Loader;
     addLoader(Loader: LoaderConstructor): Loader;

package/types/cinestation/FreelookVirtualCamera.d.ts

@@ -28,6 +28,8 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _targetFov;
     private _targetLookAt;
     private _targetOffset;
+    private _finalLookAt;
+    name: string;
     forbidX: boolean;
     forbidY: boolean;
     forbidZ: boolean;
@@ -83,6 +85,5 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
         smoothing?: number;
         rotateSmoothing?: number;
     }): void;
-    private _finalLookAt;
     update(dt: number): void;
 }

package/types/cinestation/VirtualCamera.d.ts

@@ -11,6 +11,7 @@ export declare class VirtualCamera extends Component<Object3D & {
 }> {
     private _finalPosition;
     private _finalRotation;
+    name: string;
     locked: boolean;
     priority: number;
     lens: Lens;
@@ -19,6 +20,7 @@ export declare class VirtualCamera extends Component<Object3D & {
     brain: CinestationBrain;
     get finalPosition(): Vector3;
     get finalRotation(): Quaternion;
+    constructor();
     onLoad(): void;
     onDestroy(): void;
 }

package/types/components/BoxProjection.d.ts

@@ -0,0 +1,15 @@
+import { Vector3, Vector4, WebGLProgramParametersWithUniforms } from "three";
+import { Component } from "../Component";
+export declare class BoxProjection extends Component {
+    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/components/DropFile.d.ts

@@ -0,0 +1,29 @@
+import { Component } from "../Component";
+declare enum Mode {
+    BUFFER = 0,
+    BUFFER_RAW = 1,
+    URL = 2,
+    URL_RAW = 3
+}
+export declare class DropFile extends Component {
+    static readonly Mode: typeof Mode;
+    private _onLoad;
+    private _onError;
+    private _extension;
+    constructor({ onLoad, onError, extension }?: {
+        onLoad?: Function;
+        onError?: Function;
+        extension?: {
+            [k: string]: Mode;
+        };
+        buffers?: string[];
+    });
+    onEnable(): void;
+    onDisable(): void;
+    private _onDrogOver;
+    private _onDrop;
+    private _loadItemList;
+    private _loadFiles;
+    private _loadFile;
+}
+export {};

package/types/components/Environment.d.ts

@@ -0,0 +1,37 @@
+import { Object3D, Scene, Texture, TextureDataType, Vector3 } from "three";
+import { Component } from "../Component";
+export declare class Environment extends Component {
+    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, layerMask, resolution, floatType, position, }?: {
+        envMap?: Texture;
+        scene?: Scene | Object3D;
+        performance?: number;
+        resolution?: number;
+        layerMask?: number;
+        near?: number;
+        far?: number;
+        floatType?: boolean | TextureDataType;
+        position?: Vector3;
+    });
+    update(dt: number): void;
+    manualFrame(): void;
+    private _renderFrame;
+}