@realsee/five 6.8.0-alpha.0 → 6.8.0-alpha.10

package/five/model/loaders/glTF-helpers/index.d.ts

@@ -0,0 +1,47 @@
+import { Fetcher } from '../../../utils/ajax';
+import { GlTF } from './glTF';
+import type { GlTFResult } from './type';
+import { KHR_binary_glTF } from './extensions/KHR_binary_glTF';
+import { KHR_draco_mesh_compression } from './extensions/KHR_draco_mesh_compression';
+import { KHR_texture_basisu } from './extensions/KHR_texture_basisu';
+import { KHR_texture_transform } from './extensions/KHR_texture_transform';
+import { KHR_mesh_quantization } from './extensions/KHR_mesh_quantization';
+import { KHR_materials_unlit } from './extensions/KHR_materials_unlit';
+import { KHR_node_visibility } from './extensions/KHR_node_visibility';
+import { KHR_animation_pointer } from './extensions/KHR_animation_pointer';
+import { KHR_materials_clearcoat } from './extensions/KHR_materials_clearcoat';
+import { KHR_materials_sheen } from './extensions/KHR_materials_sheen';
+import { KHR_materials_transmission } from './extensions/KHR_materials_transmission';
+import { KHR_materials_emissive_strength } from './extensions/KHR_materials_emissive_strength';
+import { EXT_meshopt_compression } from './extensions/EXT_meshopt_compression';
+import { EXT_texture_webp } from './extensions/EXT_texture_webp';
+import { CESIUM_RTC } from './extensions/CESIUM_RTC';
+import { REALSEE_materials_lightmap } from './extensions/REALSEE_materials_lightmap';
+import { KHR_gaussian_splatting_compression_spz } from './extensions/KHR_gaussian_splatting_compression_spz';
+export declare const EXTENSIONS: {
+    KHR_binary_glTF: typeof KHR_binary_glTF;
+    KHR_draco_mesh_compression: typeof KHR_draco_mesh_compression;
+    KHR_texture_basisu: typeof KHR_texture_basisu;
+    KHR_texture_transform: typeof KHR_texture_transform;
+    KHR_mesh_quantization: typeof KHR_mesh_quantization;
+    KHR_materials_unlit: typeof KHR_materials_unlit;
+    KHR_node_visibility: typeof KHR_node_visibility;
+    KHR_animation_pointer: typeof KHR_animation_pointer;
+    KHR_materials_clearcoat: typeof KHR_materials_clearcoat;
+    KHR_materials_sheen: typeof KHR_materials_sheen;
+    KHR_materials_transmission: typeof KHR_materials_transmission;
+    KHR_materials_emissive_strength: typeof KHR_materials_emissive_strength;
+    EXT_meshopt_compression: typeof EXT_meshopt_compression;
+    EXT_texture_webp: typeof EXT_texture_webp;
+    CESIUM_RTC: typeof CESIUM_RTC;
+    REALSEE_materials_lightmap: typeof REALSEE_materials_lightmap;
+    KHR_gaussian_splatting_compression_spz: typeof KHR_gaussian_splatting_compression_spz;
+};
+export { GlTFResult };
+export declare function parseGltf(data: ArrayBuffer | string, options: {
+    copyUV2?: boolean;
+    resourcePath?: string;
+    search?: string;
+    jsonModify?: (json: GlTF) => GlTF;
+    fetcher: Fetcher;
+}): Promise<GlTFResult>;

package/five/model/loaders/glTF-helpers/parser.d.ts

@@ -0,0 +1,114 @@
+import * as THREE from 'three';
+import { GlTF, TextureInfo, MeshPrimitive } from './glTF';
+import type { GlTFResult } from './type';
+import { BaseExtension } from './extensions/base';
+import { Fetcher } from '../../../utils/ajax';
+import { PBMMeshMaterial } from '../../materials/pbmMeshMaterial';
+import { PBMPointCloudMaterial } from '../../materials/pbmPointCloudMaterial';
+import { ImageBitmapLike } from '../../../texture/imageBitmap';
+type ParserOptions = {
+    copyUV2: boolean;
+    resourcePath: string;
+    search: string;
+    fetcher: Fetcher;
+};
+type SkinEntry = {
+    joints: number[];
+    inverseBindMatrices?: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
+};
+export declare class Parser {
+    json: GlTF;
+    extensions: Record<string, BaseExtension>;
+    options: ParserOptions;
+    cache: Map<string, any>;
+    disposeSet: Set<{
+        dispose?: () => void;
+        close?: () => void;
+    }>;
+    textureSet: Set<THREE.Texture>;
+    private nodeNamesUsed;
+    constructor(json: GlTF, extensions: Record<string, BaseExtension>, options: ParserOptions);
+    dispose(): void;
+    markDefs(): void;
+    parse(): Promise<GlTFResult>;
+    /**
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+     * @param index
+     * @returns
+     */
+    loadCamera(index: number): Promise<THREE.Camera>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+     * @param index
+     * @return
+     */
+    loadSkin(index: number): Promise<SkinEntry>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+     * @param index
+     */
+    loadAnimation(index: number): Promise<THREE.AnimationClip>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+     * @param index
+     * @returns
+     */
+    loadBuffer(index: number): Promise<ArrayBuffer>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+     * @param index
+     * @returns
+     */
+    loadBufferView(index: number): Promise<ArrayBuffer>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+     * @param index
+     */
+    loadAccessor(index: number): Promise<THREE.BufferAttribute | THREE.InterleavedBufferAttribute | null>;
+    createPrimitiveKey(primitiveDef: MeshPrimitive): string;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
+     * @param primitiveDef
+     */
+    loadGeometry(primitiveDef: MeshPrimitive): Promise<THREE.BufferGeometry>;
+    loadImage(index: number): Promise<ImageBitmapLike>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+     * @param index
+     */
+    loadMesh(index: number): Promise<THREE.Object3D>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+     * @param primitiveDef
+     */
+    loadMaterial(primitiveDef: MeshPrimitive): Promise<THREE.Material>;
+    loadMaterialAsPBMPointCloudMaterial(primitiveDef: MeshPrimitive): Promise<PBMPointCloudMaterial>;
+    loadMaterialAsPBMMeshMaterial(primitiveDef: MeshPrimitive): Promise<PBMMeshMaterial>;
+    loadMaterialAsLineBasicMaterial(primitiveDef: MeshPrimitive): Promise<THREE.LineBasicMaterial>;
+    loadTexture(index: number): Promise<THREE.Texture>;
+    /**
+     * 当骨骼权重和不足 1 时，可能出现问题。
+     * skinnedMesh.normalizeSkinWeights 只能处理非 normalized 的数据。
+     * 需要对 normalized 也做检测。
+     */
+    normalizeSkinWeights(skinnedMesh: THREE.SkinnedMesh): void;
+    assignFinalMaterial(mesh: THREE.Points | THREE.Line | THREE.Mesh): void;
+    loadNodeAttachments(index: number): Promise<THREE.Object3D>[];
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+     * @param index
+     * @returns
+     */
+    loadNode(index: number): Promise<THREE.Object3D>;
+    /**
+     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+     * @param index
+     */
+    loadScene(index: number): Promise<THREE.Group>;
+    createMaterialTexture(mapDef: TextureInfo): Promise<THREE.Texture>;
+    addGeometryPrimitiveAttributes(geometry: THREE.BufferGeometry, primitiveDef: MeshPrimitive): Promise<THREE.BufferGeometry>;
+    buildNodeHierarchy(nodeId: number, parentObject: THREE.Object3D): Promise<THREE.Object3D>;
+    resolveResouce(uri: string): string;
+    toGeometryTrianglesDrawMode(geometry: THREE.BufferGeometry, drawMode: THREE.TrianglesDrawModes): THREE.BufferGeometry;
+}
+export {};

package/five/model/loaders/glTF-helpers/type.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import { GlTF } from './glTF';
+export type GlTFResult = {
+    json: GlTF;
+    scenes: THREE.Object3D[];
+    scene: THREE.Object3D;
+    animations: THREE.AnimationClip[];
+    cameras: THREE.Camera[];
+    textures: THREE.Texture[];
+    CESIUM_RTC?: {
+        center: THREE.Vector3;
+    };
+    dispose: () => void;
+};

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

@@ -0,0 +1,10 @@
+import { Fetcher } from "../../utils/ajax";
+import { LoadResultType } from './shared';
+export declare function loadGltf(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/obj.d.ts

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

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

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import { LoadResultType } from './shared';
+import { TextureOptions } from "../../types/imageOptions";
+import { Fetcher } from "../../utils/ajax";
+import { PBMMesh } from "../objects/pbmMesh";
+import { IModel } from "./protobuf/pbm";
+declare function guessTextureBaseUriFromFileUrl(url: string): string;
+export declare function loadPbm(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>;
+declare function loadTexture(url: string, textureOptions: TextureOptions, fetcher: Fetcher): Promise<THREE.Texture>;
+declare function parse(pbmModel: IModel, light: boolean, textureBaseUri: string, textures: string[], textureOptions: TextureOptions, textureCachePromiseMap: Map<string, Promise<THREE.Texture>> | null, fetcher: Fetcher): Promise<{
+    createAt: number;
+    description: string;
+    objects: PBMMesh[];
+    textures: THREE.Texture[];
+    dispose: () => void;
+}>;
+declare function autoRestImageOptionsByTextureLength(textureOptions: TextureOptions, textureLength: number): TextureOptions;
+export { parse, loadTexture, autoRestImageOptionsByTextureLength, guessTextureBaseUriFromFileUrl, };

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

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import { Fetcher } from "../../utils/ajax";
+import { LoadResultType } from './shared';
+import { PBMPointCloud } from '../objects/pbmPointCloud';
+import { PBMMesh } from '../objects/pbmMesh';
+export declare function loadPly<Type extends 'geometry' | 'line' | 'pbmMesh' | 'pbmPointCloud', ResultType = {
+    'geometry': THREE.BufferGeometry;
+    'line': THREE.Line<THREE.BufferGeometry>;
+    'pbmMesh': PBMMesh;
+    'pbmPointCloud': PBMPointCloud;
+}[Type]>(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
+    upAxis?: 'Y' | 'Z';
+    light?: boolean;
+    propertyNameMapping?: Record<string, string>;
+    customPropertyMapping?: Record<string, {
+        itemType: 'float32' | 'uint32' | 'int32' | 'uint16' | 'int16' | 'uint8' | 'int8';
+        itemNames: string[];
+        normalized?: boolean;
+    }>;
+    type?: Type;
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType<ResultType>>;

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

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