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

package/types/bmfont/BMFontTextLayout.d.ts

@@ -0,0 +1,93 @@
+export interface Glyph {
+    id: number;
+    char: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    page: number;
+    chnl: number;
+}
+export interface BMFontInfo {
+    pages: string[];
+    chars: Glyph[];
+    info: {
+        face: string;
+        size: number;
+        bold: number;
+        italic: number;
+        charset: string[];
+        unicode: number;
+        stretchH: number;
+        smooth: number;
+        aa: number;
+        padding: number[];
+        spacing: number[];
+        outline: number;
+    };
+    common: {
+        lineHeight: number;
+        base: number;
+        scaleW: number;
+        scaleH: number;
+        pages: number;
+        packed: number;
+    };
+    distanceField: {
+        fieldType: string;
+        distanceRange: number;
+    };
+    kernings: {
+        first: number;
+        second: number;
+        amount: number;
+    }[];
+}
+export interface LayoutSetting {
+    tabSize?: number;
+    width?: number;
+    anchor?: number[];
+    letterSpacing?: number;
+    lineHeight?: number;
+    mode?: "nowrap" | "pre" | "greedy";
+    align?: "center" | "right" | "left";
+    flipY?: boolean;
+}
+export interface LayoutGlyph {
+    position: number[];
+    data: Glyph;
+    index: number;
+    line: number;
+}
+export declare class BMFontTextLayout {
+    private _width;
+    private _height;
+    private _descender;
+    private _ascender;
+    private _xHeight;
+    private _baseline;
+    private _capHeight;
+    private _lineHeight;
+    private _linesTotal;
+    private _glyphs;
+    private _fallbackSpaceGlyph;
+    private _fallbackTabGlyph;
+    private _font;
+    get width(): number;
+    get height(): number;
+    get descender(): number;
+    get ascender(): number;
+    get xHeight(): number;
+    get baseline(): number;
+    get capHeight(): number;
+    get lineHeight(): number;
+    get glyphs(): LayoutGlyph[];
+    get linesTotal(): number;
+    update(font: BMFontInfo, text: string, setting: LayoutSetting): void;
+    private _setupSpaceGlyphs;
+    private _getGlyph;
+    private _computeMetrics;
+}

package/types/bmfont/index.d.ts

@@ -0,0 +1,3 @@
+export { BMFontAtlas } from "./BMFontAtlas";
+export { BMFontTextGeometry } from "./BMFontTextGeometry";
+export { BMFontTextLayout } from "./BMFontTextLayout";

package/types/bmfont/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function computeBox(positions: any, output: any): void;
+export declare function computeSphere(positions: any, output: any): void;

package/types/bmfont/wordwrap.d.ts

@@ -0,0 +1,8 @@
+export declare function wordwrap(text: string, opt?: {
+    width?: number;
+    mode?: "nowrap" | "pre" | "greedy";
+    start?: number;
+    end?: number;
+    measure?: Function;
+    letterSpacing?: number;
+}): any[];

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

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

@@ -0,0 +1,26 @@
+import { Material, Mesh } from "three";
+import { BMFontAtlas } from "../bmfont/BMFontAtlas";
+import { BMFontTextGeometry } from "../bmfont/BMFontTextGeometry";
+import { LayoutSetting } from "../bmfont/BMFontTextLayout";
+import { Component } from "../Component";
+export interface LabelSetting extends LayoutSetting {
+    text?: string;
+    material?: Material;
+    font: BMFontAtlas;
+}
+export declare class Label extends Component<Mesh<BMFontTextGeometry>> {
+    needsUpdate: boolean;
+    private _text;
+    private _font;
+    private _setting;
+    get text(): string;
+    set text(v: string);
+    get font(): BMFontAtlas;
+    set font(v: BMFontAtlas);
+    get setting(): LayoutSetting;
+    set setting(v: LayoutSetting);
+    get layout(): import("../bmfont/BMFontTextLayout").BMFontTextLayout;
+    constructor({ text, font, material, ...setting }: LabelSetting);
+    forceUpdate(): void;
+    update(dt: number): void;
+}

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,13 @@
 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";
+export { Label } from "./Label";

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,20 @@
 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 * from "./bmfont";
 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, transcoderPath, 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/MSDFMaterial.d.ts

@@ -0,0 +1,20 @@
+import { Color, ShaderMaterial, Texture, Vector2 } from "three";
+export declare class MSDFMaterial extends ShaderMaterial {
+    constructor();
+    get weight(): number;
+    set weight(v: number);
+    get color(): Color;
+    set color(v: Color);
+    get strokeColor(): Color;
+    set strokeColor(v: Color);
+    get strokeWidth(): number;
+    set strokeWidth(v: number);
+    get shadowColor(): Color;
+    set shadowColor(v: Color);
+    get shadowBlur(): number;
+    set shadowBlur(v: number);
+    get shadowOffset(): Vector2;
+    set shadowOffset(v: Vector2);
+    get fontTexture(): Texture;
+    set fontTexture(v: Texture);
+}

package/types/materials/ReflectorMaterial.d.ts

@@ -1,4 +1,4 @@
-import { Color, IUniform, ShaderMaterial, Texture, WebGLProgramParametersWithUniforms } from "three";
+import { Color, IUniform, ShaderMaterial, Texture, Vector4, WebGLProgramParametersWithUniforms } from "three";
 import { Reflector } from "../components";
 export declare class ReflectorMaterial extends ShaderMaterial {
     vertexShader: string;
@@ -10,13 +10,19 @@ 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;
         metalness?: number;
+        roughness?: number;
+        roughnessMap?: Texture;
+        normalMap?: Texture;
+        normalScaleBias?: Vector4;
+        roughnessScaleBias?: Vector4;
     });
     onBeforeCompile(shader: WebGLProgramParametersWithUniforms): void;
     get color(): Color;
@@ -29,8 +35,12 @@ export declare class ReflectorMaterial extends ShaderMaterial {
     set map(v: Texture);
     get roughnessMap(): Texture;
     set roughnessMap(v: Texture);
+    get roughnessScaleBias(): Vector4;
+    set roughnessScaleBias(v: Vector4);
     get normalMap(): Texture;
     set normalMap(v: Texture);
+    get normalScaleBias(): Vector4;
+    set normalScaleBias(v: Vector4);
     get aoMap(): Texture;
     set aoMap(v: Texture);
     get lightMap(): Texture;

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