three-stdlib 2.35.7 → 2.35.9

package/loaders/MMDLoader.d.cts

@@ -0,0 +1,63 @@
+import type { Loader, Camera, AnimationClip, FileLoader, LoadingManager, SkinnedMesh } from 'three'
+
+export interface MMDLoaderAnimationObject {
+  animation: AnimationClip
+  mesh: SkinnedMesh
+}
+
+export class MMDLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  animationBuilder: object
+  animationPath: string
+  loader: FileLoader
+  meshBuilder: object
+  parser: object | null
+
+  load(
+    url: string,
+    onLoad: (mesh: SkinnedMesh) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<SkinnedMesh>
+  loadAnimation(
+    url: string,
+    object: SkinnedMesh | Camera,
+    onLoad: (object: SkinnedMesh | AnimationClip) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadPMD(
+    url: string,
+    onLoad: (object: object) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadPMX(
+    url: string,
+    onLoad: (object: object) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadVMD(
+    url: string,
+    onLoad: (object: object) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadVPD(
+    url: string,
+    isUnicode: boolean,
+    onLoad: (object: object) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadWithAnimation(
+    url: string,
+    vmdUrl: string | string[],
+    onLoad: (object: MMDLoaderAnimationObject) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  setAnimationPath(animationPath: string): this
+}

package/loaders/MMDLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Camera, AnimationClip, FileLoader, LoadingManager, SkinnedMesh } from 'three'
+import type { Loader, Camera, AnimationClip, FileLoader, LoadingManager, SkinnedMesh } from 'three'
 
 export interface MMDLoaderAnimationObject {
   animation: AnimationClip

package/loaders/MTLLoader.d.cts

@@ -0,0 +1,100 @@
+import type { Loader, Material, LoadingManager, Mapping, BufferGeometry, Side, Texture, Vector2, Wrapping } from 'three'
+
+export interface MaterialCreatorOptions {
+  /**
+   * side: Which side to apply the material
+   * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide
+   */
+  side?: Side | undefined
+  /*
+   * wrap: What type of wrapping to apply for textures
+   * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping
+   */
+  wrap?: Wrapping | undefined
+  /*
+   * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255
+   * Default: false, assumed to be already normalized
+   */
+  normalizeRGB?: boolean | undefined
+  /*
+   * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's
+   * Default: false
+   */
+  ignoreZeroRGBs?: boolean | undefined
+  /*
+   * invertTrProperty: Use values 1 of Tr field for fully opaque. This option is useful for obj
+   * exported from 3ds MAX, vcglib or meshlab.
+   * Default: false
+   */
+  invertTrProperty?: boolean | undefined
+}
+
+export class MTLLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  materialOptions: MaterialCreatorOptions
+
+  load(
+    url: string,
+    onLoad: (materialCreator: MaterialCreator) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  parse(text: string, path: string): MaterialCreator
+  setMaterialOptions(value: MaterialCreatorOptions): void
+
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MaterialCreator>
+}
+
+export interface MaterialInfo {
+  ks?: number[] | undefined
+  kd?: number[] | undefined
+  ke?: number[] | undefined
+  map_kd?: string | undefined
+  map_ks?: string | undefined
+  map_ke?: string | undefined
+  norm?: string | undefined
+  map_bump?: string | undefined
+  bump?: string | undefined
+  map_d?: string | undefined
+  ns?: number | undefined
+  d?: number | undefined
+  tr?: number | undefined
+}
+
+export interface TexParams {
+  scale: Vector2
+  offset: Vector2
+  url: string
+}
+
+export class MaterialCreator {
+  constructor(baseUrl?: string, options?: MaterialCreatorOptions)
+
+  baseUrl: string
+  options: MaterialCreatorOptions
+  materialsInfo: { [key: string]: MaterialInfo }
+  materials: { [key: string]: Material }
+  private materialsArray: Material[]
+  nameLookup: { [key: string]: number }
+  side: Side
+  wrap: Wrapping
+  crossOrigin: string
+
+  setCrossOrigin(value: string): this
+  setManager(value: LoadingManager): void
+  setMaterials(materialsInfo: { [key: string]: MaterialInfo }): void
+  convert(materialsInfo: { [key: string]: MaterialInfo }): { [key: string]: MaterialInfo }
+  preload(): void
+  getIndex(materialName: string): number
+  getAsArray(): Material[]
+  create(materialName: string): Material
+  createMaterial_(materialName: string): Material
+  getTextureParams(value: string, matParams: any): TexParams
+  loadTexture(
+    url: string,
+    mapping?: Mapping,
+    onLoad?: (bufferGeometry: BufferGeometry) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): Texture
+}

package/loaders/MTLLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Material, LoadingManager, Mapping, BufferGeometry, Side, Texture, Vector2, Wrapping } from 'three'
+import type { Loader, Material, LoadingManager, Mapping, BufferGeometry, Side, Texture, Vector2, Wrapping } from 'three'
 
 export interface MaterialCreatorOptions {
   /**

package/loaders/NRRDLoader.d.cts

@@ -0,0 +1,22 @@
+import type { Loader, LoadingManager } from 'three'
+
+import type { Volume } from '../misc/Volume.d.cts'
+
+export class NRRDLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  manager: LoadingManager
+  path: string
+
+  fieldFunctions: object
+
+  load(
+    url: string,
+    onLoad: (group: Volume) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Volume>
+  parse(data: string): Volume
+  parseChars(array: number[], start?: number, end?: number): string
+  setPath(value: string): this
+}

package/loaders/NRRDLoader.d.ts

@@ -1,6 +1,6 @@
-import { Loader, LoadingManager } from 'three'
+import type { Loader, LoadingManager } from 'three'
 
-import { Volume } from '../misc/Volume'
+import type { Volume } from '../misc/Volume.d.ts'
 
 export class NRRDLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/OBJLoader.d.cts

@@ -0,0 +1,17 @@
+import type { Loader, LoadingManager, Group } from 'three'
+import type { MaterialCreator } from './MTLLoader.d.cts'
+
+export class OBJLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  materials: MaterialCreator
+
+  load(
+    url: string,
+    onLoad: (group: Group) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
+  parse(data: string): Group
+  setMaterials(materials: MaterialCreator): this
+}

package/loaders/OBJLoader.d.ts

@@ -1,5 +1,5 @@
-import { Loader, LoadingManager, Group } from 'three'
-import { MaterialCreator } from './MTLLoader'
+import type { Loader, LoadingManager, Group } from 'three'
+import type { MaterialCreator } from './MTLLoader.d.ts'
 
 export class OBJLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/PCDLoader.d.cts

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

package/loaders/PCDLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Points, LoadingManager } from 'three'
+import type { Loader, Points, LoadingManager } from 'three'
 
 export class PCDLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/PDBLoader.d.cts

@@ -0,0 +1,22 @@
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
+
+export interface PDB {
+  geometryAtoms: BufferGeometry
+  geometryBonds: BufferGeometry
+  json: {
+    atoms: any[][]
+  }
+}
+
+export class PDBLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (pdb: PDB) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<PDB>
+  parse(text: string): PDB
+}

package/loaders/PDBLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, BufferGeometry, LoadingManager } from 'three'
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
 
 export interface PDB {
   geometryAtoms: BufferGeometry

package/loaders/PLYLoader.d.cts

@@ -0,0 +1,16 @@
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
+
+export class PLYLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  propertyNameMapping: object
+
+  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>
+  setPropertyNameMapping(mapping: object): void
+  parse(data: ArrayBuffer | string): BufferGeometry
+}

package/loaders/PLYLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, BufferGeometry, LoadingManager } from 'three'
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
 
 export class PLYLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/PRWMLoader.d.cts

@@ -0,0 +1,16 @@
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
+
+export class PRWMLoader 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
+
+  static isBigEndianPlatform(): boolean
+}

package/loaders/PRWMLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, BufferGeometry, LoadingManager } from 'three'
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
 
 export class PRWMLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/PVRLoader.d.cts

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

package/loaders/PVRLoader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, CompressedTextureLoader, CompressedPixelFormat } from 'three'
+import type { LoadingManager, CompressedTextureLoader, CompressedPixelFormat } from 'three'
 
 export interface PVR {
   mipmaps: object[]

package/loaders/RGBELoader.d.cts

@@ -0,0 +1,20 @@
+import type { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
+
+export interface RGBE {
+  width: number
+  height: number
+  data: Float32Array | Uint8Array
+  header: string
+  gamma: number
+  exposure: number
+  format: PixelFormat
+  type: TextureDataType
+}
+
+export class RGBELoader extends DataTextureLoader {
+  constructor(manager?: LoadingManager)
+  type: TextureDataType
+
+  parse(buffer: ArrayBuffer): RGBE
+  setDataType(type: TextureDataType): this
+}

package/loaders/RGBELoader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
+import type { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
 
 export interface RGBE {
   width: number

package/loaders/RGBMLoader.d.cts

@@ -0,0 +1,32 @@
+import type { CubeTexture, LoadingManager, DataTextureLoader, PixelFormat, TextureDataType } from 'three'
+
+export interface RGBM {
+  width: number
+  height: number
+  data: Uint16Array | Float32Array
+  header: string
+  format: PixelFormat
+  type: TextureDataType
+  flipY: boolean
+}
+
+export class RGBMLoader extends DataTextureLoader {
+  type: TextureDataType
+
+  maxRange: number
+
+  constructor(manager?: LoadingManager)
+
+  loadCubemap(
+    urls: string[],
+    onLoad?: (texture: CubeTexture) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): CubeTexture
+
+  parse(buffer: ArrayBuffer): RGBM
+
+  setDataType(dataType: TextureDataType): this
+
+  setMaxRange(value: number): this
+}

package/loaders/RGBMLoader.d.ts

@@ -1,4 +1,4 @@
-import { CubeTexture, LoadingManager, DataTextureLoader, PixelFormat, TextureDataType } from 'three'
+import type { CubeTexture, LoadingManager, DataTextureLoader, PixelFormat, TextureDataType } from 'three'
 
 export interface RGBM {
   width: number

package/loaders/STLLoader.d.cts

@@ -0,0 +1,14 @@
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
+
+export class STLLoader 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 | string): BufferGeometry
+}

package/loaders/STLLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, BufferGeometry, LoadingManager } from 'three'
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
 
 export class STLLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/SVGLoader.d.cts

@@ -0,0 +1,63 @@
+import type { Loader, LoadingManager, ShapePath, BufferGeometry, Vector2, Shape } from 'three'
+
+export interface SVGResultPaths extends ShapePath {
+  userData?:
+    | {
+        [key: string]: any
+      }
+    | undefined
+}
+
+export interface SVGResult {
+  paths: SVGResultPaths[]
+  xml: XMLDocument
+}
+
+export interface StrokeStyle {
+  strokeColor: string
+  strokeWidth: number
+  strokeLineJoin: string
+  strokeLineCap: string
+  strokeMiterLimit: number
+}
+
+export class SVGLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  defaultDPI: number
+  defaultUnit: string
+
+  load(
+    url: string,
+    onLoad: (data: SVGResult) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<SVGResult>
+  parse(text: string): SVGResult
+
+  static getStrokeStyle(
+    width?: number,
+    color?: string,
+    lineJoin?: string,
+    lineCap?: string,
+    miterLimit?: number,
+  ): StrokeStyle
+  static pointsToStroke(
+    points: Vector2[],
+    style: StrokeStyle,
+    arcDivisions?: number,
+    minDistance?: number,
+  ): BufferGeometry
+  static pointsToStrokeWithBuffers(
+    points: Vector2[],
+    style: StrokeStyle,
+    arcDivisions?: number,
+    minDistance?: number,
+    vertices?: number[],
+    normals?: number[],
+    uvs?: number[],
+    vertexOffset?: number,
+  ): number
+  static createShapes(shapePath: ShapePath): Shape[]
+}

package/loaders/SVGLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, ShapePath, BufferGeometry, Vector2, Shape } from 'three'
+import type { Loader, LoadingManager, ShapePath, BufferGeometry, Vector2, Shape } from 'three'
 
 export interface SVGResultPaths extends ShapePath {
   userData?:

package/loaders/TDSLoader.d.cts

@@ -0,0 +1,42 @@
+import type { Loader, Color, Group, LoadingManager, Material, Mesh, Texture } from 'three'
+
+export class TDSLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  debug: boolean
+  group: Group
+  manager: LoadingManager
+  materials: Material[]
+  meshes: Mesh[]
+  position: number
+
+  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(arraybuffer: ArrayBuffer, path: string): Group
+
+  debugMessage(message: object): void
+  endChunk(chunk: object): void
+  nextChunk(data: DataView, chunk: object): void
+  readByte(data: DataView): number
+  readChunk(data: DataView): object
+  readColor(data: DataView): Color
+  readDWord(data: DataView): number
+  readFaceArray(data: DataView, mesh: Mesh): void
+  readFile(arraybuffer: ArrayBuffer, path: string): void
+  readFloat(data: DataView): number
+  readInt(data: DataView): number
+  readMap(data: DataView, path: string): Texture
+  readMesh(data: DataView): Mesh
+  readMeshData(data: DataView, path: string): void
+  readMaterialEntry(data: DataView, path: string): void
+  readMaterialGroup(data: DataView): object
+  readNamedObject(data: DataView): void
+  readShort(data: DataView): number
+  readString(data: DataView, maxLength: number): string
+  readWord(data: DataView): number
+  resetPosition(): void
+}

package/loaders/TDSLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Color, Group, LoadingManager, Material, Mesh, Texture } from 'three'
+import type { Loader, Color, Group, LoadingManager, Material, Mesh, Texture } from 'three'
 
 export class TDSLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/TGALoader.d.cts

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

package/loaders/TGALoader.d.ts

@@ -1,4 +1,4 @@
-import { DataTexture, DataTextureLoader, LoadingManager } from 'three'
+import type { DataTexture, DataTextureLoader, LoadingManager } from 'three'
 
 export class TGALoader extends DataTextureLoader {
   constructor(manager?: LoadingManager)

package/loaders/TTFLoader.d.cts

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

package/loaders/TTFLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager } from 'three'
+import type { Loader, LoadingManager } from 'three'
 
 export class TTFLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/TiltLoader.d.cts

@@ -0,0 +1,14 @@
+import type { Loader, LoadingManager, Group } from 'three'
+
+export class TiltLoader 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/TiltLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Group } from 'three'
+import type { Loader, LoadingManager, Group } from 'three'
 
 export class TiltLoader extends Loader {
   constructor(manager?: LoadingManager)