@woosh/meep-engine 2.106.1 → 2.108.0

package/src/engine/graphics/postprocess/threejs/WaterShader.js

@@ -1,306 +0,0 @@
-/**
- * @author jbouny / https://github.com/jbouny
- *
- * Work based on :
- * @author Slayvin / http://slayvin.net : Flat mirror for three.js
- * @author Stemkoski / http://www.adelphi.edu/~stemkoski : An implementation of water shader based on the flat mirror
- * @author Jonas Wagner / http://29a.ch/ && http://29a.ch/slides/2012/webglwater/ : Water shader explanations in WebGL
- */
-
-import * as THREE from 'three';
-import Mirror from './Mirror.js';
-
-const Shader = {
-
-    uniforms: THREE.UniformsUtils.merge([
-        THREE.UniformsLib["fog"], {
-            "normalSampler": { value: null },
-            "mirrorSampler": { value: null },
-            "alpha": { value: 1.0 },
-            "time": { value: 0.0 },
-            "distortionScale": { value: 20.0 },
-            "noiseScale": { value: 1.0 },
-            "textureMatrix": { value: new THREE.Matrix4() },
-            "sunColor": { value: new THREE.Color(0x7F7F7F) },
-            "sunDirection": { value: new THREE.Vector3(0.70707, 0.70707, 0) },
-            "eye": { value: new THREE.Vector3() },
-            "waterColor": { value: new THREE.Color(0x555555) }
-        }
-    ]),
-
-    vertexShader: [
-        'uniform mat4 textureMatrix;',
-        'uniform float time;',
-
-        'varying vec4 mirrorCoord;',
-        'varying vec3 worldPosition;',
-
-        THREE.ShaderChunk["fog_pars_vertex"],
-
-        'void main()',
-        '{',
-        '	mirrorCoord = modelMatrix * vec4( position, 1.0 );',
-        '	worldPosition = mirrorCoord.xyz;',
-        '	mirrorCoord = textureMatrix * mirrorCoord;',
-        '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-
-        THREE.ShaderChunk["fog_vertex"],
-
-        '}'
-    ].join('\n'),
-
-    fragmentShader: [
-        'precision highp float;',
-
-        'uniform sampler2D mirrorSampler;',
-        'uniform float alpha;',
-        'uniform float time;',
-        'uniform float distortionScale;',
-        'uniform sampler2D normalSampler;',
-        'uniform vec3 sunColor;',
-        'uniform vec3 sunDirection;',
-        'uniform vec3 eye;',
-        'uniform vec3 waterColor;',
-
-        'varying vec4 mirrorCoord;',
-        'varying vec3 worldPosition;',
-
-        'vec4 getNoise( vec2 uv )',
-        '{',
-        '	vec2 uv0 = ( uv / 103.0 ) + vec2(time / 17.0, time / 29.0);',
-        '	vec2 uv1 = uv / 107.0-vec2( time / -19.0, time / 31.0 );',
-        '	vec2 uv2 = uv / vec2( 8907.0, 9803.0 ) + vec2( time / 101.0, time / 97.0 );',
-        '	vec2 uv3 = uv / vec2( 1091.0, 1027.0 ) - vec2( time / 109.0, time / -113.0 );',
-        '	vec4 noise = texture2D( normalSampler, uv0 ) +',
-        '		texture2D( normalSampler, uv1 ) +',
-        '		texture2D( normalSampler, uv2 ) +',
-        '		texture2D( normalSampler, uv3 );',
-        '	return noise * 0.5 - 1.0;',
-        '}',
-
-        'void sunLight( const vec3 surfaceNormal, const vec3 eyeDirection, float shiny, float spec, float diffuse, inout vec3 diffuseColor, inout vec3 specularColor )',
-        '{',
-        '	vec3 reflection = normalize( reflect( -sunDirection, surfaceNormal ) );',
-        '	float direction = max( 0.0, dot( eyeDirection, reflection ) );',
-        '	specularColor += pow( direction, shiny ) * sunColor * spec;',
-        '	diffuseColor += max( dot( sunDirection, surfaceNormal ), 0.0 ) * sunColor * diffuse;',
-        '}',
-
-        THREE.ShaderChunk["common"],
-        THREE.ShaderChunk["fog_pars_fragment"],
-
-        'void main()',
-        '{',
-        '	vec4 noise = getNoise( worldPosition.xz );',
-        '	vec3 surfaceNormal = normalize( noise.xzy * vec3( 1.5, 1.0, 1.5 ) );',
-
-        '	vec3 diffuseLight = vec3(0.0);',
-        '	vec3 specularLight = vec3(0.0);',
-
-        '	vec3 worldToEye = eye-worldPosition;',
-        '	vec3 eyeDirection = normalize( worldToEye );',
-        '	sunLight( surfaceNormal, eyeDirection, 100.0, 2.0, 0.5, diffuseLight, specularLight );',
-
-        '	float distance = length(worldToEye);',
-
-        '	vec2 distortion = surfaceNormal.xz * ( 0.001 + 1.0 / distance ) * distortionScale;',
-        '	vec3 reflectionSample = vec3( texture2D( mirrorSampler, mirrorCoord.xy / mirrorCoord.z + distortion ) );',
-
-        '	float theta = max( dot( eyeDirection, surfaceNormal ), 0.0 );',
-        '	float rf0 = 0.3;',
-        '	float reflectance = rf0 + ( 1.0 - rf0 ) * pow( ( 1.0 - theta ), 5.0 );',
-        '	vec3 scatter = max( 0.0, dot( surfaceNormal, eyeDirection ) ) * waterColor;',
-        '	vec3 albedo = mix( sunColor * diffuseLight * 0.3 + scatter, ( vec3( 0.1 ) + reflectionSample * 0.9 + reflectionSample * specularLight ), reflectance );',
-        '	vec3 outgoingLight = albedo;',
-        THREE.ShaderChunk["fog_fragment"],
-        '	gl_FragColor = vec4( outgoingLight, alpha );',
-        '}'
-    ].join('\n')
-
-};
-
-const Water = function (renderer, camera, scene, options) {
-
-    THREE.Object3D.call(this);
-    this.name = 'water_' + this.id;
-
-    function optionalParameter(value, defaultValue) {
-
-        return value !== undefined ? value : defaultValue;
-
-    }
-
-    options = options || {};
-
-    this.matrixNeedsUpdate = true;
-
-    const width = optionalParameter(options.textureWidth, 512);
-    const height = optionalParameter(options.textureHeight, 512);
-    this.clipBias = optionalParameter(options.clipBias, 0.0);
-    this.alpha = optionalParameter(options.alpha, 1.0);
-    this.time = optionalParameter(options.time, 0.0);
-    this.normalSampler = optionalParameter(options.waterNormals, null);
-    this.sunDirection = optionalParameter(options.sunDirection, new THREE.Vector3(0.70707, 0.70707, 0.0));
-    this.sunColor = new THREE.Color(optionalParameter(options.sunColor, 0xffffff));
-    this.waterColor = new THREE.Color(optionalParameter(options.waterColor, 0x7F7F7F));
-    this.eye = optionalParameter(options.eye, new THREE.Vector3(0, 0, 0));
-    this.distortionScale = optionalParameter(options.distortionScale, 20.0);
-    this.side = optionalParameter(options.side, THREE.FrontSide);
-    this.fog = optionalParameter(options.fog, false);
-
-    this.graphics = renderer;
-    this.scene = scene;
-    this.mirrorPlane = new THREE.Plane();
-    this.normal = new THREE.Vector3(0, 0, 1);
-    this.mirrorWorldPosition = new THREE.Vector3();
-    this.cameraWorldPosition = new THREE.Vector3();
-    this.rotationMatrix = new THREE.Matrix4();
-    this.lookAtPosition = new THREE.Vector3(0, 0, -1);
-    this.clipPlane = new THREE.Vector4();
-
-    if (camera instanceof THREE.PerspectiveCamera) {
-
-        this.camera = camera;
-
-    } else {
-
-        this.camera = new THREE.PerspectiveCamera();
-        console.log(this.name + ': camera is not a Perspective Camera!');
-
-    }
-
-    this.textureMatrix = new THREE.Matrix4();
-
-    this.mirrorCamera = this.camera.clone();
-
-    this.renderTarget = new THREE.WebGLRenderTarget(width, height);
-    this.renderTarget2 = new THREE.WebGLRenderTarget(width, height);
-
-    const mirrorShader = Shader;
-    const mirrorUniforms = THREE.UniformsUtils.clone(mirrorShader.uniforms);
-
-    this.material = new THREE.ShaderMaterial({
-        fragmentShader: mirrorShader.fragmentShader,
-        vertexShader: mirrorShader.vertexShader,
-        uniforms: mirrorUniforms,
-        transparent: true,
-        side: this.side,
-        fog: this.fog
-    });
-
-    this.material.uniforms.mirrorSampler.value = this.renderTarget.texture;
-    this.material.uniforms.textureMatrix.value = this.textureMatrix;
-    this.material.uniforms.alpha.value = this.alpha;
-    this.material.uniforms.time.value = this.time;
-    this.material.uniforms.normalSampler.value = this.normalSampler;
-    this.material.uniforms.sunColor.value = this.sunColor;
-    this.material.uniforms.waterColor.value = this.waterColor;
-    this.material.uniforms.sunDirection.value = this.sunDirection;
-    this.material.uniforms.distortionScale.value = this.distortionScale;
-
-    this.material.uniforms.eye.value = this.eye;
-
-    if (!THREE.Math.isPowerOfTwo(width) || !THREE.Math.isPowerOfTwo(height)) {
-
-        this.renderTarget.texture.generateMipmaps = false;
-        this.renderTarget.texture.minFilter = THREE.LinearFilter;
-        this.renderTarget2.texture.generateMipmaps = false;
-        this.renderTarget2.texture.minFilter = THREE.LinearFilter;
-
-    }
-
-
-};
-
-Water.prototype = Object.create(Mirror.prototype);
-Water.prototype.constructor = Water;
-
-
-Water.prototype.updateTextureMatrix = function () {
-
-    function sign(x) {
-
-        return x ? x < 0 ? -1 : 1 : 0;
-
-    }
-
-    this.updateMatrixWorld();
-    this.camera.updateMatrixWorld();
-
-    this.mirrorWorldPosition.setFromMatrixPosition(this.matrixWorld);
-    this.cameraWorldPosition.setFromMatrixPosition(this.camera.matrixWorld);
-
-    this.rotationMatrix.extractRotation(this.matrixWorld);
-
-    this.normal.set(0, 0, 1);
-    this.normal.applyMatrix4(this.rotationMatrix);
-
-    const view = this.mirrorWorldPosition.clone().sub(this.cameraWorldPosition);
-    view.reflect(this.normal).negate();
-    view.add(this.mirrorWorldPosition);
-
-    this.rotationMatrix.extractRotation(this.camera.matrixWorld);
-
-    this.lookAtPosition.set(0, 0, -1);
-    this.lookAtPosition.applyMatrix4(this.rotationMatrix);
-    this.lookAtPosition.add(this.cameraWorldPosition);
-
-    const target = this.mirrorWorldPosition.clone().sub(this.lookAtPosition);
-    target.reflect(this.normal).negate();
-    target.add(this.mirrorWorldPosition);
-
-    this.up.set(0, -1, 0);
-    this.up.applyMatrix4(this.rotationMatrix);
-    this.up.reflect(this.normal).negate();
-
-    this.mirrorCamera.position.copy(view);
-    this.mirrorCamera.up = this.up;
-    this.mirrorCamera.lookAt(target);
-    this.mirrorCamera.aspect = this.camera.aspect;
-
-    this.mirrorCamera.updateProjectionMatrix();
-    this.mirrorCamera.updateMatrixWorld();
-    this.mirrorCamera.matrixWorldInverse.getInverse(this.mirrorCamera.matrixWorld);
-
-    // Update the texture matrix
-    this.textureMatrix.set(0.5, 0.0, 0.0, 0.5,
-        0.0, 0.5, 0.0, 0.5,
-        0.0, 0.0, 0.5, 0.5,
-        0.0, 0.0, 0.0, 1.0);
-    this.textureMatrix.multiply(this.mirrorCamera.projectionMatrix);
-    this.textureMatrix.multiply(this.mirrorCamera.matrixWorldInverse);
-
-    // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
-    // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
-    this.mirrorPlane.setFromNormalAndCoplanarPoint(this.normal, this.mirrorWorldPosition);
-    this.mirrorPlane.applyMatrix4(this.mirrorCamera.matrixWorldInverse);
-
-    this.clipPlane.set(this.mirrorPlane.normal.x, this.mirrorPlane.normal.y, this.mirrorPlane.normal.z, this.mirrorPlane.constant);
-
-    const q = new THREE.Vector4();
-    const projectionMatrix = this.mirrorCamera.projectionMatrix;
-
-    q.x = (sign(this.clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
-    q.y = (sign(this.clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
-    q.z = -1.0;
-    q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
-
-    // Calculate the scaled plane vector
-    let c = new THREE.Vector4();
-    c = this.clipPlane.multiplyScalar(2.0 / this.clipPlane.dot(q));
-
-    // Replacing the third row of the projection matrix
-    projectionMatrix.elements[2] = c.x;
-    projectionMatrix.elements[6] = c.y;
-    projectionMatrix.elements[10] = c.z + 1.0 - this.clipBias;
-    projectionMatrix.elements[14] = c.w;
-
-    const worldCoordinates = new THREE.Vector3();
-    worldCoordinates.setFromMatrixPosition(this.camera.matrixWorld);
-    this.eye = worldCoordinates;
-    this.material.uniforms.eye.value = this.eye;
-
-};
-
-
-export default Water;

package/src/engine/graphics/postprocess/threejs/postprocessing/AdaptiveToneMappingPass.js

@@ -1,338 +0,0 @@
-/**
- * @author miibond
- * Generate a texture that represents the luminosity of the current scene, adapted over time
- * to simulate the optic nerve responding to the amount of light it is receiving.
- * Based on a GDC2007 presentation by Wolfgang Engel titled "Post-Processing Pipeline"
- *
- * Full-screen tone-mapping shader based on http://www.graphics.cornell.edu/~jaf/publications/sig02_paper.pdf
- */
-import {
-    LinearFilter,
-    LinearMipMapLinearFilter,
-    Mesh,
-    MeshBasicMaterial,
-    NoBlending,
-    OrthographicCamera,
-    PlaneBufferGeometry,
-    RGBFormat,
-    Scene,
-    ShaderMaterial,
-    UniformsUtils,
-    WebGLRenderTarget
-} from 'three';
-import CopyShader from "../shaders/CopyShader.js";
-import LuminosityShader from "../shaders/LuminosityShader.js";
-import ToneMapShader from "../shaders/ToneMapShader.js";
-
-const AdaptiveToneMappingPass = function (adaptive, resolution) {
-
-    this.resolution = (resolution !== undefined) ? resolution : 256;
-    this.needsInit = true;
-    this.adaptive = adaptive !== undefined ? !!adaptive : true;
-
-    this.luminanceRT = null;
-    this.previousLuminanceRT = null;
-    this.currentLuminanceRT = null;
-
-    if (CopyShader === undefined)
-        console.error("THREE.AdaptiveToneMappingPass relies on THREE.CopyShader");
-
-    const copyShader = CopyShader;
-
-    this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
-
-    this.materialCopy = new ShaderMaterial({
-
-        uniforms: this.copyUniforms,
-        vertexShader: copyShader.vertexShader,
-        fragmentShader: copyShader.fragmentShader,
-        blending: NoBlending,
-        depthTest: false
-
-    });
-
-    if (LuminosityShader === undefined)
-        console.error("THREE.AdaptiveToneMappingPass relies on THREE.LuminosityShader");
-
-    this.materialLuminance = new ShaderMaterial({
-
-        uniforms: UniformsUtils.clone(LuminosityShader.uniforms),
-        vertexShader: LuminosityShader.vertexShader,
-        fragmentShader: LuminosityShader.fragmentShader,
-        blending: NoBlending
-    });
-
-    this.adaptLuminanceShader = {
-        defines: {
-            "MIP_LEVEL_1X1": (Math.log(this.resolution) / Math.log(2.0)).toFixed(1)
-        },
-        uniforms: {
-            "lastLum": { type: "t", value: null },
-            "currentLum": { type: "t", value: null },
-            "delta": { type: 'f', value: 0.016 },
-            "tau": { type: 'f', value: 1.0 }
-        },
-        vertexShader: [
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "vUv = uv;",
-            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-            "}"
-        ].join('\n'),
-        fragmentShader: [
-            "varying vec2 vUv;",
-
-            "uniform sampler2D lastLum;",
-            "uniform sampler2D currentLum;",
-            "uniform float delta;",
-            "uniform float tau;",
-
-            "void main() {",
-
-            "vec4 lastLum = texture2D( lastLum, vUv, MIP_LEVEL_1X1 );",
-            "vec4 currentLum = texture2D( currentLum, vUv, MIP_LEVEL_1X1 );",
-
-            "float fLastLum = lastLum.r;",
-            "float fCurrentLum = currentLum.r;",
-
-            //The adaption seems to work better in extreme lighting differences
-            //if the input luminance is squared.
-            "fCurrentLum *= fCurrentLum;",
-
-            // Adapt the luminance using Pattanaik's technique
-            "float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));",
-            // "fAdaptedLum = sqrt(fAdaptedLum);",
-            "gl_FragColor = vec4( vec3( fAdaptedLum ), 1.0 );",
-            "}"
-        ].join('\n')
-    };
-
-    this.materialAdaptiveLum = new ShaderMaterial({
-
-        uniforms: UniformsUtils.clone(this.adaptLuminanceShader.uniforms),
-        vertexShader: this.adaptLuminanceShader.vertexShader,
-        fragmentShader: this.adaptLuminanceShader.fragmentShader,
-        defines: this.adaptLuminanceShader.defines,
-        blending: NoBlending
-    });
-
-    if (ToneMapShader === undefined)
-        console.error("THREE.AdaptiveToneMappingPass relies on THREE.ToneMapShader");
-
-    this.materialToneMap = new ShaderMaterial({
-
-        uniforms: UniformsUtils.clone(ToneMapShader.uniforms),
-        vertexShader: ToneMapShader.vertexShader,
-        fragmentShader: ToneMapShader.fragmentShader,
-        blending: NoBlending
-    });
-
-    this.enabled = true;
-    this.needsSwap = true;
-    this.clear = false;
-
-    this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
-    this.scene = new Scene();
-
-    this.quad = new Mesh(new PlaneBufferGeometry(2, 2), null);
-    this.scene.add(this.quad);
-
-};
-
-AdaptiveToneMappingPass.prototype = {
-
-    render: function (renderer, writeBuffer, readBuffer, delta, maskActive) {
-
-        if (this.needsInit) {
-
-            this.reset(renderer);
-            this.luminanceRT.texture.type = readBuffer.texture.type;
-            this.previousLuminanceRT.texture.type = readBuffer.texture.type;
-            this.currentLuminanceRT.texture.type = readBuffer.texture.type;
-            this.needsInit = false;
-
-        }
-
-        if (this.adaptive) {
-
-            //Render the luminance of the current scene into a render target with mipmapping enabled
-            this.quad.material = this.materialLuminance;
-            this.materialLuminance.uniforms.tDiffuse.value = readBuffer;
-            renderer.render(this.scene, this.camera, this.currentLuminanceRT);
-
-            //Use the new luminance values, the previous luminance and the frame delta to
-            //adapt the luminance over time.
-            this.quad.material = this.materialAdaptiveLum;
-            this.materialAdaptiveLum.uniforms.delta.value = delta;
-            this.materialAdaptiveLum.uniforms.lastLum.value = this.previousLuminanceRT;
-            this.materialAdaptiveLum.uniforms.currentLum.value = this.currentLuminanceRT;
-            renderer.render(this.scene, this.camera, this.luminanceRT);
-
-            //Copy the new adapted luminance value so that it can be used by the next frame.
-            this.quad.material = this.materialCopy;
-            this.copyUniforms.tDiffuse.value = this.luminanceRT;
-            renderer.render(this.scene, this.camera, this.previousLuminanceRT);
-
-        }
-
-        this.quad.material = this.materialToneMap;
-        this.materialToneMap.uniforms.tDiffuse.value = readBuffer;
-        renderer.render(this.scene, this.camera, writeBuffer, this.clear);
-
-    },
-
-    reset: function (renderer) {
-
-        // render targets
-        if (this.luminanceRT) {
-
-            this.luminanceRT.dispose();
-
-        }
-        if (this.currentLuminanceRT) {
-
-            this.currentLuminanceRT.dispose();
-
-        }
-        if (this.previousLuminanceRT) {
-
-            this.previousLuminanceRT.dispose();
-
-        }
-        const pars = {
-            minFilter: LinearFilter,
-            magFilter: LinearFilter,
-            format: RGBFormat,
-            generateMipmaps: false
-        };
-
-        this.luminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
-        this.previousLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
-
-        //We only need mipmapping for the current luminosity because we want a down-sampled version to sample in our adaptive shader
-        pars.generateMipmaps = true;
-        pars.minFilter = LinearMipMapLinearFilter;
-        this.currentLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
-
-        if (this.adaptive) {
-
-            this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
-            this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT;
-
-        }
-        //Put something in the adaptive luminance texture so that the scene can render initially
-        this.quad.material = new MeshBasicMaterial({ color: 0x777777 });
-        this.materialLuminance.needsUpdate = true;
-        this.materialAdaptiveLum.needsUpdate = true;
-        this.materialToneMap.needsUpdate = true;
-        // renderer.render( this.scene, this.camera, this.luminanceRT );
-        // renderer.render( this.scene, this.camera, this.previousLuminanceRT );
-        // renderer.render( this.scene, this.camera, this.currentLuminanceRT );
-
-    },
-
-    setAdaptive: function (adaptive) {
-
-        if (adaptive) {
-
-            this.adaptive = true;
-            this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
-            this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT;
-
-        } else {
-
-            this.adaptive = false;
-            delete this.materialToneMap.defines["ADAPTED_LUMINANCE"];
-            this.materialToneMap.uniforms.luminanceMap.value = undefined;
-
-        }
-        this.materialToneMap.needsUpdate = true;
-
-    },
-
-    setAdaptionRate: function (rate) {
-
-        if (rate) {
-
-            this.materialAdaptiveLum.uniforms.tau.value = Math.abs(rate);
-
-        }
-
-    },
-
-    setMaxLuminance: function (maxLum) {
-
-        if (maxLum) {
-
-            this.materialToneMap.uniforms.maxLuminance.value = maxLum;
-
-        }
-
-    },
-
-    setAverageLuminance: function (avgLum) {
-
-        if (avgLum) {
-
-            this.materialToneMap.uniforms.averageLuminance.value = avgLum;
-
-        }
-
-    },
-
-    setMiddleGrey: function (middleGrey) {
-
-        if (middleGrey) {
-
-            this.materialToneMap.uniforms.middleGrey.value = middleGrey;
-
-        }
-
-    },
-
-    dispose: function () {
-
-        if (this.luminanceRT) {
-
-            this.luminanceRT.dispose();
-
-        }
-        if (this.previousLuminanceRT) {
-
-            this.previousLuminanceRT.dispose();
-
-        }
-        if (this.currentLuminanceRT) {
-
-            this.currentLuminanceRT.dispose();
-
-        }
-        if (this.materialLuminance) {
-
-            this.materialLuminance.dispose();
-
-        }
-        if (this.materialAdaptiveLum) {
-
-            this.materialAdaptiveLum.dispose();
-
-        }
-        if (this.materialCopy) {
-
-            this.materialCopy.dispose();
-
-        }
-        if (this.materialToneMap) {
-
-            this.materialToneMap.dispose();
-
-        }
-
-    }
-
-};
-
-export default AdaptiveToneMappingPass;