three-stdlib 2.35.7 → 2.35.8

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)

package/postprocessing/SSAARenderPass.d.cts

@@ -0,0 +1,17 @@
+import type { Scene, Camera, Color, ShaderMaterial, WebGLRenderTarget } from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export class SSAARenderPass extends Pass {
+  constructor(scene: Scene, camera: Camera, clearColor?: Color | string | number, clearAlpha?: number)
+  scene: Scene
+  camera: Camera
+  sampleLevel: number
+  unbiased: boolean
+  clearColor: Color | string | number
+  clearAlpha: number
+  copyUniforms: object
+  copyMaterial: ShaderMaterial
+  fsQuad: FullScreenQuad
+  sampleRenderTarget: undefined | WebGLRenderTarget
+}

package/postprocessing/SSAARenderPass.d.ts

@@ -1,6 +1,6 @@
-import { Scene, Camera, Color, ShaderMaterial, WebGLRenderTarget } from 'three'
+import type { Scene, Camera, Color, ShaderMaterial, WebGLRenderTarget } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export class SSAARenderPass extends Pass {
   constructor(scene: Scene, camera: Camera, clearColor?: Color | string | number, clearAlpha?: number)

package/postprocessing/SSAOPass.d.cts

@@ -0,0 +1,70 @@
+import type {
+  Camera,
+  Color,
+  DataTexture,
+  Material,
+  MeshNormalMaterial,
+  Scene,
+  ShaderMaterial,
+  Vector3,
+  WebGLRenderer,
+  WebGLRenderTarget,
+} from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export enum SSAOPassOUTPUT {
+  Default,
+  SSAO,
+  Blur,
+  Beauty,
+  Depth,
+  Normal,
+}
+
+export class SSAOPass extends Pass {
+  constructor(scene: Scene, camera: Camera, width?: number, height?: number)
+  scene: Scene
+  camera: Camera
+  width: number
+  height: boolean
+  clear: boolean
+  kernelRadius: number
+  kernelSize: number
+  kernel: Vector3[]
+  noiseTexture: DataTexture
+  output: SSAOPassOUTPUT
+  minDistance: number
+  maxDistance: number
+  beautyRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  ssaoRenderTarget: WebGLRenderTarget
+  blurRenderTarget: WebGLRenderTarget
+  ssaoMaterial: ShaderMaterial
+  normalMaterial: MeshNormalMaterial
+  blurMaterial: ShaderMaterial
+  depthRenderMaterial: ShaderMaterial
+  copyMaterial: ShaderMaterial
+  fsQuad: FullScreenQuad
+  originalClearColor: Color
+
+  static OUTPUT: SSAOPassOUTPUT
+
+  dipose(): void
+  generateSampleKernel(): Vector3[]
+  generateRandomKernelRotations(): void
+  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/SSAOPass.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Camera,
   Color,
   DataTexture,
@@ -11,7 +11,7 @@ import {
   WebGLRenderTarget,
 } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export enum SSAOPassOUTPUT {
   Default,

package/postprocessing/SSRPass.d.cts

@@ -0,0 +1,123 @@
+import type {
+  Color,
+  MeshNormalMaterial,
+  MeshBasicMaterial,
+  ShaderMaterial,
+  WebGLRenderTarget,
+  Scene,
+  WebGLRenderer,
+  Camera,
+  Mesh,
+  Material,
+} from 'three'
+import type { Pass, FullScreenQuad } from '../postprocessing/Pass.d.cts'
+import type { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass.d.cts'
+
+export interface SSRPassParams {
+  renderer: WebGLRenderer
+  scene: Scene
+  camera: Camera
+  width?: number | undefined
+  height?: number | undefined
+  selects: Mesh[] | null
+  isPerspectiveCamera?: boolean | undefined
+  isBouncing?: boolean | undefined
+  groundReflector: ReflectorForSSRPass | null
+}
+
+export class SSRPass extends Pass {
+  width: number
+  height: number
+  clear: boolean
+  renderer: WebGLRenderer
+  scene: Scene
+  camera: Camera
+  groundReflector: ReflectorForSSRPass | null
+  opacity: number
+  output: number
+  maxDistance: number
+  thickness: number
+  tempColor: Color
+
+  get selects(): Mesh[] | null
+  set selects(val: Mesh[] | null)
+  selective: boolean
+  get isBouncing(): boolean
+  set isBouncing(val: boolean)
+
+  blur: boolean
+
+  get isDistanceAttenuation(): boolean
+  set isDistanceAttenuation(val: boolean)
+  get isFresnel(): boolean
+  set isFresnel(val: boolean)
+  get isInfiniteThick(): boolean
+  set isInfiniteThick(val: boolean)
+
+  thickTolerance: number
+
+  beautyRenderTarget: WebGLRenderTarget
+  prevRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  metalnessRenderTarget: WebGLRenderTarget
+  ssrRenderTarget: WebGLRenderTarget
+
+  blurRenderTarget: WebGLRenderTarget
+  blurRenderTarget2: WebGLRenderTarget
+
+  ssrMaterial: ShaderMaterial
+
+  normalMaterial: MeshNormalMaterial
+
+  metalnessOnMaterial: MeshBasicMaterial
+
+  metalnessOffMaterial: MeshBasicMaterial
+
+  blurMaterial: ShaderMaterial
+  blurMaterial2: ShaderMaterial
+
+  depthRenderMaterial: ShaderMaterial
+
+  copyMaterial: ShaderMaterial
+
+  fsQuad: FullScreenQuad
+
+  originalClearColor: Color
+
+  static OUTPUT: {
+    Default: 0
+    SSR: 1
+    Beauty: 3
+    Depth: 4
+    Normal: 5
+    Metalness: 7
+  }
+
+  constructor(params: SSRPassParams)
+
+  dispose: () => void
+
+  renderPass: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: Color | string | number,
+    clearAlpha: Color | string | number,
+  ) => void
+
+  renderOverride: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: Color | string | number,
+    clearAlpha: Color | string | number,
+  ) => void
+
+  renderMetalness: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: Color | string | number,
+    clearAlpha: Color | string | number,
+  ) => void
+}