three-stdlib 2.35.10 → 2.35.12

package/loaders/3MFLoader.d.cts

@@ -1,16 +0,0 @@
-import type { Loader, LoadingManager, Group } from 'three'
-
-export class ThreeMFLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  availableExtensions: object[]
-
-  load(
-    url: string,
-    onLoad: (object: Group) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
-  parse(data: ArrayBuffer): Group
-  addExtension(extension: object): void
-}

package/loaders/AMFLoader.d.cts

@@ -1,14 +0,0 @@
-import type { Loader, LoadingManager, Group } from 'three'
-
-export class AMFLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (object: Group) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
-  parse(data: ArrayBuffer): Group
-}

package/loaders/AssimpLoader.d.cts

@@ -1,19 +0,0 @@
-import type { Loader, Object3D, LoadingManager } from 'three'
-
-export interface Assimp {
-  animation: any
-  object: Object3D
-}
-
-export class AssimpLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (result: Assimp) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Assimp>
-  parse(buffer: ArrayBuffer, path: string): Assimp
-}

package/loaders/BVHLoader.d.cts

@@ -1,21 +0,0 @@
-import type { Loader, AnimationClip, Skeleton, LoadingManager } from 'three'
-
-export interface BVH {
-  clip: AnimationClip
-  skeleton: Skeleton
-}
-
-export class BVHLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  animateBonePositions: boolean
-  animateBoneRotations: boolean
-
-  load(
-    url: string,
-    onLoad: (bvh: BVH) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>
-  parse(text: string): BVH
-}

package/loaders/BasisTextureLoader.d.cts

@@ -1,32 +0,0 @@
-import type { Loader, CompressedTexture, LoadingManager, WebGLRenderer } from 'three'
-
-export class BasisTextureLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  transcoderBinary: ArrayBuffer | null
-  transcoderPath: string
-  transcoderPending: Promise<void> | null
-
-  workerConfig: {
-    format: number
-    astcSupported: boolean
-    etcSupported: boolean
-    dxtSupported: boolean
-    pvrtcSupported: boolean
-  }
-  workerLimit: number
-  workerNextTaskID: number
-  workerPool: object[]
-  workerSourceURL: string
-
-  detectSupport(renderer: WebGLRenderer): this
-  load(
-    url: string,
-    onLoad: (texture: CompressedTexture) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CompressedTexture>
-  setTranscoderPath(path: string): this
-  setWorkerLimit(workerLimit: number): this
-  dispose(): void
-}

package/loaders/ColladaLoader.d.cts

@@ -1,20 +0,0 @@
-import type { Loader, LoadingManager, Scene } from 'three'
-
-export interface Collada {
-  kinematics: object
-  library: object
-  scene: Scene
-}
-
-export class ColladaLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (collada: Collada) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>
-  parse(text: string, path: string): Collada
-}

package/loaders/DDSLoader.d.cts

@@ -1,16 +0,0 @@
-import type { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
-
-export interface DDS {
-  mipmaps: object[]
-  width: number
-  height: number
-  format: PixelFormat | CompressedPixelFormat
-  mipmapCount: number
-  isCubemap: boolean
-}
-
-export class DDSLoader extends CompressedTextureLoader {
-  constructor(manager?: LoadingManager)
-
-  parse(buffer: ArrayBuffer, loadMipmaps: boolean): DDS
-}

package/loaders/DRACOLoader.d.cts

@@ -1,18 +0,0 @@
-import type { Loader, LoadingManager, BufferGeometry } from 'three'
-
-export class DRACOLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (geometry: BufferGeometry) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>
-  setDecoderPath(path: string): DRACOLoader
-  setDecoderConfig(config: object): DRACOLoader
-  setWorkerLimit(workerLimit: number): DRACOLoader
-  preload(): DRACOLoader
-  dispose(): DRACOLoader
-}

package/loaders/EXRLoader.d.cts

@@ -1,18 +0,0 @@
-import type { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
-
-export interface EXR {
-  header: object
-  width: number
-  height: number
-  data: Float32Array
-  format: PixelFormat
-  type: TextureDataType
-}
-
-export class EXRLoader extends DataTextureLoader {
-  constructor(manager?: LoadingManager)
-  type: TextureDataType
-
-  parse(buffer: ArrayBuffer): EXR
-  setDataType(type: TextureDataType): this
-}

package/loaders/FBXLoader.d.cts

@@ -1,14 +0,0 @@
-import type { Loader, Group, LoadingManager } from 'three'
-
-export class FBXLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (object: Group) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
-  parse(FBXBuffer: ArrayBuffer | string, path: string): Group
-}

package/loaders/FontLoader.d.cts

@@ -1,37 +0,0 @@
-import type { Loader } from 'three';
-import type { LoadingManager, Shape } from 'three';
-type Options = {
-    lineHeight: number;
-    letterSpacing: number;
-};
-export declare class FontLoader extends Loader {
-    constructor(manager?: LoadingManager);
-    load(url: string, onLoad?: (responseFont: Font) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Font>;
-    parse(json: FontData): Font;
-}
-type Glyph = {
-    _cachedOutline: string[];
-    ha: number;
-    o: string;
-};
-type FontData = {
-    boundingBox: {
-        yMax: number;
-        yMin: number;
-    };
-    familyName: string;
-    glyphs: {
-        [k: string]: Glyph;
-    };
-    resolution: number;
-    underlineThickness: number;
-};
-export declare class Font {
-    data: FontData;
-    isFont: boolean;
-    type: string;
-    constructor(data: FontData);
-    generateShapes(text: string, size?: number, _options?: Partial<Options>): Shape[];
-}
-export type {};

package/loaders/GCodeLoader.d.cts

@@ -1,15 +0,0 @@
-import type { Loader, Group, LoadingManager } from 'three'
-
-export class GCodeLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  splitLayer: boolean
-
-  load(
-    url: string,
-    onLoad: (object: Group) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
-  parse(data: string): Group
-}

package/loaders/GLTFLoader.d.cts

@@ -1,155 +0,0 @@
-import type {
-  AnimationClip,
-  BufferAttribute,
-  BufferGeometry,
-  Camera,
-  Group,
-  InterleavedBufferAttribute,
-  LoadingManager,
-  Mesh,
-  MeshStandardMaterial,
-  Object3D,
-  Material,
-  SkinnedMesh,
-  Texture,
-  TextureLoader,
-  FileLoader,
-  ImageBitmapLoader,
-  Skeleton,
-  Loader,
-} from 'three'
-
-import type { DRACOLoader } from './DRACOLoader.d.cts'
-import type { KTX2Loader } from './KTX2Loader.d.cts'
-
-export interface GLTF {
-  animations: AnimationClip[]
-  scene: Group
-  scenes: Group[]
-  cameras: Camera[]
-  asset: {
-    copyright?: string | undefined
-    generator?: string | undefined
-    version?: string | undefined
-    minVersion?: string | undefined
-    extensions?: any
-    extras?: any
-  }
-  parser: GLTFParser
-  userData: any
-}
-
-export class GLTFLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  dracoLoader: DRACOLoader | null
-
-  load(
-    url: string,
-    onLoad: (gltf: GLTF) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<GLTF>
-
-  setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader
-
-  register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader
-  unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader
-
-  setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader
-  setMeshoptDecoder(meshoptDecoder: /* MeshoptDecoder */ any): GLTFLoader
-
-  parse(
-    data: ArrayBuffer | string,
-    path: string,
-    onLoad: (gltf: GLTF) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-
-  parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>
-}
-
-export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes'
-
-export interface GLTFReference {
-  materials?: number
-  nodes?: number
-  textures?: number
-  meshes?: number
-}
-
-export class GLTFParser {
-  json: any
-
-  options: {
-    path: string
-    manager: LoadingManager
-    ktx2Loader: KTX2Loader
-    meshoptDecoder: /* MeshoptDecoder */ any
-    crossOrigin: string
-    requestHeader: { [header: string]: string }
-  }
-
-  fileLoader: FileLoader
-  textureLoader: TextureLoader | ImageBitmapLoader
-  plugins: { [name: string]: GLTFLoaderPlugin }
-  extensions: { [name: string]: any }
-  associations: Map<Object3D | Material | Texture, GLTFReference>
-
-  setExtensions(extensions: { [name: string]: any }): void
-  setPlugins(plugins: { [name: string]: GLTFLoaderPlugin }): void
-
-  parse(onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void
-
-  getDependency: (type: string, index: number) => Promise<any>
-  getDependencies: (type: string) => Promise<any[]>
-  loadBuffer: (bufferIndex: number) => Promise<ArrayBuffer>
-  loadBufferView: (bufferViewIndex: number) => Promise<ArrayBuffer>
-  loadAccessor: (accessorIndex: number) => Promise<BufferAttribute | InterleavedBufferAttribute>
-  loadTexture: (textureIndex: number) => Promise<Texture>
-  loadTextureImage: (textureIndex: number, sourceIndex: number, loader: Loader) => Promise<Texture>
-  loadImageSource: (sourceIndex: number, loader: Loader) => Promise<Texture>
-  assignTexture: (
-    materialParams: { [key: string]: any },
-    mapName: string,
-    mapDef: {
-      index: number
-      texCoord?: number | undefined
-      extensions?: any
-    },
-  ) => Promise<void>
-  assignFinalMaterial: (object: Mesh) => void
-  getMaterialType: () => typeof MeshStandardMaterial
-  loadMaterial: (materialIndex: number) => Promise<Material>
-  createUniqueName: (originalName: string) => string
-  createNodeMesh: (nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh>
-  loadGeometries: (
-    /**
-     * GLTF.Primitive[]
-     * See: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/mesh.primitive.schema.json
-     */
-    primitives: Array<{ [key: string]: any }>,
-  ) => Promise<BufferGeometry[]>
-  loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>
-  loadCamera: (cameraIndex: number) => Promise<Camera>
-  loadSkin: (skinIndex: number) => Promise<Skeleton>
-  loadAnimation: (animationIndex: number) => Promise<AnimationClip>
-  loadNode: (nodeIndex: number) => Promise<Object3D>
-  loadScene: () => Promise<Group>
-}
-
-export interface GLTFLoaderPlugin {
-  beforeRoot?: (() => Promise<void> | null) | undefined
-  afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined
-  loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined
-  loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined
-  loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined
-  loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined
-  loadTexture?: ((textureIndex: number) => Promise<Texture> | null) | undefined
-  getMaterialType?: ((materialIndex: number) => typeof Material | null) | undefined
-  extendMaterialParams?:
-    | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
-    | undefined
-  createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined
-  createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined
-}

package/loaders/HDRCubeTextureLoader.d.cts

@@ -1,18 +0,0 @@
-import type { Loader, CubeTexture, LoadingManager, TextureDataType } from 'three'
-
-import type { RGBELoader } from './RGBELoader.d.cts'
-
-export class HDRCubeTextureLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  hdrLoader: RGBELoader
-  type: TextureDataType
-
-  load(
-    urls: string | string[],
-    onLoad: (texture: CubeTexture) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): CubeTexture
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CubeTexture>
-  setDataType(type: TextureDataType): this
-}

package/loaders/KMZLoader.d.cts

@@ -1,16 +0,0 @@
-import type { Loader, LoadingManager } from 'three'
-
-import type { Collada } from './ColladaLoader.d.cts'
-
-export class KMZLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (kmz: Collada) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>
-  parse(data: ArrayBuffer): Collada
-}

package/loaders/KTX2Loader.d.cts

@@ -1,10 +0,0 @@
-import type { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from 'three'
-
-export class KTX2Loader extends CompressedTextureLoader {
-  constructor(manager?: LoadingManager)
-
-  setTranscoderPath(path: string): KTX2Loader
-  setWorkerLimit(limit: number): KTX2Loader
-  detectSupport(renderer: WebGLRenderer): KTX2Loader
-  dispose(): KTX2Loader
-}

package/loaders/KTXLoader.d.cts

@@ -1,16 +0,0 @@
-import type { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
-
-export interface KTX {
-  mipmaps: object[]
-  width: number
-  height: number
-  format: PixelFormat | CompressedPixelFormat
-  mipmapCount: number
-  isCubemap: boolean
-}
-
-export class KTXLoader extends CompressedTextureLoader {
-  constructor(manager?: LoadingManager)
-
-  parse(buffer: ArrayBuffer, loadMipmaps: boolean): KTX
-}

package/loaders/LDrawLoader.d.cts

@@ -1,26 +0,0 @@
-import type { Loader, LoadingManager, Group, Material } from 'three'
-
-export class LDrawLoader extends Loader {
-  materials: Material[]
-  materialsLibrary: Record<string, Material>
-  fileMap: Record<string, string>
-  smoothNormals: boolean
-
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (data: Group) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
-  preloadMaterials(url: string): Promise<void>
-  setFileMap(fileMap: Record<string, string>): void
-  setMaterials(materials: Material[]): void
-
-  parse(text: string, path: string, onLoad: (data: Group) => void): void
-
-  addMaterial(material: Material): void
-  getMaterial(colourCode: string): Material | null
-}

package/loaders/LUT3dlLoader.d.cts

@@ -1,20 +0,0 @@
-import type { Loader, LoadingManager, DataTexture, Texture } from 'three'
-
-export interface LUT3dlResult {
-  size: number
-  texture: DataTexture
-  texture3D: Texture // Data3DTexture
-}
-
-export class LUT3dlLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (result: LUT3dlResult) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: Error) => void,
-  ): any
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUT3dlResult>
-  parse(data: string): LUT3dlResult
-}

package/loaders/LUTCubeLoader.d.cts

@@ -1,23 +0,0 @@
-import type { Loader, LoadingManager, Vector3, DataTexture, Texture } from 'three'
-
-export interface LUTCubeResult {
-  title: string
-  size: number
-  domainMin: Vector3
-  domainMax: Vector3
-  texture: DataTexture
-  texture3D: Texture // Data3DTexture
-}
-
-export class LUTCubeLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (result: LUTCubeResult) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: Error) => void,
-  ): any
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUTCubeResult>
-  parse(data: string): LUTCubeResult
-}

package/loaders/LWOLoader.d.cts

@@ -1,26 +0,0 @@
-import type { Loader, LoadingManager, Material, Object3D } from 'three'
-
-export interface LWO {
-  materials: Material[]
-  meshes: Object3D[]
-}
-
-export interface LWOLoaderParameters {
-  /**
-   * Base content delivery folder path, use when it differs from Lightwave default structure
-   */
-  resourcePath?: string
-}
-
-export class LWOLoader extends Loader {
-  constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters)
-
-  load(
-    url: string,
-    onLoad: (lwo: LWO) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LWO>
-  parse(data: ArrayBuffer, path: string, modelName: string): LWO
-}

package/loaders/LottieLoader.d.cts

@@ -1,15 +0,0 @@
-import type { Loader, CanvasTexture, LoadingManager } from 'three'
-
-export class LottieLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (texture: CanvasTexture) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CanvasTexture>
-
-  setQuality(value: number): void
-}

package/loaders/MD2Loader.d.cts

@@ -1,14 +0,0 @@
-import type { Loader, BufferGeometry, LoadingManager } from 'three'
-
-export class MD2Loader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (geometry: BufferGeometry) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>
-  parse(data: ArrayBuffer): BufferGeometry
-}

package/loaders/MDDLoader.d.cts

@@ -1,19 +0,0 @@
-import type { Loader, AnimationClip, BufferAttribute, LoadingManager } from 'three'
-
-export interface MDD {
-  morphTargets: BufferAttribute[]
-  clip: AnimationClip
-}
-
-export class MDDLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (result: MDD) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>
-  parse(data: ArrayBuffer): MDD
-}