@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/io/OutlineManager.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from "../core/entities/Object3D";
+import { Color } from "../math/Color";
+export declare class OutlinePostManager {
+    private _tempIndexArray;
+    setOutline(objectList: Object3D[], color?: Color): void;
+    setOutlineList(groupList: Object3D[][], colorList?: Color[]): void;
+    clearOutline(): this;
+    private _rendererList;
+    private getEntityIdList;
+}
+export declare let outlinePostManager: OutlinePostManager;

package/dist/types/io/OutlinePostData.d.ts

@@ -0,0 +1,22 @@
+import { Color } from "../math/Color";
+export declare class OutlinePostSlot {
+    indexList: Float32Array;
+    color: Color;
+    count: number;
+}
+export declare class OutlinePostData {
+    readonly SlotCount: number;
+    readonly MaxEntities: number;
+    readonly defaultColor: Color;
+    private readonly slots;
+    private dataDirty;
+    constructor();
+    clear(): void;
+    clearAt(slotIndex: number): this;
+    fillDataAt(slot: number, indexList: number[], color: Color): this;
+    fetchData(target: {
+        dirty: boolean;
+        slots: OutlinePostSlot[];
+    }): this;
+}
+export declare let outlinePostData: OutlinePostData;

package/dist/types/io/PickFire.d.ts

@@ -0,0 +1,32 @@
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { Ray } from "../math/Ray";
+import { ColliderComponent } from "../components/ColliderComponent";
+import { View3D } from "../core/View3D";
+export declare class PickFire extends CEventDispatcher {
+    ray: Ray;
+    isTouching: boolean;
+    private _mouseCode;
+    private _pickEvent;
+    private _outEvent;
+    private _overEvent;
+    private _upEvent;
+    private _downEvent;
+    private _mouseMove;
+    private _pickCompute;
+    private _lastDownTarget;
+    mouseEnableMap: Map<number, ColliderComponent>;
+    private _view;
+    constructor(view: View3D);
+    private init;
+    start(): void;
+    stop(): void;
+    private onTouchStart;
+    private onTouchEnd;
+    private _lastFocus;
+    private getPickInfo;
+    private onTouchMove;
+    private onTouchOnce;
+    private findNearestObj;
+    private _interestList;
+    private pick;
+}

package/dist/types/io/PickResult.d.ts

@@ -0,0 +1,59 @@
+import { Color } from "../math/Color";
+import { Triangle } from "../math/Triangle";
+import { Vector2 } from "../math/Vector2";
+import { Vector3 } from "../math/Vector3";
+/**
+ * 拾取结果信息，包含目标Object3D、位置、UV等数据
+ * @internal   // 内部使用
+ * @group IO   // 属于IO组
+ */
+export declare class PickResult {
+    /**
+     * 模型上的相交点(局部坐标系)
+     */
+    localPosition: Vector3;
+    /**
+     * 模型上的相交点(世界坐标系)
+     */
+    worldPosition: Vector3;
+    /**
+     * 模型上的UV坐标
+     * 只有当对象的PickType为UVPick且模型有UV时才有效
+     * @see PickType
+     */
+    uv: Vector2;
+    /**
+     * 网格相交位置的三角形索引
+     */
+    faceIndex: number;
+    isIn: boolean;
+    t: number;
+    u: number;
+    v: number;
+    /**
+     * 网格相交位置的三角形数据
+     */
+    triangle: Triangle;
+    /**
+     * @internal
+     * 网格相交位置的uv0坐标
+     */
+    v0: number;
+    /**
+     * @internal
+     * 网格相交位置的uv1坐标
+     */
+    v1: number;
+    /**
+     * @internal
+     */
+    v2: number;
+    /**
+     * @internal
+     */
+    pickList: any;
+    /**
+     * @internal
+     */
+    color: Color;
+}

package/dist/types/io/RayCastMeshDetail.d.ts

@@ -0,0 +1,32 @@
+import { Triangle } from "../math/Triangle";
+import { Ray } from "../math/Ray";
+import { Vector3 } from "../math/Vector3";
+import { PickResult } from "./PickResult";
+/**
+ * @internal
+ * @group IO
+ */
+export declare class RayCastMeshDetail {
+    /**
+     * 取一个最小值
+     */
+    static EPS: number;
+    /**
+     * 定义一个极大值
+     */
+    static FLT_MAX: number;
+    /**
+     * 计算点与平面(由三点a、b、c定义)之间的距离
+     * @param p 测试点
+     * @param a 三角形顶点A
+     * @param b 三角形顶点B
+     * @param c 三角形顶点C
+     * @returns 点到平面的距离
+     */
+    static distPtTri(p: Vector3, a: Vector3, b: Vector3, c: Vector3): number;
+    private static _info;
+    static IntersectTriangle(ray: Ray, face: Triangle, backfaceCulling: boolean): PickResult;
+    private static _u0;
+    private static _u1;
+    private static _u2;
+}

package/dist/types/io/TouchData.d.ts

@@ -0,0 +1,12 @@
+export declare class TouchData {
+    constructor(touch: Touch);
+    canvasX: number;
+    canvasY: number;
+    identifier: number;
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+}

package/dist/types/io/picker/PickCompute.d.ts

@@ -0,0 +1,14 @@
+import { View3D } from "../../core/View3D";
+import { Vector2 } from "../../math/Vector2";
+import { Vector3 } from "../../math/Vector3";
+export declare class PickCompute {
+    private _computeShader;
+    private _outBuffer;
+    constructor();
+    init(): void;
+    compute(view: View3D): void;
+    getPickMeshID(): number;
+    getPickWorldPosition(target?: Vector3): Vector3;
+    getPickWorldNormal(target?: Vector3): Vector3;
+    getPickScreenUV(target?: Vector2): Vector2;
+}

package/dist/types/loader/FileLoader.d.ts

@@ -0,0 +1,7 @@
+import { LoaderBase } from "./LoaderBase";
+import { LoaderFunctions } from "./LoaderFunctions";
+import { ParserBase } from "./parser/ParserBase";
+import { Parser } from "../util/Global";
+export declare class FileLoader extends LoaderBase {
+    load<T extends ParserBase>(url: string, c: Parser<T>, loaderFunctions?: LoaderFunctions, userData?: any): Promise<T>;
+}

package/dist/types/loader/LoaderBase.d.ts

@@ -0,0 +1,30 @@
+import { BitmapTexture2D } from "../textures/BitmapTexture2D";
+import { LoaderFunctions } from "./LoaderFunctions";
+export declare class LoaderBase {
+    baseUrl: string;
+    initUrl: string;
+    private _progress;
+    constructor();
+    /**
+     * @private
+     */
+    loadBinData(url: string, loaderFunctions?: LoaderFunctions): Promise<any>;
+    /**
+     *
+     * @private
+     */
+    loadAsyncBitmapTexture(url: string, loaderFunctions?: LoaderFunctions): Promise<BitmapTexture2D>;
+    /**
+     *
+     * @private
+     */
+    loadJson(url: string, loaderFunctions?: LoaderFunctions): Promise<object>;
+    /**
+     * @private
+     */
+    loadTxt(url: string, loaderFunctions?: LoaderFunctions): Promise<object>;
+    /**
+     * @private
+     */
+    static read(url: string, response: any, loaderFunctions?: LoaderFunctions): Promise<Uint8Array>;
+}

package/dist/types/loader/LoaderFunctions.d.ts

@@ -0,0 +1,7 @@
+export type LoaderFunctions = {
+    onProgress?: Function;
+    onComplete?: Function;
+    onError?: Function;
+    onUrl?: Function;
+    headers?: {};
+};

package/dist/types/loader/LoaderManager.d.ts

@@ -0,0 +1,36 @@
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { ParserBase } from "./parser/ParserBase";
+/**
+ * @internal
+ * 加载管理
+ * @group Loader
+ */
+export declare class LoaderManager extends CEventDispatcher {
+    private static _instance;
+    private _maxRetry;
+    /**
+     * 同时加载多个同类型资源
+     * @param urls 资源URL列表
+     * @param c 资源解析器类型
+     * @returns 返回解析器数组的Promise
+     */
+    loadAll<T extends ParserBase>(urls: string[], c: {
+        new (): T;
+    }): Promise<T[]>;
+    constructor();
+    static getInstance(): LoaderManager;
+    /**
+     * 加载多个URL资源
+     * @param urls 资源URL列表
+     * @param c 资源解析器类型
+     * @returns 返回解析器数组的Promise
+     */
+    loadUrls(urls: string[], c: {
+        new (): ParserBase;
+    }): Promise<ParserBase[]>;
+    get maxRetry(): number;
+    set maxRetry(value: number);
+    load<T extends ParserBase>(url: string, c: {
+        new (): T;
+    }): Promise<T>;
+}

package/dist/types/loader/parser/3dgs/GaussianSplatAsset.d.ts

@@ -0,0 +1,21 @@
+export type SHEncoding = {
+    order: number;
+    coeffs: Float32Array;
+};
+export type GaussianSplatAsset = {
+    count: number;
+    position: Float32Array;
+    rotation?: Float32Array;
+    scale?: Float32Array;
+    opacity?: Float32Array;
+    sh?: SHEncoding;
+    bbox?: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    meta?: Record<string, any>;
+};
+export declare function computeAABBFromPositions(position: Float32Array): {
+    min: [number, number, number];
+    max: [number, number, number];
+};

package/dist/types/loader/parser/3dgs/GaussianSplatParser.d.ts

@@ -0,0 +1,8 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { GaussianSplatAsset } from "./GaussianSplatAsset";
+export declare class GaussianSplatParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): Promise<GaussianSplatAsset>;
+    verification(): boolean;
+}

package/dist/types/loader/parser/3dgs/loaders/FormatDetector.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Gaussian Splatting file format types
+ */
+export declare enum GSplatFormat {
+    PLY = "ply",
+    SPLAT = "splat",
+    KSPLAT = "ksplat",
+    UNKNOWN = "unknown"
+}
+/**
+ * Detect Gaussian Splatting file format from buffer
+ */
+export declare function detectGSplatFormat(buffer: ArrayBuffer): GSplatFormat;

package/dist/types/loader/parser/3dgs/loaders/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Gaussian Splatting file format loaders
+ *
+ * This module provides loaders for various Gaussian Splatting file formats:
+ * - PLY: Standard Point Cloud Library format (currently supported)
+ * - SPLAT: Custom binary format (TODO)
+ * - KSPLAT: Compressed format (TODO)
+ */
+export * from './FormatDetector';
+export * from './ply';

package/dist/types/loader/parser/3dgs/loaders/ply/PlyLoader.d.ts

@@ -0,0 +1,9 @@
+import { PlyHeader, PlyGaussianSplatData } from './PlyTypes';
+/**
+ * Parse PLY header from buffer
+ */
+export declare function parsePlyHeader(buffer: ArrayBuffer): PlyHeader;
+/**
+ * Parse PLY binary data for Gaussian Splatting
+ */
+export declare function parsePlyGaussianSplat(buffer: ArrayBuffer): PlyGaussianSplatData;

package/dist/types/loader/parser/3dgs/loaders/ply/PlyTypes.d.ts

@@ -0,0 +1,30 @@
+/**
+ * PLY property definition
+ */
+export type PlyProperty = {
+    name: string;
+    type: string;
+};
+/**
+ * PLY header information
+ */
+export type PlyHeader = {
+    format: string;
+    vertexCount: number;
+    properties: PlyProperty[];
+    headerByteLength: number;
+};
+/**
+ * Parsed PLY data for Gaussian Splatting
+ */
+export type PlyGaussianSplatData = {
+    vertexCount: number;
+    position: Float32Array;
+    scale?: Float32Array;
+    rotation?: Float32Array;
+    opacity?: Float32Array;
+    sh?: {
+        order: number;
+        coeffs: Float32Array;
+    };
+};

package/dist/types/loader/parser/3dgs/loaders/ply/PlyUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get byte size for PLY data type
+ */
+export declare function byteSizeOfType(t: string): number;
+/**
+ * Read value from DataView by PLY type
+ */
+export declare function readByType(view: DataView, offset: number, type: string): number;
+/**
+ * Infer Spherical Harmonics order from coefficients per color
+ * coeffsPerColor = (order+1)^2
+ */
+export declare function inferSHOrder(coeffsPerColor: number): number;

package/dist/types/loader/parser/3dgs/loaders/ply/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PLY Loader for Gaussian Splatting
+ *
+ * This module provides utilities to parse PLY files containing Gaussian Splat data.
+ */
+export * from './PlyTypes';
+export * from './PlyUtils';
+export * from './PlyLoader';

package/dist/types/loader/parser/AtlasParser.d.ts

@@ -0,0 +1,10 @@
+import { ParserBase } from "../../loader/parser/ParserBase";
+import { ParserFormat } from "./ParserFormat";
+export declare class AtlasParser extends ParserBase {
+    static format: ParserFormat;
+    private _json;
+    private _texture;
+    parseString(data: string): Promise<void>;
+    verification(): boolean;
+    private parseAtlas;
+}

package/dist/types/loader/parser/B3DMParser.d.ts

@@ -0,0 +1,24 @@
+import { Object3D } from "../../core/entities/Object3D";
+import { ParserBase } from "./ParserBase";
+import { ParserFormat } from "./ParserFormat";
+export declare class B3DMParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    verification(): boolean;
+}
+export declare class GLTFBinaryExtension {
+    name: string;
+    content: string;
+    body: ArrayBuffer;
+    header: {
+        magic: string;
+        length: number;
+        version: number;
+    };
+    constructor(data: ArrayBuffer);
+}
+export declare class B3DMParseUtil {
+    private _binary;
+    parseBinary(bytes: ArrayBuffer): Promise<Object3D>;
+    private parseGLB;
+}

package/dist/types/loader/parser/FontParser.d.ts

@@ -0,0 +1,54 @@
+import { GUITexture } from "../../components/gui/core/GUITexture";
+import { ParserBase } from "./ParserBase";
+import { ParserFormat } from "./ParserFormat";
+export declare class FontInfo {
+    face: string;
+    size: number;
+    bold: boolean;
+    italic: boolean;
+    stretchH: number;
+    spacing: string;
+    outline: number;
+    lineHeight: number;
+    base: number;
+    scaleW: number;
+    scaleH: number;
+    pages: number;
+    packed: number;
+    alphaChnl: number;
+    redChnl: number;
+    greenChnl: number;
+    blueChnl: number;
+    count: number;
+    fontPage: FontPage[];
+    fontChar: {
+        [key: string]: FontChar;
+    };
+    constructor();
+}
+export declare class FontPage {
+    id: number;
+    file: string;
+}
+export declare class FontChar {
+    id: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    page: number;
+    chnl: number;
+}
+export declare class FontParser extends ParserBase {
+    static format: ParserFormat;
+    static parseSprite(guiTexture: GUITexture[], fontData: FontInfo): void;
+    verification(): boolean;
+    parseString(data: string): Promise<void>;
+    private getNewLine;
+    private loadFontTextures;
+    private static insertSpaceChar;
+    private static readLineProperty;
+}

package/dist/types/loader/parser/I3DMParser.d.ts

@@ -0,0 +1,7 @@
+import { ParserBase } from "./ParserBase";
+import { ParserFormat } from "./ParserFormat";
+export declare class I3DMParser extends ParserBase {
+    static format: ParserFormat;
+    parseBuffer(buffer: ArrayBuffer): Promise<void>;
+    verification(): boolean;
+}

package/dist/types/loader/parser/OBJParser.d.ts

@@ -0,0 +1,72 @@
+import { ParserBase } from "./ParserBase";
+import { ParserFormat } from "./ParserFormat";
+type MatData = {
+    name?: string;
+    Kd?: string[];
+    Ks?: string[];
+    Tr?: string;
+    d?: string[];
+    Tf?: string[];
+    Pr?: string;
+    Pm?: string;
+    Pc?: string;
+    Pcr?: string;
+    Ni?: string;
+    Kr?: string[];
+    illum?: string;
+    map_Kd?: string;
+    textures?: string[];
+};
+type GeometryData = {
+    name: string;
+    type: string;
+    vertex_arr?: number[];
+    normal_arr?: number[];
+    uv_arr?: number[];
+    indeice_arr?: number[];
+    index?: number;
+    source_mat: string;
+    source_faces: Face[];
+};
+type Face = {
+    indices: string[];
+    texture: string[];
+    normal: string[];
+};
+export declare class OBJParser extends ParserBase {
+    static format: ParserFormat;
+    private textData;
+    private source_vertices;
+    private source_normals;
+    private source_tangents;
+    private source_textureCoords;
+    matLibs: {
+        [name: string]: MatData;
+    };
+    geometrys: {
+        [name: string]: GeometryData;
+    };
+    private activeGeo;
+    facesMaterialsIndex: {
+        materialName: string;
+        materialStartIndex: number;
+    }[];
+    mtl: string;
+    mtlUrl: string;
+    parseString(obj: string): Promise<string>;
+    private applyVector2;
+    private applyVector3;
+    private applyVector4;
+    private loadMTL;
+    private load_textures;
+    private parserLine;
+    private parserOBJ;
+    private parser_mesh;
+    /**
+     * Verify parsing validity
+     * @param ret
+     * @returns
+     */
+    verification(): boolean;
+}
+export {};

package/dist/types/loader/parser/ParserBase.d.ts

@@ -0,0 +1,18 @@
+import { Texture } from "../../gfx/graphics/webGpu/core/texture/Texture";
+import { LoaderFunctions } from "../LoaderFunctions";
+import { ParserFormat } from "./ParserFormat";
+export declare class ParserBase {
+    static format: ParserFormat;
+    baseUrl: string;
+    initUrl: string;
+    loaderFunctions?: LoaderFunctions;
+    userData?: any;
+    data: any;
+    parseString(str: string): void;
+    parseJson(obj: object): void;
+    parseBuffer(buffer: ArrayBuffer): void;
+    parseTexture(buffer: ArrayBuffer): Texture;
+    parse(data: any): void;
+    verification(ret: void): boolean;
+    protected parserError(info: string, id: number): void;
+}

package/dist/types/loader/parser/ParserFormat.d.ts

@@ -0,0 +1,5 @@
+export declare enum ParserFormat {
+    TEXT = 0,
+    BIN = 1,
+    JSON = 2
+}

package/dist/types/loader/parser/RGBEParser.d.ts

@@ -0,0 +1,40 @@
+import { Texture } from "../../gfx/graphics/webGpu/core/texture/Texture";
+import { HDRTexture } from "../../textures/HDRTexture";
+import { HDRTextureCube } from "../../textures/HDRTextureCube";
+import { ParserBase } from "./ParserBase";
+export declare enum RGBEErrorCode {
+    RGBE_RETURN_FAILURE = -1,
+    rgbe_read_error = 1,
+    rgbe_write_error = 2,
+    rgbe_format_error = 3,
+    rgbe_memory_error = 4
+}
+export declare class RGBEHeader {
+    valid: number;
+    string: string;
+    comments: string;
+    programtype: string;
+    format: string;
+    gamma: number;
+    exposure: number;
+    width: number;
+    height: number;
+}
+export declare class RGBEParser extends ParserBase {
+    private _rgbeArray;
+    private _width;
+    private _height;
+    private _RGBE_RETURN_FAILURE;
+    private _parserType;
+    parseBuffer(buffer: ArrayBuffer): Texture;
+    verification(): boolean;
+    getTexture(): Texture;
+    getCubeTexture(): HDRTextureCube;
+    getHDRTexture(): HDRTexture;
+    protected parseError(rgbe_error_code: any, msg: any): RGBEErrorCode;
+    protected parserBlock(buffer: Uint8Array, lineLimit?: number, consume?: boolean): string | false;
+    protected paserHeader(buffer: Uint8Array): RGBEHeader | number;
+    protected parserPixel(buffer: any, w: any, h: any): Uint8Array<any> | RGBEErrorCode;
+    protected rbgeToFloat(sourceArray: any, sourceOffset: any, destArray: any, destOffset: any): void;
+    protected rbgeToHalfFloat(sourceArray: any, sourceOffset: any, destArray: any, destOffset: any): void;
+}

package/dist/types/loader/parser/b3dm/B3DMLoader.d.ts

@@ -0,0 +1,10 @@
+import { B3DMLoaderBase } from "./B3DMLoaderBase";
+import { Matrix4 } from "../../../math/Matrix4";
+export declare class B3DMLoader extends B3DMLoaderBase {
+    adjustmentTransform: Matrix4;
+    private gltfBuffer;
+    private static tempMatrix;
+    constructor();
+    parse(buffer: ArrayBuffer): Promise<any>;
+    static decodeText(array: any): string;
+}

package/dist/types/loader/parser/b3dm/B3DMLoaderBase.d.ts

@@ -0,0 +1,9 @@
+import { FeatureTable, BatchTable } from "./FeatureTable";
+export declare class B3DMLoaderBase {
+    parse(buffer: ArrayBuffer): Promise<{
+        version: number;
+        featureTable: FeatureTable;
+        batchTable: BatchTable;
+        glbBytes: Uint8Array<ArrayBuffer>;
+    }>;
+}

package/dist/types/loader/parser/b3dm/FeatureTable.d.ts

@@ -0,0 +1,14 @@
+export declare class FeatureTable {
+    private buffer;
+    private binOffset;
+    private binLength;
+    private header;
+    constructor(buffer: any, start: any, headerLength: any, binLength: any);
+    getKeys(): string[];
+    getData(key: any, count?: any, defaultComponentType?: any, defaultType?: any): any;
+}
+export declare class BatchTable extends FeatureTable {
+    private batchSize;
+    constructor(buffer: any, batchSize: any, start: any, headerLength: any, binLength: any);
+    getData(key: any, componentType?: any, type?: any): any;
+}