three-stdlib 2.35.11 → 2.35.12

package/modifiers/CurveModifier.d.cts

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

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

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

@@ -1,11 +0,0 @@
-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/objects/BatchedMesh.d.cts

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

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

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

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

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

@@ -1,23 +0,0 @@
-import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
-import type { TextureEncoding } from '../types/shared.d.cts'
-
-export interface ReflectorOptions {
-  color?: Color | string | number
-  textureWidth?: number
-  textureHeight?: number
-  clipBias?: number
-  shader?: object
-  encoding?: TextureEncoding
-  multisample?: number
-}
-
-export class Reflector extends Mesh {
-  type: 'Reflector'
-  camera: PerspectiveCamera
-
-  constructor(geometry?: BufferGeometry, options?: ReflectorOptions)
-
-  getRenderTarget(): WebGLRenderTarget
-
-  dispose(): void
-}

package/objects/ReflectorForSSRPass.d.cts

@@ -1,48 +0,0 @@
-import type { Mesh, ShaderMaterial, WebGLRenderTarget, BufferGeometry, WebGLRenderer, Scene, Camera, IUniform } from 'three'
-
-export interface ReflectorShader {
-  defines: {
-    DISTANCE_ATTENUATION: boolean
-    FRESNEL: boolean
-  }
-  uniforms: {
-    [key: string]: IUniform
-  }
-  vertexShader: string
-  fragmentShader: string
-}
-
-export interface ReflectorForSSRPassOptions {
-  clipBias?: number | undefined
-  textureWidth?: number | undefined
-  textureHeight?: number | undefined
-  color?: number | undefined
-  useDepthTexture?: boolean | undefined
-  shader?: ReflectorShader | undefined
-}
-
-export class ReflectorForSSRPass<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
-  type: 'ReflectorForSSRPass'
-  options: ReflectorForSSRPassOptions
-
-  static ReflectorShader: ReflectorShader
-
-  needsUpdate: boolean
-  maxDistance: number
-  opacity: number
-
-  get distanceAttenuation(): boolean
-  set distanceAttenuation(val: boolean)
-  get fresnel(): boolean
-  set fresnel(val: boolean)
-
-  material: ShaderMaterial
-
-  renderTarget: WebGLRenderTarget
-
-  constructor(geometry: TGeometry, options: ReflectorForSSRPassOptions)
-
-  doRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera) => void
-
-  getRenderTarget: () => WebGLRenderTarget
-}

package/objects/ReflectorRTT.d.cts

@@ -1,6 +0,0 @@
-import type { BufferGeometry } from 'three';
-import type { Reflector, ReflectorOptions } from '../objects/Reflector.d.cts';
-declare class ReflectorRTT extends Reflector {
-    constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
-}
-export type { ReflectorRTT };

package/objects/Refractor.d.cts

@@ -1,23 +0,0 @@
-import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
-import type { TextureEncoding } from '../types/shared.d.cts'
-
-export interface RefractorOptions {
-  color?: Color | string | number
-  textureWidth?: number
-  textureHeight?: number
-  clipBias?: number
-  shader?: object
-  encoding?: TextureEncoding
-  multisample?: number
-}
-
-export class Refractor extends Mesh {
-  type: 'Refractor'
-  camera: PerspectiveCamera
-
-  constructor(geometry?: BufferGeometry, options?: RefractorOptions)
-
-  getRenderTarget(): WebGLRenderTarget
-
-  dispose(): void
-}

package/objects/ShadowMesh.d.cts

@@ -1,10 +0,0 @@
-import type { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from 'three'
-
-export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
-  readonly isShadowMesh: true
-  meshMatrix: Matrix4
-
-  constructor(mesh: Mesh)
-
-  update(plane: Plane, lightPosition4D: Vector4): void
-}

package/objects/Sky.d.cts

@@ -1,18 +0,0 @@
-import type { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
-
-declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
-  static SkyShader: {
-    uniforms: {
-      turbidity: { value: number }
-      rayleigh: { value: number }
-      mieCoefficient: { value: number }
-      mieDirectionalG: { value: number }
-      sunPosition: { value: Vector3 }
-      up: { value: Vector3 }
-    }
-  }
-
-  static material: ShaderMaterial
-}
-
-export type { Sky }

package/objects/Water.d.cts

@@ -1,22 +0,0 @@
-import type { BufferGeometry, Color, Mesh, ShaderMaterial, Side, Texture, Vector3 } from 'three'
-
-export interface WaterOptions {
-  textureWidth?: number
-  textureHeight?: number
-  clipBias?: number
-  alpha?: number
-  time?: number
-  waterNormals?: Texture
-  sunDirection?: Vector3
-  sunColor?: Color | string | number
-  waterColor?: Color | string | number
-  eye?: Vector3
-  distortionScale?: number
-  side?: Side
-  fog?: boolean
-}
-
-export class Water extends Mesh {
-  material: ShaderMaterial
-  constructor(geometry: BufferGeometry, options: WaterOptions)
-}

package/objects/Water2.d.cts

@@ -1,23 +0,0 @@
-import type { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
-import type { TextureEncoding } from '../types/shared.d.cts'
-
-export interface Water2Options {
-  color?: Color | string | number
-  textureWidth?: number
-  textureHeight?: number
-  clipBias?: number
-  flowDirection?: Vector2
-  flowSpeed?: number
-  reflectivity?: number
-  scale?: number
-  shader?: object
-  flowMap?: Texture
-  normalMap0?: Texture
-  normalMap1?: Texture
-  encoding?: TextureEncoding
-}
-
-export class Water2 extends Mesh {
-  material: ShaderMaterial
-  constructor(geometry: BufferGeometry, options: Water2Options)
-}

package/physics/AmmoPhysics.d.cts

@@ -1,7 +0,0 @@
-import type { Mesh, Vector3 } from 'three'
-
-export class AmmoPhysics {
-  constructor()
-  addMesh(mesh: Mesh, mass: number): void
-  setMeshPosition(mesh: Mesh, position: Vector3, index: number): void
-}

package/postprocessing/AdaptiveToneMappingPass.d.cts

@@ -1,29 +0,0 @@
-import type { WebGLRenderTarget, ShaderMaterial } from 'three'
-
-import type { Pass, FullScreenQuad } from './Pass.d.cts'
-
-export class AdaptiveToneMappingPass extends Pass {
-  constructor(adaptive?: boolean, resolution?: number)
-  adaptive: boolean
-  resolution: number
-  needsInit: number
-  luminanceRT: WebGLRenderTarget
-  previousLuminanceRT: WebGLRenderTarget
-  currentLuminanceRT: WebGLRenderTarget
-  copyUniforms: object
-  materialCopy: ShaderMaterial
-  materialLuminance: ShaderMaterial
-  adaptLuminanceShader: object
-  materialAdaptiveLum: ShaderMaterial
-  materialToneMap: ShaderMaterial
-  fsQuad: FullScreenQuad
-
-  reset(): void
-  setAdaptive(adaptive: boolean): void
-  setAdaptionRate(rate: number): void
-  setMinLuminance(minLum: number): void
-  setMaxLuminance(maxLum: number): void
-  setAverageLuminance(avgLum: number): void
-  setMiddleGrey(middleGrey: number): void
-  dispose(): void
-}

package/postprocessing/AfterimagePass.d.cts

@@ -1,15 +0,0 @@
-import type { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
-import type { Pass, FullScreenQuad } from './Pass.d.cts';
-declare class AfterimagePass extends Pass {
-    shader: import("../shaders/AfterimageShader").IAfterimageShader;
-    uniforms: any;
-    textureComp: WebGLRenderTarget;
-    textureOld: WebGLRenderTarget;
-    shaderMaterial: ShaderMaterial;
-    compFsQuad: FullScreenQuad<ShaderMaterial>;
-    copyFsQuad: FullScreenQuad<MeshBasicMaterial>;
-    constructor(damp?: number, shader?: import("../shaders/AfterimageShader").IAfterimageShader);
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
-    setSize(width: number, height: number): void;
-}
-export type { AfterimagePass };

package/postprocessing/BloomPass.d.cts

@@ -1,29 +0,0 @@
-import type { Pass, FullScreenQuad } from './Pass.d.cts';
-import type { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
-import type { ConvolutionShader } from '../shaders/ConvolutionShader.d.cts';
-declare class BloomPass extends Pass {
-    renderTargetX: WebGLRenderTarget;
-    renderTargetY: WebGLRenderTarget;
-    materialCombine: ShaderMaterial;
-    materialConvolution: ShaderMaterial;
-    fsQuad: FullScreenQuad;
-    combineUniforms: Record<keyof typeof CombineShader['uniforms'], IUniform<any>>;
-    convolutionUniforms: Record<keyof typeof ConvolutionShader['uniforms'], IUniform<any>>;
-    blurX: Vector2;
-    blurY: Vector2;
-    constructor(strength?: number, kernelSize?: number, sigma?: number, resolution?: number);
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number, maskActive: boolean): void;
-}
-declare const CombineShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        strength: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-export type { BloomPass };

package/postprocessing/BokehPass.d.cts

@@ -1,26 +0,0 @@
-/**
- * Depth-of-field post-process with bokeh shader
- */
-import type { Pass, FullScreenQuad } from './Pass.d.cts';
-import type { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
-type BokehPassParams = {
-    focus?: number;
-    aspect?: number;
-    aperture?: number;
-    maxblur?: number;
-    width?: number;
-    height?: number;
-};
-declare class BokehPass extends Pass {
-    scene: Scene;
-    camera: PerspectiveCamera;
-    renderTargetDepth: WebGLRenderTarget;
-    materialDepth: MeshDepthMaterial;
-    materialBokeh: ShaderMaterial;
-    fsQuad: FullScreenQuad;
-    private _oldClearColor;
-    uniforms: any;
-    constructor(scene: Scene, camera: PerspectiveCamera, params: BokehPassParams);
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
-}
-export type { BokehPass };

package/postprocessing/ClearPass.d.cts

@@ -1,10 +0,0 @@
-import type { Pass } from './Pass.d.cts';
-import type { Color, WebGLRenderer, WebGLRenderTarget } from 'three';
-declare class ClearPass extends Pass {
-    clearColor: Color | string | number;
-    clearAlpha: number;
-    private _oldClearColor;
-    constructor(clearColor?: Color | string | number, clearAlpha?: number);
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
-}
-export type { ClearPass };

package/postprocessing/CubeTexturePass.d.cts

@@ -1,14 +0,0 @@
-import type { PerspectiveCamera, CubeTexture, Mesh, Scene } from 'three'
-
-import type { Pass } from './Pass.d.cts'
-
-export class CubeTexturePass extends Pass {
-  constructor(camera: PerspectiveCamera, envMap?: CubeTexture, opacity?: number)
-  camera: PerspectiveCamera
-  cubeShader: object
-  cubeMesh: Mesh
-  envMap: CubeTexture
-  opacity: number
-  cubeScene: Scene
-  cubeCamera: PerspectiveCamera
-}

package/postprocessing/DotScreenPass.d.cts

@@ -1,11 +0,0 @@
-import type { Pass, FullScreenQuad } from './Pass.d.cts';
-import type { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
-import type { DotScreenShader } from '../shaders/DotScreenShader.d.cts';
-declare class DotScreenPass extends Pass {
-    material: ShaderMaterial;
-    fsQuad: FullScreenQuad;
-    uniforms: Record<keyof typeof DotScreenShader['uniforms'], IUniform<any>>;
-    constructor(center?: Vector2, angle?: number, scale?: number);
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
-}
-export type { DotScreenPass };