@xviewer.js/core 1.0.0-alpha.44 → 1.0.0-alpha.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.0-alpha.44",
+  "version": "1.0.0-alpha.46",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,

package/types/Viewer.d.ts

@@ -20,8 +20,17 @@ export declare class Viewer extends EventEmitter {
     static createFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes>;
     static findChild<T extends Object3D>(node: T, path: string): T;
     static getChildByName<T extends Object3D>(node: T, name: string): T;
-    static getObject<T extends Object3D>(node: T, filter: (value: T) => any): any;
-    static getObjects<T extends Object3D>(node: T, filter: (value: T) => any): any[];
+    static getObject<T extends Object3D>(node: T, filter: (value: T) => any, group?: boolean): any;
+    static __emtpyObject: {};
+    static _getObjectValue<T extends Object & {
+        name: string;
+    }>(object: any, name?: string, group?: boolean): T | T[];
+    static getMaterial<T extends Material>(node: Object3D): T[];
+    static getMaterial<T extends Material>(node: Object3D, name: string): T;
+    static getTexture<T extends Texture>(node: Object3D): T[];
+    static getTexture<T extends Texture>(node: Object3D, name: string): T;
+    static getMesh<T extends Mesh>(node: Object3D): T[];
+    static getMesh<T extends Mesh>(node: Object3D, name: string): T;
     static fullscreenMesh: Mesh;
     static fullscreenCamera: OrthographicCamera;
     private _root;
@@ -135,8 +144,8 @@ export declare class Viewer extends EventEmitter {
     addNode<T, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
     removeNode(node: Object3D): void;
     activeNode(node: Object3D, active: boolean): Object3D<import("three").Object3DEventMap>;
-    createRenderTarget(width: number, height: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean): WebGLRenderTarget<Texture>;
-    createCubeRenderTarget(size: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean): WebGLCubeRenderTarget;
+    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: BufferSource, width: number, height: number, floatType?: boolean, nearest?: boolean): DataTexture;
     /**
      * 传送门，得到一个全新的场景

package/types/asset/aLoader.d.ts

@@ -11,7 +11,7 @@ export interface LoadProperties {
 export declare abstract class aLoader {
     manager: ResourceManager;
     static _texKeys: string[];
-    static _setMeshData(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    static _setUserData(node: Object3D): Object3D<import("three").Object3DEventMap>;
     constructor(manager: ResourceManager);
     abstract extension: string[];
     abstract load(props: LoadProperties): void;

package/types/cinestation/FreelookVirtualCamera.d.ts

@@ -66,7 +66,7 @@ export declare class FreelookVirtualCamera extends VirtualCamera {
     private _calculatePanDelta;
     private _calculateTargetLookAt;
     private _calculateTargetSpringArm;
-    gotoPOI({ duration, easing, springLength, theta, phi, lookAt, fov, smoothing, rotateSmoothing, }: {
+    gotoPOI({ duration, easing, springLength, theta, phi, lookAt, fov, smoothing, rotateSmoothing }: {
         duration?: number;
         easing?: EasingFunction;
         springLength?: number;

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

@@ -1 +1,2 @@
 export { Reflector } from "./Reflector";
+export { PerformanceMonitor } from "./PerformanceMonitor";

package/types/plugins/EnvironmentPlugin.d.ts

@@ -13,12 +13,14 @@ export declare class EnvironmentPlugin extends Plugin {
     private _mergeInfo;
     private _debug;
     private _debugNode;
+    private _elapsed;
     get debug(): boolean;
     set debug(v: boolean);
     performance: number;
     envMapIntensity: number;
     reflectExposure: number;
     reflectBlurIntensity: number;
+    interval: number;
     constructor({ envMap, scene, near, far, layer, resolution, floatType, position, }?: {
         envMap?: Texture;
         scene?: Scene | Object3D;
@@ -30,5 +32,6 @@ export declare class EnvironmentPlugin extends Plugin {
         floatType?: boolean | TextureDataType;
         position?: Vector3;
     });
-    onRender(): void;
+    onRender(dt: number): void;
+    private _renderFrame;
 }