three-stdlib 2.35.6 → 2.35.8

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 };

package/postprocessing/GlitchPass.d.cts

@@ -0,0 +1,16 @@
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { DataTexture, ShaderMaterial, WebGLRenderTarget, WebGLRenderer, IUniform } from 'three';
+import type { DigitalGlitch } from '../shaders/DigitalGlitch.d.cts';
+declare class GlitchPass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    goWild: boolean;
+    curF: number;
+    randX: number;
+    uniforms: Record<keyof typeof DigitalGlitch['uniforms'], IUniform<any>>;
+    constructor(dt_size?: number);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+    generateTrigger(): void;
+    generateHeightmap(dt_size: number): DataTexture;
+}
+export { type GlitchPass };

package/postprocessing/GlitchPass.d.ts

@@ -1,6 +1,6 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { DataTexture, ShaderMaterial, WebGLRenderTarget, WebGLRenderer, IUniform } from 'three';
-import { DigitalGlitch } from '../shaders/DigitalGlitch';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { DataTexture, ShaderMaterial, WebGLRenderTarget, WebGLRenderer, IUniform } from 'three';
+import type { DigitalGlitch } from '../shaders/DigitalGlitch.d.ts';
 declare class GlitchPass extends Pass {
     material: ShaderMaterial;
     fsQuad: FullScreenQuad;
@@ -13,4 +13,4 @@ declare class GlitchPass extends Pass {
     generateTrigger(): void;
     generateHeightmap(dt_size: number): DataTexture;
 }
-export { GlitchPass };
+export { type GlitchPass };

package/postprocessing/HalftonePass.d.cts

@@ -0,0 +1,26 @@
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+type HalftonePassParams = {
+    shape?: number;
+    radius?: number;
+    rotateR?: number;
+    rotateB?: number;
+    rotateG?: number;
+    scatter?: number;
+    blending?: number;
+    blendingMode?: number;
+    greyscale?: number;
+    disable?: number;
+};
+/**
+ * RGB Halftone pass for three.js effects composer. Requires HalftoneShader.
+ */
+declare class HalftonePass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    uniforms: any;
+    constructor(width: number, height: number, params: HalftonePassParams);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+    setSize(width: number, height: number): void;
+}
+export { type HalftonePass };

package/postprocessing/HalftonePass.d.ts

@@ -1,5 +1,5 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
 type HalftonePassParams = {
     shape?: number;
     radius?: number;
@@ -23,4 +23,4 @@ declare class HalftonePass extends Pass {
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
     setSize(width: number, height: number): void;
 }
-export { HalftonePass };
+export { type HalftonePass };

package/postprocessing/LUTPass.d.cts

@@ -0,0 +1,13 @@
+import type { DataTexture, Texture } from 'three'
+import type { ShaderPass } from './ShaderPass.d.cts'
+
+export interface LUTPassParameters {
+  lut?: DataTexture | Texture // Data3DTexture
+  intensity?: number
+}
+
+export class LUTPass extends ShaderPass {
+  lut?: DataTexture | Texture // Data3DTexture
+  intensity?: number
+  constructor(params: LUTPassParameters)
+}

package/postprocessing/LUTPass.d.ts

@@ -1,5 +1,5 @@
-import { DataTexture, Texture } from 'three'
-import { ShaderPass } from './ShaderPass'
+import type { DataTexture, Texture } from 'three'
+import type { ShaderPass } from './ShaderPass.d.ts'
 
 export interface LUTPassParameters {
   lut?: DataTexture | Texture // Data3DTexture

package/postprocessing/MaskPass.d.cts

@@ -0,0 +1,14 @@
+import type { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass } from './Pass.d.cts';
+declare class MaskPass extends Pass {
+    scene: Scene;
+    camera: Camera;
+    inverse: boolean;
+    constructor(scene: Scene, camera: Camera);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+declare class ClearMaskPass extends Pass {
+    constructor();
+    render(renderer: WebGLRenderer): void;
+}
+export { type MaskPass, ClearMaskPass };

package/postprocessing/MaskPass.d.ts

@@ -1,5 +1,5 @@
-import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { Pass } from './Pass';
+import type { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass } from './Pass.d.ts';
 declare class MaskPass extends Pass {
     scene: Scene;
     camera: Camera;
@@ -11,4 +11,4 @@ declare class ClearMaskPass extends Pass {
     constructor();
     render(renderer: WebGLRenderer): void;
 }
-export { MaskPass, ClearMaskPass };
+export { type MaskPass, ClearMaskPass };

package/postprocessing/OutlinePass.d.cts

@@ -0,0 +1,53 @@
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { Camera, Color, Matrix4, MeshDepthMaterial, Object3D, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+declare class OutlinePass extends Pass {
+    renderScene: Scene;
+    renderCamera: Camera;
+    selectedObjects: Object3D[];
+    visibleEdgeColor: Color;
+    hiddenEdgeColor: Color;
+    edgeGlow: number;
+    usePatternTexture: boolean;
+    edgeThickness: number;
+    edgeStrength: number;
+    downSampleRatio: number;
+    pulsePeriod: number;
+    resolution: Vector2;
+    renderTargetMaskBuffer: WebGLRenderTarget;
+    depthMaterial: MeshDepthMaterial;
+    prepareMaskMaterial: ShaderMaterial;
+    renderTargetDepthBuffer: WebGLRenderTarget;
+    renderTargetMaskDownSampleBuffer: WebGLRenderTarget;
+    renderTargetBlurBuffer1: WebGLRenderTarget;
+    renderTargetBlurBuffer2: WebGLRenderTarget;
+    edgeDetectionMaterial: ShaderMaterial;
+    renderTargetEdgeBuffer1: WebGLRenderTarget;
+    renderTargetEdgeBuffer2: WebGLRenderTarget;
+    separableBlurMaterial1: ShaderMaterial;
+    separableBlurMaterial2: ShaderMaterial;
+    overlayMaterial: ShaderMaterial;
+    materialCopy: ShaderMaterial;
+    oldClearAlpha: number;
+    fsQuad: FullScreenQuad;
+    tempPulseColor1: Color;
+    tempPulseColor2: Color;
+    textureMatrix: Matrix4;
+    patternTexture?: Texture;
+    private _visibilityCache;
+    private _oldClearColor;
+    copyUniforms: any;
+    BlurDirectionX: Vector2;
+    BlurDirectionY: Vector2;
+    constructor(resolution: Vector2, scene: Scene, camera: Camera, selectedObjects?: Object3D[]);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    changeVisibilityOfSelectedObjects(bVisible: boolean): void;
+    changeVisibilityOfNonSelectedObjects(bVisible: boolean): void;
+    updateTextureMatrix(): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number, maskActive: boolean): void;
+    getPrepareMaskMaterial(): ShaderMaterial;
+    getEdgeDetectionMaterial(): ShaderMaterial;
+    getSeperableBlurMaterial(maxRadius: number): ShaderMaterial;
+    getOverlayMaterial(): ShaderMaterial;
+}
+export { type OutlinePass };

package/postprocessing/OutlinePass.d.ts

@@ -1,5 +1,5 @@
-import { Pass, FullScreenQuad } from './Pass';
-import { Camera, Color, Matrix4, MeshDepthMaterial, Object3D, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { Camera, Color, Matrix4, MeshDepthMaterial, Object3D, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
 declare class OutlinePass extends Pass {
     renderScene: Scene;
     renderCamera: Camera;
@@ -50,4 +50,4 @@ declare class OutlinePass extends Pass {
     getSeperableBlurMaterial(maxRadius: number): ShaderMaterial;
     getOverlayMaterial(): ShaderMaterial;
 }
-export { OutlinePass };
+export { type OutlinePass };

package/postprocessing/Pass.d.cts

@@ -0,0 +1,21 @@
+import type { OrthographicCamera, PlaneGeometry, Material, WebGLRenderer, WebGLRenderTarget } from 'three';
+declare class Pass {
+    enabled: boolean;
+    needsSwap: boolean;
+    clear: boolean;
+    renderToScreen: boolean;
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number, maskActive?: unknown): void;
+    dispose(): void;
+}
+declare class FullScreenQuad<TMaterial extends Material = Material> {
+    camera: OrthographicCamera;
+    geometry: PlaneGeometry;
+    private mesh;
+    constructor(material: TMaterial);
+    get material(): TMaterial;
+    set material(value: TMaterial);
+    dispose(): void;
+    render(renderer: WebGLRenderer): void;
+}
+export { type Pass, FullScreenQuad };

package/postprocessing/Pass.d.ts

@@ -1,4 +1,4 @@
-import { OrthographicCamera, PlaneGeometry, Material, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { OrthographicCamera, PlaneGeometry, Material, WebGLRenderer, WebGLRenderTarget } from 'three';
 declare class Pass {
     enabled: boolean;
     needsSwap: boolean;
@@ -18,4 +18,4 @@ declare class FullScreenQuad<TMaterial extends Material = Material> {
     dispose(): void;
     render(renderer: WebGLRenderer): void;
 }
-export { Pass, FullScreenQuad };
+export { type Pass, FullScreenQuad };

package/postprocessing/RenderPass.d.cts

@@ -0,0 +1,14 @@
+import type { Camera, Color, Material, Scene, WebGLRenderTarget, WebGLRenderer } from 'three';
+import type { Pass } from './Pass.d.cts';
+declare class RenderPass extends Pass {
+    scene: Scene;
+    camera: Camera;
+    overrideMaterial: Material | undefined;
+    clearColor: Color | undefined;
+    clearAlpha: number;
+    clearDepth: boolean;
+    private _oldClearColor;
+    constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+export { type RenderPass };

package/postprocessing/RenderPass.d.ts

@@ -1,5 +1,5 @@
-import { Camera, Color, Material, Scene, WebGLRenderTarget, WebGLRenderer } from 'three';
-import { Pass } from './Pass';
+import type { Camera, Color, Material, Scene, WebGLRenderTarget, WebGLRenderer } from 'three';
+import type { Pass } from './Pass.d.ts';
 declare class RenderPass extends Pass {
     scene: Scene;
     camera: Camera;
@@ -11,4 +11,4 @@ declare class RenderPass extends Pass {
     constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number);
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
 }
-export { RenderPass };
+export { type RenderPass };

package/postprocessing/RenderPixelatedPass.d.cts

@@ -0,0 +1,34 @@
+import type { Scene, Camera, ShaderMaterial, Vector2, MeshNormalMaterial, WebGLRenderTarget } from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export interface RenderPixelatedPassParameters {
+  normalEdgeStrength?: number
+  depthEdgeStrength?: number
+}
+
+export class RenderPixelatedPass extends Pass {
+  constructor(
+    resolution: Vector2,
+    pixelSize: number,
+    scene: Scene,
+    camera: Camera,
+    options?: RenderPixelatedPassParameters,
+  )
+  pixelSize: number
+  resolution: Vector2
+  renderResolution: Vector2
+
+  pixelatedMaterial: ShaderMaterial
+  normalMaterial: MeshNormalMaterial
+
+  fsQuad: FullScreenQuad
+  scene: Scene
+  camera: Camera
+
+  normalEdgeStrength: RenderPixelatedPassParameters['normalEdgeStrength']
+  depthEdgeStrength: RenderPixelatedPassParameters['depthEdgeStrength']
+
+  rgbRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+}

package/postprocessing/RenderPixelatedPass.d.ts

@@ -1,6 +1,6 @@
-import { Scene, Camera, ShaderMaterial, Vector2, MeshNormalMaterial, WebGLRenderTarget } from 'three'
+import type { Scene, Camera, ShaderMaterial, Vector2, MeshNormalMaterial, WebGLRenderTarget } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export interface RenderPixelatedPassParameters {
   normalEdgeStrength?: number

package/postprocessing/SAOPass.d.cts

@@ -0,0 +1,78 @@
+import type {
+  Scene,
+  Camera,
+  Material,
+  MeshDepthMaterial,
+  MeshNormalMaterial,
+  ShaderMaterial,
+  Color,
+  Vector2,
+  WebGLRenderer,
+  WebGLRenderTarget,
+} from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export enum OUTPUT {
+  Beauty,
+  Default,
+  SAO,
+  Depth,
+  Normal,
+}
+
+export interface SAOPassParams {
+  output: OUTPUT
+  saoBias: number
+  saoIntensity: number
+  saoScale: number
+  saoKernelRadius: number
+  saoMinResolution: number
+  saoBlur: boolean
+  saoBlurRadius: number
+  saoBlurStdDev: number
+  saoBlurDepthCutoff: number
+}
+
+export class SAOPass extends Pass {
+  constructor(scene: Scene, camera: Camera, depthTexture?: boolean, useNormals?: boolean, resolution?: Vector2)
+  scene: Scene
+  camera: Camera
+  supportsDepthTextureExtension: boolean
+  supportsNormalTexture: boolean
+  originalClearColor: Color
+  oldClearColor: Color
+  oldClearAlpha: number
+  resolution: Vector2
+  saoRenderTarget: WebGLRenderTarget
+  blurIntermediateRenderTarget: WebGLRenderTarget
+  beautyRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  depthRenderTarget: WebGLRenderTarget
+  depthMaterial: MeshDepthMaterial
+  normalMaterial: MeshNormalMaterial
+  saoMaterial: ShaderMaterial
+  vBlurMaterial: ShaderMaterial
+  hBlurMaterial: ShaderMaterial
+  materialCopy: ShaderMaterial
+  depthCopy: ShaderMaterial
+  fsQuad: FullScreenQuad
+  params: SAOPassParams
+
+  static OUTPUT: typeof OUTPUT
+
+  renderPass(
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor?: Color | string | number,
+    clearAlpha?: number,
+  ): void
+  renderOverride(
+    renderer: WebGLRenderer,
+    overrideMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor?: Color | string | number,
+    clearAlpha?: number,
+  ): void
+}

package/postprocessing/SAOPass.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Scene,
   Camera,
   Material,
@@ -11,7 +11,7 @@ import {
   WebGLRenderTarget,
 } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export enum OUTPUT {
   Beauty,

package/postprocessing/SMAAPass.d.cts

@@ -0,0 +1,21 @@
+import type { ShaderMaterial, Texture, WebGLRenderTarget } from 'three'
+
+import type { Pass } from './Pass.d.cts'
+
+export class SMAAPass extends Pass {
+  constructor(width: number, height: number)
+  edgesRT: WebGLRenderTarget
+  weightsRT: WebGLRenderTarget
+  areaTexture: Texture
+  searchTexture: Texture
+  uniformsEdges: object
+  materialEdges: ShaderMaterial
+  uniformsWeights: object
+  materialWeights: ShaderMaterial
+  uniformsBlend: object
+  materialBlend: ShaderMaterial
+  fsQuad: object
+
+  getAreaTexture(): string
+  getSearchTexture(): string
+}

package/postprocessing/SMAAPass.d.ts

@@ -1,6 +1,6 @@
-import { ShaderMaterial, Texture, WebGLRenderTarget } from 'three'
+import type { ShaderMaterial, Texture, WebGLRenderTarget } from 'three'
 
-import { Pass } from './Pass'
+import type { Pass } from './Pass.d.ts'
 
 export class SMAAPass extends Pass {
   constructor(width: number, height: number)