@realsee/five 6.8.0-alpha.2 → 6.8.0-alpha.21

package/five/utils/easing.d.ts

@@ -0,0 +1,63 @@
+export type EasingFunction = (progress: number) => number;
+/** https://easings.net/#linear */
+export declare const linear: EasingFunction;
+/** https://easings.net/#easeInQuad */
+export declare const easeInQuad: EasingFunction;
+/** https://easings.net/#easeOutQuad */
+export declare const easeOutQuad: EasingFunction;
+/** https://easings.net/#easeInOutQuad */
+export declare const easeInOutQuad: EasingFunction;
+/** https://easings.net/#easeInCubic */
+export declare const easeInCubic: EasingFunction;
+/** https://easings.net/#easeOutCubic */
+export declare const easeOutCubic: EasingFunction;
+/** https://easings.net/#easeInOutCubic */
+export declare const easeInOutCubic: EasingFunction;
+/** https://easings.net/#easeInQuart */
+export declare const easeInQuart: EasingFunction;
+/** https://easings.net/#easeOutQuart */
+export declare const easeOutQuart: EasingFunction;
+/** https://easings.net/#easeInOutQuart */
+export declare const easeInOutQuart: EasingFunction;
+/** https://easings.net/#easeInQuint */
+export declare const easeInQuint: EasingFunction;
+/** https://easings.net/#easeOutQuint */
+export declare const easeOutQuint: EasingFunction;
+/** https://easings.net/#easeInOutQuint */
+export declare const easeInOutQuint: EasingFunction;
+/** https://easings.net/#easeInSine */
+export declare const easeInSine: EasingFunction;
+/** https://easings.net/#easeOutSine */
+export declare const easeOutSine: EasingFunction;
+/** https://easings.net/#easeInOutSine */
+export declare const easeInOutSine: EasingFunction;
+/** https://easings.net/#easeInExpo */
+export declare const easeInExpo: EasingFunction;
+/** https://easings.net/#easeOutExpo */
+export declare const easeOutExpo: EasingFunction;
+/** https://easings.net/#easeInOutExpo */
+export declare const easeInOutExpo: EasingFunction;
+/** https://easings.net/#easeInCirc */
+export declare const easeInCirc: EasingFunction;
+/** https://easings.net/#easeOutCirc */
+export declare const easeOutCirc: EasingFunction;
+/** https://easings.net/#easeInOutCirc */
+export declare const easeInOutCirc: EasingFunction;
+/** https://easings.net/#easeInBack */
+export declare const easeInBack: EasingFunction;
+/** https://easings.net/#easeOutBack */
+export declare const easeOutBack: EasingFunction;
+/** https://easings.net/#easeInOutBack */
+export declare const easeInOutBack: EasingFunction;
+/** https://easings.net/#easeInElastic */
+export declare const easeInElastic: EasingFunction;
+/** https://easings.net/#easeOutElastic */
+export declare const easeOutElastic: EasingFunction;
+/** https://easings.net/#easeInOutElastic */
+export declare const easeInOutElastic: EasingFunction;
+/** https://easings.net/#easeInBounce */
+export declare const easeInBounce: EasingFunction;
+/** https://easings.net/#easeOutBounce */
+export declare const easeOutBounce: EasingFunction;
+/** https://easings.net/#easeInOutBounce */
+export declare const easeInOutBounce: EasingFunction;

package/five/utils/event.d.ts

@@ -0,0 +1,159 @@
+import * as THREE from 'three';
+import { State } from '../types/state';
+import { Pano } from './pano';
+import { Mode } from '../application/mode';
+import { NetWorkMeta, NetworkType, NetworkState } from './ajax';
+import { Works, Work } from '../work';
+import { ModelScene, Model } from '../model';
+import { type Tile } from '../model/tile3d/tile';
+import { Intersection } from '../model/intersection';
+import { MovePanoOptions } from '../types/movePanoOptions';
+export interface BaseEvent {
+    type: string;
+    timeStamp: number;
+    preventDefault(): void;
+    defaultPrevented: boolean;
+}
+export interface IntersectEvent extends BaseEvent {
+    object: THREE.Object3D;
+    raycaster: THREE.Raycaster;
+    intersection: Intersection | null;
+}
+export interface StateEvent extends BaseEvent {
+    state: State;
+    userAction: boolean;
+}
+export interface PanoEvent extends StateEvent {
+    prevPano: Pano;
+    progress: number;
+    options: MovePanoOptions;
+    error: Error | null;
+}
+export interface PanoTextureEvent extends BaseEvent {
+    pano: Pano;
+    progress: number;
+    meta: NetWorkMeta[] | null;
+    error: Error | null;
+}
+export interface GestureEvent extends StateEvent {
+    target: EventTarget | null;
+    pointerType: 'touch' | 'pen' | 'mouse' | 'kinect';
+    srcEvent: MouseEvent | TouchEvent | PointerEvent;
+    pointers: {
+        x: number;
+        y: number;
+        delta: number;
+        button: number;
+        buttons: number;
+        shiftKey: boolean;
+        ctrlKey: boolean;
+        altKey: boolean;
+        metaKey: boolean;
+        coords: THREE.Vector2;
+        raycaster: THREE.Raycaster;
+    }[];
+    isFirst: boolean;
+    isFinal: boolean;
+    scale: number;
+    center: {
+        x: number;
+        y: number;
+        delta: number;
+        button: number;
+        buttons: number;
+        shiftKey: boolean;
+        ctrlKey: boolean;
+        altKey: boolean;
+        metaKey: boolean;
+        coords: THREE.Vector2;
+        raycaster: THREE.Raycaster;
+    };
+    velocityX: number;
+    velocityY: number;
+    overallVelocityX: number;
+    overallVelocityY: number;
+}
+export interface XRSessionEvent extends BaseEvent {
+    session: XRSession | null;
+    machineType: 'Pico' | 'Oculus';
+}
+export interface XRControllerEvent extends BaseEvent {
+    left: {
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
+        };
+        raycaster: THREE.Raycaster;
+        deltaTime: number;
+    };
+    right: {
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
+        };
+        raycaster: THREE.Raycaster;
+        deltaTime: number;
+    };
+    buttons: {
+        X: boolean;
+        Y: boolean;
+        LeftTrigger: boolean;
+        LeftPinch: boolean;
+        A: boolean;
+        B: boolean;
+        RightTrigger: boolean;
+        RightPinch: boolean;
+    };
+}
+export interface XRGestureEvent extends BaseEvent {
+    session: XRSession | null;
+    buttons: 'A' | 'B' | 'X' | 'Y' | 'RightTrigger' | 'RightPinch' | 'LeftTrigger' | 'LeftPinch' | 'LeftAxesLeft' | 'LeftAxesRight' | 'LeftAxesUp' | 'LeftAxesDown' | 'RightAxesLeft' | 'RightAxesRight' | 'RightAxesUp' | 'RightAxesDown';
+    machineType: 'Pico' | 'Oculus';
+    isFirst: boolean;
+    isFinal: boolean;
+    controllers: {
+        raycaster: {
+            leftRay: THREE.Raycaster;
+            rightRay: THREE.Raycaster;
+        };
+    };
+}
+export interface WorksEvent extends BaseEvent {
+    input: any;
+    works: Works;
+    userAction: boolean;
+}
+export interface ModelSceneEvent extends BaseEvent {
+    modelScene: ModelScene;
+}
+export interface ModelEvent extends BaseEvent {
+    model: Model;
+    work: Work;
+    error: Error | null;
+}
+export interface ModelTileEvent extends BaseEvent {
+    model: Model;
+    work: Work;
+    tile: Tile;
+}
+export interface ModeChangeEvent extends StateEvent {
+    prevMode: Mode;
+    mode: Mode;
+}
+export interface RenderEvent extends BaseEvent {
+    needsRender: boolean;
+}
+export interface ObjectEvent extends BaseEvent {
+    object: THREE.Object3D;
+}
+export interface NetworkResourceEvent extends BaseEvent {
+    source: string;
+    requestType: NetworkType;
+    requestState: NetworkState;
+    detail: string;
+}
+export declare function createEvent<T extends BaseEvent = BaseEvent>(type: string, eventArgs: Omit<T, keyof BaseEvent>): T;

package/five/utils/formatRad.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 将弧度转成 0 - 2PI 中的值
+ * @param rad - 任意弧度值
+ * @return 0 - 2PI 的数值
+ */
+declare function formatRad(rad: number): number;
+export { formatRad };

package/five/utils/imageSupport.d.ts

@@ -0,0 +1,6 @@
+declare function imageSupport(): Promise<{
+    webp: boolean;
+    avif: boolean;
+    heif: boolean;
+}>;
+export { imageSupport };

package/five/utils/imageURL.d.ts

@@ -0,0 +1,42 @@
+interface ImageURLMappings {
+    [publicDomain: string]: {
+        "type"?: string;
+        "pano": [string, string];
+        "tile": [string, string];
+        "model": [string, string];
+        "texture": [string];
+        "default": [string];
+    };
+}
+interface ImageURLOptions {
+    /** 图片类型标识 */
+    key: string;
+    /** 图片尺寸参数 尽量使用 2 的幂次 如 256 512 1024 */
+    size?: number;
+    /** 图片质量参数(0-100) */
+    quality?: number;
+    /** 图片格式参数 */
+    format?: "jpg" | "jpeg" | "png" | "heif" | "heic" | "webp" | "avif";
+    /** 图片裁切 */
+    cut?: [x: number, y: number, width: number, height: number];
+    /** 锐化参数 海外不支持 */
+    sharpen?: number;
+    /** 腾讯云在做裁切, 旋转等操作时，需要此参数，应用 exif orientation */
+    forceUseExifOrientation?: boolean;
+    /** 域名匹配规则 */
+    mappings?: ImageURLMappings;
+}
+/**
+ * URL 地址的转换
+ * @param source - url 原地址
+ * @param options - url 转换参数
+ * @returns url 转换结果
+ */
+declare function imageURL(source: string, options: ImageURLOptions): string;
+declare function applyImageURLOptions(source: string, imageURLTransform: (source: string, options: ImageURLOptions) => string, imageURLOptions: ImageURLOptions): string;
+/** 从 url 获取图片尺寸， 图片中有 cube_<size> 特征  */
+declare function getImageSizeFromURL(url: string): number | null;
+/** 从 url 替换图片尺寸， 图片中有 cube_<size> 特征  */
+declare function replaceImageSize(url: string, size: number): string;
+declare function getImageSizeLevel(size: number): number;
+export { imageURL, ImageURLOptions, applyImageURLOptions, ImageURLMappings, getImageSizeFromURL, replaceImageSize, getImageSizeLevel };

package/five/utils/isEmptyObject.d.ts

@@ -0,0 +1,2 @@
+declare function isEmptyObject(obj: object): boolean;
+export { isEmptyObject };

package/five/utils/isNil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 判断当前内容是否是 undefined 或者 null
+ * @param object - 任何东西
+ */
+declare function isNil(object: any): object is undefined | null;
+export { isNil };

package/five/utils/isNumber.d.ts

@@ -0,0 +1,2 @@
+declare function isNumber(value: any): value is number;
+export { isNumber };

package/five/utils/isPowerOfTwo.d.ts

@@ -0,0 +1,2 @@
+declare function isPowerOfTwo(value: number): boolean;
+export { isPowerOfTwo };

package/five/utils/isPromise.d.ts

@@ -0,0 +1,2 @@
+declare function isPromise<T>(obj: PromiseLike<T> | T): obj is PromiseLike<T>;
+export { isPromise };

package/five/utils/isSimilar.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from "three";
+declare function isSimilarValue(value: number, anotherValue: number, circleLength?: number): boolean;
+declare function notSimilarValue(value: number, anotherValue: number, circleLength?: number): boolean;
+declare function isSimilarVector3(vector: THREE.Vector3, anotherVector: THREE.Vector3): boolean;
+declare function notSimilarVector3(vector: THREE.Vector3, anotherVector: THREE.Vector3): boolean;
+export { isSimilarValue, isSimilarVector3, notSimilarValue, notSimilarVector3, };

package/five/utils/json.d.ts

@@ -0,0 +1,7 @@
+export type JsonValue = undefined | number | string | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function jsonClone<T>(value: T): T;
+export declare function jsonMerge(object: any, anotherOject: any): JsonValue;
+export declare function jsonStableStrinfiy(object: any): string;
+export declare function jsonHash(object: any): string;

package/five/utils/ktx2.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Loader for KTX 2.0 GPU Texture containers.
+ *
+ * KTX 2.0 is a container format for various GPU texture formats. The loader
+ * supports Basis Universal GPU textures, which can be quickly transcoded to
+ * a wide variety of GPU texture compression formats. While KTX 2.0 also allows
+ * other hardware-specific formats, this loader does not yet parse them.
+ *
+ * References:
+ * - KTX: http://github.khronos.org/KTX-Specification/
+ * - DFD: https://www.khronos.org/registry/DataFormat/specs/1.3/dataformat.1.3.html#basicdescriptor
+ */
+import * as THREE from 'three';
+export declare class KTX2 {
+    transcoderPath: string;
+    private workerPool;
+    private transcoderBinary;
+    private transcoderPending;
+    private workerSourceURL;
+    private workerConfig;
+    constructor();
+    setTranscoderPath(transcoderPath: string): void;
+    detectSupport(renderer: THREE.WebGLRenderer): this;
+    init(): Promise<void>;
+    parse(buffer: ArrayBuffer): Promise<THREE.CompressedTexture>;
+    _createTextureFrom(transcodeResult: any): Promise<THREE.CompressedTexture>;
+    _createTexture(buffers: ArrayBuffer[]): Promise<THREE.CompressedTexture>;
+    dispose(): this;
+}
+export declare const ktx2: KTX2;

package/five/utils/lzma/index.d.ts

@@ -0,0 +1,2 @@
+declare function lzma(binary: ArrayBufferLike): Promise<Uint8Array<ArrayBufferLike>[]>;
+export { lzma };

package/five/utils/lzma/lzma.d.ts

@@ -0,0 +1,3 @@
+declare function createLZMA(): any;
+declare const LZMA: any;
+export { LZMA, createLZMA };

package/five/utils/lzma/lzmaWASM.d.ts

@@ -0,0 +1,2 @@
+declare function createWASM(): ArrayBuffer;
+export { createWASM };

package/five/utils/lzma/lzmaWorker.d.ts

@@ -0,0 +1,14 @@
+interface OnCompleteCallback {
+    (error: Error | null, result?: Uint8Array): void;
+}
+declare class LZMAWorker {
+    private worker;
+    private callCounter;
+    private requests;
+    static support: boolean;
+    constructor();
+    private getKey;
+    decompress(data: Uint8Array, onCompleteCallback: OnCompleteCallback): void;
+    terminate(): void;
+}
+export { LZMAWorker };

package/five/utils/memoryUsage.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+import { PBMGaussianSplattingObject } from '../model/objects/pbmGaussianSplattingObject';
+/**
+ * 统计 Geometry 的存储占用 单位 bytes
+ * @param geometry
+ * @returns
+ */
+export declare function getGeometryMemoryUsed(geometry: THREE.BufferGeometry | THREE.Geometry): number;
+export declare function getPBMGSObjectMemoryUsed(object: PBMGaussianSplattingObject): number;
+/**
+ * 统计 Texture 的存储占用 单位 bytes
+ * Textures are often the part of a three.js app that use the most memory.
+ * It's important to understand that in general, textures take width * height * 4 * 1.33 bytes of memory.
+ * @param texture
+ * @returns
+ */
+export declare function getTextureMemoryUsed(texture: THREE.Texture): number;
+/**
+ * 统计 Material 的存储占用 单位 bytes
+ * @param material
+ * @returns
+ */
+export declare function getMaterialMemoryUsed(material: THREE.Material): number;
+/**
+ * 统计内部使用到的 Geometry Material 的内存占用 单位bytes
+ * @param scene
+ * @returns
+ */
+export declare function getMemoryUsage(scene: THREE.Object3D): number;

package/five/utils/motion.d.ts

@@ -0,0 +1,38 @@
+type MotionValue<K extends string> = Record<K, number>;
+type MotionConfig<K extends string> = Record<K, {
+    circle: MotionCircle | false;
+}>;
+type MotionInitalValue<K extends string> = Record<K, MotionValue<K>[K] | ({
+    value: MotionValue<K>[K];
+} & MotionConfig<K>[K])>;
+interface MotionKeyframe<K extends string> {
+    progress: number;
+    value: MotionValue<K>;
+    key?: string;
+}
+/** 是否是循环变化，比如 [0, 2 * Math.PI], 前闭后开 */
+type MotionCircle = [number, number];
+type ValueOfMotion<M> = M extends Motion<infer K> ? MotionValue<K> : never;
+type KeyframeOfMotion<M> = M extends Motion<infer K> ? MotionKeyframe<K> : never;
+declare class Motion<K extends string> {
+    config: MotionConfig<K>;
+    value: MotionValue<K>;
+    progress: number;
+    ended: boolean;
+    startTime: number;
+    startVelocity: number;
+    duration: number;
+    keyframes: MotionKeyframe<K>[];
+    private callbacks?;
+    constructor(initalValue: MotionInitalValue<K>);
+    private getProgress;
+    private getValue;
+    getProgressVelocity(time: number): number;
+    update(time: number): boolean;
+    getKeyFrameSegment(time: number): [MotionKeyframe<K>, MotionKeyframe<K>];
+    getTargetKeyframe(): MotionKeyframe<K>;
+    set(value: Partial<MotionValue<K>>, duration: number, startProgressVelocity?: number, time?: number): Promise<void>;
+    setKeyframes(keyframes: MotionKeyframe<K>[], duration: number, startProgressVelocity?: number, time?: number): Promise<void>;
+    dispose(): void;
+}
+export { Motion, MotionCircle, MotionConfig, MotionValue, MotionInitalValue, MotionKeyframe, ValueOfMotion, KeyframeOfMotion };

package/five/utils/noop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 空函数
+ * @param args - 任意参数
+ */
+declare function noop(...args: any[]): any;
+export { noop };

package/five/utils/now.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 获取当前时间戳
+ */
+declare const now: () => number;
+declare function domHighResTimeStampToDateNow(domHighResTimeStamp: number): number;
+declare function dateNowToDomHighResTimeStamp(dateNow: number): number;
+export { now, domHighResTimeStampToDateNow, dateNowToDomHighResTimeStamp };

package/five/utils/pano.d.ts

@@ -0,0 +1,9 @@
+export type Pano = {
+    workCode: string;
+    panoIndex: number;
+};
+export type PanoId = `${Pano['workCode']}[${number}]`;
+export declare function panoStringify(pano: Pano): PanoId;
+export declare function panoParse(panoId: PanoId): Pano;
+export declare function panoEqual(a: Pano, b: Pano): boolean;
+export declare function isPanoId(id: any): id is PanoId;

package/five/utils/pick.d.ts

@@ -0,0 +1,3 @@
+export declare function pick<T extends Record<any, any>, K extends keyof T>(object: T, keys: K[]): Pick<T, K>;
+export declare function omit<T extends Record<any, any>, K extends keyof T>(object: T, keys: K[]): Omit<T, K>;
+export declare function omitUndefinedFields<T extends Record<any, any>>(object: T): T;

package/five/utils/poseUtils.d.ts

@@ -0,0 +1,5 @@
+import { Pose } from "../types/pose";
+declare function assignPose(pose: Pose, fromPose: Pose): void;
+declare function poseEqual(pose: Pose, equalsPose: Pose): boolean;
+declare function clonePose(pose: Pose): Pose;
+export { assignPose, poseEqual, clonePose };

package/five/utils/renderCubeTextureToCubeRenderTarget.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+declare function renderCubeTextureToCubeRenderTarget(cubeTexture: THREE.Texture, cubeRenderTarget: THREE.WebGLCubeRenderTarget, renderer: THREE.WebGLRenderer): void;
+export { renderCubeTextureToCubeRenderTarget };

package/five/utils/renderDepth.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export declare function renderDepthCube(renderer: THREE.WebGLRenderer, scene: THREE.Scene, cubeCamera: THREE.CubeCamera, maxDepth?: number): void;

package/five/utils/renderTexturesToCubeRenderTarget.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { CubeFace } from "../types/cube";
+export type RenderTextureType = {
+    face: CubeFace;
+    position: THREE.Vector2;
+    size: THREE.Vector2;
+    texture: THREE.Texture;
+    flipY: boolean;
+};
+export declare function renderTexturesToCubeRenderTarget(textures: RenderTextureType[], cubeRenderTarget: THREE.WebGLCubeRenderTarget, renderer: THREE.WebGLRenderer): void;

package/five/utils/requestPermission.d.ts

@@ -0,0 +1,3 @@
+declare function requestDeviceOrientationPermission(): Promise<void>;
+declare function requestXRSessionPermission(): Promise<any>;
+export { requestDeviceOrientationPermission, requestXRSessionPermission };

package/five/utils/shaderContentFix.d.ts

@@ -0,0 +1,7 @@
+declare function shaderContentFix(shaderContent: string, { prefix, beforeMain, mainPrefix, mainSuffix }?: {
+    prefix?: string;
+    beforeMain?: string;
+    mainPrefix?: string;
+    mainSuffix?: string;
+}): string;
+export { shaderContentFix };

package/five/utils/shaderMaterial.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+import { Uniforms } from './uniform';
+export interface ShaderMaterialParameters<U extends Uniforms, D extends Record<string, any>> extends THREE.ShaderMaterialParameters {
+    uniforms: U;
+    defines: D;
+}
+export declare class ShaderMaterial<U extends Uniforms, D extends Record<string, any>> extends THREE.ShaderMaterial {
+    uniforms: U;
+    defines: D;
+    constructor(options: ShaderMaterialParameters<U, D>);
+    getUniform<K extends keyof Uniforms>(name: K): Uniforms[K]['value'];
+    setUniform<K extends keyof Uniforms>(name: K, value: Uniforms[K]['value']): void;
+}
+export declare class RawShaderMaterial<U extends Uniforms, D extends Record<string, any>> extends THREE.RawShaderMaterial {
+    uniforms: U;
+    defines: D;
+    constructor(options: ShaderMaterialParameters<U, D>);
+    getUniform<K extends keyof Uniforms>(name: K): Uniforms[K]['value'];
+    setUniform<K extends keyof Uniforms>(name: K, value: Uniforms[K]['value']): void;
+}

package/five/utils/stateUtils.d.ts

@@ -0,0 +1,5 @@
+import { State } from "../types/state";
+declare function assignState(state: State, fromState: State): void;
+declare function stateEqual(state: State, equalsState: State): boolean;
+declare function cloneState(state: State): State;
+export { assignState, stateEqual, cloneState };

package/five/utils/string-pattern.d.ts

@@ -0,0 +1,8 @@
+export declare class StringPattern {
+    private strings;
+    private keys;
+    private matchRegexp?;
+    constructor(pattern: string);
+    stringify(values: Record<string, any>): string;
+    match(string: string): Record<string, string> | null;
+}

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';
+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;