three-stdlib 2.35.7 → 2.35.8

package/misc/ProgressiveLightmap.d.cts

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

@@ -1,4 +1,4 @@
-import {
+import type {
   Camera,
   Material,
   Mesh,

package/misc/RollerCoaster.d.cts

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

@@ -1,4 +1,4 @@
-import { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
+import type { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
 
 export class RollerCoasterGeometry extends BufferGeometry {
   constructor(curve: Curve<Vector3>, divisions: number)

package/misc/Timer.d.cts

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

@@ -24,4 +24,4 @@ declare class Timer {
     get elapsedTime(): number;
     private _now;
 }
-export { Timer };
+export { type Timer };

package/misc/TubePainter.d.cts

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

@@ -1,4 +1,4 @@
-import { Matrix4, Mesh, Vector3 } from 'three'
+import type { Matrix4, Mesh, Vector3 } from 'three'
 
 export class TubePainter {
   constructor()

package/misc/Volume.d.cts

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

@@ -1,6 +1,6 @@
-import { Matrix3 } from 'three'
+import type { Matrix3 } from 'three'
 
-import { VolumeSlice } from './VolumeSlice'
+import type { VolumeSlice } from './VolumeSlice.d.ts'
 
 export class Volume {
   constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>)

package/misc/VolumeSlice.d.cts

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

@@ -1,6 +1,6 @@
-import { Matrix3, Mesh } from 'three'
+import type { Matrix3, Mesh } from 'three'
 
-import { Volume } from './Volume'
+import type { Volume } from './Volume.d.ts'
 
 export class VolumeSlice {
   constructor(volume: Volume, index?: number, axis?: string)

package/misc/WebGL.d.cts

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

package/modifiers/CurveModifier.d.cts

@@ -0,0 +1,91 @@
+import type { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
+import type { IUniform } from 'three';
+/**
+ * Make a new DataTexture to store the descriptions of the curves.
+ *
+ * @param { number } numberOfCurves the number of curves needed to be described by this texture.
+ */
+export declare const initSplineTexture: (numberOfCurves?: number) => DataTexture;
+/**
+ * Write the curve description to the data texture
+ *
+ * @param { DataTexture } texture The DataTexture to write to
+ * @param { Curve } splineCurve The curve to describe
+ * @param { number } offset Which curve slot to write to
+ */
+export declare const updateSplineTexture: <TCurve extends Curve<any>>(texture: DataTexture, splineCurve: TCurve, offset?: number) => void;
+export interface INumericUniform extends IUniform {
+    type: 'f' | 'i';
+    value: number;
+}
+export type CurveModifierUniforms = {
+    spineTexture: IUniform<DataTexture>;
+    pathOffset: INumericUniform;
+    pathSegment: INumericUniform;
+    spineOffset: INumericUniform;
+    spineLength: INumericUniform;
+    flow: INumericUniform;
+};
+/**
+ * Create a new set of uniforms for describing the curve modifier
+ *
+ * @param { DataTexture } Texture which holds the curve description
+ */
+export declare const getUniforms: (splineTexture: DataTexture) => CurveModifierUniforms;
+export type ModifiedMaterial<TMaterial extends Material> = TMaterial & {
+    __ok: boolean;
+};
+export declare function modifyShader<TMaterial extends Material = Material>(material: ModifiedMaterial<TMaterial>, uniforms: CurveModifierUniforms, numberOfCurves?: number): void;
+/**
+ * A helper class for making meshes bend aroudn curves
+ */
+export declare class Flow<TMesh extends Mesh = Mesh> {
+    curveArray: Curve<any>[];
+    curveLengthArray: number[];
+    object3D: TMesh;
+    splineTexure: DataTexture;
+    uniforms: CurveModifierUniforms;
+    /**
+     * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+     * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+     */
+    constructor(mesh: TMesh, numberOfCurves?: number);
+    updateCurve<TCurve extends Curve<any>>(index: number, curve: TCurve): void;
+    moveAlongCurve(amount: number): void;
+}
+/**
+ * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
+ */
+export declare class InstancedFlow<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material = Material> extends Flow<InstancedMesh<TGeometry, TMaterial>> {
+    offsets: number[];
+    whichCurve: number[];
+    /**
+     *
+     * @param {number} count The number of instanced elements
+     * @param {number} curveCount The number of curves to preallocate for
+     * @param {Geometry} geometry The geometry to use for the instanced mesh
+     * @param {Material} material The material to use for the instanced mesh
+     */
+    constructor(count: number, curveCount: number, geometry: TGeometry, material: TMaterial);
+    /**
+     * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+     * This writes that information to the matrix and marks it as needing update.
+     *
+     * @param {number} index of the instanced element to update
+     */
+    private writeChanges;
+    /**
+     * Move an individual element along the curve by a specific amount
+     *
+     * @param {number} index Which element to update
+     * @param {number} offset Move by how much
+     */
+    moveIndividualAlongCurve(index: number, offset: number): void;
+    /**
+     * Select which curve to use for an element
+     *
+     * @param {number} index the index of the instanced element to update
+     * @param {number} curveNo the index of the curve it should use
+     */
+    setCurve(index: number, curveNo: number): void;
+}

package/modifiers/CurveModifier.d.ts

@@ -1,4 +1,4 @@
-import { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
+import type { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
 import type { IUniform } from 'three';
 /**
  * Make a new DataTexture to store the descriptions of the curves.

package/modifiers/EdgeSplitModifier.d.cts

@@ -0,0 +1,19 @@
+import type { BufferGeometry } from 'three';
+declare class EdgeSplitModifier {
+    private A;
+    private B;
+    private C;
+    private positions;
+    private normals;
+    private indexes;
+    private pointToIndexMap;
+    private splitIndexes;
+    private oldNormals;
+    constructor();
+    private computeNormals;
+    private mapPositionsToIndexes;
+    private edgeSplitToGroups;
+    private edgeSplit;
+    modify: (geometry: BufferGeometry, cutOffAngle: number, tryKeepNormals?: boolean) => BufferGeometry;
+}
+export { type EdgeSplitModifier };

package/modifiers/EdgeSplitModifier.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three';
+import type { BufferGeometry } from 'three';
 declare class EdgeSplitModifier {
     private A;
     private B;
@@ -16,4 +16,4 @@ declare class EdgeSplitModifier {
     private edgeSplit;
     modify: (geometry: BufferGeometry, cutOffAngle: number, tryKeepNormals?: boolean) => BufferGeometry;
 }
-export { EdgeSplitModifier };
+export { type EdgeSplitModifier };

package/modifiers/SimplifyModifier.d.cts

@@ -0,0 +1,19 @@
+import type { BufferGeometry } from 'three';
+/**
+ *	Simplification Geometry Modifier
+ *    - based on code and technique
+ *	  - by Stan Melax in 1998
+ *	  - Progressive Mesh type Polygon Reduction Algorithm
+ *    - http://www.melax.com/polychop/
+ */
+declare class SimplifyModifier {
+    constructor();
+    private computeEdgeCollapseCost;
+    private removeVertex;
+    private computeEdgeCostAtVertex;
+    private removeFace;
+    private collapse;
+    private minimumCostEdge;
+    modify: (geometry: BufferGeometry, count: number) => BufferGeometry;
+}
+export { type SimplifyModifier };

package/modifiers/SimplifyModifier.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three';
+import type { BufferGeometry } from 'three';
 /**
  *	Simplification Geometry Modifier
  *    - based on code and technique
@@ -16,4 +16,4 @@ declare class SimplifyModifier {
     private minimumCostEdge;
     modify: (geometry: BufferGeometry, count: number) => BufferGeometry;
 }
-export { SimplifyModifier };
+export { type SimplifyModifier };

package/modifiers/TessellateModifier.d.cts

@@ -0,0 +1,11 @@
+import type { BufferGeometry } from 'three';
+/**
+ * Break faces with edges longer than maxEdgeLength
+ */
+declare class TessellateModifier {
+    maxEdgeLength: number;
+    maxIterations: number;
+    constructor(maxEdgeLength?: number, maxIterations?: number);
+    modify: (geometry: BufferGeometry) => BufferGeometry;
+}
+export { type TessellateModifier };

package/modifiers/TessellateModifier.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three';
+import type { BufferGeometry } from 'three';
 /**
  * Break faces with edges longer than maxEdgeLength
  */
@@ -8,4 +8,4 @@ declare class TessellateModifier {
     constructor(maxEdgeLength?: number, maxIterations?: number);
     modify: (geometry: BufferGeometry) => BufferGeometry;
 }
-export { TessellateModifier };
+export { type TessellateModifier };

package/objects/BatchedMesh.d.cts

@@ -0,0 +1,48 @@
+import type { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from 'three';
+declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
+    _vertexStarts: number[];
+    _vertexCounts: number[];
+    _indexStarts: number[];
+    _indexCounts: number[];
+    _reservedRanges: {
+        vertexStart: number;
+        vertexCount: number;
+        indexStart: number;
+        indexCount: number;
+    }[];
+    _visible: boolean[];
+    _active: boolean[];
+    _maxGeometryCount: number;
+    _maxVertexCount: number;
+    _maxIndexCount: number;
+    _geometryInitialized: boolean;
+    _geometryCount: number;
+    _matrices: Matrix4[];
+    _matricesTexture: DataTexture | null;
+    _customUniforms: Record<string, IUniform>;
+    constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+    _initMatricesTexture(): void;
+    _initShader(): void;
+    _initializeGeometry(reference: BufferGeometry): void;
+    _validateGeometry(geometry: BufferGeometry): void;
+    getGeometryCount(): number;
+    getVertexCount(): number;
+    getIndexCount(): number;
+    addGeometry(geometry: BufferGeometry, vertexCount?: number, indexCount?: number): number;
+    /**
+     * @deprecated use `addGeometry` instead.
+     */
+    applyGeometry(geometry: BufferGeometry): number;
+    setGeometryAt(id: number, geometry: BufferGeometry): number;
+    deleteGeometry(geometryId: number): this;
+    optimize(): never;
+    setMatrixAt(geometryId: number, matrix: Matrix4): this;
+    getMatrixAt(geometryId: number, matrix: Matrix4): Matrix4;
+    setVisibleAt(geometryId: number, value: boolean): this;
+    getVisibleAt(geometryId: number): boolean;
+    raycast(): void;
+    copy(): never;
+    toJSON(): never;
+    dispose(): this;
+}
+export { type BatchedMesh };

package/objects/BatchedMesh.d.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from 'three';
+import type { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from 'three';
 declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     _vertexStarts: number[];
     _vertexCounts: number[];
@@ -45,4 +45,4 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     toJSON(): never;
     dispose(): this;
 }
-export { BatchedMesh };
+export { type BatchedMesh };

package/objects/GroundProjectedEnv.d.cts

@@ -0,0 +1,12 @@
+import type { Mesh, ShaderMaterial, Texture, CubeTexture, BufferGeometry } from 'three';
+export interface GroundProjectedEnvParameters {
+    height?: number;
+    radius?: number;
+}
+export declare class GroundProjectedEnv extends Mesh<BufferGeometry, ShaderMaterial> {
+    constructor(texture: CubeTexture | Texture, options?: GroundProjectedEnvParameters);
+    set radius(radius: number);
+    get radius(): number;
+    set height(height: number);
+    get height(): number;
+}

package/objects/GroundProjectedEnv.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, ShaderMaterial, Texture, CubeTexture, BufferGeometry } from 'three';
+import type { Mesh, ShaderMaterial, Texture, CubeTexture, BufferGeometry } from 'three';
 export interface GroundProjectedEnvParameters {
     height?: number;
     radius?: number;

package/objects/Lensflare.d.cts

@@ -0,0 +1,17 @@
+import type { Mesh, Texture, Color } from 'three'
+
+export class LensflareElement {
+  constructor(texture: Texture, size?: number, distance?: number, color?: Color)
+  texture: Texture
+  size: number
+  distance: number
+  color: Color
+}
+
+export class Lensflare extends Mesh {
+  constructor()
+  readonly isLensflare: true
+
+  addElement(element: LensflareElement): void
+  dispose(): void
+}

package/objects/Lensflare.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, Texture, Color } from 'three'
+import type { Mesh, Texture, Color } from 'three'
 
 export class LensflareElement {
   constructor(texture: Texture, size?: number, distance?: number, color?: Color)

package/objects/LightningStorm.d.cts

@@ -0,0 +1,32 @@
+import type { Material, Object3D, Vector3 } from 'three'
+
+import type { LightningStrike, RayParameters } from '../geometries/LightningStrike.d.cts'
+
+export interface StormParams {
+  size?: number
+  minHeight?: number
+  maxHeight?: number
+  maxSlope?: number
+
+  maxLightnings?: number
+
+  lightningMinPeriod?: number
+  lightningMaxPeriod?: number
+  lightningMinDuration?: number
+  lightningMaxDuration?: number
+
+  lightningParameters?: RayParameters
+  lightningMaterial?: Material
+
+  isEternal?: boolean
+
+  onRayPosition?: (source: Vector3, dest: Vector3) => void
+  onLightningDown?: (lightning: LightningStrike) => void
+}
+
+export class LightningStorm extends Object3D {
+  constructor(stormParams?: StormParams)
+  update(time: number): void
+  copy(source: LightningStorm, recursive?: boolean): this
+  clone(): this
+}

package/objects/LightningStorm.d.ts

@@ -1,6 +1,6 @@
-import { Material, Object3D, Vector3 } from 'three'
+import type { Material, Object3D, Vector3 } from 'three'
 
-import { LightningStrike, RayParameters } from '../geometries/LightningStrike'
+import type { LightningStrike, RayParameters } from '../geometries/LightningStrike.d.ts'
 
 export interface StormParams {
   size?: number

package/objects/MarchingCubes.d.cts

@@ -0,0 +1,76 @@
+import type { BufferGeometry, Material, Mesh, Color } from 'three'
+
+export class MarchingCubes extends Mesh {
+  constructor(
+    resolution: number,
+    material: Material,
+    enableUvs?: boolean,
+    enableColors?: boolean,
+    maxPolyCount?: number,
+  )
+
+  enableUvs: boolean
+  enableColors: boolean
+
+  resolution: number
+
+  // parameters
+
+  isolation: number
+
+  // size of field, 32 is pushing it in Javascript :)
+
+  size: number
+  size2: number
+  size3: number
+  halfsize: number
+
+  // deltas
+
+  delta: number
+  yd: number
+  zd: number
+
+  field: Float32Array
+  normal_cache: Float32Array
+  palette: Float32Array
+
+  maxCount: number
+  count: number
+
+  hasPositions: boolean
+  hasNormals: boolean
+  hasColors: boolean
+  hasUvs: boolean
+
+  positionArray: Float32Array
+  normalArray: Float32Array
+
+  uvArray: Float32Array
+  colorArray: Float32Array
+
+  begin(): void
+  end(): void
+
+  init(resolution: number): void
+
+  addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors?: Color): void
+
+  addPlaneX(strength: number, subtract: number): void
+  addPlaneY(strength: number, subtract: number): void
+  addPlaneZ(strength: number, subtract: number): void
+
+  setCell(x: number, y: number, z: number, value: number): void
+  getCell(x: number, y: number, z: number): number
+
+  blur(intensity: number): void
+
+  reset(): void
+  update(): void
+  render(renderCallback: any): void
+  generateGeometry(): BufferGeometry
+  generateBufferGeometry(): BufferGeometry
+}
+
+export const edgeTable: Int32Array[]
+export const triTable: Int32Array[]

package/objects/MarchingCubes.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Material, Mesh, Color } from 'three'
+import type { BufferGeometry, Material, Mesh, Color } from 'three'
 
 export class MarchingCubes extends Mesh {
   constructor(