three-stdlib 2.35.11 → 2.35.13

package/postprocessing/EffectComposer.d.cts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/postprocessing/SavePass.d.cts

@@ -1,12 +0,0 @@
-import type { ShaderMaterial, WebGLRenderTarget } from 'three'
-
-import type { Pass } from './Pass.d.cts'
-
-export class SavePass extends Pass {
-  constructor(renderTarget: WebGLRenderTarget)
-  textureID: string
-  renderTarget: WebGLRenderTarget
-  uniforms: object
-  material: ShaderMaterial
-  fsQuad: object
-}

package/postprocessing/ShaderPass.d.cts

@@ -1,13 +0,0 @@
-import type { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
-import type { Pass, FullScreenQuad } from './Pass.d.cts';
-import type { Defines, IShader, Uniforms } from '../shaders/types.d.cts';
-declare class ShaderPass extends Pass {
-    textureID: string;
-    uniforms: Uniforms;
-    material: ShaderMaterial;
-    fsQuad: FullScreenQuad;
-    constructor(shader: ShaderMaterial | IShader<Uniforms, Defines | undefined>, textureID?: string);
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
-    dispose(): void;
-}
-export type { ShaderPass };

package/postprocessing/TAARenderPass.d.cts

@@ -1,8 +0,0 @@
-import type { Scene, Camera, Color } from 'three'
-
-import type { SSAARenderPass } from './SSAARenderPass.d.cts'
-
-export class TAARenderPass extends SSAARenderPass {
-  constructor(scene: Scene, camera: Camera, clearColor: Color | string | number, clearAlpha: number)
-  accumulate: boolean
-}

package/postprocessing/TexturePass.d.cts

@@ -1,12 +0,0 @@
-import type { Texture, ShaderMaterial } from 'three'
-
-import type { Pass, FullScreenQuad } from './Pass.d.cts'
-
-export class TexturePass extends Pass {
-  constructor(map: Texture, opacity?: number)
-  map: Texture
-  opacity: number
-  uniforms: object
-  material: ShaderMaterial
-  fsQuad: FullScreenQuad
-}

package/postprocessing/UnrealBloomPass.d.cts

@@ -1,31 +0,0 @@
-import type { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from 'three'
-
-import type { Pass } from './Pass.d.cts'
-
-export class UnrealBloomPass extends Pass {
-  constructor(resolution: Vector2, strength: number, radius: number, threshold: number)
-  resolution: Vector2
-  strength: number
-  radius: number
-  threshold: number
-  clearColor: Color
-  renderTargetsHorizontal: WebGLRenderTarget[]
-  renderTargetsVertical: WebGLRenderTarget[]
-  nMips: number
-  renderTargetBright: WebGLRenderTarget
-  highPassUniforms: object
-  materialHighPassFilter: ShaderMaterial
-  separableBlurMaterials: ShaderMaterial[]
-  compositeMaterial: ShaderMaterial
-  bloomTintColors: Vector3[]
-  copyUniforms: object
-  materialCopy: ShaderMaterial
-  oldClearColor: Color
-  oldClearAlpha: number
-  basic: MeshBasicMaterial
-  fsQuad: object
-
-  dispose(): void
-  getSeperableBlurMaterial(): ShaderMaterial
-  getCompositeMaterial(): ShaderMaterial
-}

package/postprocessing/WaterPass.d.cts

@@ -1,35 +0,0 @@
-import type { WebGLRenderer, WebGLRenderTarget, ShaderMaterial, Vector2, IUniform, Texture } from 'three';
-import type { Pass, FullScreenQuad } from '../postprocessing/Pass.d.cts';
-/**
- * Simple underwater shader
- *
- 
- parameters:
- tex: texture
- time: this should increase with time passing
- factor: to what degree will the shader distort the screen
-
- explaination:
- the shader is quite simple
- it chooses a center and start from there make pixels around it to "swell" then "shrink" then "swell"...
- this is of course nothing really similar to underwater scene
- but you can combine several this shaders together to create the effect you need...
- And yes, this shader could be used for something other than underwater effect, for example, magnifier effect :)
-
- * @author vergil Wang
- */
-declare class WaterPass extends Pass {
-    material: ShaderMaterial;
-    fsQuad: FullScreenQuad;
-    factor: number;
-    time: number;
-    uniforms: {
-        tex: IUniform<Texture>;
-        time: IUniform<number>;
-        factor: IUniform<number>;
-        resolution: IUniform<Vector2>;
-    };
-    constructor();
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
-}
-export type { WaterPass };