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

package/package.json

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

package/types/Component.d.ts

@@ -28,7 +28,6 @@ export declare class Component<T extends Object3D = Object3D> extends ObjectInst
         onEnableCalled?: boolean;
         startCalled?: boolean;
         deActivating?: boolean;
-        isStartCalled?: boolean;
     };
     get enabled(): boolean;
     set enabled(v: boolean);

package/types/DeviceInput.d.ts

@@ -7,6 +7,15 @@ export interface InputTarget {
     removeEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     addEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
 }
+export interface InputOption {
+    source: HTMLElement | Document;
+    normalizeWheel?: (e: WheelEvent) => {
+        spinX: number;
+        spinY: number;
+        pixelX: number;
+        pixelY: number;
+    };
+}
 export declare class DeviceInput extends Component {
     static readonly CLICK = "click";
     static readonly MOUSE_WHEEL = "mousewheel";
@@ -22,14 +31,18 @@ export declare class DeviceInput extends Component {
     static readonly KEYPRESS = "keypress";
     static readonly KEYUP = "keyup";
     private _target;
+    private _normalizeWheel;
     private _listeners;
     private _touches;
     private _touchCount;
+    private _touchStart;
+    private _touchMoving;
     private _pointer;
     private _pointerPixel;
     private _pointerButton;
     private _prePointer;
     private _prePointerPixel;
+    private _preTouches;
     private _mouseWheel;
     private _keys;
     private _pressability;
@@ -38,7 +51,13 @@ export declare class DeviceInput extends Component {
     get pointerButton(): number;
     get prePointer(): Vector2;
     get prePointerPixel(): Vector2;
+    get preTouches(): {
+        id: number;
+        position: Vector2;
+    }[];
     get mouseWheel(): number;
+    get touchStart(): boolean;
+    get touchMoving(): boolean;
     get touchCount(): number;
     get touches(): {
         id: number;
@@ -47,7 +66,7 @@ export declare class DeviceInput extends Component {
     get keys(): {
         [k: string]: boolean;
     };
-    constructor(target: HTMLElement | Document);
+    constructor(option: InputOption);
     onEnable(): void;
     onDisable(): void;
     lastUpdate(dt: number): void;

package/types/Viewer.d.ts

@@ -1,7 +1,7 @@
 import { BufferGeometry, Camera, Color, ColorRepresentation, ColorSpace, DataTexture, LoadingManager, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, ShaderMaterial, ShadowMapType, Texture, TextureDataType, ToneMapping, Vector3, WebGLCubeRenderTarget, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget } from "three";
 import { EventEmitter } from "./base";
 import { ComponentManager } from "./ComponentManager";
-import { DeviceInput } from "./DeviceInput";
+import { DeviceInput, InputOption } from "./DeviceInput";
 import { Orientation, ResizeMode } from "./enums";
 import { AssetProperties, LoaderConstructor } from "./asset/ResourceManager";
 import { __C, __P, __Properties } from "./types";
@@ -66,13 +66,13 @@ export declare class Viewer extends EventEmitter {
     get scene(): Scene;
     get camera(): Camera;
     get renderer(): WebGLRenderer;
-    constructor({ root, canvas, input, shadows, sortObjects, resize, orthographic, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, orientation, loader, tasker, ...webglOpts }?: {
+    constructor({ root, canvas, input, shadows, sortObjects, resize, orthographic, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, transcoderPath, orientation, loader, tasker, ...webglOpts }?: {
         /** 根节点，用于屏幕旋转 */
         root?: HTMLElement;
         /** 渲染用的 canvas 元素，如果不提供，默认获取 id 为 "canvas" 的元素 */
         canvas?: HTMLCanvasElement;
         /** 设备输入容器，默认使用canvas */
-        input?: HTMLElement | Document;
+        input?: InputOption;
         /** 是否开启阴影或阴影类型，true/false 表示默认 PCFSoftShadowMap */
         shadows?: boolean | ShadowMapType;
         /** 渲染是否开启排序，默认 True */
@@ -97,6 +97,8 @@ export declare class Viewer extends EventEmitter {
         resourcePath?: string;
         /** Draco 压缩解码器路径，默认 Google CDN 地址 */
         dracoPath?: string;
+        /** The WASM transcoder and JS wrapper are available from the examples/jsm/libs/basis directory. */
+        transcoderPath?: string;
         /** 页面方向，AUTO: 自动，LANDSCAPE: 横屏，PORTRAIT: 竖屏 */
         orientation?: Orientation;
         /** Creates an orthographic camera */
@@ -141,6 +143,7 @@ export declare class Viewer extends EventEmitter {
     blit(renderTarget: WebGLRenderTarget, material: Material, lod?: number, face?: number): void;
     copy(src: WebGLRenderTarget | Texture, dest: WebGLRenderTarget): void;
     clearColor(renderTarget: WebGLRenderTarget, color: ColorRepresentation, alpha?: number): void;
+    stash(renderTarget: WebGLRenderTarget | null, callback: (renderer: WebGLRenderer) => void, clearColor?: ColorRepresentation, clearAlpha?: number): void;
     blur(blurLevel: number, shadingScale: number, inputBuffer: WebGLRenderTarget, tempBuffer: WebGLRenderTarget, outputBuffer?: WebGLRenderTarget, fixedOutput?: boolean): void;
     render(renderTarget: WebGLRenderTarget | null, node: Object3D, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number): void;
     compile(target?: Object3D | Scene | Material | Texture): void;
@@ -159,7 +162,7 @@ export declare class Viewer extends EventEmitter {
     static Copy(renderer: WebGLRenderer, src: WebGLRenderTarget | Texture, dest: WebGLRenderTarget): void;
     static ClearColor(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, clearColor: ColorRepresentation, clearAlpha?: number): void;
     static Render(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, node: Object3D, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number): void;
-    static Stash(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, callback: () => void, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    static Stash(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, callback: (renderer: WebGLRenderer) => void, clearColor?: ColorRepresentation, clearAlpha?: number): void;
     static CreateFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
 }
 export {};

package/types/asset/Loader.d.ts

@@ -8,6 +8,7 @@ export interface LoadProperties {
     path?: string;
     resourcePath?: string;
     dracoPath?: string;
+    transcoderPath?: string;
     manager?: LoadingManager;
     onLoad: (asset: any) => void;
     onProgress?: (event: ProgressEvent) => void;

package/types/asset/ResourceManager.d.ts

@@ -10,6 +10,7 @@ export interface AssetProperties extends TextureSettings {
     path?: string;
     resourcePath?: string;
     dracoPath?: string;
+    transcoderPath?: string;
     manager?: LoadingManager;
     onProgress?: (event: ProgressEvent) => void;
 }
@@ -27,5 +28,5 @@ export declare class ResourceManager {
     destroy(): void;
     getLoader(ext: string): Loader;
     addLoader(Loader: LoaderConstructor): Loader;
-    loadAsset<T = any>({ url, buffer, ext, path, resourcePath, dracoPath, manager, onProgress, ...props }: AssetProperties): Promise<T>;
+    loadAsset<T = any>({ url, ext, onProgress, ...props }: AssetProperties): Promise<T>;
 }

package/types/bmfont/BMFontAtlas.d.ts

@@ -0,0 +1,44 @@
+import { Color, ShaderMaterial, ShaderMaterialParameters, Texture, Vector2 } from "three";
+import { BMFontInfo, BMFontTextLayout, LayoutSetting } from "./BMFontTextLayout";
+export declare class BMFontAtlas {
+    info: BMFontInfo;
+    material: ShaderMaterial;
+    uniforms: {
+        u_color: {
+            value: Color;
+        };
+        u_opacity: {
+            value: number;
+        };
+        u_weight: {
+            value: number;
+        };
+        u_strokeColor: {
+            value: Color;
+        };
+        u_strokeWidth: {
+            value: number;
+        };
+        u_shadowColor: {
+            value: Color;
+        };
+        u_shadowBlur: {
+            value: number;
+        };
+        u_shadowOffset: {
+            value: Vector2;
+        };
+        u_fontTexture: {
+            value: any;
+        };
+    };
+    constructor({ info, texture, uniforms, ...props }: {
+        info: BMFontInfo;
+        texture: Texture;
+    } & ShaderMaterialParameters);
+    build(layout: BMFontTextLayout, setting: LayoutSetting): {
+        position: Float32Array<ArrayBuffer>;
+        uv: Float32Array<ArrayBuffer>;
+        indice: Uint16Array<ArrayBuffer>;
+    };
+}

package/types/bmfont/BMFontTextGeometry.d.ts

@@ -0,0 +1,9 @@
+import { BufferGeometry } from "three";
+import { BMFontAtlas } from "./BMFontAtlas";
+import { LayoutSetting, BMFontTextLayout } from "./BMFontTextLayout";
+export declare class BMFontTextGeometry extends BufferGeometry {
+    layout: BMFontTextLayout;
+    update(fontAtlas: BMFontAtlas, text: string, setting: LayoutSetting): void;
+    computeBoundingSphere(): void;
+    computeBoundingBox(): void;
+}

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

@@ -10,3 +10,4 @@ export { Environment } from "./Environment";
 export { BoxProjection } from "./BoxProjection";
 export { PerformanceMonitor } from "./PerformanceMonitor";
 export { DropFile } from "./DropFile";
+export { Label } from "./Label";

package/types/index.d.ts

@@ -7,6 +7,7 @@ export * from "./components";
 export * from "./materials";
 export * from "./Utils";
 export * from "./enums";
+export * from "./bmfont";
 export { Viewer } from "./Viewer";
 export { Task } from "./Task";
 export { Component } from "./Component";

package/types/loaders/KTX2Loader.d.ts

@@ -1,6 +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;
+    load({ url, path, resourcePath, transcoderPath, manager, texSettings, onLoad, onProgress, onError }: LoadProperties): void;
     private _loader;
 }

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;
@@ -17,8 +17,12 @@ export declare class ReflectorMaterial extends ShaderMaterial {
         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;
@@ -31,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;