104 lines
4.1 KiB
GLSL
104 lines
4.1 KiB
GLSL
/*********************************************************************NVMH3****
|
|
Copyright NVIDIA Corporation 2003
|
|
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
|
|
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
|
|
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
|
|
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
|
|
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
|
|
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
|
|
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
|
|
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
|
|
|
|
|
|
Comments:
|
|
Simple ocean shader with animated bump map and geometric waves
|
|
Based partly on "Effective Water Simulation From Physical Models", GPU Gems
|
|
|
|
11 Aug 05: converted from HLSL to GLSL by Jeff Doyle (nfz) to work in Ogre
|
|
15 Jun 25: converted to OgreUnifiedShader.h by Sergey Lapin
|
|
|
|
******************************************************************************/
|
|
|
|
OGRE_NATIVE_GLSL_VERSION_DIRECTIVE
|
|
#include <OgreUnifiedShader.h>
|
|
|
|
SAMPLER2D(noiseMap, 0);
|
|
SAMPLER2D(reflectMap, 1);
|
|
SAMPLER2D(refractMap, 2);
|
|
|
|
OGRE_UNIFORMS(
|
|
uniform vec4 ambient;
|
|
uniform vec4 diffuse;
|
|
uniform highp float time;
|
|
uniform vec4 deepColor;
|
|
uniform vec4 shallowColor;
|
|
uniform vec4 reflectionColor;
|
|
uniform float reflectionAmount;
|
|
uniform float reflectionBlur;
|
|
uniform float waterAmount;
|
|
uniform vec4 tintColour;
|
|
uniform float noiseScale;
|
|
uniform float fresnelScale;
|
|
uniform float fresnelPower;
|
|
uniform float fresnelBias;
|
|
uniform float hdrMultiplier;
|
|
)
|
|
MAIN_PARAMETERS
|
|
IN(mat3 rotMatrix, 17) // first row of the 3x3 transform from tangent to cube space
|
|
IN(vec2 bumpCoord0, 18)
|
|
IN(vec2 bumpCoord1, 19)
|
|
IN(vec2 bumpCoord2, 20)
|
|
IN(vec3 eyeVector, 21)
|
|
IN(vec3 noiseCoord, 22)
|
|
IN(highp vec4 projectionCoord, 23)
|
|
IN(vec3 eyeDir, 24)
|
|
IN(vec3 oNormal, 25)
|
|
MAIN_DECLARATION
|
|
{
|
|
// vec4 t0 = texture2D(NormalMap, bumpCoord0) * 2.0 - 1.0;
|
|
// vec4 t1 = texture2D(NormalMap, bumpCoord1) * 2.0 - 1.0;
|
|
// vec4 t2 = texture2D(NormalMap, bumpCoord2) * 2.0 - 1.0;
|
|
vec4 t0 = normalize(vec4(0.1, 1, 0, 1));
|
|
vec4 t1 = normalize(vec4(0, 1, 0.1, 1));
|
|
vec4 t2 = normalize(vec4(-0.1, 1, 0.1, 1));
|
|
// Do the tex projection manually so we can distort _after_
|
|
vec2 final = projectionCoord.xy / projectionCoord.w;
|
|
|
|
// Noise
|
|
vec3 noiseNormal = (texture2D(noiseMap, (noiseCoord.xy / 5.0)).rgb - 0.5).rbg * noiseScale;
|
|
final += noiseNormal.xz;
|
|
|
|
// final.x = clamp(1.0 + final.x - floor(1.0 + final.x), 0.0, 1.0);
|
|
// float m = 0.2;
|
|
// final.y = final.y * (1.0 - m) + m * 0.5;
|
|
// final.y = clamp(1.0 + final.y - floor(1.0 + final.y), 0.0, 1.0);
|
|
|
|
vec3 N = t0.xyz + t1.xyz + t2.xyz;
|
|
N = normalize(rotMatrix * N);
|
|
vec3 E = normalize(eyeVector);
|
|
vec3 R = reflect(E, N);
|
|
R.z = -R.z;
|
|
// vec4 reflection = vec4(0.4, 0.4, 0.8, 1.0);
|
|
// vec4 reflection = textureCube(EnvironmentMap, R, reflectionBlur);
|
|
// Reflection / refraction
|
|
|
|
vec4 reflectionColour = texture2D(reflectMap, final);
|
|
vec4 refractionColour = texture2D(refractMap, final) + tintColour;
|
|
reflectionColour.rgb *= (reflectionColour.r + reflectionColour.g + reflectionColour.b) * hdrMultiplier;
|
|
float facing = 1.0 - dot(-E, N);
|
|
|
|
// float fresnel = clamp(fresnelBias + pow(facing, fresnelPower), 0.0, 1.0);
|
|
float fresnel = clamp(fresnelBias + fresnelScale * pow(1.0 + dot(eyeDir, oNormal), fresnelPower), 0.0, 1.0);
|
|
vec4 waterColor = mix(shallowColor, deepColor, facing) * waterAmount;
|
|
vec4 reflection = mix(waterColor, reflectionColour, fresnel) * reflectionAmount;
|
|
// reflection = mix(waterColor, reflection * reflectionColor, fresnel) * reflectionAmount;
|
|
// gl_FragColor = mix(waterColor, reflectionColour, reflectionAmount);
|
|
vec4 r = mix(refractionColour, reflectionColour, fresnel) * reflectionAmount;
|
|
gl_FragColor = waterColor + r;
|
|
//gl_FragColor = waterColor + mix(refractionColour, reflection, fresnel);
|
|
//gl_FragColor = refractionColour;
|
|
//gl_FragColor = reflectionColour;
|
|
//gl_FragColor = ambient * diffuse;
|
|
}
|