three-stdlib 2.35.7 → 2.35.8

package/csm/CSM.d.cts

@@ -0,0 +1,61 @@
+import type { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from 'three'
+
+export enum CMSMode {
+  practical = 'practical',
+  uniform = 'uniform',
+  logarithmic = 'logarithmic',
+  custom = 'custom',
+}
+
+export interface CMSParameters {
+  camera?: Camera
+  parent?: Object3D
+  cascades?: number
+  maxFar?: number
+  mode?: CMSMode
+  shadowMapSize?: number
+  shadowBias?: number
+  lightDirection?: Vector3
+  lightIntensity?: number
+  lightNear?: number
+  lightFar?: number
+  lightMargin?: number
+  customSplitsCallback?: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void
+}
+
+export class CSM {
+  constructor(data?: CMSParameters)
+  camera: Camera
+  parent: Object3D
+  cascades: number
+  maxFar: number
+  mode: CMSMode
+  shadowMapSize: number
+  shadowBias: number
+  lightDirection: Vector3
+  lightIntensity: number
+  lightNear: number
+  lightFar: number
+  lightMargin: number
+  customSplitsCallback: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void
+  fade: boolean
+  mainFrustum: CSMFrustrum
+  frustums: CSMFrustrum[]
+  breaks: number[]
+  lights: DirectionalLight[]
+  shaders: Map<unknown, string>
+  createLights(): void
+  initCascades(): void
+  updateShadowBounds(): void
+  getBreaks(): void
+  update(): void
+  injectInclude(): void
+  setupMaterial(material: Material): void
+  updateUniforms(): void
+  getExtendedBreaks(target: Vector2[]): void
+  updateFrustums(): void
+  remove(): void
+  dispose(): void
+}
+
+import type CSMFrustrum from './CSMFrustum.d.cts'

package/csm/CSM.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from 'three'
+import type { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from 'three'
 
 export enum CMSMode {
   practical = 'practical',
@@ -58,4 +58,4 @@ export class CSM {
   dispose(): void
 }
 
-import CSMFrustrum from './CSMFrustum.js'
+import type CSMFrustrum from './CSMFrustum.d.ts'

package/csm/CSMFrustum.d.cts

@@ -0,0 +1,19 @@
+import type { Matrix4, Vector3 } from 'three'
+
+export interface CSMFrustumVerticies {
+  near: Vector3[]
+  far: Vector3[]
+}
+
+export interface CSMFrustumParameters {
+  projectionMatrix?: Matrix4
+  maxFar?: number
+}
+
+export default class CSMFrustum {
+  constructor(data?: CSMFrustumParameters)
+  vertices: CSMFrustumVerticies
+  setFromProjectionMatrix(projectionMatrix: Matrix4, maxFar: number): CSMFrustumVerticies
+  split(breaks: number[], target: CSMFrustum[]): void
+  toSpace(cameraMatrix: Matrix4, target: CSMFrustum): void
+}

package/csm/CSMFrustum.d.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Vector3 } from 'three'
+import type { Matrix4, Vector3 } from 'three'
 
 export interface CSMFrustumVerticies {
   near: Vector3[]

package/csm/CSMHelper.d.cts

@@ -0,0 +1,26 @@
+import type {
+  Box3Helper,
+  BufferGeometry,
+  Group,
+  LineBasicMaterial,
+  LineSegments,
+  Mesh,
+  MeshBasicMaterial,
+  PlaneGeometry,
+} from 'three'
+
+import type { CSM } from './CSM.d.cts'
+
+export class CSMHelper<TCSM extends CSM = CSM> extends Group {
+  constructor(csm: TCSM)
+  csm: TCSM
+  displayFrustum: boolean
+  displayPlanes: boolean
+  displayShadowBounds: boolean
+  frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>
+  cascadeLines: Box3Helper[]
+  cascadePlanes: Array<Mesh<PlaneGeometry, MeshBasicMaterial>>
+  shadowLines: Box3Helper[]
+  updateVisibility(): void
+  update(): void
+}

package/csm/CSMHelper.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Box3Helper,
   BufferGeometry,
   Group,
@@ -9,7 +9,7 @@ import {
   PlaneGeometry,
 } from 'three'
 
-import { CSM } from './CSM'
+import type { CSM } from './CSM.d.ts'
 
 export class CSMHelper<TCSM extends CSM = CSM> extends Group {
   constructor(csm: TCSM)

package/csm/CSMShader.d.cts

@@ -0,0 +1,4 @@
+export interface CSMShader {
+  lights_fragment_begin: string
+  lights_pars_begin: string
+}

package/curves/CurveExtras.d.cts

@@ -0,0 +1,68 @@
+import type { Curve, Vector3 } from 'three'
+
+export class GrannyKnot extends Curve<Vector3> {
+  constructor()
+}
+
+export class HeartCurve extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class VivianiCurve extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class KnotCurve extends Curve<Vector3> {
+  constructor()
+}
+
+export class HelixCurve extends Curve<Vector3> {
+  constructor()
+}
+
+export class TrefoilKnot extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class TorusKnot extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class CinquefoilKnot extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class TrefoilPolynomialKnot extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class FigureEightPolynomialKnot extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class DecoratedTorusKnot4a extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class DecoratedTorusKnot4b extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class DecoratedTorusKnot5a extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}
+
+export class DecoratedTorusKnot5c extends Curve<Vector3> {
+  constructor(scale?: number)
+  scale: number
+}

package/curves/CurveExtras.d.ts

@@ -1,4 +1,4 @@
-import { Curve, Vector3 } from 'three'
+import type { Curve, Vector3 } from 'three'
 
 export class GrannyKnot extends Curve<Vector3> {
   constructor()

package/curves/NURBSCurve.d.cts

@@ -0,0 +1,11 @@
+import type { Curve, Vector2, Vector3, Vector4 } from 'three'
+
+export class NURBSCurve extends Curve<Vector3> {
+  constructor(
+    degree: number,
+    knots: number[],
+    controlPoints: Vector2[] | Vector3[] | Vector4[],
+    startKnot: number,
+    endKnot: number,
+  )
+}

package/curves/NURBSCurve.d.ts

@@ -1,4 +1,4 @@
-import { Curve, Vector2, Vector3, Vector4 } from 'three'
+import type { Curve, Vector2, Vector3, Vector4 } from 'three'
 
 export class NURBSCurve extends Curve<Vector3> {
   constructor(

package/curves/NURBSSurface.d.cts

@@ -0,0 +1,13 @@
+import type { Vector2, Vector3, Vector4 } from 'three'
+
+export class NURBSSurface {
+  constructor(
+    degree1: number,
+    degree2: number,
+    knots1: number[],
+    knots2: number[],
+    controlPoints: Vector2[][] | Vector3[][] | Vector4[][],
+  )
+
+  getPoint(t1: number, t2: number, target: Vector3): void
+}

package/curves/NURBSSurface.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Vector3, Vector4 } from 'three'
+import type { Vector2, Vector3, Vector4 } from 'three'
 
 export class NURBSSurface {
   constructor(

package/curves/NURBSUtils.d.cts

@@ -0,0 +1,20 @@
+import type { Vector3, Vector4 } from 'three'
+
+export function findSpan(p: number, u: number, U: number[]): number
+export function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[]
+export function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4
+export function calcBasisFunctionDerivatives(span: number, u: number, p: number, n: number, U: number[]): number[][]
+export function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[]
+export function calcKoverI(k: number, i: number): number
+export function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[]
+export function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[]
+export function calcSurfacePoint(
+  p: number,
+  q: number,
+  U: number[],
+  V: number[],
+  P: Vector4[],
+  u: number,
+  v: number,
+  target: Vector3,
+): Vector3

package/curves/NURBSUtils.d.ts

@@ -1,4 +1,4 @@
-import { Vector3, Vector4 } from 'three'
+import type { Vector3, Vector4 } from 'three'
 
 export function findSpan(p: number, u: number, U: number[]): number
 export function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[]

package/deprecated/Geometry.d.cts

@@ -0,0 +1,341 @@
+import type {
+  Vector3,
+  Color,
+  Vector2,
+  Vector4,
+  Box3,
+  Sphere,
+  Matrix4,
+  BufferGeometry,
+  Mesh,
+  Bone,
+  AnimationClip,
+  EventDispatcher,
+  Object3D,
+} from 'three'
+
+/**
+ * @deprecated Use Face3 instead.
+ */
+
+export interface MorphTarget {
+  name: string
+  vertices: Vector3[]
+}
+
+export interface MorphColor {
+  name: string
+  colors: Color[]
+}
+
+export interface MorphNormals {
+  name: string
+  normals: Vector3[]
+}
+
+/**
+ * Base class for geometries
+ */
+export class Geometry extends EventDispatcher {
+  constructor()
+
+  /**
+   * Unique number of this geometry instance
+   */
+  id: number
+
+  uuid: string
+
+  readonly isGeometry: true
+
+  /**
+   * Name for this geometry. Default is an empty string.
+   * @default ''
+   */
+  name: string
+
+  /**
+   * @default 'Geometry'
+   */
+  type: string
+
+  /**
+   * The array of vertices hold every position of points of the model.
+   * To signal an update in this array, Geometry.verticesNeedUpdate needs to be set to true.
+   * @default []
+   */
+  vertices: Vector3[]
+
+  /**
+   * Array of vertex colors, matching number and order of vertices.
+   * Used in ParticleSystem, Line and Ribbon.
+   * Meshes use per-face-use-of-vertex colors embedded directly in faces.
+   * To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.
+   * @default []
+   */
+  colors: Color[]
+
+  /**
+   * Array of triangles or/and quads.
+   * The array of faces describe how each vertex in the model is connected with each other.
+   * To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.
+   * @default []
+   */
+  faces: Face3[]
+
+  /**
+   * Array of face UV layers.
+   * Each UV layer is an array of UV matching order and number of vertices in faces.
+   * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.
+   * @default [[]]
+   */
+  faceVertexUvs: Vector2[][][]
+
+  /**
+   * Array of morph targets. Each morph target is a Javascript object:
+   *
+   * { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
+   *
+   * Morph vertices match number and order of primary vertices.
+   * @default []
+   */
+  morphTargets: MorphTarget[]
+
+  /**
+   * Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object:
+   *
+   * morphNormal = { name: "NormalName", normals: [ new THREE.Vector3(), ... ] }
+   * @default []
+   */
+  morphNormals: MorphNormals[]
+
+  /**
+   * Array of skinning weights, matching number and order of vertices.
+   * @default []
+   */
+  skinWeights: Vector4[]
+
+  /**
+   * Array of skinning indices, matching number and order of vertices.
+   * @default []
+   */
+  skinIndices: Vector4[]
+
+  /**
+   * @default []
+   */
+  lineDistances: number[]
+
+  /**
+   * Bounding box.
+   * @default null
+   */
+  boundingBox: Box3 | null
+
+  /**
+   * Bounding sphere.
+   * @default null
+   */
+  boundingSphere: Sphere | null
+
+  /**
+   * Set to true if the vertices array has been updated.
+   * @default false
+   */
+  verticesNeedUpdate: boolean
+
+  /**
+   * Set to true if the faces array has been updated.
+   * @default false
+   */
+  elementsNeedUpdate: boolean
+
+  /**
+   * Set to true if the uvs array has been updated.
+   * @default false
+   */
+  uvsNeedUpdate: boolean
+
+  /**
+   * Set to true if the normals array has been updated.
+   * @default false
+   */
+  normalsNeedUpdate: boolean
+
+  /**
+   * Set to true if the colors array has been updated.
+   * @default false
+   */
+  colorsNeedUpdate: boolean
+
+  /**
+   * Set to true if the linedistances array has been updated.
+   * @default false
+   */
+  lineDistancesNeedUpdate: boolean
+
+  /**
+   *
+   * @default false
+   */
+  groupsNeedUpdate: boolean
+
+  /**
+   * Bakes matrix transform directly into vertex coordinates.
+   */
+  applyMatrix4(matrix: Matrix4): Geometry
+
+  rotateX(angle: number): Geometry
+  rotateY(angle: number): Geometry
+  rotateZ(angle: number): Geometry
+
+  translate(x: number, y: number, z: number): Geometry
+  scale(x: number, y: number, z: number): Geometry
+  lookAt(vector: Vector3): void
+
+  fromBufferGeometry(geometry: BufferGeometry): Geometry
+
+  center(): Geometry
+
+  normalize(): Geometry
+
+  /**
+   * Computes face normals.
+   */
+  computeFaceNormals(): void
+
+  /**
+   * Computes vertex normals by averaging face normals.
+   * Face normals must be existing / computed beforehand.
+   */
+  computeVertexNormals(areaWeighted?: boolean): void
+
+  /**
+   * Compute vertex normals, but duplicating face normals.
+   */
+  computeFlatVertexNormals(): void
+
+  /**
+   * Computes morph normals.
+   */
+  computeMorphNormals(): void
+
+  /**
+   * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute.
+   */
+  computeBoundingBox(): void
+
+  /**
+   * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
+   * Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null.
+   */
+  computeBoundingSphere(): void
+
+  merge(geometry: Geometry, matrix?: Matrix4, materialIndexOffset?: number): void
+
+  mergeMesh(mesh: Mesh): void
+
+  /**
+   * Checks for duplicate vertices using hashmap for specified number of decimal points, e.g. 4 for epsilon of 0.0001
+   * Duplicated vertices are removed and faces' vertices are updated.
+   */
+  mergeVertices(precisionPoints?: number): number
+
+  setFromPoints(points: Vector2[] | Vector3[]): this
+
+  sortFacesByMaterialIndex(): void
+
+  toBufferGeometry(): BufferGeometry
+
+  static createBufferGeometryFromObject(object: Object3D): BufferGeometry
+
+  toJSON(): any
+
+  /**
+   * Creates a new clone of the Geometry.
+   */
+  clone(): Geometry
+
+  copy(source: Geometry): this
+
+  /**
+   * Removes The object from memory.
+   * Don't forget to call this method when you remove an geometry because it can cuase meomory leaks.
+   */
+  dispose(): void
+
+  // These properties do not exist in a normal Geometry class, but if you use the instance that was passed by JSONLoader, it will be added.
+  bones: Bone[]
+  animation: AnimationClip
+  animations: AnimationClip[]
+}
+
+/**
+ * Triangle face.
+ */
+export class Face3 {
+  /**
+   * @param a Vertex A index.
+   * @param b Vertex B index.
+   * @param c Vertex C index.
+   * @param normal Face normal or array of vertex normals.
+   * @param color Face color or array of vertex colors.
+   * @param materialIndex Material index.
+   */
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    normal?: Vector3 | Vector3[],
+    color?: Color | Color[],
+    materialIndex?: number,
+  )
+
+  /**
+   * Vertex A index.
+   */
+  a: number
+
+  /**
+   * Vertex B index.
+   */
+  b: number
+
+  /**
+   * Vertex C index.
+   */
+  c: number
+
+  /**
+   * Face normal.
+   * @default new THREE.Vector3()
+   */
+  normal: Vector3
+
+  /**
+   * Array of 3 vertex normals.
+   * @default []
+   */
+  vertexNormals: Vector3[]
+
+  /**
+   * Face color.
+   * @default new THREE.Color()
+   */
+  color: Color
+
+  /**
+   * Array of 3 vertex colors.
+   * @default []
+   */
+  vertexColors: Color[]
+
+  /**
+   * Material index (points to {@link Mesh.material}).
+   * @default 0
+   */
+  materialIndex: number
+
+  clone(): this
+  copy(source: Face3): this
+}

package/deprecated/Geometry.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Vector3,
   Color,
   Vector2,

package/effects/AnaglyphEffect.d.cts

@@ -0,0 +1,11 @@
+import type { Camera, Matrix3, Scene, WebGLRenderer } from 'three'
+
+export class AnaglyphEffect {
+  constructor(renderer: WebGLRenderer, width?: number, height?: number)
+  colorMatrixLeft: Matrix3
+  colorMatrixRight: Matrix3
+
+  dispose(): void
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/effects/AnaglyphEffect.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Matrix3, Scene, WebGLRenderer } from 'three'
+import type { Camera, Matrix3, Scene, WebGLRenderer } from 'three'
 
 export class AnaglyphEffect {
   constructor(renderer: WebGLRenderer, width?: number, height?: number)

package/effects/AsciiEffect.d.cts

@@ -0,0 +1,18 @@
+import type { Camera, Scene, WebGLRenderer } from 'three'
+
+export interface AsciiEffectOptions {
+  resolution?: number
+  scale?: number
+  color?: boolean
+  alpha?: boolean
+  block?: boolean
+  invert?: boolean
+}
+
+export class AsciiEffect {
+  constructor(renderer: WebGLRenderer, charSet?: string, options?: AsciiEffectOptions)
+  domElement: HTMLElement
+
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/effects/AsciiEffect.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Scene, WebGLRenderer } from 'three'
+import type { Camera, Scene, WebGLRenderer } from 'three'
 
 export interface AsciiEffectOptions {
   resolution?: number