three-stdlib 2.35.10 → 2.35.12

package/loaders/MMDLoader.d.cts

@@ -1,63 +0,0 @@
-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/MTLLoader.d.cts

@@ -1,100 +0,0 @@
-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/NRRDLoader.d.cts

@@ -1,22 +0,0 @@
-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/OBJLoader.d.cts

@@ -1,17 +0,0 @@
-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/PCDLoader.d.cts

@@ -1,15 +0,0 @@
-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/PDBLoader.d.cts

@@ -1,22 +0,0 @@
-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/PLYLoader.d.cts

@@ -1,16 +0,0 @@
-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/PRWMLoader.d.cts

@@ -1,16 +0,0 @@
-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/PVRLoader.d.cts

@@ -1,16 +0,0 @@
-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/RGBELoader.d.cts

@@ -1,20 +0,0 @@
-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/RGBMLoader.d.cts

@@ -1,32 +0,0 @@
-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/STLLoader.d.cts

@@ -1,14 +0,0 @@
-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/SVGLoader.d.cts

@@ -1,63 +0,0 @@
-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/TDSLoader.d.cts

@@ -1,42 +0,0 @@
-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/TGALoader.d.cts

@@ -1,14 +0,0 @@
-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/TTFLoader.d.cts

@@ -1,15 +0,0 @@
-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/TiltLoader.d.cts

@@ -1,14 +0,0 @@
-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/VOXLoader.d.cts

@@ -1,29 +0,0 @@
-import type { Loader, Texture, Mesh, LoadingManager } from 'three'
-
-export interface Chunk {
-  palette: number[]
-  size: { x: number; y: number; z: number }
-  data: Uint8Array
-}
-
-export class VOXLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (chunks: Chunk[]) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<object[]>
-  parse(data: ArrayBuffer): object[]
-}
-
-export class VOXMesh extends Mesh {
-  constructor(chunk: Chunk)
-}
-
-// Data3DTexture
-export class VOXData3DTexture extends Texture {
-  constructor(chunk: Chunk)
-}

package/loaders/VRMLLoader.d.cts

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

package/loaders/VRMLoader.d.cts

@@ -1,19 +0,0 @@
-import type { Loader, LoadingManager } from 'three'
-
-import type { GLTFLoader, GLTF } from './GLTFLoader.d.cts'
-import type { DRACOLoader } from './DRACOLoader.d.cts'
-
-export class VRMLoader extends Loader {
-  constructor(manager?: LoadingManager)
-  gltfLoader: GLTFLoader
-
-  load(
-    url: string,
-    onLoad: (scene: GLTF) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<GLTF>
-  parse(gltf: GLTF, onLoad: (scene: GLTF) => void): void
-  setDRACOLoader(dracoLoader: DRACOLoader): this
-}

package/loaders/VTKLoader.d.cts

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

package/loaders/XLoader.d.cts

@@ -1,19 +0,0 @@
-import type { Loader, Mesh, LoadingManager } from 'three'
-
-export interface XResult {
-  animations: object[]
-  models: Mesh[]
-}
-
-export class XLoader extends Loader {
-  constructor(manager?: LoadingManager)
-
-  load(
-    url: string,
-    onLoad: (object: XResult) => void,
-    onProgress?: (event: ProgressEvent) => void,
-    onError?: (event: ErrorEvent) => void,
-  ): void
-  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<XResult>
-  parse(data: ArrayBuffer | string, onLoad: (object: object) => void): object
-}

package/loaders/XYZLoader.d.cts

@@ -1,14 +0,0 @@
-import type { Loader, BufferGeometry, LoadingManager } from 'three'
-
-export class XYZLoader 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: string, onLoad: (geometry: BufferGeometry) => void): object
-}

package/math/Capsule.d.cts

@@ -1,27 +0,0 @@
-import type { Vector3, Line3, Box3 } from 'three'
-
-export class Capsule {
-  constructor(start?: Vector3, end?: Vector3, radius?: number)
-  start: Vector3
-  end: Vector3
-  radius: number
-
-  set(start: Vector3, end: Vector3, radius: number): this
-  clone(): Capsule
-  copy(capsule: Capsule): this
-  getCenter(target: Vector3): Vector3
-  translate(v: Vector3): this
-  checkAABBAxis(
-    p1x: number,
-    p1y: number,
-    p2x: number,
-    p2y: number,
-    minx: number,
-    maxx: number,
-    miny: number,
-    maxy: number,
-    radius: number,
-  ): boolean
-  intersectsBox(box: Box3): boolean
-  lineLineMinimumPoints(line1: Line3, line2: Line3): Vector3[]
-}