@xviewer.js/core 1.0.1 → 1.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.1",
+  "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/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 getChildren<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;
@@ -52,7 +56,6 @@ export declare class Viewer extends EventEmitter {
     private _resourceManager;
     private _componentManager;
     private _loadingManager;
-    private _tweens;
     get root(): HTMLElement;
     get container(): HTMLElement;
     get time(): number;
@@ -128,14 +131,13 @@ export declare class Viewer extends EventEmitter {
     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/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/index.d.ts

@@ -1,3 +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/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 {};

package/types/types.d.ts

@@ -7,7 +7,25 @@ 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> & {
+export type __E = {
+    /**
+ * The object's local scale.
+ */
+    scale?: Vector3;
+    /**
+     * Object's local position.
+     */
+    position?: Vector3;
+    /**
+     * Object's local rotation
+     */
+    rotation?: Euler;
+    /**
+     * Object's layer mask
+     */
+    layer?: number;
+};
+export type __P<T, K extends __C<T>> = __Properties<T> & __E & {
     /**
      * Target node for component
      */
@@ -37,22 +55,6 @@ export type __P<T, K extends __C<T>> = __Properties<T> & {
      * @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;
-    /**
-     * Object's layer mask
-     */
-    layer?: number;
 };
 export type __Comp<T, K extends __C<T>> = __Properties<T> & {
     /**
@@ -60,3 +62,4 @@ export type __Comp<T, K extends __C<T>> = __Properties<T> & {
      */
     args?: ConstructorParameters<K>;
 };
+export type ConstructorRepresentation<T = any> = new (...args: any[]) => T;