@realsee/five-webgpu 1.0.0-alpha.1

package/five/meshes/boundingMesh.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three/webgpu";
+import { PBMMesh } from "../model";
+import { type Camera } from '../core/camera';
+import { type ModelScene } from '../model';
+declare class BoundingMesh extends PBMMesh {
+    constructor(options?: {
+        name?: string;
+    });
+    update(renderer: THREE.WebGPURenderer, camera: Camera, modelScene: ModelScene): boolean;
+    dispose(): void;
+}
+export { BoundingMesh };

package/five/meshes/intersectMesh.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three/webgpu";
+import { IntersectMeshInterface } from "../types/intersectMeshInterface";
+declare class IntersectMesh extends THREE.Object3D implements IntersectMeshInterface {
+    private ringMesh;
+    constructor();
+    dispose(): void;
+}
+export { IntersectMesh };

package/five/meshes/panoCircleMesh.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from "three/webgpu";
+import { PanoCircleMeshInterface } from "../types/panoCircleMeshInterface";
+interface PanoCircleMeshOptions {
+    scale?: number;
+    color?: number;
+}
+declare class PanoCircleMesh extends THREE.Object3D implements PanoCircleMeshInterface {
+    needsRender: boolean;
+    private currentStartTime;
+    private currentMotion;
+    private ringMotion;
+    private tapMotion;
+    private loadingOpacityMotion;
+    private progressMotion;
+    private progressOpacityMotion;
+    private opacityMotion;
+    private disableMotion;
+    progress: number;
+    opacity: number;
+    current: boolean;
+    loading: boolean;
+    disabled: boolean;
+    private panoMesh;
+    private panoU;
+    constructor(options?: PanoCircleMeshOptions);
+    setProgress(progress: number): void;
+    setOpacity(opacity: number): void;
+    setCurrent(current: boolean): void;
+    setLoading(loading: boolean): void;
+    setDisabled(disabled: boolean): void;
+    tap(): Promise<void>;
+    updateTime(time: number, deltaTime: number): void;
+    dispose(): void;
+}
+export { PanoCircleMesh };
+export type { PanoCircleMeshOptions };

package/five/meshes/panoCircleMeshCustom.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from "three/webgpu";
+import { PanoCircleMeshInterface } from "../types/panoCircleMeshInterface";
+interface PanoCircleMeshCustomOptions {
+    scale?: number;
+    color?: number;
+    map?: THREE.Texture;
+    mapAlpha?: number;
+    borderWidth?: number;
+    borderColor?: number;
+    mapUseColor?: boolean;
+    mapUseReverse?: boolean;
+}
+declare class PanoCircleMeshCustom extends THREE.Object3D implements PanoCircleMeshInterface {
+    needsRender: boolean;
+    private currentStartTime;
+    private currentMotion;
+    private tapMotion;
+    private loadingOpacityMotion;
+    private progressMotion;
+    private progressOpacityMotion;
+    private opacityMotion;
+    private disableMotion;
+    progress: number;
+    opacity: number;
+    current: boolean;
+    loading: boolean;
+    disabled: boolean;
+    private panoMesh;
+    constructor(options?: PanoCircleMeshCustomOptions);
+    setProgress(progress: number): void;
+    setOpacity(opacity: number): void;
+    setCurrent(current: boolean): void;
+    setLoading(loading: boolean): void;
+    setDisabled(disabled: boolean): void;
+    tap(): Promise<void>;
+    updateTime(time: number, deltaTime: number): void;
+    dispose(): void;
+}
+export { PanoCircleMeshCustom };
+export type { PanoCircleMeshCustomOptions };

package/five/meshes/panoCircleMeshSolid.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from "three/webgpu";
+import { PanoCircleMeshInterface } from "../types/panoCircleMeshInterface";
+interface PanoCircleMeshSolidOptions {
+    scale?: number;
+    color?: number;
+}
+declare class PanoCircleMeshSolid extends THREE.Object3D implements PanoCircleMeshInterface {
+    needsRender: boolean;
+    private currentStartTime;
+    private currentMotion;
+    private tapMotion;
+    private loadingOpacityMotion;
+    private progressMotion;
+    private progressOpacityMotion;
+    private opacityMotion;
+    private disableMotion;
+    progress: number;
+    opacity: number;
+    current: boolean;
+    loading: boolean;
+    disabled: boolean;
+    private panoMesh;
+    private panoU;
+    constructor(options?: PanoCircleMeshSolidOptions);
+    setProgress(progress: number): void;
+    setOpacity(opacity: number): void;
+    setCurrent(current: boolean): void;
+    setLoading(loading: boolean): void;
+    setDisabled(disabled: boolean): void;
+    tap(): Promise<void>;
+    updateTime(time: number, deltaTime: number): void;
+    dispose(): void;
+}
+export { PanoCircleMeshSolid };
+export type { PanoCircleMeshSolidOptions };

package/five/meshes/panoSphereMesh.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three/webgpu";
+import { PanoCircleMeshInterface } from "../types/panoCircleMeshInterface";
+declare class PanoSphereMesh extends THREE.Object3D implements PanoCircleMeshInterface {
+    needsRender: boolean;
+    hitTestMesh: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
+    private ringMesh;
+    private panoMesh;
+    private ringU;
+    private panoU;
+    private currentMotion;
+    private opacityMotion;
+    private loadingMotion;
+    private disableMotion;
+    progress: number;
+    opacity: number;
+    current: boolean;
+    loading: boolean;
+    disabled: boolean;
+    constructor();
+    setProgress(progress: number): void;
+    setOpacity(opacity: number): void;
+    setCurrent(current: boolean): void;
+    setLoading(loading: boolean): void;
+    setDisabled(disabled: boolean): void;
+    tap(): Promise<void>;
+    updateTime(time: number, deltaTime: number): void;
+    dispose(): void;
+}
+export { PanoSphereMesh };

package/five/model/helpers/coordinate-transform.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three/webgpu';
+export declare const enuToLocalMatrix: THREE.Matrix4;
+export declare const localToEnuMatrix: THREE.Matrix4;

package/five/model/helpers/ellipsoid-coordinates.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three/webgpu';
+/**
+ * 坐标转化 ecef -> lla
+ * @param vector x: lat, y: lon, z: alt
+ * @returns ecef 坐标系下的 xyz
+ */
+export declare function ecefToLla(vector: THREE.Vector3): THREE.Vector3;
+/**
+ * 坐标转化 lla -> ecef
+ * @param vector ecef 坐标系下的 xyz
+ * @returns x: lat, y: lon, z: alt
+ */
+export declare function llaToEcef(vector: THREE.Vector3): THREE.Vector3;
+export declare function getEcefToEnuMatrix(vector: THREE.Vector3, target: THREE.Matrix4): THREE.Matrix4;

package/five/model/helpers/get-edges-by-sphere.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three/webgpu";
+/**
+ * 获取模型边界线
+ * @param sphere - 获取区域
+ * @param threshold - 面片间夹角阈值
+ * @returns 所有模型边界线
+ */
+export declare function getEdgesBySphere(object: THREE.Object3D, sphere: THREE.Sphere, threshold?: number): THREE.Line3[];

package/five/model/helpers/get-recommend-tile3d-parameters.d.ts

@@ -0,0 +1,8 @@
+import type { Tile3D } from '../tile3d';
+export declare function getRecommendTile3dProps(tile3d: Tile3D, options?: {
+    powerPreference?: 'high' | 'default';
+}): {
+    pointScale: number;
+    pointMinPixel: number;
+    maxScreenSpaceError: number;
+};

package/five/model/index.d.ts

@@ -0,0 +1,55 @@
+export { PBMGroup } from "./objects/pbmGroup";
+export { PBMMesh, PBMSkinnedMesh, } from "./objects/pbmMesh";
+export { PBMGaussianSplattingObject, type SplatData, } from "./objects/pbmGaussianSplattingObject";
+export { PBMGaussianSplattingObject as PBMGSObject, } from "./objects/pbmGaussianSplattingObject";
+export { PBMPointCloud, type PointCloudData, } from "./objects/pbmPointCloud";
+export { PBMGaussianSplattingRenderMesh, } from "./objects/pbmGaussianSplattingRenderMesh";
+export { PBMGaussianSplattingNodeMaterial, } from "./materials/pbmGaussianSplattingNodeMaterial";
+export { PBMUpdateable, PBMPanoFilter, type IPBMMaterial, type PBMPanoFilterValue, type PBMAlphaMode, type PBMClipperParameter, type PBMColorStyle, type PBMFloorStyle, type PBMPanoPicture, type PBMHDRConfig, type PBMPanoDepth, type PBMPointBack, type PBMPointCloudShaderType, type PBMPointShape, type PBMPointSize, type PBMRefinedScreen, type PBMTransition, } from "./materials/pbmMaterial";
+export { type PBMMeshMaterial, PBMMeshBasicMaterial, PBMMeshPhongMaterial, PBMMeshPhysicalMaterial, PBMMeshPanoOnlyMaterial } from './materials/pbmMeshMaterial';
+export { registerPBMMaterials, } from './materials/pbmMaterialRegister';
+export { PBMMeshBasicNodeMaterial, } from './materials/nodes/pbmMeshBasicNodeMaterial';
+export { PBMMeshPhongNodeMaterial, } from './materials/nodes/pbmMeshPhongNodeMaterial';
+export { PBMMeshPhysicalNodeMaterial, } from './materials/nodes/pbmMeshPhysicalNodeMaterial';
+export { PBMMeshPanoOnlyNodeMaterial, } from './materials/nodes/pbmMeshPanoOnlyNodeMaterial';
+export { type LoadResultType } from "./loaders/shared";
+export { loadPbm } from "./loaders/pbm";
+export { loadAt3d } from "./loaders/at3d";
+export { loadDome } from "./loaders/dome";
+export { loadDomez } from "./loaders/domez";
+export { loadPly } from "./loaders/ply";
+export { loadGltf } from "./loaders/gltf";
+export { type TilesetHeader, type TileHeader, type TrajectoryHeader } from './tile3d/header';
+export { Tile, type TileContentData } from './tile3d/tile';
+export { TileNode } from './tile3d/tile-node';
+export { Trajectory, type TrajectoryContentData, } from './tile3d/trajectory';
+export { TrajectoryNode } from './tile3d/trajectory-node';
+export { Tileset, type TilesetOptions } from './tile3d/tileset';
+export { TileCache, type TileCacheOptions, } from './tile3d/tile-cache';
+export { TileRequestScheduler, type TileRequestSchedulerOptions, } from './tile3d/tile-request-scheduler';
+export { type FrameState as TilesetFrameState, type TileRequestOrder, } from './tile3d/types';
+export { Tile3D, 
+/**
+ * @deprecated
+ * use Tile3D insread.
+ */
+Tile3D as Tile3DModel, type Tile3DOptions, 
+/**
+ * @deprecated
+ * use Tile3DOptions insread.
+ */
+type Tile3DOptions as Tile3DModelLoaderOptions, type TileCoordinateSystem, } from './tile3d';
+export { type ViewLayer } from './view-layer';
+export { Model, } from './model';
+export { ModelScene, type ModelOptions, type Models } from './model-scene';
+export { Parameter, type ParameterValue, 
+/**
+ * @deprecated
+ * use ParameterValue instead
+ */
+type ParameterValue as PBMParameters, type ResolvedParameterValue, type ParameterMaterialValue, 
+/**
+ * @deprecated
+ * use ParameterMaterialValue instead
+ */
+type ParameterMaterialValue as ModelMaterialValues, type ParameterTilesetValue } from './parameter';

package/five/model/intersection.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three/webgpu';
+import { type ViewLayer } from './view-layer';
+import { type Model } from './model';
+import { type Tile } from './tile3d/tile';
+export interface Intersection extends THREE.Intersection {
+    /** 楼层 */
+    floorIndex: number;
+    /**
+     * 楼层
+     * @deprecated
+     * use floorIndex instead.
+     */
+    floor: number;
+    model?: Model;
+    viewLayer?: ViewLayer;
+    tile?: Tile;
+}
+export declare function sortIntersects(intersects: Intersection[], sortByDistance?: boolean, firstHitOnly?: boolean): Intersection[];

package/five/model/loaders/at3d.d.ts

@@ -0,0 +1,12 @@
+import { Fetcher } from "../../utils/ajax";
+import { LoadResultType } from './shared';
+import { TextureOptions } from "../../types/imageOptions";
+export declare function loadAt3d(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
+    light?: boolean;
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    textureArray?: string[];
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;

package/five/model/loaders/b3dm.d.ts

@@ -0,0 +1,10 @@
+import { Fetcher } from '../../utils/ajax';
+import { LoadResultType } from './shared';
+export declare function loadB3dm(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
+    upAxis?: 'Y' | 'Z';
+    light?: boolean;
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+    jsonModify?: (json: any) => any;
+}): Promise<LoadResultType>;

package/five/model/loaders/dome.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from "three/webgpu";
+import { LoadResultType } from './shared';
+import { Fetcher } from "../../utils/ajax";
+import { WorkModel } from "../../work";
+import { PBMMesh } from "../objects/pbmMesh";
+import { TextureOptions } from "../../types/imageOptions";
+export declare function loadDome(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
+    light?: boolean;
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;
+declare function parse(domeBuffer: ArrayLike<number>, light: boolean, textureBase: WorkModel["textureBase"], textureOptions: TextureOptions, fetcher: Fetcher): Promise<{
+    createAt: number;
+    description: string;
+    objects: (THREE.Group<THREE.Object3DEventMap> | PBMMesh)[];
+    textures: THREE.Texture<unknown>[];
+    dispose: () => void;
+}>;
+export { parse };

package/five/model/loaders/domez.d.ts

@@ -0,0 +1,11 @@
+import { LoadResultType } from "./shared";
+import { Fetcher } from "../../utils/ajax";
+import { TextureOptions } from "../../types/imageOptions";
+export declare function loadDomez(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
+    light?: boolean;
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;

package/five/model/loaders/fbx.d.ts

@@ -0,0 +1,8 @@
+import { Fetcher } from "../../utils/ajax";
+import { LoadResultType } from './shared';
+export declare function loadFbx(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
+    light?: boolean;
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;

package/five/model/loaders/glTF-helpers/extensions/CESIUM_RTC.d.ts

@@ -0,0 +1,9 @@
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import type { GlTFResult } from '../type';
+/**
+ * Specification https://github.com/KhronosGroup/glTF/blob/main/extensions/1.0/Vendor/CESIUM_RTC/README.md
+ */
+export declare class CESIUM_RTC extends BaseExtension {
+    emitResult(result: GlTFResult, parser: Parser): void | Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/EXT_meshopt_compression.d.ts

@@ -0,0 +1,8 @@
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
+ */
+export declare class EXT_meshopt_compression extends BaseExtension {
+    loadBufferView(index: number, parser: Parser): Promise<ArrayBuffer> | null;
+}

package/five/model/loaders/glTF-helpers/extensions/EXT_texture_webp.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
+ */
+export declare class EXT_texture_webp extends BaseExtension {
+    private supportsWep;
+    prepare(parser: Parser): void | Promise<void>;
+    loadTexture(index: number, parser: Parser): null | Promise<THREE.Texture>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_animation_pointer.d.ts

@@ -0,0 +1,6 @@
+import { BaseExtension } from './base';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_animation_pointer
+ */
+export declare class KHR_animation_pointer extends BaseExtension {
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_binary_glTF.d.ts

@@ -0,0 +1,25 @@
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/1.0/Khronos/KHR_binary_glTF
+ */
+export declare class KHR_binary_glTF extends BaseExtension {
+    static HEADER_MAGIC: string;
+    static HEADER_LENGTH: number;
+    static CHUNK_TYPES: {
+        JSON: number;
+        BIN: number;
+    };
+    static getMagic(data: ArrayBuffer): string;
+    header: {
+        magic: string;
+        version: number;
+        length: number;
+    };
+    content: string;
+    body: ArrayBuffer | null;
+    constructor();
+    loadGlbBinary(data: ArrayBuffer): void;
+    loadBuffer(index: number, parser: Parser): Promise<ArrayBuffer> | null;
+    clear(): void;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_draco_mesh_compression.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_draco_mesh_compression
+ */
+export declare class KHR_draco_mesh_compression extends BaseExtension {
+    loadGeometry(primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.BufferGeometry>;
+    private decodePrimitive;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_gaussian_splatting.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { Mesh, MeshPrimitive } from '../glTF';
+import type { GaussianSplattingExtensionSpz2 } from './KHR_gaussian_splatting_compression_spz_2';
+export interface GaussianSplattingExtensionOld {
+    antialiased: boolean;
+    bufferView: number;
+    compression: {
+        extension: "KHR_gaussian_splatting_compression_spz";
+    };
+    count: number;
+}
+export interface GaussianSplattingExtension {
+    colorSpace: "srgb_rec709_display" | "lin_rec709_display";
+    kernel: "ellipse";
+    sortingMethod: "cameraDistance";
+    projection: "perspective";
+    extensions: {
+        KHR_gaussian_splatting_compression_spz_2?: GaussianSplattingExtensionSpz2;
+    };
+}
+export declare class KHR_gaussian_splatting extends BaseExtension {
+    loadMeshPrimitive(meshDef: Mesh, primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.Points | THREE.Line | THREE.Mesh>;
+    private loadGaussianSplating;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_gaussian_splatting_compression_spz.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { PBMGaussianSplattingObject } from '../../../objects/pbmGaussianSplattingObject';
+export declare const EXTENSION_NAME = "KHR_gaussian_splatting_compression_spz";
+export declare class KHR_gaussian_splatting_compression_spz extends BaseExtension {
+    load(gaussianSplattingExtension: {
+        bufferView: number;
+    }, parser: Parser): Promise<THREE.Points>;
+    loadSpz(buffer: Uint8Array): Promise<PBMGaussianSplattingObject>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_gaussian_splatting_compression_spz_2.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { PBMGaussianSplattingObject } from '../../../objects/pbmGaussianSplattingObject';
+export interface GaussianSplattingExtensionSpz2 {
+    bufferView: number;
+}
+export declare const EXTENSION_NAME = "KHR_gaussian_splatting_compression_spz_2";
+export declare class KHR_gaussian_splatting_compression_spz_2 extends BaseExtension {
+    constructor();
+    load(gaussianSplattingExtension: GaussianSplattingExtensionSpz2, parser: Parser): Promise<THREE.Points>;
+    loadSpz(buffer: Uint8Array): Promise<PBMGaussianSplattingObject>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_materials_clearcoat.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
+ */
+export declare class KHR_materials_clearcoat extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_materials_emissive_strength.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_emissive_strength
+ */
+export declare class KHR_materials_emissive_strength extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_materials_sheen.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
+ */
+export declare class KHR_materials_sheen extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_materials_transmission.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
+ */
+export declare class KHR_materials_transmission extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_materials_unlit.d.ts

@@ -0,0 +1,12 @@
+import { BaseExtension } from './base';
+declare const EXTENSION_NAME = "KHR_materials_unlit";
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_unlit
+ *
+ * WebGPU 下：material 类已在 parser.loadMaterialAsPBMMeshMaterial 阶段根据是否带
+ * `KHR_materials_unlit` 预先选择了 PBMMeshBasicNodeMaterial / PBMMeshPhysicalMaterial，
+ * 因此这里无需再做 shaderType 切换（旧 WebGL 版本的逻辑），保持空实现即可。
+ */
+export declare class KHR_materials_unlit extends BaseExtension {
+}
+export { EXTENSION_NAME };

package/five/model/loaders/glTF-helpers/extensions/KHR_mesh_quantization.d.ts

@@ -0,0 +1,6 @@
+import { BaseExtension } from './base';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_mesh_quantization
+ */
+export declare class KHR_mesh_quantization extends BaseExtension {
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_node_visibility.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { Node } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_node_visibility
+ */
+export declare class KHR_node_visibility extends BaseExtension {
+    extendNode(node: THREE.Object3D, nodeDef: Node, parser: Parser): Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_texture_basisu.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_basisu
+ */
+export declare class KHR_texture_basisu extends BaseExtension {
+    loadTexture(index: number, parser: Parser): Promise<THREE.Texture> | null;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_texture_transform.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { TextureInfo } from '../glTF';
+/**
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform
+ */
+export declare class KHR_texture_transform extends BaseExtension {
+    extendTexture(texture: THREE.Texture, mapDef: TextureInfo, parser: Parser): null | THREE.Texture;
+}

package/five/model/loaders/glTF-helpers/extensions/REALSEE_materials_lightmap.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three/webgpu';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
+export declare class REALSEE_materials_lightmap extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
+}

package/five/model/loaders/glTF-helpers/extensions/base.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from 'three/webgpu';
+import type { Mesh, MeshPrimitive, TextureInfo, Node } from '../glTF';
+import type { Parser } from '../parser';
+import type { GlTFResult } from '../type';
+import type { ImageBitmapLike } from '../../../../texture/imageBitmap';
+export declare class BaseExtension {
+    markDefs(parser: Parser): void;
+    prepare(parser: Parser): void | Promise<void>;
+    emitResult(result: GlTFResult, parser: Parser): void | Promise<void>;
+    createPrimitiveKey(primitiveDef: MeshPrimitive, parser: Parser): void | string;
+    extendTexture(texture: THREE.Texture, mapDef: TextureInfo, parser: Parser): null | THREE.Texture;
+    loadBuffer(index: number, parser: Parser): null | Promise<ArrayBuffer>;
+    loadBufferView(index: number, parser: Parser): null | Promise<ArrayBuffer>;
+    loadImage(index: number, parser: Parser): null | Promise<ImageBitmapLike>;
+    loadTexture(index: number, parser: Parser): null | Promise<THREE.Texture>;
+    loadGeometry(primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.BufferGeometry>;
+    loadMaterial(primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.Material>;
+    loadMeshPrimitive(meshDef: Mesh, primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.Points | THREE.Line | THREE.Mesh>;
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
+    loadMesh(index: number, parser: Parser): null | Promise<THREE.Object3D>;
+    extendNode(node: THREE.Object3D, nodeDef: Node, parser: Parser): Promise<void>;
+    loadNodeAttachments(index: number, parser: Parser): null | Promise<THREE.Object3D>;
+    loadCamera(index: number, parser: Parser): null | Promise<THREE.Camera>;
+    loadAnimation(index: number, parser: Parser): null | Promise<THREE.AnimationClip>;
+}