three-stdlib 2.35.11 → 2.35.13

package/math/ColorConverter.d.cts

@@ -1,21 +0,0 @@
-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 type 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/ConvexHull.d.cts

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

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

package/math/Lut.d.cts

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

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

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

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

@@ -1,21 +0,0 @@
-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

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

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

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

package/misc/MD2Character.d.cts

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

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

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

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

@@ -1,60 +0,0 @@
-import type {
-  Camera,
-  Material,
-  Mesh,
-  MeshBasicMaterial,
-  MeshPhongMaterial,
-  Object3D,
-  PlaneGeometry,
-  Texture,
-  Vector3,
-  WebGLRenderer,
-  Scene,
-  WebGLRenderTarget,
-} from 'three'
-
-export interface UVBoxes {
-  w: number
-  h: number
-  index: number
-}
-
-export interface LightMapContainers {
-  basicMat: Material | Material[]
-  object: Object3D
-}
-
-export class ProgressiveLightMap {
-  renderer: WebGLRenderer
-  res: number
-  lightMapContainers: LightMapContainers[]
-  compiled: boolean
-  scene: Scene
-  tinyTarget: WebGLRenderTarget
-  buffer1Active: boolean
-  firstUpdate: boolean
-  warned: boolean
-
-  progressiveLightMap1: WebGLRenderTarget
-  progressiveLightMap2: WebGLRenderTarget
-
-  uvMat: MeshPhongMaterial
-
-  uv_boxes: UVBoxes[]
-
-  blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>
-
-  labelMaterial: MeshBasicMaterial
-  labelPlane: PlaneGeometry
-  labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial>
-
-  constructor(renderer: WebGLRenderer, res?: number)
-
-  addObjectsToLightMap(objects: Object3D[]): void
-
-  update(camera: Camera, blendWindow?: number, blurEdges?: boolean): void
-
-  showDebugLightmap(visible: boolean, position?: Vector3): void
-
-  private _initializeBlurPlane(res: number, lightMap?: Texture | null): void
-}

package/misc/RollerCoaster.d.cts

@@ -1,21 +0,0 @@
-import type { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
-
-export class RollerCoasterGeometry extends BufferGeometry {
-  constructor(curve: Curve<Vector3>, divisions: number)
-}
-
-export class RollerCoasterLiftersGeometry extends BufferGeometry {
-  constructor(curve: Curve<Vector3>, divisions: number)
-}
-
-export class RollerCoasterShadowGeometry extends BufferGeometry {
-  constructor(curve: Curve<Vector3>, divisions: number)
-}
-
-export class SkyGeometry extends BufferGeometry {
-  constructor(curve: Curve<Vector3>, divisions: number)
-}
-
-export class TreesGeometry extends BufferGeometry {
-  constructor(landscape: Mesh)
-}

package/misc/Timer.d.cts

@@ -1,27 +0,0 @@
-declare class Timer {
-    private _previousTime;
-    private _currentTime;
-    private _delta;
-    private _elapsed;
-    private _timescale;
-    private _useFixedDelta;
-    private _fixedDelta;
-    private _usePageVisibilityAPI;
-    private _pageVisibilityHandler;
-    constructor();
-    connect(): this;
-    dispose(): this;
-    disableFixedDelta(): this;
-    enableFixedDelta(): this;
-    getDelta(): number;
-    getElapsedTime(): number;
-    getFixedDelta(): number;
-    getTimescale(): number;
-    reset(): this;
-    setFixedDelta(fixedDelta: number): this;
-    setTimescale(timescale: number): this;
-    update(): this;
-    get elapsedTime(): number;
-    private _now;
-}
-export type { Timer };

package/misc/TubePainter.d.cts

@@ -1,10 +0,0 @@
-import type { Matrix4, Mesh, Vector3 } from 'three'
-
-export class TubePainter {
-  constructor()
-
-  mesh: Mesh
-
-  stroke(position1: Vector3, position2: Vector3, matrix1: Matrix4, matrix2: Matrix4): void
-  updateGeometry(start: number, end: number): void
-}

package/misc/Volume.d.cts

@@ -1,37 +0,0 @@
-import type { Matrix3 } from 'three'
-
-import type { VolumeSlice } from './VolumeSlice.d.cts'
-
-export class Volume {
-  constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>)
-
-  xLength: number
-  yLength: number
-  zLength: number
-
-  axisOrder: Array<'x' | 'y' | 'z'>
-
-  data: ArrayLike<number>
-
-  spacing: number[]
-  offset: number[]
-
-  matrix: Matrix3
-
-  lowerThreshold: number
-  upperThreshold: number
-
-  sliceList: VolumeSlice[]
-
-  getData(i: number, j: number, k: number): number
-  access(i: number, j: number, k: number): number
-  reverseAccess(index: number): number[]
-
-  map(functionToMap: () => void, context: this): this
-
-  extractPerpendicularPlane(axis: string, RASIndex: number): object
-  extractSlice(axis: string, index: number): VolumeSlice
-
-  repaintAllSlices(): this
-  computeMinMax(): number[]
-}

package/misc/VolumeSlice.d.cts

@@ -1,28 +0,0 @@
-import type { Matrix3, Mesh } from 'three'
-
-import type { Volume } from './Volume.d.cts'
-
-export class VolumeSlice {
-  constructor(volume: Volume, index?: number, axis?: string)
-
-  index: number
-  axis: string
-
-  canvas: HTMLCanvasElement
-  canvasBuffer: HTMLCanvasElement
-
-  ctx: CanvasRenderingContext2D
-  ctxBuffer: CanvasRenderingContext2D
-
-  mesh: Mesh
-
-  geometryNeedsUpdate: boolean
-
-  sliceAccess: number
-  jLength: number
-  iLength: number
-  matrix: Matrix3
-
-  repaint(): void
-  updateGeometry(): void
-}

package/misc/WebGL.d.cts

@@ -1,5 +0,0 @@
-export declare function isWebGLAvailable(): boolean;
-export declare function isWebGL2Available(): boolean;
-export declare function getWebGLErrorMessage(): HTMLDivElement;
-export declare function getWebGL2ErrorMessage(): HTMLDivElement;
-export declare function getErrorMessage(version: 1 | 2): HTMLDivElement;