three-stdlib 2.35.7 → 2.35.8

package/loaders/VRMLoader.d.ts

@@ -1,7 +1,7 @@
-import { Loader, LoadingManager } from 'three'
+import type { Loader, LoadingManager } from 'three'
 
-import { GLTFLoader, GLTF } from './GLTFLoader'
-import { DRACOLoader } from './DRACOLoader'
+import type { GLTFLoader, GLTF } from './GLTFLoader.d.ts'
+import type { DRACOLoader } from './DRACOLoader.d.ts'
 
 export class VRMLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/VTKLoader.d.cts

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

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

package/loaders/XLoader.d.cts

@@ -0,0 +1,19 @@
+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/XLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Mesh, LoadingManager } from 'three'
+import type { Loader, Mesh, LoadingManager } from 'three'
 
 export interface XResult {
   animations: object[]

package/loaders/XYZLoader.d.cts

@@ -0,0 +1,14 @@
+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/loaders/XYZLoader.d.ts

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

package/math/Capsule.d.cts

@@ -0,0 +1,27 @@
+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[]
+}

package/math/Capsule.d.ts

@@ -1,4 +1,4 @@
-import { Vector3, Line3, Box3 } from 'three'
+import type { Vector3, Line3, Box3 } from 'three'
 
 export class Capsule {
   constructor(start?: Vector3, end?: Vector3, radius?: number)

package/math/ColorConverter.d.cts

@@ -0,0 +1,21 @@
+import type { Color } from 'three'
+
+export interface HSL {
+  h: number
+  s: number
+  l: number
+}
+
+export interface CMYK {
+  c: number
+  m: number
+  y: number
+  k: number
+}
+
+export namespace ColorConverter {
+  function setHSV(color: Color, h: number, s: number, v: number): Color
+  function getHSV(color: Color, target: HSL): HSL
+  function setCMYK(color: Color, c: number, m: number, y: number, k: number): Color
+  function getCMYK(color: Color, target: CMYK): CMYK
+}

package/math/ColorConverter.d.ts

@@ -1,4 +1,4 @@
-import { Color } from 'three'
+import type { Color } from 'three'
 
 export interface HSL {
   h: number

package/math/ConvexHull.d.cts

@@ -0,0 +1,89 @@
+import type { Object3D, Ray, Vector3 } from 'three'
+
+export class Face {
+  constructor()
+  normal: Vector3
+  midpoint: Vector3
+  area: number
+  constant: number
+  outside: VertexNode
+  mark: number
+  edge: HalfEdge
+
+  static create(a: VertexNode, b: VertexNode, c: VertexNode): Face
+
+  compute(): this
+  getEdge(i: number): HalfEdge
+}
+
+export class HalfEdge {
+  constructor(vertex: VertexNode, face: Face)
+  vertex: VertexNode
+  prev: HalfEdge
+  next: HalfEdge
+  twin: HalfEdge
+  face: Face
+
+  head(): VertexNode
+  length(): number
+  lengthSquared(): number
+  setTwin(edge: HalfEdge): this
+  tail(): VertexNode
+}
+
+export class VertexNode {
+  constructor(point: Vector3)
+  point: Vector3
+  prev: VertexNode
+  next: VertexNode
+  face: Face
+}
+
+export class VertexList {
+  constructor()
+  head: VertexNode
+  tail: VertexNode
+
+  append(vertex: VertexNode): this
+  appendChain(vertex: VertexNode): this
+  clear(): this
+  first(): VertexNode
+  insertAfter(target: VertexNode, vertex: VertexNode): this
+  insertBefore(target: VertexNode, vertex: VertexNode): this
+  isEmpty(): boolean
+  last(): VertexNode
+  remove(vertex: VertexNode): this
+  removeSubList(a: VertexNode, b: VertexNode): this
+}
+
+export class ConvexHull {
+  constructor()
+  tolerance: number
+  faces: Face[]
+  newFaces: Face[]
+  assigned: VertexList
+  unassigned: VertexList
+  vertices: VertexNode[]
+
+  addAdjoiningFace(eyeVertex: VertexNode, horizonEdge: HalfEdge): HalfEdge
+  addNewFaces(eyeVertex: VertexNode, horizon: HalfEdge[]): this
+  addVertexToFace(vertex: VertexNode, face: Face): this
+  addVertexToHull(eyeVertex: VertexNode): this
+  cleanup(): this
+  compute(): this
+  computeExtremes(): object
+  computeHorizon(eyePoint: Vector3, crossEdge: HalfEdge, face: Face, horizon: HalfEdge[]): this
+  computeInitialHull(): this
+  containsPoint(point: Vector3): boolean
+  deleteFaceVertices(face: Face, absorbingFace: Face): this
+  intersectRay(ray: Ray, target: Vector3): Vector3 | null
+  intersectsRay(ray: Ray): boolean
+  makeEmpty(): this
+  nextVertexToAdd(): VertexNode | undefined
+  reindexFaces(): this
+  removeAllVerticesFromFace(face: Face): VertexNode | undefined
+  removeVertexFromFace(vertex: VertexNode, face: Face): this
+  resolveUnassignedPoints(newFaces: Face[]): this
+  setFromPoints(points: Vector3[]): this
+  setFromObject(object: Object3D): this
+}

package/math/ConvexHull.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Ray, Vector3 } from 'three'
+import type { Object3D, Ray, Vector3 } from 'three'
 
 export class Face {
   constructor()

package/math/ImprovedNoise.d.cts

@@ -0,0 +1,4 @@
+export class ImprovedNoise {
+  constructor()
+  noise(x: number, y: number, z: number): number
+}

package/math/Lut.d.cts

@@ -0,0 +1,27 @@
+import type { Color } from 'three'
+
+export class Lut {
+  constructor(colormap?: string, numberofcolors?: number)
+  lut: Color[]
+  map: object[]
+  n: number
+  minV: number
+  maxV: number
+
+  set(value: Lut): this
+  setMin(min: number): this
+  setMax(max: number): this
+  setColorMap(colormap?: string, numberofcolors?: number): this
+  copy(lut: Lut): this
+  getColor(alpha: number): Color
+  addColorMap(colormapName: string, arrayOfColors: number[][]): void
+  createCanvas(): HTMLCanvasElement
+  updateCanvas(canvas: HTMLCanvasElement): HTMLCanvasElement
+}
+
+export interface ColorMapKeywords {
+  rainbow: number[][]
+  cooltowarm: number[][]
+  blackbody: number[][]
+  grayscale: number[][]
+}

package/math/Lut.d.ts

@@ -1,4 +1,4 @@
-import { Color } from 'three'
+import type { Color } from 'three'
 
 export class Lut {
   constructor(colormap?: string, numberofcolors?: number)

package/math/MeshSurfaceSampler.d.cts

@@ -0,0 +1,18 @@
+import type { BufferGeometry, Color, Mesh, Vector3 } from 'three'
+
+export class MeshSurfaceSampler {
+  distribution: Float32Array | null
+  geometry: BufferGeometry
+  positionAttribute: Float32Array
+  weightAttribute: string | null
+  randomFunction: () => number
+
+  setRandomGenerator(randomFunction: () => number): this
+  constructor(mesh: Mesh)
+  binarySearch(x: number): number
+  build(): this
+  sample(targetPosition: Vector3, targetNormal?: Vector3, targetColor?: Color): this
+  sampleFace(faceIndex: number, targetPosition: Vector3, targetNormal?: Vector3, targetColor?: Color): this
+  sampleFaceIndex(): number
+  setWeightAttribute(name: string | null): this
+}

package/math/MeshSurfaceSampler.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Color, Mesh, Vector3 } from 'three'
+import type { BufferGeometry, Color, Mesh, Vector3 } from 'three'
 
 export class MeshSurfaceSampler {
   distribution: Float32Array | null

package/math/OBB.d.cts

@@ -0,0 +1,24 @@
+import type { Box3, Matrix3, Matrix4, Plane, Ray, Sphere, Vector3 } from 'three'
+
+export class OBB {
+  center: Vector3
+  halfSize: Vector3
+  rotation: Matrix3
+
+  constructor(center?: Vector3, halfSize?: Vector3, rotation?: Matrix3)
+  set(center: Vector3, halfSize: Vector3, rotation: Matrix3): this
+  copy(obb: OBB): this
+  clone(): this
+  getSize(result: Vector3): Vector3
+  clampPoint(point: Vector3, result: Vector3): Vector3
+  containsPoint(point: Vector3): boolean
+  intersectsBox3(box3: Box3): boolean
+  intersectsSphere(sphere: Sphere): boolean
+  intersectsOBB(obb: OBB, epsilon?: number): boolean
+  intersectsPlane(plane: Plane): boolean
+  intersectRay(ray: Ray, result: Vector3): Vector3 | null
+  intersectsRay(ray: Ray): boolean
+  fromBox3(box3: Box3): this
+  equals(obb: OBB): boolean
+  applyMatrix4(matrix: Matrix4): this
+}

package/math/OBB.d.ts

@@ -1,4 +1,4 @@
-import { Box3, Matrix3, Matrix4, Plane, Ray, Sphere, Vector3 } from 'three'
+import type { Box3, Matrix3, Matrix4, Plane, Ray, Sphere, Vector3 } from 'three'
 
 export class OBB {
   center: Vector3

package/math/Octree.d.cts

@@ -0,0 +1,24 @@
+import type { Triangle, Box3, Ray, Sphere, Object3D } from 'three'
+
+import type { Capsule } from './Capsule.d.cts'
+
+export class Octree {
+  constructor(box?: Box3)
+  triangles: Triangle[]
+  box: Box3
+  subTrees: Octree[]
+
+  addTriangle(triangle: Triangle): this
+  calcBox(): this
+  split(level: number): this
+  build(): this
+  getRayTriangles(ray: Ray, triangles: Triangle[]): Triangle[]
+  triangleCapsuleIntersect(capsule: Capsule, triangle: Triangle): any
+  triangleSphereIntersect(sphere: Sphere, triangle: Triangle): any
+  getSphereTriangles(sphere: Sphere, triangles: Triangle[]): Triangle[]
+  getCapsuleTriangles(capsule: Capsule, triangles: Triangle[]): Triangle[]
+  sphereIntersect(sphere: Sphere): any
+  capsuleIntersect(capsule: Capsule): any
+  rayIntersect(ray: Ray): any
+  fromGraphNode(group: Object3D): this
+}

package/math/Octree.d.ts

@@ -1,6 +1,6 @@
-import { Triangle, Box3, Ray, Sphere, Object3D } from 'three'
+import type { Triangle, Box3, Ray, Sphere, Object3D } from 'three'
 
-import { Capsule } from './Capsule'
+import type { Capsule } from './Capsule.d.ts'
 
 export class Octree {
   constructor(box?: Box3)

package/math/SimplexNoise.d.cts

@@ -0,0 +1,21 @@
+export interface NumberGenerator {
+    random: () => number;
+}
+export declare class SimplexNoise {
+    private grad3;
+    private grad4;
+    private p;
+    private perm;
+    private simplex;
+    /**
+     * You can pass in a random number generator object if you like.
+     * It is assumed to have a random() method.
+     */
+    constructor(r?: NumberGenerator);
+    dot: (g: number[], x: number, y: number) => number;
+    dot3: (g: number[], x: number, y: number, z: number) => number;
+    dot4: (g: number[], x: number, y: number, z: number, w: number) => number;
+    noise: (xin: number, yin: number) => number;
+    private noise3d;
+    noise4d: (x: number, y: number, z: number, w: number) => number;
+}

package/misc/ConvexObjectBreaker.d.cts

@@ -0,0 +1,25 @@
+import type { Object3D, Plane, Vector3 } from 'three'
+
+export interface CutByPlaneOutput {
+  object1: Object3D
+  object2: Object3D
+}
+
+export class ConvexObjectBreaker {
+  constructor(minSizeForBreak?: number, smallDelta?: number)
+  prepareBreakableObject(
+    object: Object3D,
+    mass: number,
+    velocity: Vector3,
+    angularVelocity: Vector3,
+    breakable: boolean,
+  ): void
+  subdivideByImpact(
+    object: Object3D,
+    pointOfImpact: Vector3,
+    normal: Vector3,
+    maxRadialIterations: number,
+    maxRandomIterations: number,
+  ): Object3D[]
+  cutByPlane(object: Object3D, plane: Plane, output: CutByPlaneOutput): number
+}

package/misc/ConvexObjectBreaker.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Plane, Vector3 } from 'three'
+import type { Object3D, Plane, Vector3 } from 'three'
 
 export interface CutByPlaneOutput {
   object1: Object3D

package/misc/GPUComputationRenderer.d.cts

@@ -0,0 +1,53 @@
+import type {
+  WebGLRenderer,
+  WebGLRenderTarget,
+  Texture,
+  DataTexture,
+  Material,
+  ShaderMaterial,
+  Wrapping,
+  TextureFilter,
+  TextureDataType,
+  IUniform,
+} from 'three'
+
+export interface Variable {
+  name: string
+  initialValueTexture: Texture
+  material: ShaderMaterial
+  dependencies: Variable[]
+  renderTargets: WebGLRenderTarget[]
+  wrapS: number
+  wrapT: number
+  minFilter: number
+  magFilter: number
+}
+
+export class GPUComputationRenderer {
+  constructor(sizeX: number, sizeY: number, renderer: WebGLRenderer)
+
+  setDataType(type: TextureDataType): void
+
+  addVariable(variableName: string, computeFragmentShader: string, initialValueTexture: Texture): Variable
+  setVariableDependencies(variable: Variable, dependencies: Variable[] | null): void
+
+  init(): string | null
+  compute(): void
+
+  getCurrentRenderTarget(variable: Variable): WebGLRenderTarget
+  getAlternateRenderTarget(variable: Variable): WebGLRenderTarget
+  addResolutionDefine(materialShader: ShaderMaterial): void
+  createShaderMaterial(computeFragmentShader: string, uniforms?: { [uniform: string]: IUniform }): ShaderMaterial
+  createRenderTarget(
+    sizeXTexture: number,
+    sizeYTexture: number,
+    wrapS: Wrapping,
+    wrapT: number,
+    minFilter: TextureFilter,
+    magFilter: TextureFilter,
+  ): WebGLRenderTarget
+  createTexture(): DataTexture
+  renderTexture(input: Texture, output: Texture): void
+  doRenderTarget(material: Material, output: WebGLRenderTarget): void
+  dispose(): void
+}

package/misc/GPUComputationRenderer.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   WebGLRenderer,
   WebGLRenderTarget,
   Texture,

package/misc/Gyroscope.d.cts

@@ -0,0 +1,5 @@
+import type { Object3D } from 'three'
+
+export class Gyroscope extends Object3D {
+  constructor()
+}

package/misc/Gyroscope.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three'
+import type { Object3D } from 'three'
 
 export class Gyroscope extends Object3D {
   constructor()

package/misc/MD2Character.d.cts

@@ -0,0 +1,33 @@
+import type { Object3D, Mesh, Texture, AnimationMixer } from 'three'
+
+export interface MD2PartsConfig {
+  baseUrl: string
+  body: string
+  skins: string[]
+  weapons: Array<[string, string]>
+}
+
+export class MD2Character {
+  constructor()
+  scale: number
+  animationFPS: number
+  root: Object3D
+  meshBody: Mesh | null
+  meshWeapon: Mesh | null
+  skinsBody: Texture[]
+  skinsWeapon: Texture[]
+  weapons: Mesh[]
+  activeAnimation: string | null
+  mixer: AnimationMixer | null
+  loadCounter: number
+
+  onLoadComplete(): void
+  loadParts(config: MD2PartsConfig): void
+  setPlaybackRate(rate: number): void
+  setWireframe(wireframeEnabled: boolean): void
+  setSkin(index: number): void
+  setWeapon(index: number): void
+  setAnimation(clipName: string): void
+  syncWeaponAnimation(): void
+  update(delta: number): void
+}

package/misc/MD2Character.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Mesh, Texture, AnimationMixer } from 'three'
+import type { Object3D, Mesh, Texture, AnimationMixer } from 'three'
 
 export interface MD2PartsConfig {
   baseUrl: string

package/misc/MD2CharacterComplex.d.cts

@@ -0,0 +1,47 @@
+import type { Object3D, Mesh, Texture } from 'three'
+
+export class MD2CharacterComplex {
+  constructor()
+  scale: number
+  animationFPS: number
+  transitionFrames: number
+  maxSpeed: number
+  maxReverseSpeed: number
+  frontAcceleration: number
+  backAcceleration: number
+  frontDecceleration: number
+  angularSpeed: number
+  root: Object3D
+  meshBody: Mesh | null
+  meshWeapon: Mesh | null
+  controls: null
+  skinsBody: Texture[]
+  skinsWeapon: Texture[]
+  weapons: Mesh[]
+  currentSkin: number
+  onLoadComplete: () => void
+
+  meshes: Mesh[]
+  animations: object[]
+  loadCounter: number
+  speed: number
+  bodyOrientation: number
+  walkSpeed: number
+  crouchSpeed: number
+  activeAnimation: string
+  oldAnimation: string
+
+  enableShadows(enable: boolean): void
+  setVisible(enable: boolean): void
+  shareParts(original: MD2CharacterComplex): void
+  loadParts(config: object): void
+  setPlaybackRate(rate: number): void
+  setWireframe(wireframeEnabled: boolean): void
+  setSkin(index: number): void
+  setWeapon(index: number): void
+  setAnimation(animationName: string): void
+  update(delta: number): void
+  updateAnimations(delta: number): void
+  updateBehaviors(): void
+  updateMovementModel(delta: number): void
+}

package/misc/MD2CharacterComplex.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Mesh, Texture } from 'three'
+import type { Object3D, Mesh, Texture } from 'three'
 
 export class MD2CharacterComplex {
   constructor()

package/misc/MorphAnimMesh.d.cts

@@ -0,0 +1,13 @@
+import type { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from 'three'
+
+export class MorphAnimMesh extends Mesh {
+  constructor(geometry: BufferGeometry, material: Material)
+  mixer: AnimationMixer
+  activeAction: AnimationAction | null
+
+  setDirectionForward(): void
+  setDirectionBackward(): void
+  playAnimation(label: string, fps: number): void
+  updateAnimation(delta: number): void
+  copy(source: MorphAnimMesh, recursive?: boolean): this
+}

package/misc/MorphAnimMesh.d.ts

@@ -1,4 +1,4 @@
-import { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from 'three'
+import type { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from 'three'
 
 export class MorphAnimMesh extends Mesh {
   constructor(geometry: BufferGeometry, material: Material)

package/misc/MorphBlendMesh.d.cts

@@ -0,0 +1,21 @@
+import type { BufferGeometry, Material, Mesh } from 'three'
+
+export class MorphBlendMesh extends Mesh {
+  constructor(geometry: BufferGeometry, material: Material)
+  animationsMap: object
+  animationsList: object[]
+
+  createAnimation(name: string, start: number, end: number, fps: number): void
+  autoCreateAnimations(fps: number): void
+  setAnimationDirectionForward(name: string): void
+  setAnimationDirectionBackward(name: string): void
+  setAnimationFPS(name: string, fps: number): void
+  setAnimationDuration(name: string, duration: number): void
+  setAnimationWeight(name: string, weight: number): void
+  setAnimationTime(name: string, time: number): void
+  getAnimationTime(name: string): number
+  getAnimationDuration(name: string): number
+  playAnimation(name: string): void
+  stopAnimation(name: string): void
+  update(delta: number): void
+}

package/misc/MorphBlendMesh.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Material, Mesh } from 'three'
+import type { BufferGeometry, Material, Mesh } from 'three'
 
 export class MorphBlendMesh extends Mesh {
   constructor(geometry: BufferGeometry, material: Material)