109 lines
3.8 KiB
GLSL
109 lines
3.8 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: modified to work with OgreUnifiedShader.h
|
|
|
|
******************************************************************************/
|
|
OGRE_NATIVE_GLSL_VERSION_DIRECTIVE
|
|
#include <OgreUnifiedShader.h>
|
|
#line 3
|
|
|
|
OGRE_UNIFORMS(
|
|
uniform vec3 eyePosition;
|
|
uniform float BumpScale;
|
|
uniform vec2 textureScale;
|
|
uniform vec2 bumpSpeed;
|
|
uniform highp float time;
|
|
uniform float waveFreq;
|
|
uniform float waveAmp;
|
|
uniform mat4 worldViewProj;
|
|
uniform mat4 textureProjMatrix;
|
|
uniform mat3 normalMatrix;
|
|
uniform float scale; // the amount to scale the noise texture by
|
|
uniform float scroll; // the amount by which to scroll the noise
|
|
uniform float noise; // the noise perturb as a factor of the time
|
|
)
|
|
// wave functions
|
|
struct Wave {
|
|
float freq; // 2*PI / wavelength
|
|
float amp; // amplitude
|
|
float phase; // speed * 2*PI / wavelength
|
|
vec2 dir;
|
|
};
|
|
|
|
MAIN_PARAMETERS
|
|
IN(vec4 vertex, POSITION)
|
|
IN(vec3 normal, NORMAL)
|
|
// IN(vec3 tangent, TANGENT)
|
|
IN(vec3 uv0, TEXCOORD0)
|
|
OUT(mat3 rotMatrix, 17)
|
|
OUT(vec2 bumpCoord0, 18)
|
|
OUT(vec2 bumpCoord1, 19)
|
|
OUT(vec2 bumpCoord2, 20)
|
|
OUT(vec3 eyeVector, 21)
|
|
OUT(vec3 noiseCoord, 22)
|
|
OUT(highp vec4 projectionCoord, 23)
|
|
OUT(vec3 eyeDir, 24)
|
|
OUT(vec3 oNormal, 25)
|
|
MAIN_DECLARATION
|
|
{
|
|
#define NWAVES 4
|
|
Wave wave[NWAVES];
|
|
wave[0] = Wave( waveFreq, waveAmp, 0.5, vec2(-1.0, 0.0) );
|
|
wave[1] = Wave( 3.0 * waveFreq, 0.33 * waveAmp, 1.7, vec2(-0.7, 0.7) );
|
|
wave[2] = Wave( 7.5 * waveFreq, 0.15 * waveAmp, 2.9, vec2(-0.2, 0.2) );
|
|
wave[3] = Wave( 11.5 * waveFreq, 0.075 * waveAmp, 5.9, vec2(-0.2, 0.3) );
|
|
vec4 P = worldViewProj * vertex;
|
|
vec4 R = vertex;
|
|
// sum waves
|
|
float ddx = 0.0, ddy = 0.0;
|
|
float deriv;
|
|
float angle;
|
|
projectionCoord = mul(textureProjMatrix, vertex);
|
|
|
|
// Noise map coords
|
|
noiseCoord.xy = (uv0.xy + (time * scroll)) * scale;
|
|
noiseCoord.z = noise * time;
|
|
// wave synthesis using two sine waves at different frequencies and phase shift
|
|
for(int i = 0; i<NWAVES; ++i)
|
|
{
|
|
angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
|
|
P.y += wave[i].amp * sin( angle );
|
|
// calculate derivate of wave function
|
|
deriv = wave[i].freq * wave[i].amp * cos(angle);
|
|
ddx -= deriv * wave[i].dir.x;
|
|
ddy -= deriv * wave[i].dir.y;
|
|
}
|
|
R.y = P.y;
|
|
// compute the 3x3 transform from tangent space to object space
|
|
// compute tangent basis
|
|
vec3 T = normalize(vec3(1.0, ddy, 0.0)) * BumpScale;
|
|
vec3 B = normalize(vec3(0.0, ddx, 1.0)) * BumpScale;
|
|
vec3 N = normalize(vec3(ddx, 1.0, ddy));
|
|
rotMatrix = mat3(T, B, N);
|
|
gl_Position = P;
|
|
// calculate texture coordinates for normal map lookup
|
|
bumpCoord0.xy = uv0.xy * textureScale + time * bumpSpeed;
|
|
bumpCoord1.xy = uv0.xy * textureScale * 2.0 + time * bumpSpeed * 4.0;
|
|
bumpCoord2.xy = uv0.xy * textureScale * 4.0 + time * bumpSpeed * 8.0;
|
|
|
|
eyeVector = R.xyz - eyePosition; // eye position in vertex space
|
|
eyeDir = normalize(R.xyz - eyePosition);
|
|
oNormal = normal;
|
|
}
|