constructor( geometry, options = {} ) {

			super( geometry );
			this.type = 'Water';
			const scope = this;
			const color = options.color !== undefined ? new THREE.Color( options.color ) : new THREE.Color( 0xFFFFFF );
			const textureWidth = options.textureWidth || 512;
			const textureHeight = options.textureHeight || 512;
			const clipBias = options.clipBias || 0;
			const flowDirection = options.flowDirection || new THREE.Vector2( 1, 0 );
			const flowSpeed = options.flowSpeed || 0.03;
			const reflectivity = options.reflectivity || 0.02;
			const scale = options.scale || 1;
			const shader = options.shader || Water.WaterShader;
			const encoding = options.encoding !== undefined ? options.encoding : THREE.LinearEncoding;
			const textureLoader = new THREE.TextureLoader();
			const flowMap = options.flowMap || undefined;
			const normalMap0 = options.normalMap0 || textureLoader.load( 'textures/water/Water_1_M_Normal.jpg' );
			const normalMap1 = options.normalMap1 || textureLoader.load( 'textures/water/Water_2_M_Normal.jpg' );
			const cycle = 0.15; // a cycle of a flow map phase

			const halfCycle = cycle * 0.5;
			const textureMatrix = new THREE.Matrix4();
			const clock = new THREE.Clock(); // internal components

			if ( THREE.Reflector === undefined ) {

				console.error( 'THREE.Water: Required component THREE.Reflector not found.' );
				return;

			}

			if ( THREE.Refractor === undefined ) {

				console.error( 'THREE.Water: Required component THREE.Refractor not found.' );
				return;

			}

			const reflector = new THREE.Reflector( geometry, {
				textureWidth: textureWidth,
				textureHeight: textureHeight,
				clipBias: clipBias,
				encoding: encoding
			} );
			const refractor = new THREE.Refractor( geometry, {
				textureWidth: textureWidth,
				textureHeight: textureHeight,
				clipBias: clipBias,
				encoding: encoding
			} );
			reflector.matrixAutoUpdate = false;
			refractor.matrixAutoUpdate = false; // material

			this.material = new THREE.ShaderMaterial( {
				uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ 'fog' ], shader.uniforms ] ),
				vertexShader: shader.vertexShader,
				fragmentShader: shader.fragmentShader,
				transparent: true,
				fog: true
			} );

			if ( flowMap !== undefined ) {

				this.material.defines.USE_FLOWMAP = '';
				this.material.uniforms[ 'tFlowMap' ] = {
					type: 't',
					value: flowMap
				};

			} else {

				this.material.uniforms[ 'flowDirection' ] = {
					type: 'v2',
					value: flowDirection
				};

			} // maps


			normalMap0.wrapS = normalMap0.wrapT = THREE.RepeatWrapping;
			normalMap1.wrapS = normalMap1.wrapT = THREE.RepeatWrapping;
			this.material.uniforms[ 'tReflectionMap' ].value = reflector.getRenderTarget().texture;
			this.material.uniforms[ 'tRefractionMap' ].value = refractor.getRenderTarget().texture;
			this.material.uniforms[ 'tNormalMap0' ].value = normalMap0;
			this.material.uniforms[ 'tNormalMap1' ].value = normalMap1; // water

			this.material.uniforms[ 'color' ].value = color;
			this.material.uniforms[ 'reflectivity' ].value = reflectivity;
			this.material.uniforms[ 'textureMatrix' ].value = textureMatrix; // inital values

			this.material.uniforms[ 'config' ].value.x = 0; // flowMapOffset0

			this.material.uniforms[ 'config' ].value.y = halfCycle; // flowMapOffset1

			this.material.uniforms[ 'config' ].value.z = halfCycle; // halfCycle

			this.material.uniforms[ 'config' ].value.w = scale; // scale
			// functions

			function updateTextureMatrix( camera ) {

				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 );
				textureMatrix.multiply( camera.projectionMatrix );
				textureMatrix.multiply( camera.matrixWorldInverse );
				textureMatrix.multiply( scope.matrixWorld );

			}

			function updateFlow() {

				const delta = clock.getDelta();
				const config = scope.material.uniforms[ 'config' ];
				config.value.x += flowSpeed * delta; // flowMapOffset0

				config.value.y = config.value.x + halfCycle; // flowMapOffset1
				// Important: The distance between offsets should be always the value of "halfCycle".
				// Moreover, both offsets should be in the range of [ 0, cycle ].
				// This approach ensures a smooth water flow and avoids "reset" effects.

				if ( config.value.x >= cycle ) {

					config.value.x = 0;
					config.value.y = halfCycle;

				} else if ( config.value.y >= cycle ) {

					config.value.y = config.value.y - cycle;

				}

			} //


			this.onBeforeRender = function ( renderer, scene, camera ) {

				updateTextureMatrix( camera );
				updateFlow();
				scope.visible = false;
				reflector.matrixWorld.copy( scope.matrixWorld );
				refractor.matrixWorld.copy( scope.matrixWorld );
				reflector.onBeforeRender( renderer, scene, camera );
				refractor.onBeforeRender( renderer, scene, camera );
				scope.visible = true;

			};

		}
References:
	http://www.valvesoftware.com/publications/2010/siggraph2010_vlachos_waterflow.pdf
	http://graphicsrunner.blogspot.de/2010/08/water-using-flow-maps.html