@xviewer.js/debug 1.0.0-alpha.6 → 1.0.0-alpha.7

package/types/base/EventEmitter.d.ts

@@ -0,0 +1,29 @@
+interface EventHandler {
+    name: string;
+    callback: (...args: any[]) => any;
+    target?: Object;
+    once?: boolean;
+}
+interface Listener {
+    name: string;
+    callback: (...args: any[]) => any;
+}
+export declare class EventEmitter {
+    protected _events: {
+        [k: string]: EventHandler[];
+    };
+    protected _removeEvent(list: EventHandler[], index: number, name: string): this;
+    clear(): this;
+    has(name: string): boolean;
+    on(name: string, callback: (...args: any[]) => any, target?: Object, once?: boolean): this;
+    off(name: string, callback: (...args: any[]) => any, target?: Object): this;
+    onof(name: string, callback: (...args: any[]) => any, container: Object & {
+        _listeners?: Listener[];
+    }): this;
+    offof(container: Object & {
+        _listeners?: Listener[];
+    }): this;
+    targetOff(target: Object): this;
+    emit(name: string, ...args: any[]): this;
+}
+export {};

package/types/base/Logger.d.ts

@@ -0,0 +1,11 @@
+export declare const Logger: {
+    debug: (message?: any, ...optionalParams: any[]) => void;
+    info: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+    isEnabled: boolean;
+    /** Turn on log */
+    enable(): void;
+    /** Turn off log */
+    disable(): void;
+};

package/types/base/index.d.ts

@@ -0,0 +1,3 @@
+export { EventEmitter } from "./EventEmitter";
+export { Logger } from "./Logger";
+export { mixin } from "./mixin";

package/types/base/mixin.d.ts

@@ -0,0 +1 @@
+export declare function mixin(derivedCtor: any, baseCtors: any[]): void;

package/types/cinestation/CinestationBlendDefinition.d.ts

@@ -0,0 +1,11 @@
+export declare const CinestationBlendStyle: {
+    Linear: (amount: number) => number;
+    QuadraticIn: (amount: number) => number;
+    QuadraticOut: (amount: number) => number;
+    QuadraticInOut: (amount: number) => number;
+};
+export type CinestationBlendStyle = typeof CinestationBlendStyle[keyof typeof CinestationBlendStyle];
+export declare class CinestationBlendDefinition {
+    style: CinestationBlendStyle;
+    time: number;
+}

package/types/cinestation/CinestationBrain.d.ts

@@ -0,0 +1,21 @@
+import { PerspectiveCamera } from "three";
+import { CinestationBlendDefinition } from "./CinestationBlendDefinition";
+import { VirtualCamera } from "./VirtualCamera";
+import { Component } from "../Component";
+export declare class CinestationBrain extends Component<PerspectiveCamera> {
+    private _vcam;
+    private _vcamSolo;
+    private _vcams;
+    private _lerpTime;
+    private _isChanged;
+    brainBlend: CinestationBlendDefinition;
+    onChanged: (v: boolean) => void;
+    get vcam(): VirtualCamera;
+    get vcams(): VirtualCamera[];
+    lastUpdate(dt: number): void;
+    activeCamera(vcam: VirtualCamera, time?: number): void;
+    addCamera(vcam: VirtualCamera): void;
+    removeCamera(vcam: VirtualCamera): void;
+    getActiveCamera(): VirtualCamera;
+    private _lerpToMainCamera;
+}

package/types/cinestation/FreelookVirtualCamera.d.ts

@@ -0,0 +1,63 @@
+import { Object3D, Quaternion, Spherical, Vector2, Vector3 } from "three";
+import { VirtualCamera } from "./VirtualCamera";
+export declare const VCamFreeLookMode: {
+    FREE: number;
+    TRANSLATE: number;
+};
+export type VCamFreeLookMode = typeof VCamFreeLookMode[keyof typeof VCamFreeLookMode];
+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 __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;
+    forbidX: boolean;
+    forbidY: boolean;
+    forbidZ: boolean;
+    forbidPanX: boolean;
+    forbidPanY: boolean;
+    forbitPanOffsetY: boolean;
+    rotateSpeed: 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>;
+    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;
+    private _onMouseWheel;
+    private _onTouchStart;
+    private _onTouchMove;
+    private _calculateDistanceScale;
+    private _calculateRotateDelta;
+    private _calculatePanDelta;
+    update(dt: number): void;
+}

package/types/cinestation/VirtualCamera.d.ts

@@ -0,0 +1,25 @@
+import { Object3D, Quaternion, Vector3 } from "three";
+import { Component } from "../Component";
+import { CinestationBrain } from "./CinestationBrain";
+export declare class VirtualCamera extends Component<Object3D & {
+    isCamera?: boolean;
+}> {
+    private _finalPosition;
+    private _finalRotation;
+    priority: number;
+    lookAt: Object3D | null;
+    follow: Object3D | null;
+    fov: number;
+    near: number;
+    far: number;
+    correctPosition: Vector3;
+    correctRotation: Quaternion;
+    lookaheadPosition: Vector3;
+    trackedObjectOffset: Vector3;
+    brain: CinestationBrain;
+    get finalPosition(): Vector3;
+    get finalRotation(): Quaternion;
+    onLoad(): void;
+    onDestroy(): void;
+    update(dt: number): void;
+}

package/types/cinestation/index.d.ts

@@ -0,0 +1,4 @@
+export { CinestationBrain } from "./CinestationBrain";
+export { CinestationBlendDefinition } from "./CinestationBlendDefinition";
+export { FreelookVirtualCamera } from "./FreelookVirtualCamera";
+export { VirtualCamera } from "./VirtualCamera";

package/types/enums/Orientation.d.ts

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

package/types/index.d.ts

@@ -1,3 +1,12 @@
-export { GUI } from "./gui/GUI";
-export { InspectorPlugin } from "./InspectorPlugin";
-export { StatsPlugin } from "./StatsPlugin";
+export * from "./types";
+export * from "./base";
+export * from "./tween";
+export * from "./loader";
+export * from "./cinestation";
+export * from "./primitives";
+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";

package/types/loader/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/aFBXLoader.d.ts

@@ -0,0 +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/aGLTFLoader.d.ts

@@ -0,0 +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/aHDRLoader.d.ts

@@ -0,0 +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/loader/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/aTextureLoader.d.ts

@@ -0,0 +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/index.d.ts

@@ -0,0 +1,6 @@
+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/material/getShaderMaterial.d.ts

@@ -0,0 +1,4 @@
+import { Color, CubeTexture, Matrix3, Matrix4, Quaternion, ShaderMaterial, Texture, Vector2, Vector3, Vector4 } from "three";
+export declare function getShaderMaterial(uniforms: {
+    [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;

package/types/material/glsl/boxfilterblur.glsl.d.ts

@@ -0,0 +1 @@
+export declare const frag_BoxfilterBlur = "\n#include <common>\nuniform sampler2D tLast;\nuniform sampler2D tBlur;\nuniform float\t  uLod;\nuniform float\t  uWeight;\nvarying vec2      vUv;\n\nvoid main() {\n\tvec3 col0 = textureLod(tLast, vUv, 0.).rgb;\n\tvec3 col1 = textureLod(tBlur, vUv, uLod).rgb;\n    gl_FragColor = vec4(mix(col0, col1, uWeight), 1.);\n}\n";

package/types/material/glsl/copy.glsl.d.ts

@@ -0,0 +1 @@
+export declare const frag_Copy = "\nvarying vec2      vUv;\nuniform sampler2D tMain;\nuniform float     uLod;\n\nvoid main() {\n    gl_FragColor = texture(tMain, vUv, uLod);\n\t#include <encodings_fragment>\n}\n";

package/types/material/glsl/fullscreen.glsl.d.ts

@@ -0,0 +1 @@
+export declare const vert_fullscreen = "\nvarying vec2 vUv;\nvoid main() {\n\tvUv = position.xy * 0.5 + 0.5;\n\tgl_Position = vec4(position.xy, 1.0, 1.0);\n}\n";

package/types/material/glsl/panorama.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const frag_panoramaToCubeMap = "\n#include <xv_common>\n\nvarying vec2      vUv;\nuniform sampler2D tMain;\nuniform int       uFace;\nuniform vec4      uTilingOffset;\n\nvec3 uvToXYZ(int face, vec2 uv) {\n    if (face == 0) return vec3(-1.0, uv.y, -uv.x);\n    else if (face == 1) return vec3(1.0, uv.y, uv.x);\n    else if (face == 2) return vec3(-uv.x, -1.0, uv.y);\n    else if (face == 3) return vec3(-uv.x, 1.0, -uv.y);\n    else if (face == 4) return vec3(-uv.x, uv.y, 1.0);\n    else return vec3(uv.x, uv.y, -1.0);\n}\n\nvec4 panoramaToCubeMap(int face, vec2 uv_i) {\n    vec2 uv = uv_i * 2.0 - 1.0;\n    vec3 dir = normalize(uvToXYZ(face, uv));\n    vec2 uv_o = dirToUv(dir);\n    uv_o = vec2(uv_o.x, uv_o.y) * uTilingOffset.xy + uTilingOffset.zw;\n    return texture(tMain, uv_o);\n}\n\nvoid main() {\n    gl_FragColor = panoramaToCubeMap(uFace, vUv);\n}\n";
+export declare const frag_cubeMapToPanorama = "\n#include <xv_common>\n\nvarying vec2        vUv;\nuniform samplerCube tMain;\n\nvec4 cubeMapToPanorama(vec2 uv_i) {\n    return texture(tMain, uvToDir(uv_i));\n}\n\nvoid main() {\n    gl_FragColor = cubeMapToPanorama(vUv);\n}\n";

package/types/math/AnimationCurve.d.ts

@@ -0,0 +1,23 @@
+declare class CurvePoint {
+    x: number;
+    y: number;
+    mode: number;
+    constructor(x?: number, y?: number, mode?: number);
+    set(x: number, y: number): this;
+    lerp(p: CurvePoint, t: number, out?: CurvePoint): CurvePoint;
+}
+export declare class AnimationCurve {
+    name: string;
+    points: CurvePoint[];
+    needsUpdate: boolean;
+    isAnimationCurve: boolean;
+    private _samples;
+    private _interpolant;
+    constructor(name?: string, points?: CurvePoint[]);
+    private _getInterpolant;
+    createCurvePoint(x?: number, y?: number, mode?: number): CurvePoint;
+    resample(samples?: number): void;
+    evaluate(t: number): any;
+    getPoint(t: number, out: CurvePoint): CurvePoint;
+}
+export {};

package/types/math/Constant.d.ts

@@ -0,0 +1,2 @@
+import { Vector3 } from "three";
+export declare const Vector3_ZERO: Vector3;

package/types/math/Damp.d.ts

@@ -0,0 +1,10 @@
+import { Quaternion, Vector3 } from "three";
+export declare function exponentialDamp(current: number, target: number, dampTime: number, deltaTime: number): number;
+export declare function quarticDamp(current: number, target: number, dampTime: number, deltaTime: number): number;
+export declare function smoothDamp(state: Object & {
+    _velocity?: number;
+}, current: number, target: number, smoothTime: number, maxSpeed: number, deltaTime: number): number;
+export declare function Quat_exponentialDamp(current: Quaternion, target: Quaternion, dampTime: number, deltaTime: number, out?: Quaternion): Quaternion;
+export declare function Quat_quarticDamp(current: Quaternion, target: Quaternion, dampTime: number, deltaTime: number, out?: Quaternion): Quaternion;
+export declare function Quat_smoothDamp(current: Quaternion, target: Quaternion, dampTime: number, deltaTime: number, out?: Quaternion): Quaternion;
+export declare function Vec3_smoothDamp(current: Vector3, target: Vector3, dampTime: number, deltaTime: number, out?: Vector3): Vector3;

package/types/math/Interpolation.d.ts

@@ -0,0 +1,9 @@
+import { Quaternion } from "three";
+export declare function VInterpTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
+export declare function VInterpConstantTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
+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 QInterpConstantTo(current: any, target: any, deltaTime: any, speed: any, out?: any): any;
+export declare function FInterpTo(current: any, target: any, deltaTime: any, speed: any): any;
+export declare function FInterpConstantTo(current: any, target: any, deltaTime: any, speed: any): any;

package/types/primitives/Box.d.ts

@@ -0,0 +1,4 @@
+import { BoxGeometry, Material, Mesh } from "three";
+export declare class Box<M extends Material | Material[] = Material | Material[]> extends Mesh<BoxGeometry, M> {
+    constructor(...args: ConstructorParameters<typeof BoxGeometry>);
+}

package/types/primitives/Plane.d.ts

@@ -0,0 +1,4 @@
+import { Material, Mesh, PlaneGeometry } from "three";
+export declare class Plane<M extends Material | Material[] = Material | Material[]> extends Mesh<PlaneGeometry, M> {
+    constructor(...args: ConstructorParameters<typeof PlaneGeometry>);
+}

package/types/primitives/Sphere.d.ts

@@ -0,0 +1,4 @@
+import { Material, Mesh, SphereGeometry } from "three";
+export declare class Sphere<M extends Material | Material[] = Material | Material[]> extends Mesh<SphereGeometry, M> {
+    constructor(...args: ConstructorParameters<typeof SphereGeometry>);
+}

package/types/primitives/index.d.ts

@@ -0,0 +1,3 @@
+export { Box } from "./Box";
+export { Sphere } from "./Sphere";
+export { Plane } from "./Plane";

package/types/tween/TweenChain.d.ts

@@ -0,0 +1,15 @@
+import { Group, Tween } from "./tween";
+export declare class TweenChain {
+    private _object;
+    private _tween;
+    private _chainedTween;
+    constructor(object: Object, group?: Group);
+    start(): this;
+    stop(): this;
+    repeat(times: any): this;
+    union(): this;
+    call(callback: any): this;
+    delay(amount: any): this;
+    to(properties: any, duration: any, props: any): this;
+    _chainTween(): Tween<Object>;
+}

package/types/tween/TweenManager.d.ts

@@ -0,0 +1,10 @@
+import { TweenChain } from "./TweenChain";
+import { Tween } from "./tween";
+export declare class TweenManager {
+    private _group;
+    destroy(): void;
+    update(time: number): void;
+    tween(target: Object): Tween<Object>;
+    timeline(target: Object): TweenChain;
+    killTweensOf(target: Object): void;
+}

package/types/tween/index.d.ts

@@ -0,0 +1,3 @@
+export { TweenChain } from "./TweenChain";
+export { TweenManager } from "./TweenManager";
+export { Tween } from "./tween";

package/types/types.d.ts

@@ -0,0 +1,54 @@
+import { Euler, Object3D, Vector3 } from "three";
+import { Component } from "./Component";
+export type __FunctionKeys<T> = {
+    [K in keyof T]-?: T[K] extends Function ? K : never;
+}[keyof T];
+export type __Properties<T> = Omit<Partial<T>, __FunctionKeys<T>> & {
+    [k: string]: any;
+};
+export type __C<T> = new (...args: any[]) => T;
+export type __P<T, K extends __C<T>> = __Properties<T> & {
+    /**
+     * Set contructor parameters of node
+     */
+    args?: ConstructorParameters<K>;
+    /**
+     * Set components of node
+     */
+    component?: Component | Component[];
+    /**
+     * Set parent node
+     */
+    parent?: Object3D;
+    /**
+     * Debug node
+     */
+    debug?: boolean;
+    /**
+     * Set as default camera, only valid for camera
+     */
+    makeDefault?: boolean;
+    /**
+     * Set shadow arguments, only valid for Directional Light
+     * @example ["top", "bottom", "left", "right", "near", "far", "bias", "width", "height"];
+     */
+    shadowArgs?: number[];
+    /**
+     * The object's local scale.
+     */
+    scale?: Vector3;
+    /**
+     * Object's local position.
+     */
+    position?: Vector3;
+    /**
+     * Object's local rotation
+     */
+    rotation?: Euler;
+};
+export type __Comp<T, K extends __C<T>> = __Properties<T> & {
+    /**
+     * Set contructor parameters of component
+     */
+    args?: ConstructorParameters<K>;
+};

package/types/InspectorPlugin.d.ts

@@ -1,22 +0,0 @@
-import { Plugin } from "@xviewer.js/core";
-type uuidObject = {
-    uuid: string;
-    name: string;
-    type: string;
-};
-export declare class InspectorPlugin extends Plugin {
-    static _getTargetName(target: uuidObject): string;
-    private _gui;
-    private _statesMap;
-    private _targetMap;
-    constructor();
-    onUpdate(dt: number): void;
-    private _initFolders;
-    private _initViewer;
-    private _updateFolders;
-    private _getPropertiesList;
-    inspect<T extends uuidObject>(target: T): T;
-    private _addPropsListGUI;
-    uninspect(target: uuidObject): void;
-}
-export {};

package/types/StatsPlugin.d.ts

@@ -1,10 +0,0 @@
-import { Plugin } from "@xviewer.js/core";
-export declare class StatsPlugin extends Plugin {
-    private _stats;
-    private _dcPanel;
-    private _triPanel;
-    private _texPanel;
-    private _prgPanel;
-    constructor();
-    onUpdate(dt: number): void;
-}