@realsee/five-webgpu 1.0.0-alpha.1

package/five/utils/subscribe.d.ts

@@ -0,0 +1,67 @@
+type SubscribeEventMap = {
+    [name: string]: (...args: any[]) => void | boolean;
+};
+/**
+ * 监听者模式
+ * @template T - 预设的监听回调类型
+ * @example
+ * ```
+ * new Subscribe<{
+ * "foo": [arg1: number, arg2: string],
+ * "bar": [arg: boolean],
+ * }>()
+ * ```
+ */
+declare class Subscribe<T extends SubscribeEventMap> {
+    /**
+     * 判断是否注册了事件
+     * @param name - 事件类型
+     */
+    hasListener(name: keyof T): boolean;
+    /**
+     * 注册事件
+     * @param name - 事件类型
+     * @param callback - 事件回调函数
+     * @param once - 是否只执行一次
+     * @returns 解除事件
+     * @template K - 预设的监听事件名称
+     * @template C - 回调函数函数上下文
+     */
+    on<K extends keyof T>(name: K, callback: (...args: Parameters<T[K]>) => ReturnType<T[K]>, once?: boolean): () => void;
+    /**
+     * 注册事件(是否只执行一次)
+     * @param name - 事件类型
+     * @param callback - 事件回调函数
+     * @returns 解除事件
+     * @template K - 预设的监听事件名称
+     * @template C - 回调函数函数上下文
+     */
+    once<K extends keyof T>(name: K, callback: (...args: Parameters<T[K]>) => ReturnType<T[K]>): () => void;
+    /**
+     * 解除事件
+     *
+     * 如果 name 不传的话解除对应所有事件
+     * 如果 name, callback 不传的话解除所有name的所有事件
+     * @param name - 事件类型
+     * @param callback - 事件回调函数
+     * @template K - 预设的监听事件名称
+     */
+    off<K extends keyof T>(name?: K, callback?: (...args: Parameters<T[K]>) => ReturnType<T[K]>): void;
+    /**
+     * 触发事件
+     * @param name - 事件类型
+     * @param data - 触发事件的数据
+     * @returns canceled 是否被触发取消
+     * @template K - 预设的监听事件名称
+     */
+    emit<K extends keyof T>(name: K, ...data: Parameters<T[K]>): boolean;
+    /**
+     * 等待事件
+     * @param name - 事件类型
+     * @param filter - 事件类型
+     * @returns 触发事件的数据
+     * @template K - 预设的监听事件名称
+     */
+    waitUntil<K extends keyof T>(name: K, filter?: (...args: Parameters<T[K]>) => boolean | void): Promise<Parameters<T[K]>>;
+}
+export { Subscribe, SubscribeEventMap };

package/five/utils/tileCube.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three/webgpu';
+import { CubeFace } from '../types/cube';
+interface TileCubeTree {
+    maxLevel: number;
+    children: TileCubeNode[];
+}
+interface TileCubeNode {
+    level: number;
+    face: CubeFace;
+    position: THREE.Vector2;
+    size: number;
+    box: THREE.Box3;
+    parent: TileCubeNode | null;
+    children: TileCubeNode[];
+}
+declare function createTileCubeTree(level: number): TileCubeTree;
+declare function traverseTileCubeNode(nodeOrTree: TileCubeTree | TileCubeNode, callback: (node: TileCubeNode) => false | void): void;
+export { createTileCubeTree, traverseTileCubeNode };
+export type { TileCubeTree, TileCubeNode };

package/five/utils/toFastProperties.d.ts

@@ -0,0 +1 @@
+export declare function toFastProperties<T extends any>(object: T): T;

package/five/utils/typedCache.d.ts

@@ -0,0 +1,10 @@
+export type TypedCacheSymbol<T> = {
+    id: string;
+};
+export declare class TypedCache {
+    static createSymbol<T>(id: string): TypedCacheSymbol<T>;
+    private store;
+    set<T>(symbol: TypedCacheSymbol<T>, value: T): void;
+    get<T>(symbol: TypedCacheSymbol<T>): T | undefined;
+    clear(): void;
+}

package/five/utils/uniform.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three/webgpu';
+export interface IUniform<T> {
+    value: T;
+}
+export type Uniforms = Record<string, IUniform<any>>;
+export declare class Uniform<T> extends THREE.Uniform implements IUniform<T> {
+    value: T;
+    constructor(value: T);
+}
+export declare function setUniform<T>(uniform: IUniform<T>, value: T): void;
+export declare function cloneUniforms<T extends Uniforms>(uniforms: T): T;
+export declare function mergeUniforms<A extends Uniforms>(a: A): A;
+export declare function mergeUniforms<A extends Uniforms, B extends Uniforms>(a: A, b: B): A & B;
+export declare function mergeUniforms<A extends Uniforms, B extends Uniforms, C extends Uniforms>(a: A, b: B, c: C): A & B & C;
+export declare function mergeUniforms<A extends Uniforms, B extends Uniforms, C extends Uniforms, D extends Uniforms>(a: A, b: B, c: C, d: D): A & B & C & D;

package/five/utils/url.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 判断是否是url的绝对地址
+ * @param url - url地址
+ */
+export declare function isAbsoluteURL(url: string): boolean;
+/**
+ * 获取完整 URL 地址
+ * @param url - url地址
+ */
+export declare function getFullURL(url: string): string;
+/**
+ * 路径拼接
+ * @param segments 路径片段
+ * @returns
+ */
+export declare function pathJoin(...segments: string[]): string;
+/**
+ * 添加 URL 参数
+ * @param url
+ * @param search
+ * @returns
+ */
+export declare function appendSearch(url: string, search?: string): string;
+/**
+ * 标准化 url
+ * @param url
+ * @returns
+ */
+export declare function normalizeURL(url: string): string;
+/**
+ * 获取文件后缀名, 返回 .png .jpeg 等形式
+ * @param url
+ * @returns
+ */
+export declare function getExtname(url: string): string;

package/five/utils/uuid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 计算一个唯一 id
+ */
+declare function createUuid(): string;
+export { createUuid as uuid };

package/five/utils/values.d.ts

@@ -0,0 +1,2 @@
+declare function values<T>(object: Record<any, T>): T[];
+export { values };

package/five/utils/vectorCoordinates.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three/webgpu";
+/** 坐标转换成单位向量 */
+export declare function coordinatesToVector(coordinates: {
+    longitude: number;
+    latitude: number;
+}, target?: THREE.Vector3): THREE.Vector3;
+/** 单位向量转换成坐标 */
+export declare function vectorToCoordinates(vector: THREE.Vector3): {
+    longitude: number;
+    latitude: number;
+};
+/**
+ * 通过经度计算 Heading, Heading 是个古老的参数，新的工程中请不要使用了
+ *
+ * @deprecated
+ * 不再使用 heading 这种计算方式。
+ *
+ * @param longitude - 经度
+ */
+export declare function longitudeToHeading(longitude: number): number;
+/**
+ * 通过 heading 计算 longitude
+ *
+ *  @deprecated
+ * 不再使用 heading 这种计算方式。
+ *
+ * @param heading - 方向
+ */
+export declare function headingToLongitude(heading: number): number;

package/five/utils/volume.d.ts

@@ -0,0 +1,111 @@
+import * as THREE from 'three/webgpu';
+export type RegionBoundingVolumeJson = {
+    region: number[];
+};
+export type BoxBoundingVolumeJson = {
+    box: number[];
+};
+export type SphereBoundingVolumeJson = {
+    sphere: number[];
+};
+export type BoundingVolumeJson = RegionBoundingVolumeJson | BoxBoundingVolumeJson | SphereBoundingVolumeJson;
+export declare enum VolumePlaneIntersect {
+    Outside = -1,
+    Intersecting = 0,
+    Inside = 1
+}
+export declare class CullingVolume {
+    static get MASK_OUTSIDE(): number;
+    static get MASK_INSIDE(): number;
+    static get MASK_INDETERMINATE(): number;
+    planes: THREE.Plane[];
+    constructor(planes?: THREE.Plane[]);
+    setFromFrustum(frustum: THREE.Frustum): this;
+    setFromCamera(camera: THREE.Camera): this;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    copy(cullingVolume: CullingVolume): this;
+    clone(): CullingVolume;
+    computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
+    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
+}
+export interface BoundingVolume {
+    type: 'box' | 'sphere' | 'regin';
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+    clone(): BoundingVolume;
+    copy(boundingVolume: this): this;
+    fromJson(json: any): this;
+    toJson(): BoundingVolumeJson;
+}
+export declare class BoxBoundingVolume implements BoundingVolume {
+    type: "box";
+    center: THREE.Vector3;
+    halfSize: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    constructor();
+    fromJson({ box }: BoxBoundingVolumeJson): this;
+    toJson(): BoxBoundingVolumeJson;
+    copy(boxBoundingVolume: BoxBoundingVolume): this;
+    clone(): BoxBoundingVolume;
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+}
+export declare class SphereBoundingVolume implements BoundingVolume {
+    type: "sphere";
+    center: THREE.Vector3;
+    radius: number;
+    constructor();
+    fromJson({ sphere }: SphereBoundingVolumeJson): this;
+    toJson(): SphereBoundingVolumeJson;
+    copy(sphereBoundingVolume: SphereBoundingVolume): this;
+    clone(): SphereBoundingVolume;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+}
+export declare class RegionBoundingVolume implements BoundingVolume {
+    type: "regin";
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    minHeight: number;
+    maxHeight: number;
+    constructor();
+    fromJson({ region }: RegionBoundingVolumeJson): this;
+    toJson(): RegionBoundingVolumeJson;
+    copy(regionBoundingVolume: RegionBoundingVolume): this;
+    clone(): RegionBoundingVolume;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+}
+export declare function isBoundingVolume(obj: any): obj is BoundingVolume;
+export declare function makeBoundingVolume(header: BoundingVolumeJson | BoundingVolume): BoundingVolume;
+export declare function createDebugBoundingMesh(boundingVolume: BoundingVolume, level?: number): THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial> | null;

package/five/utils/worker.d.ts

@@ -0,0 +1,26 @@
+export type WorkerType<Input, Output> = {
+    Input: Input;
+    Output: Output;
+};
+export type WorkerCallback<T extends WorkerType<any, any>> = (input: T['Input']) => Promise<{
+    output: T['Output'];
+    transfer: Transferable[];
+}>;
+export declare function defineWorker<T extends WorkerType<any, any>>(callback: WorkerCallback<T>): void;
+export type WorkerCreator = (workId: number) => Worker;
+export declare class WorkerPool<T extends WorkerType<any, any>> {
+    private disposed;
+    private pool;
+    private queue;
+    private workers;
+    private workerResolvers;
+    private workerStatus;
+    private workerCreator;
+    constructor(workerCreator: WorkerCreator | null, pool: number);
+    setWorkerCreator(workerCreator: WorkerCreator): void;
+    private initWorker;
+    private getIdleWorker;
+    private onMessage;
+    postMessage(input: T['Input'], transfer?: Transferable[]): Promise<T['Output']>;
+    dispose(): void;
+}

package/five/work/_ALLOW_HOST.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/work/index.d.ts

@@ -0,0 +1,6 @@
+export { parseWork, type ParseOptions, Work, type WorkCubeImage, type WorkImage, type WorkInitial, type WorkModel, type WorkModelLayer, type WorkObserver, type WorkTile, type WorkVideo, } from './work';
+export { type WorkInitialJson, type WorkJson, type WorkModelJson, type WorkModelLayerJson, type WorkObserverJson, type WorkPanoramaJson, type WorkPanoramasJson, } from './workJsonType';
+export { workToJson, } from './workJson';
+export { type LoosePanoWork, type LooseWork, type LooseWorkInitial, type LooseWorkModel, type LooseWorkObserver, type LooseWorkPanorama, type LooseWorkVideo, type LooseWorkWithExtrinsics, } from './looseWorkType';
+export { type Works, createWorks, } from './works';
+export { WorkResolvedObserver, } from './workResolvedObserver';

package/five/work/keychain.d.ts

@@ -0,0 +1,5 @@
+import { X509 } from "../thirdparty/jsrsasign";
+declare function verifyCertificate(certificate: X509): boolean;
+declare function addCertificate(certificate: X509 | string): boolean;
+declare function verifyMessage(message: string, signature: string, certificate: X509 | string): boolean;
+export { verifyCertificate, addCertificate, verifyMessage };

package/five/work/looseWorkType.d.ts

@@ -0,0 +1,128 @@
+import type { ParseOptions } from './work';
+import type { TilesetHeader } from "../model/tile3d/header";
+export interface LooseWorkVideo {
+    source: string;
+    matrix: number[];
+    size: number[];
+}
+export interface LooseWorkPanorama {
+    active?: boolean;
+    loadable?: boolean;
+    index?: number;
+    right?: string;
+    left?: string;
+    up?: string;
+    down?: string;
+    front?: string;
+    back?: string;
+    video?: LooseWorkVideo;
+    tiles?: number[];
+    size_list?: number[];
+    derived_id?: number;
+    derived_id_str?: string;
+    hdr_config?: string;
+    gainmap_right?: string;
+    gainmap_left?: string;
+    gainmap_up?: string;
+    gainmap_down?: string;
+    gainmap_front?: string;
+    gainmap_back?: string;
+}
+export interface LooseWorkInitial {
+    mode?: string;
+    pano_index?: number;
+    panoIndex?: number;
+    pano?: number;
+    longitude?: number;
+    latitude?: number;
+    fov?: number;
+    distance?: number;
+    offset?: number[] | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    heading?: number;
+}
+export interface LooseWorkModel {
+    file_url?: string;
+    material_textures?: string[];
+    material_base_url?: string;
+    up_axis?: string;
+    coordinate?: NonNullable<TilesetHeader['rootMeta']>['coordinate'];
+    tiles?: {
+        type?: 'point_cloud' | 'mesh' | 'gaussian_splatting' | string;
+        name?: string;
+        up_axis?: string;
+        tileset_url: string;
+    };
+    layers?: [
+        {
+            type?: 'point_cloud' | 'mesh' | 'gaussian_splatting' | string;
+            name?: string;
+            up_axis?: string;
+            tileset_url: string;
+        }
+    ];
+}
+export interface LooseWorkObserver {
+    active?: boolean;
+    loadable?: boolean;
+    index?: number;
+    visible_nodes?: number[];
+    visibleNodes?: number[];
+    accessible_nodes?: number[];
+    accessibleNodes?: number[];
+    quaternion?: {
+        y: number;
+        x: number;
+        z: number;
+        w: number;
+    };
+    standing_position?: number[];
+    standingPosition?: number[];
+    position?: number[];
+    floor?: number;
+    floor_index?: number;
+    floorIndex?: number;
+    derived_id?: number;
+    derived_id_str?: string;
+}
+export interface LooseWork {
+    work_code?: string;
+    code?: string;
+    resource_code?: string;
+    basic_code?: string;
+    vr_code?: string;
+    workCode?: string;
+    project_id?: string;
+    name?: string;
+    modelAsync?: boolean;
+    initial?: LooseWorkInitial;
+    base_url?: string;
+    model?: LooseWorkModel;
+    panorama?: {
+        base_url?: string;
+        pano_high_cube_base_url?: string;
+        pano_cube_base_url?: string;
+        pattern?: LooseWorkPanorama;
+        info?: LooseWorkPanorama[];
+        list?: LooseWorkPanorama[];
+    };
+    observers?: LooseWorkObserver[];
+}
+export interface LooseWorkWithExtrinsics extends ParseOptions {
+    /** work 数据 */
+    work: LooseWork;
+}
+export interface LoosePanoWork {
+    name?: string;
+    code?: string;
+    up: string;
+    down: string;
+    right: string;
+    left: string;
+    front: string;
+    back: string;
+    size: number;
+}

package/five/work/verify.d.ts

@@ -0,0 +1,7 @@
+export interface VerifyResult {
+    issuer: string;
+    expire: Date;
+    allowHosts: readonly string[];
+}
+export declare function verify(inputObject: any | any[]): VerifyResult | Error;
+export declare function verifyURL(source: string, allowHosts: readonly string[]): string | Error;