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

package/types/components/FreelookVirtualCamera.d.ts

@@ -0,0 +1,110 @@
+import { Object3D, Quaternion, Vector2, Vector3 } from "three";
+import { Component } from "../Component";
+export declare class FreelookVirtualCamera extends Component<Object3D & {
+    isCamera?: boolean;
+}> {
+    static loc0: Vector2;
+    static loc1: Vector2;
+    static center: Vector2;
+    static preCenter: Vector2;
+    static panDelta: Vector2;
+    static rotateDelta: Vector2;
+    static posDelta: Vector3;
+    static lookAtOffset: Vector3;
+    static xAxis: Vector3;
+    static yAxis: Vector3;
+    static quat: Quaternion;
+    private _button;
+    private _touchID;
+    private _preLoc0;
+    private _preLoc1;
+    private _spherical;
+    private _lookAt;
+    private _offset;
+    private _fov;
+    private _near;
+    private _far;
+    private _tempSmoothing;
+    private _tempRotateSmoothing;
+    private _targetPosition;
+    private _targetTheta;
+    private _targetPhi;
+    private _targetSpringLength;
+    private _targetFov;
+    private _targetNear;
+    private _targetFar;
+    private _targetLookAt;
+    private _targetOffset;
+    private _finalLookAt;
+    name: string;
+    forbidX: boolean;
+    forbidY: boolean;
+    forbidZ: boolean;
+    forbidPanX: boolean;
+    forbidPanY: boolean;
+    forbitPanOffsetY: boolean;
+    panSpeed: number;
+    rotateSpeed: number;
+    smoothing: number;
+    rotateSmoothing: number;
+    phiMin: number;
+    phiMax: number;
+    thetaMin: number;
+    thetaMax: number;
+    distanceMin: number;
+    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;
+    set theta(v: number);
+    get phi(): number;
+    set phi(v: number);
+    get fov(): number;
+    set fov(v: number);
+    get near(): number;
+    set near(v: number);
+    get far(): number;
+    set far(v: number);
+    private _onMultiTouch;
+    private _onSingleTouch;
+    private _onCalculatePan;
+    private _onDragging;
+    private _onDistanceScale;
+    private _lerpCamera;
+    private _syncCamera;
+    constructor();
+    onEnable(): void;
+    onDisable(): void;
+    reset(): void;
+    goto({ phi, theta, springLength, offset, lookAt, fov, near, far, smoothing, rotateSmoothing, }: {
+        phi?: number;
+        theta?: number;
+        springLength?: number;
+        lookAt?: Vector3;
+        offset?: Vector2;
+        fov?: number;
+        near?: number;
+        far?: number;
+        smoothing?: number;
+        rotateSmoothing?: number;
+    }): void;
+    update(dt: number): void;
+    private _onPointerDown;
+    private _onPointerUp;
+    private _onPointerMove;
+    private _onMouseWheel;
+    private _onTouchStart;
+    private _onTouchMove;
+    private _calculateDistanceScale;
+    private _calculateRotate;
+    private _calculatePanDelta;
+    private _calculateLookAtOffset;
+    private _setTargetLookAt;
+    private _setTargetRotation;
+    private _setTargetPosition;
+    private _setTargetSpringLength;
+}

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

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

package/types/components/RenderTexture.d.ts

@@ -0,0 +1,7 @@
+import { RenderTargetOptions } from "three";
+import { Component } from "../Component";
+export declare class RenderTexture extends Component {
+    private _fbo;
+    get texture(): import("three").Texture;
+    constructor(width?: number, height?: number, options?: RenderTargetOptions);
+}

package/types/components/Renderer.d.ts

@@ -0,0 +1,6 @@
+import { Component } from "../Component";
+export declare class Renderer extends Component {
+    order: number;
+    render(dt: number): void;
+    resize(width: number, height: number): void;
+}

package/types/components/UI.d.ts

@@ -0,0 +1,30 @@
+import { Vector2 } from "three";
+import { Component } from "../Component";
+export declare class UI extends Component {
+    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/components/index.d.ts

@@ -1,5 +1,12 @@
 export { Reflector } from "./Reflector";
 export { Animation } from "./Animation";
 export { ContactShadows } from "./ContactShadows";
-export { AccumulativeShadows, RandomizedLight } from "../components/AccumulativeShadows";
+export { AccumulativeShadows, RandomizedLight } from "./AccumulativeShadows";
 export { Center } from "./Center";
+export { Renderer } from "./Renderer";
+export { RenderTexture } from "./RenderTexture";
+export { FreelookVirtualCamera } from "./FreelookVirtualCamera";
+export { Environment } from "./Environment";
+export { BoxProjection } from "./BoxProjection";
+export { PerformanceMonitor } from "./PerformanceMonitor";
+export { DropFile } from "./DropFile";

package/types/enums/index.d.ts

@@ -0,0 +1,9 @@
+export declare enum Orientation {
+    AUTO = 0,
+    LANDSCAPE = 1,
+    PORTRAIT = 2
+}
+export declare enum ResizeMode {
+    AUTO = 0,
+    MUNUAL = 1
+}

package/types/index.d.ts

@@ -1,21 +1,19 @@
 export * from "./types";
 export * from "./base";
 export * from "./loaders";
-export * from "./cinestation";
 export * from "./primitive";
 export * from "./math";
 export * from "./components";
 export * from "./materials";
-export * from "./plugins";
 export * from "./Utils";
+export * from "./enums";
 export { Viewer } from "./Viewer";
+export { Task } from "./Task";
 export { Component } from "./Component";
-export { Mount } from "./Mount";
 export { SystemInfo } from "./SystemInfo";
 export { ObjectInstance } from "./ObjectInstance";
 export { property, PropertyManager } from "./PropertyManager";
 export { dependencies, DependentMode } from "./ComponentManager";
 export { DeviceInput } from "./DeviceInput";
-export { Orientation } from "./enums/Orientation";
 export { Loader, type LoadProperties } from "./asset/Loader";
 export { ResourceManager, type AssetProperties } from "./asset/ResourceManager";

package/types/loaders/KTX2Loader.d.ts

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

package/types/loaders/SVGLoader.d.ts

@@ -0,0 +1,8 @@
+import { Loader, LoadProperties } from "../asset/Loader";
+import { SVGLoader as SVGLoaderPrimitive } from "three/examples/jsm/loaders/SVGLoader.js";
+export declare class SVGLoader extends Loader {
+    extension: string[];
+    load({ url, path, resourcePath, manager, onLoad, onProgress, onError, }: LoadProperties): void;
+    private _loader;
+    static Primitive: typeof SVGLoaderPrimitive;
+}

package/types/loaders/index.d.ts

@@ -5,3 +5,5 @@ export { HDRLoader } from "./HDRLoader";
 export { JSONLoader } from "./JSONLoader";
 export { TextureLoader } from "./TextureLoader";
 export { BINLoader } from "./BINLoader";
+export { SVGLoader } from "./SVGLoader";
+export { KTX2Loader } from "./KTX2Loader";

package/types/materials/ReflectorMaterial.d.ts

@@ -10,9 +10,11 @@ export declare class ReflectorMaterial extends ShaderMaterial {
         [uniform: string]: IUniform<any>;
     };
     constructor({ reflector, ...parameters }: {
-        reflector: Reflector;
         name?: string;
+        color?: Color;
         opacity?: number;
+        reflector: Reflector;
+        reflectIntensity?: number;
         transparent?: boolean;
         depthWrite?: boolean;
         roughness?: number;

package/types/plugins/BoxProjection.d.ts

@@ -1,6 +1,6 @@
 import { Vector3, Vector4, WebGLProgramParametersWithUniforms } from "three";
-import { Mount } from "../Mount";
-export declare class BoxProjection extends Mount {
+import { Component } from "../Component";
+export declare class BoxProjection extends Component {
     private _center;
     private _boxMin;
     private _boxMax;

package/types/plugins/DropFile.d.ts

@@ -1,14 +1,22 @@
-import { Mount } from "../Mount";
-export declare class DropFile extends Mount {
+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 _extensions;
-    private _raw;
-    constructor({ onLoad, onError, extension, raw, }?: {
+    private _extension;
+    constructor({ onLoad, onError, extension }?: {
         onLoad?: Function;
         onError?: Function;
-        extension?: string | string[];
-        raw?: boolean;
+        extension?: {
+            [k: string]: Mode;
+        };
+        buffers?: string[];
     });
     onEnable(): void;
     onDisable(): void;
@@ -18,3 +26,4 @@ export declare class DropFile extends Mount {
     private _loadFiles;
     private _loadFile;
 }
+export {};

package/types/plugins/Environment.d.ts

@@ -1,6 +1,6 @@
 import { Object3D, Scene, Texture, TextureDataType, Vector3 } from "three";
-import { Mount } from "../Mount";
-export declare class Environment extends Mount {
+import { Component } from "../Component";
+export declare class Environment extends Component {
     static readonly Quality: {
         LOW: number;
         MEDIUM: number;

package/types/plugins/Exporter.d.ts

@@ -0,0 +1,7 @@
+import { Mount } from "../Mount";
+export declare class Exporter extends Mount {
+    trs: boolean;
+    binary: boolean;
+    maxTextureSize: number;
+    export(): void;
+}

package/types/plugins/PerformanceMonitor.d.ts

@@ -1,4 +1,4 @@
-import { Mount } from "../Mount";
+import { Component } from "../Component";
 type PerformanceMonitorProps = {
     /** How much time in milliseconds to collect an average fps, 250 */
     ms?: number;
@@ -32,7 +32,7 @@ type PerformanceMonitorSubscriber = {
     /** 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 Mount {
+export declare class PerformanceMonitor extends Component {
     fps: number;
     index: number;
     factor: number;

package/types/plugins/UI.d.ts

@@ -1,6 +1,6 @@
 import { Vector2 } from "three";
-import { Mount } from "../Mount";
-export declare class UI extends Mount {
+import { Component } from "../Component";
+export declare class UI extends Component {
     static __loc0: Vector2;
     static __loc1: Vector2;
     static __panOffset: Vector2;

package/types/plugins/index.d.ts

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

package/types/types.d.ts

@@ -9,8 +9,8 @@ export type __Properties<T> = Omit<Partial<T>, __FunctionKeys<T>> & {
 export type __C<T> = new (...args: any[]) => T;
 export type __E = {
     /**
- * The object's local scale.
- */
+     * The object's local scale.
+     */
     scale?: Vector3;
     /**
      * Object's local position.
@@ -23,7 +23,7 @@ export type __E = {
     /**
      * Object's layer mask
      */
-    layer?: number;
+    layerMask?: number;
 };
 export type __P<T, K extends __C<T>> = __Properties<T> & __E & {
     /**
@@ -43,18 +43,13 @@ export type __P<T, K extends __C<T>> = __Properties<T> & __E & {
      */
     parent?: Object3D;
     /**
-     * Debug node
-     */
-    debug?: boolean;
-    /**
-     * Set as default camera, only valid for camera
+     * Set as default
      */
     makeDefault?: boolean;
     /**
-     * Set shadow arguments, only valid for Directional Light
-     * @example ["top", "bottom", "left", "right", "near", "far", "bias", "width", "height"];
+     * Manually set the camera’s aspect ratio
      */
-    shadowArgs?: number[];
+    manual?: boolean;
 };
 export type __Comp<T, K extends __C<T>> = __Properties<T> & {
     /**