@shapediver/viewer.rendering-engine.rendering-engine-threejs 3.3.3 → 3.3.6

package/src/managers/postprocessing/SSAARenderPass.ts

@@ -1,339 +0,0 @@
-import { ClearPass, Pass } from 'postprocessing';
-import {
-  AddEquation,
-  BufferAttribute,
-  BufferGeometry,
-  Camera,
-  Color,
-  CustomBlending,
-  HalfFloatType,
-  Mesh,
-  OneFactor,
-  OrthographicCamera,
-  PerspectiveCamera,
-  Scene,
-  ShaderMaterial,
-  SrcAlphaFactor,
-  SRGBColorSpace,
-  UniformsUtils,
-  WebGLRenderer,
-  WebGLRenderTarget
-} from 'three';
-import { CopyShader } from './utils/CopyShader';
-import { FullScreenQuad } from './utils/FullScreenQuad';
-import { CopyMaterial } from './utils/CopyMaterial';
-
-let geometry: BufferGeometry | null = null;
-
-/**
- * Returns a shared fullscreen triangle.
- *
- * The screen size is 2x2 units (NDC). A triangle needs to be 4x4 units to fill the screen.
- *
- * @private
- * @return {BufferGeometry} The fullscreen geometry.
- */
-
-const getFullscreenTriangle = () =>  {
-
-	if(geometry === null) {
-
-		const vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);
-		const uvs = new Float32Array([0, 0, 2, 0, 0, 2]);
-		geometry = new BufferGeometry();
-
-			geometry.setAttribute("position", new BufferAttribute(vertices, 3));
-			geometry.setAttribute("uv", new BufferAttribute(uvs, 2));
-
-
-	}
-
-	return geometry;
-
-}
-
-/**
-*
-* Supersample Anti-Aliasing Render Pass
-*
-* This manual approach to SSAA re-renders the scene once for each sample with camera jitter and accumulates the results.
-*
-* References: https://en.wikipedia.org/wiki/Supersampling
-*
-* original implementation from three.js@0.152.2 was modified to work with the postprocessing library
-*
-*/
-export class SSAARenderPass extends Pass {
-  // #region Properties (9)
-
-  private readonly _clearPass: ClearPass;
-  private readonly _copyUniforms: any;
-  private readonly _fsQuad: FullScreenQuad;
-  private readonly _fullScreen: Mesh;
-  private readonly _sampleRenderTarget: WebGLRenderTarget;
-  private readonly _ssaaCopyMaterial: ShaderMaterial;
-
-  private _clearAlpha: number | undefined;
-  private _clearColor: Color = new Color();
-  private _oldClearColor: Color = new Color();
-  private _sampleLevel: number = 2;
-  private _unbiased: boolean = true;
-  private _copyMaterial: CopyMaterial;
-
-  // #endregion Properties (9)
-
-  // #region Constructors (1)
-
-  constructor(scene: Scene, camera: Camera) {
-    super("SSAARenderPass", scene, camera);
-
-    this.needsSwap = false;
-
-    this._sampleRenderTarget = new WebGLRenderTarget(1, 1, {
-      type: HalfFloatType,
-    });
-    this._sampleRenderTarget.texture.name = "SSAARender.Target";
-    this._sampleRenderTarget.texture.colorSpace = SRGBColorSpace;
-
-    const copyShader = CopyShader;
-    this._copyUniforms = UniformsUtils.clone(copyShader.uniforms);
-
-    // Create a copy material to render the ssaa sample render target to.
-    this._ssaaCopyMaterial = new ShaderMaterial({
-      uniforms: this._copyUniforms,
-      vertexShader: copyShader.vertexShader,
-      fragmentShader: copyShader.fragmentShader,
-      transparent: true,
-      depthTest: false,
-      depthWrite: false,
-
-      // do not use AdditiveBlending because it mixes the alpha channel instead of adding
-      blending: CustomBlending,
-      blendEquation: AddEquation,
-      blendDst: OneFactor,
-      blendDstAlpha: OneFactor,
-      blendSrc: SrcAlphaFactor,
-      blendSrcAlpha: OneFactor,
-    });
-    this._fsQuad = new FullScreenQuad(this._ssaaCopyMaterial);
-
-    // create a second copy material to render the final results to
-    this._copyMaterial = new CopyMaterial();
-    this._fullScreen = new Mesh(getFullscreenTriangle(), this._copyMaterial);
-    this._fullScreen.frustumCulled = false;
-
-    // clear pass for color and depth
-    this._clearPass = new ClearPass(true, true, false);
-  }
-
-  // #endregion Constructors (1)
-
-  // #region Public Accessors (6)
-
-  public set mainCamera(value: Camera) {
-    this.camera = value;
-  }
-
-  public set mainScene(value: Scene) {
-    this.scene = value;
-  }
-
-  public get renderToScreen() {
-    return super.renderToScreen;
-  }
-
-  public set renderToScreen(value) {
-    super.renderToScreen = value;
-  }
-
-  public get sampleLevel() {
-    return this._sampleLevel;
-  }
-
-  /**
-   * specified as n, where the number of samples is 2^n, so sampleLevel = 4, is 2^4 samples, 16.
-   */
-  public set sampleLevel(value: number) {
-    this._sampleLevel = value;
-  }
-
-  /**
-   * to cancel out rounding errors
-   */
-  public set unbiased(value: boolean) {
-    this._unbiased = value;
-  }
-
-  // #endregion Public Accessors (6)
-
-  // #region Public Methods (3)
-
-  public dispose() {
-    this._sampleRenderTarget.dispose();
-    this._ssaaCopyMaterial.dispose();
-    this._fsQuad.dispose();
-  }
-
-  /**
-   * Renders the scene.
-   *
-   * @param {WebGLRenderer} renderer - The renderer.
-   * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
-   * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
-   * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
-   * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
-   */
-  public render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, outputBuffer: WebGLRenderTarget, deltaTime: undefined, stencilTest: undefined) {
-    // set clear color / clear alpha / color space from the current renderer
-    this._clearColor = renderer.getClearColor(new Color());
-    this._clearAlpha = renderer.getClearAlpha();
-    this._sampleRenderTarget.texture.colorSpace = renderer.outputColorSpace;
-
-    const jitterOffsets = _JitterVectors[Math.max(0, Math.min(this._sampleLevel, 5))];
-
-    // save the original auto clear and set to false
-    const autoClear = renderer.autoClear;
-    renderer.autoClear = false;
-
-    // save the original clear color and alpha
-    renderer.getClearColor(this._oldClearColor);
-    const oldClearAlpha = renderer.getClearAlpha();
-
-    const baseSampleWeight = 1.0 / jitterOffsets.length;
-    const roundingRange = 1 / 32;
-    this._copyUniforms["tDiffuse"].value = this._sampleRenderTarget.texture;
-
-    const viewOffset = {
-      fullWidth: inputBuffer.width,
-      fullHeight: inputBuffer.height,
-      offsetX: 0,
-      offsetY: 0,
-      width: inputBuffer.width,
-      height: inputBuffer.height,
-    };
-
-    const originalViewOffset = Object.assign(
-      {},
-      (<PerspectiveCamera | OrthographicCamera>this.camera).view
-    );
-
-    if (originalViewOffset.enabled)
-      Object.assign(viewOffset, originalViewOffset);
-
-    // render the scene multiple times, each slightly jitter offset from the last and accumulate the results.
-    for (let i = 0; i < jitterOffsets.length; i++) {
-      const jitterOffset = jitterOffsets[i];
-
-      if ((<PerspectiveCamera | OrthographicCamera>this.camera).setViewOffset) {
-        (<PerspectiveCamera | OrthographicCamera>this.camera).setViewOffset(
-          viewOffset.fullWidth,
-          viewOffset.fullHeight,
-
-          viewOffset.offsetX + jitterOffset[0] * 0.0625,
-          viewOffset.offsetY + jitterOffset[1] * 0.0625, // 0.0625 = 1 / 16
-
-          viewOffset.width,
-          viewOffset.height
-        );
-      }
-
-      let sampleWeight = baseSampleWeight;
-
-      if (this._unbiased) {
-        // the theory is that equal weights for each sample lead to an accumulation of rounding errors.
-        // The following equation varies the sampleWeight per sample so that it is uniformly distributed
-        // across a range of values whose rounding errors cancel each other out.
-
-        const uniformCenteredDistribution =
-          -0.5 + (i + 0.5) / jitterOffsets.length;
-        sampleWeight += roundingRange * uniformCenteredDistribution;
-      }
-
-      renderer.setClearColor(this._clearColor, this._clearAlpha);
-      renderer.setRenderTarget(this._sampleRenderTarget);
-      renderer.clear();
-      renderer.render(this.scene, this.camera);
-
-      renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);
-
-      if (i === 0) {
-        renderer.setClearColor(0x000000, 0.0);
-        renderer.clear();
-      }
-
-      // set the weight of the current samples in the ssaaCopyMaterial
-      this._copyUniforms["opacity"].value = sampleWeight;
-
-      // render the sampleRenderTarget to fullscreen
-      this._fsQuad.render(renderer);
-    }
-
-    // clear color and depth
-    this._clearPass.render(renderer, inputBuffer, inputBuffer);
-
-    // render to the final result to fullscreen
-    this._copyMaterial.uniforms.inputBuffer.value = outputBuffer.texture;
-    this._copyMaterial.uniforms.opacity.value = 1;
-    renderer.setRenderTarget(this.renderToScreen ? null : inputBuffer);
-
-    this.scene.add(this._fullScreen);
-    renderer.render(this.scene, this.camera);
-		this.scene.remove(this._fullScreen);
-
-    if ((<PerspectiveCamera | OrthographicCamera>this.camera).setViewOffset && originalViewOffset.enabled) {
-      (<PerspectiveCamera | OrthographicCamera>this.camera).setViewOffset(
-        originalViewOffset.fullWidth,
-        originalViewOffset.fullHeight,
-
-        originalViewOffset.offsetX,
-        originalViewOffset.offsetY,
-
-        originalViewOffset.width,
-        originalViewOffset.height
-      );
-    } else if ((<PerspectiveCamera | OrthographicCamera>this.camera).clearViewOffset) {
-      (<PerspectiveCamera | OrthographicCamera>this.camera).clearViewOffset();
-    }
-
-    renderer.autoClear = autoClear;
-    renderer.setClearColor(this._oldClearColor, oldClearAlpha);
-  }
-
-  public setSize(width: number, height: number) {
-    this._sampleRenderTarget.setSize(width, height);
-  }
-
-  // #endregion Public Methods (3)
-}
-
-const _JitterVectors = [
-  [
-    [0, 0]
-  ],
-  [
-    [4, 4], [- 4, - 4]
-  ],
-  [
-    [- 2, - 6], [6, - 2], [- 6, 2], [2, 6]
-  ],
-  [
-    [1, - 3], [- 1, 3], [5, 1], [- 3, - 5],
-    [- 5, 5], [- 7, - 1], [3, 7], [7, - 7]
-  ],
-  [
-    [1, 1], [- 1, - 3], [- 3, 2], [4, - 1],
-    [- 5, - 2], [2, 5], [5, 3], [3, - 5],
-    [- 2, 6], [0, - 7], [- 4, - 6], [- 6, 4],
-    [- 8, 0], [7, - 4], [6, 7], [- 7, - 8]
-  ],
-  [
-    [- 4, - 7], [- 7, - 5], [- 3, - 5], [- 5, - 4],
-    [- 1, - 4], [- 2, - 2], [- 6, - 1], [- 4, 0],
-    [- 7, 1], [- 1, 2], [- 6, 3], [- 3, 3],
-    [- 7, 6], [- 3, 6], [- 5, 7], [- 1, 7],
-    [5, - 7], [1, - 6], [6, - 5], [4, - 4],
-    [2, - 3], [7, - 2], [1, - 1], [4, - 1],
-    [2, 1], [6, 2], [0, 4], [4, 4],
-    [2, 5], [7, 5], [5, 6], [3, 7]
-  ]
-];

package/src/managers/postprocessing/SelectiveBloomManager.ts

@@ -1,58 +0,0 @@
-import * as THREE from 'three';
-import { ITreeNode } from '@shapediver/viewer.shared.node-tree';
-import { RenderingEngine } from '../../RenderingEngine';
-import { SelectiveBloomEffect } from 'postprocessing';
-
-export class SelectiveBloomManager {
-    // #region Properties (2)
-
-    private _selectiveBloomEffect!: SelectiveBloomEffect;
-    private _selectiveBloomNodes: ITreeNode[] = [];
-
-    // #endregion Properties (2)
-
-    // #region Constructors (1)
-
-    constructor(private readonly _renderingEngine: RenderingEngine) { }
-
-    // #endregion Constructors (1)
-
-    // #region Public Methods (5)
-
-    public addSelection(node: ITreeNode): void {
-        this._selectiveBloomNodes.push(node);
-        this.updateSelectiveBloomEffectObjects();
-    }
-
-    public clearSelection(): void {
-        this._selectiveBloomNodes = [];
-        this.updateSelectiveBloomEffectObjects();
-    }
-
-    public removeSelection(node: ITreeNode): boolean {
-        const index = this._selectiveBloomNodes.indexOf(node);
-        if (index !== -1)
-            this._selectiveBloomNodes.splice(index, 1);
-
-        this.updateSelectiveBloomEffectObjects();
-        return index !== -1;
-    }
-
-    public setEffect(selectiveBloomEffect: SelectiveBloomEffect) {
-        this._selectiveBloomEffect = selectiveBloomEffect;
-        this.updateSelectiveBloomEffectObjects();
-    }
-
-    public updateSelectiveBloomEffectObjects() {
-        this._selectiveBloomEffect.selection.clear();
-
-        for (let i = 0; i < this._selectiveBloomNodes.length; i++) {
-            (this._selectiveBloomNodes[i].convertedObject[this._renderingEngine.id] as THREE.Object3D).traverse(o => {
-                if (o instanceof THREE.Mesh)
-                    this._selectiveBloomEffect.selection.add(o);
-            });
-        }
-    }
-
-    // #endregion Public Methods (5)
-}

package/src/managers/postprocessing/ao/ao/AOEffect.ts

@@ -1,180 +0,0 @@
-import { Effect, EffectComposer } from 'postprocessing';
-import { Camera, Color, Scene, ShaderMaterial, Uniform, WebGLRenderer } from 'three';
-import { PoissionDenoisePass } from '../poissionDenoise/PoissionDenoisePass';
-import { AOPass } from './AOPass';
-import { ao_compose } from './shader/ao_compose';
-import { NormalPass } from '../../utils/NormalPass';
-
-const defaultAOOptions = {
-	resolutionScale: 1,
-	spp: 8,
-	distancePower: 1,
-	power: 2,
-	bias: 40,
-	thickness: 0.075,
-	color: new Color('black'),
-	useNormalPass: false,
-	velocityDepthNormalPass: null,
-	...PoissionDenoisePass.DefaultOptions
-};
-
-class AOEffect extends Effect {
-	// #region Properties (7)
-
-	public static DefaultOptions = defaultAOOptions;
-
-	public aoPass: AOPass;
-	public composer: EffectComposer;
-	public lastSize = { width: 0, height: 0, resolutionScale: 0 };
-	normalPass?: NormalPass;
-	public poissionDenoisePass: PoissionDenoisePass;
-	public resolutionScale = 1;
-
-	// #endregion Properties (7)
-
-	// #region Constructors (1)
-
-	constructor(composer: EffectComposer, camera: Camera, scene: Scene, aoPass: AOPass, options: { [key: string]: unknown } = defaultAOOptions) {
-		super('AOEffect', ao_compose, {
-			uniforms: new Map([
-				['inputTexture', new Uniform(null)],
-				['depthTexture', new Uniform(null)],
-				['power', (new Uniform(0) as Uniform)],
-				['color', new Uniform(new Color('black'))]
-			])
-		});
-
-		this.composer = composer;
-		this.aoPass = aoPass;
-		options = { ...defaultAOOptions, ...options };
-
-		this.normalPass = new NormalPass(scene, camera);
-		const normalTexture = options.normalTexture ?? this.normalPass?.texture;
-
-		(this.aoPass.fullscreenMaterial as ShaderMaterial).uniforms.normalTexture.value = normalTexture;
-		(this.aoPass.fullscreenMaterial as ShaderMaterial).defines.useNormalTexture = '';
-
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		(this.aoPass.fullscreenMaterial as ShaderMaterial).uniforms.depthTexture.value = this.normalPass.depthTexture;
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		this.uniforms.get('depthTexture')!.value = this.normalPass.depthTexture;
-
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		this.poissionDenoisePass = new PoissionDenoisePass(camera, this.aoPass.texture, this.normalPass.depthTexture!);
-
-		this.makeOptionsReactive(options);
-	}
-
-	// #endregion Constructors (1)
-
-	// #region Public Methods (3)
-
-	public makeOptionsReactive(options: { [key: string]: unknown }) {
-		for (const key of Object.keys(options)) {
-			Object.defineProperty(this, key, {
-				get() {
-					return options[key];
-				},
-				set(value) {
-					if (value === null || value === undefined) return;
-
-					options[key] = value;
-
-					switch (key) {
-						case 'spp':
-							(this.aoPass.fullscreenMaterial as ShaderMaterial).defines.spp = value.toFixed(0);
-
-							(this.aoPass.fullscreenMaterial as ShaderMaterial).needsUpdate = true;
-							break;
-
-						case 'distance':
-							(this.aoPass.fullscreenMaterial as ShaderMaterial).uniforms.aoDistance.value = value;
-							this.poissionDenoisePass.fullscreenMaterial.uniforms['distance'].value = Math.max(value, 0.0001);
-							break;
-
-						case 'resolutionScale':
-							this.setSize(this.lastSize.width, this.lastSize.height);
-							break;
-
-						case 'power':
-							this.uniforms.get('power').value = value;
-							break;
-
-						case 'color':
-							this.uniforms.get('color').value.copy(new Color(value));
-							break;
-
-						// denoiser
-						case 'iterations':
-						case 'radius':
-						case 'rings':
-						case 'samples':
-							this.poissionDenoisePass[key] = value;
-							break;
-
-						case 'lumaPhi':
-						case 'depthPhi':
-						case 'normalPhi':
-							this.poissionDenoisePass.fullscreenMaterial.uniforms[key].value = Math.max(value, 0.0001);
-							break;
-
-						default:
-							if (key in (this.aoPass.fullscreenMaterial as ShaderMaterial).uniforms) {
-								(this.aoPass.fullscreenMaterial as ShaderMaterial).uniforms[key].value = value;
-							}
-					}
-				},
-				configurable: true
-			});
-
-			// apply all uniforms and defines
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			(this as any)[key] = options[key];
-		}
-	}
-
-	public setSize(width: number, height: number) {
-		if (width === undefined || height === undefined) return;
-		if (
-			width === this.lastSize.width &&
-			height === this.lastSize.height &&
-			this.resolutionScale === this.lastSize.resolutionScale
-		) {
-			return;
-		}
-
-		this.normalPass?.setSize(width, height);
-		this.aoPass.setSize(width * this.resolutionScale, height * this.resolutionScale);
-
-		this.poissionDenoisePass.setSize(width, height);
-
-		this.lastSize = {
-			width,
-			height,
-			resolutionScale: this.resolutionScale
-		};
-	}
-
-	public update(renderer: WebGLRenderer) {
-		if ('animatedNoise' in (this.aoPass.fullscreenMaterial as ShaderMaterial).defines) {
-			delete (this.aoPass.fullscreenMaterial as ShaderMaterial).defines.animatedNoise;
-			(this.aoPass.fullscreenMaterial as ShaderMaterial).needsUpdate = true;
-		}
-
-		// set input texture
-		if (this.poissionDenoisePass.iterations > 0) {
-			this.uniforms.get('inputTexture')!.value = this.poissionDenoisePass.texture;
-		} else {
-			this.uniforms.get('inputTexture')!.value = this.aoPass.texture;
-		}
-
-		this.normalPass?.render(renderer);
-		this.aoPass.render(renderer);
-
-		this.poissionDenoisePass.render(renderer);
-	}
-
-	// #endregion Public Methods (3)
-}
-
-export { AOEffect };

package/src/managers/postprocessing/ao/ao/AOPass.ts

@@ -1,128 +0,0 @@
-import { Pass } from 'postprocessing';
-import {
-	Camera,
-	HalfFloatType,
-	Matrix4,
-	NearestFilter,
-	NoBlending,
-	NoColorSpace,
-	PerspectiveCamera,
-	RepeatWrapping,
-	Scene,
-	ShaderMaterial,
-	TextureLoader,
-	Vector2,
-	WebGLRenderTarget,
-	WebGLRenderer
-} from 'three';
-import { basic as vertexShader } from '../utils/shader/basic';
-import { sampleBlueNoise } from '../utils/shader/sampleBlueNoise';
-import { PoissionDenoisePass } from '../poissionDenoise/PoissionDenoisePass';
-
-// a general AO pass that can be used for any AO algorithm
-class AOPass extends Pass {
-	// #region Properties (3)
-
-	private _camera: PerspectiveCamera;
-	private _scene: Scene;
-
-	public renderTarget: WebGLRenderTarget;
-
-	// #endregion Properties (3)
-
-	// #region Constructors (1)
-
-	constructor(camera: Camera, scene: Scene, fragmentShader: string) {
-		super();
-		this._camera = camera as PerspectiveCamera;
-		this._scene = scene;
-
-		this.renderTarget = new WebGLRenderTarget(1, 1, {
-			type: HalfFloatType,
-			depthBuffer: false
-		});
-
-		const finalFragmentShader = fragmentShader.replace('#include <sampleBlueNoise>', sampleBlueNoise);
-
-		this.fullscreenMaterial = new ShaderMaterial({
-			fragmentShader: finalFragmentShader,
-			vertexShader,
-
-			uniforms: {
-				depthTexture: { value: null },
-				normalTexture: { value: null },
-				cameraNear: { value: 0 },
-				cameraFar: { value: 0 },
-				viewMatrix: { value: this._camera.matrixWorldInverse },
-				projectionViewMatrix: { value: new Matrix4() },
-				projectionMatrixInverse: { value: this._camera.projectionMatrixInverse },
-				cameraMatrixWorld: { value: this._camera.matrixWorld },
-				texSize: { value: new Vector2() },
-				blueNoiseTexture: { value: null },
-				blueNoiseRepeat: { value: new Vector2() },
-				aoDistance: { value: 0 },
-				distancePower: { value: 0 },
-				bias: { value: 0 },
-				thickness: { value: 0 },
-				power: { value: 0 },
-				frame: { value: 0 }
-			},
-
-			blending: NoBlending,
-			depthWrite: false,
-			depthTest: false,
-			toneMapped: false
-		});
-			
-		(this.fullscreenMaterial as ShaderMaterial).uniforms.blueNoiseTexture.value = PoissionDenoisePass.blueNoiseTexture;
-	}
-
-	// #endregion Constructors (1)
-
-	// #region Public Accessors (1)
-
-	public get texture() {
-		return this.renderTarget.texture;
-	}
-
-	// #endregion Public Accessors (1)
-
-	// #region Public Methods (2)
-
-	public render(renderer: WebGLRenderer) {
-		const spp = +(this.fullscreenMaterial as ShaderMaterial).defines.spp;
-
-		(this.fullscreenMaterial as ShaderMaterial).uniforms.frame.value = ((this.fullscreenMaterial as ShaderMaterial).uniforms.frame.value + spp) % 65536;
-
-		(this.fullscreenMaterial as ShaderMaterial).uniforms.cameraNear.value = this._camera.near;
-		(this.fullscreenMaterial as ShaderMaterial).uniforms.cameraFar.value = this._camera.far;
-
-		(this.fullscreenMaterial as ShaderMaterial).uniforms.projectionViewMatrix.value.multiplyMatrices(
-			this._camera.projectionMatrix,
-			this._camera.matrixWorldInverse
-		);
-
-		const noiseTexture = (this.fullscreenMaterial as ShaderMaterial).uniforms.blueNoiseTexture.value;
-		if (noiseTexture) {
-			const { width, height } = noiseTexture.source.data;
-
-			(this.fullscreenMaterial as ShaderMaterial).uniforms.blueNoiseRepeat.value.set(
-				this.renderTarget.width / width,
-				this.renderTarget.height / height
-			);
-		}
-
-		renderer.setRenderTarget(this.renderTarget);
-		renderer.render(this.scene, this.camera);
-	}
-
-	public setSize(width: number, height: number) {
-		this.renderTarget.setSize(width, height);
-
-		(this.fullscreenMaterial as ShaderMaterial).uniforms.texSize.value.set(this.renderTarget.width, this.renderTarget.height);
-	}
-
-	// #endregion Public Methods (2)
-}
-
-export { AOPass };