three-stdlib 2.35.7 → 2.35.8

package/objects/Reflector.d.cts

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

@@ -1,5 +1,5 @@
-import { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
-import { TextureEncoding } from '../types/shared'
+import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import type { TextureEncoding } from '../types/shared.d.ts'
 
 export interface ReflectorOptions {
   color?: Color | string | number

package/objects/ReflectorForSSRPass.d.cts

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

@@ -1,4 +1,4 @@
-import { Mesh, ShaderMaterial, WebGLRenderTarget, BufferGeometry, WebGLRenderer, Scene, Camera, IUniform } from 'three'
+import type { Mesh, ShaderMaterial, WebGLRenderTarget, BufferGeometry, WebGLRenderer, Scene, Camera, IUniform } from 'three'
 
 export interface ReflectorShader {
   defines: {

package/objects/ReflectorRTT.d.cts

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

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

package/objects/Refractor.d.cts

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

@@ -1,5 +1,5 @@
-import { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
-import { TextureEncoding } from '../types/shared'
+import type { Mesh, BufferGeometry, Color, WebGLRenderTarget, PerspectiveCamera } from 'three'
+import type { TextureEncoding } from '../types/shared.d.ts'
 
 export interface RefractorOptions {
   color?: Color | string | number

package/objects/ShadowMesh.d.cts

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

@@ -1,4 +1,4 @@
-import { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from 'three'
+import type { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from 'three'
 
 export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
   readonly isShadowMesh: true

package/objects/Sky.d.cts

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

@@ -1,4 +1,4 @@
-import { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
+import type { Mesh, BoxGeometry, ShaderMaterial, Vector3 } from 'three'
 
 declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
   static SkyShader: {
@@ -15,4 +15,4 @@ declare class Sky extends Mesh<BoxGeometry, ShaderMaterial> {
   static material: ShaderMaterial
 }
 
-export { Sky }
+export { type Sky }

package/objects/Water.d.cts

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

@@ -1,4 +1,4 @@
-import { BufferGeometry, Color, Mesh, ShaderMaterial, Side, Texture, Vector3 } from 'three'
+import type { BufferGeometry, Color, Mesh, ShaderMaterial, Side, Texture, Vector3 } from 'three'
 
 export interface WaterOptions {
   textureWidth?: number

package/objects/Water2.d.cts

@@ -0,0 +1,23 @@
+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/objects/Water2.d.ts

@@ -1,5 +1,5 @@
-import { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
-import { TextureEncoding } from '../types/shared'
+import type { BufferGeometry, Color, Mesh, ShaderMaterial, Texture, Vector2 } from 'three'
+import type { TextureEncoding } from '../types/shared.d.ts'
 
 export interface Water2Options {
   color?: Color | string | number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-stdlib",
-  "version": "2.35.7",
+  "version": "2.35.8",
   "description": "stand-alone library of threejs examples",
   "keywords": [
     "three",
@@ -22,9 +22,14 @@
   "main": "./index.cjs",
   "module": "./index.js",
   "exports": {
-    "types": "./index.d.ts",
-    "require": "./index.cjs",
-    "import": "./index.js"
+    "require": {
+      "types": "./index.d.cts",
+      "default": "./index.cjs"
+    },
+    "default": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
   },
   "sideEffects": false,
   "devDependencies": {
@@ -34,6 +39,7 @@
     "json": "^11.0.0",
     "prettier": "^2.2.1",
     "rimraf": "^3.0.2",
+    "shelljs": "^0.8.5",
     "three": "^0.128.0",
     "typescript": "^4.7.4",
     "vite": "^4.3.8"
@@ -50,7 +56,7 @@
     "three": ">=0.128.0"
   },
   "scripts": {
-    "build": "rimraf dist && vite build && tsc --emitDeclarationOnly && copyfiles -u 1 \"src/**/*.d.ts\" dist && copyfiles package.json README.md LICENSE dist && json -I -f dist/package.json -e \"this.private=undefined;this.type=\\\"module\\\";\"",
+    "build": "rimraf dist && vite build && tsc --emitDeclarationOnly && copyfiles -u 1 \"src/**/*.d.ts\" dist && copyfiles package.json README.md LICENSE dist && json -I -f dist/package.json -e \"this.private=undefined;this.type=\\\"module\\\";\" && node patch-ts.js",
     "lint": "tsc --noEmit"
   },
   "type": "module"

package/physics/AmmoPhysics.d.cts

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

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

package/postprocessing/AdaptiveToneMappingPass.d.cts

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

@@ -1,6 +1,6 @@
-import { WebGLRenderTarget, ShaderMaterial } from 'three'
+import type { WebGLRenderTarget, ShaderMaterial } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export class AdaptiveToneMappingPass extends Pass {
   constructor(adaptive?: boolean, resolution?: number)

package/postprocessing/AfterimagePass.d.cts

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

@@ -1,5 +1,5 @@
-import { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
-import { Pass, FullScreenQuad } from './Pass';
+import type { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
 declare class AfterimagePass extends Pass {
     shader: import("../shaders/AfterimageShader").IAfterimageShader;
     uniforms: any;
@@ -12,4 +12,4 @@ declare class AfterimagePass extends Pass {
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
     setSize(width: number, height: number): void;
 }
-export { AfterimagePass };
+export { type AfterimagePass };

package/postprocessing/BloomPass.d.cts

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

@@ -1,6 +1,6 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { ConvolutionShader } from '../shaders/ConvolutionShader';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { ConvolutionShader } from '../shaders/ConvolutionShader.d.ts';
 declare class BloomPass extends Pass {
     renderTargetX: WebGLRenderTarget;
     renderTargetY: WebGLRenderTarget;
@@ -26,4 +26,4 @@ declare const CombineShader: {
     vertexShader: string;
     fragmentShader: string;
 };
-export { BloomPass };
+export { type BloomPass };

package/postprocessing/BokehPass.d.cts

@@ -0,0 +1,26 @@
+/**
+ * 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/BokehPass.d.ts

@@ -1,8 +1,8 @@
 /**
  * Depth-of-field post-process with bokeh shader
  */
-import { Pass, FullScreenQuad } from './Pass';
-import { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
 type BokehPassParams = {
     focus?: number;
     aspect?: number;
@@ -23,4 +23,4 @@ declare class BokehPass extends Pass {
     constructor(scene: Scene, camera: PerspectiveCamera, params: BokehPassParams);
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
 }
-export { BokehPass };
+export { type BokehPass };

package/postprocessing/ClearPass.d.cts

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

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

package/postprocessing/CubeTexturePass.d.cts

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

@@ -1,6 +1,6 @@
-import { PerspectiveCamera, CubeTexture, Mesh, Scene } from 'three'
+import type { PerspectiveCamera, CubeTexture, Mesh, Scene } from 'three'
 
-import { Pass } from './Pass'
+import type { Pass } from './Pass.d.ts'
 
 export class CubeTexturePass extends Pass {
   constructor(camera: PerspectiveCamera, envMap?: CubeTexture, opacity?: number)

package/postprocessing/DotScreenPass.d.cts

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

package/postprocessing/DotScreenPass.d.ts

@@ -1,6 +1,6 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { DotScreenShader } from '../shaders/DotScreenShader';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { IUniform, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { DotScreenShader } from '../shaders/DotScreenShader.d.ts';
 declare class DotScreenPass extends Pass {
     material: ShaderMaterial;
     fsQuad: FullScreenQuad;
@@ -8,4 +8,4 @@ declare class DotScreenPass extends Pass {
     constructor(center?: Vector2, angle?: number, scale?: number);
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
 }
-export { DotScreenPass };
+export { type DotScreenPass };

package/postprocessing/EffectComposer.d.cts

@@ -0,0 +1,28 @@
+import type { Clock, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass } from './Pass.d.cts';
+declare class EffectComposer<TRenderTarget extends WebGLRenderTarget = WebGLRenderTarget> {
+    renderer: WebGLRenderer;
+    private _pixelRatio;
+    private _width;
+    private _height;
+    renderTarget1: WebGLRenderTarget;
+    renderTarget2: WebGLRenderTarget;
+    writeBuffer: WebGLRenderTarget;
+    readBuffer: WebGLRenderTarget;
+    renderToScreen: boolean;
+    passes: Pass[];
+    copyPass: Pass;
+    clock: Clock;
+    constructor(renderer: WebGLRenderer, renderTarget?: TRenderTarget);
+    swapBuffers(): void;
+    addPass(pass: Pass): void;
+    insertPass(pass: Pass, index: number): void;
+    removePass(pass: Pass): void;
+    isLastEnabledPass(passIndex: number): boolean;
+    render(deltaTime?: number): void;
+    reset(renderTarget: WebGLRenderTarget): void;
+    setSize(width: number, height: number): void;
+    setPixelRatio(pixelRatio: number): void;
+    dispose(): void;
+}
+export { type EffectComposer };

package/postprocessing/EffectComposer.d.ts

@@ -1,5 +1,5 @@
-import { Clock, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { Pass } from './Pass';
+import type { Clock, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass } from './Pass.d.ts';
 declare class EffectComposer<TRenderTarget extends WebGLRenderTarget = WebGLRenderTarget> {
     renderer: WebGLRenderer;
     private _pixelRatio;
@@ -25,4 +25,4 @@ declare class EffectComposer<TRenderTarget extends WebGLRenderTarget = WebGLRend
     setPixelRatio(pixelRatio: number): void;
     dispose(): void;
 }
-export { EffectComposer };
+export { type EffectComposer };

package/postprocessing/FilmPass.d.cts

@@ -0,0 +1,11 @@
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { IUniform, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { FilmShader } from '../shaders/FilmShader.d.cts';
+declare class FilmPass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    uniforms: Record<keyof typeof FilmShader['uniforms'], IUniform<any>>;
+    constructor(noiseIntensity?: number, scanlinesIntensity?: number, scanlinesCount?: number, grayscale?: boolean);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number): void;
+}
+export { type FilmPass };

package/postprocessing/FilmPass.d.ts

@@ -1,6 +1,6 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { IUniform, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { FilmShader } from '../shaders/FilmShader';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { IUniform, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { FilmShader } from '../shaders/FilmShader.d.ts';
 declare class FilmPass extends Pass {
     material: ShaderMaterial;
     fsQuad: FullScreenQuad;
@@ -8,4 +8,4 @@ declare class FilmPass extends Pass {
     constructor(noiseIntensity?: number, scanlinesIntensity?: number, scanlinesCount?: number, grayscale?: boolean);
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number): void;
 }
-export { FilmPass };
+export { type FilmPass };