fly/fgdata
1
0
Fork 0
Code Activity

fix water specular with Rembrandt

Browse source 
Signed-off-by: Emilian Huminiuc <emilianh@gmail.com>
This commit is contained in:
Emilian Huminiuc 2012-06-25 21:05:39 +03:00
parent 2b87e630bf
commit ce18b24ba9
5 changed files with 273 additions and 240 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Effects/water.eff
View file

@ -138,9 +138,6 @@
</sea_b> </sea_b>
<!-- END fog include --> <!-- END fog include -->
<rembrandt>
<use>/sim/rendering/rembrandt/enabled</use>
</rembrandt>
</parameters> </parameters>
<generate> <generate>
@ -676,7 +673,7 @@
</texture-unit> </texture-unit>
<program> <program>
<vertex-shader>Shaders/water.vert</vertex-shader> <vertex-shader>Shaders/water-gbuffer.vert</vertex-shader>
<fragment-shader>Shaders/water_sine-gbuffer.frag</fragment-shader> <fragment-shader>Shaders/water_sine-gbuffer.frag</fragment-shader>
<fragment-shader>Shaders/gbuffer-functions.frag</fragment-shader> <fragment-shader>Shaders/gbuffer-functions.frag</fragment-shader>
<fragment-shader>Shaders/gbuffer-encode.frag</fragment-shader> <fragment-shader>Shaders/gbuffer-encode.frag</fragment-shader>
@ -1064,7 +1061,7 @@
</texture-unit> </texture-unit>
<program> <program>
<vertex-shader>Shaders/water.vert</vertex-shader> <vertex-shader>Shaders/water-gbuffer.vert</vertex-shader>
<fragment-shader>Shaders/water-gbuffer.frag</fragment-shader> <fragment-shader>Shaders/water-gbuffer.frag</fragment-shader>
<fragment-shader>Shaders/gbuffer-functions.frag</fragment-shader> <fragment-shader>Shaders/gbuffer-functions.frag</fragment-shader>
<fragment-shader>Shaders/gbuffer-encode.frag</fragment-shader> <fragment-shader>Shaders/gbuffer-encode.frag</fragment-shader>

45
Shaders/water-gbuffer.frag
View file

@ -25,8 +25,8 @@ uniform int Status;
varying vec4 waterTex1; //moving texcoords varying vec4 waterTex1; //moving texcoords
varying vec4 waterTex2; //moving texcoords varying vec4 waterTex2; //moving texcoords
varying vec3 viewerdir; varying vec3 viewerdir;
// varying vec3 lightdir;
varying vec3 normal; varying vec3 normal;
varying vec3 Vnormal;
varying vec3 VTangent; varying vec3 VTangent;
varying vec3 VBinormal; varying vec3 VBinormal;
@ -56,13 +56,8 @@ void main(void)
// compute direction to viewer // compute direction to viewer
vec3 E = normalize(viewerdir); vec3 E = normalize(viewerdir);
// compute direction to light source
//vec3 L = normalize(lightdir);
// half vector
//vec3 H = normalize(L + E);
vec3 Normal = normalize(normal); vec3 Normal = normalize(normal);
vec3 vNormal = normalize(Vnormal);
const float water_shininess = 240.0; const float water_shininess = 240.0;
@ -166,11 +161,14 @@ void main(void)
N0 *= windEffect_low; N0 *= windEffect_low;
N1 *= windEffect_low; N1 *= windEffect_low;
vec3 N = normalize(mix(Normal + N0, Normal + N1, mixFactor) * waveRoughness); vec3 N2 = normalize(mix(N0, N1, mixFactor) * waveRoughness);
N = normalize(N.x * VTangent + N.y * VBinormal + N.z * normal); Normal = normalize(N2.x * VTangent + N2.y * VBinormal + N2.z * Normal);
if (normalmap_dds > 0) vNormal = normalize(mix(vNormal + N0, vNormal + N1, mixFactor) * waveRoughness);
N = -N; //dds fix
if (normalmap_dds > 0){
Normal = -Normal; //dds fix
vNormal = -vNormal;
}
// specular // specular
//vec3 specular_color = vec3(gl_LightSource[0].diffuse) //vec3 specular_color = vec3(gl_LightSource[0].diffuse)
// * pow(max(0.0, dot(N, H)), water_shininess) * 6.0; // * pow(max(0.0, dot(N, H)), water_shininess) * 6.0;
@ -188,27 +186,18 @@ void main(void)
//vec4 ambient_light = gl_LightSource[0].diffuse; //vec4 ambient_light = gl_LightSource[0].diffuse;
vec4 finalColor = refl; vec4 finalColor = refl;
// if(cover < 1.5){ float foamSlope = 0.10 + 0.1 * windScale;
// specular = 0.0; vec4 foam_texel = texture2D(sea_foam, vec2(waterTex2 * tscale) * 25.0);
// } float waveSlope = vNormal.g;
float foamSlope = 0.10 + 0.1 * windScale;
vec4 foam_texel = texture2D(sea_foam, vec2(waterTex2 * tscale) * 25.0);
float waveSlope = N.g;
if (windEffect >= 8.0) if (windEffect >= 8.0)
if (waveSlope >= foamSlope){ if (waveSlope >= foamSlope){
finalColor = mix(finalColor, max(finalColor, finalColor + foam_texel), smoothstep(0.01, 0.50, N.g)); finalColor = mix(finalColor, max(finalColor, finalColor + foam_texel), smoothstep(0.01, 0.50, vNormal.g));
} }
//finalColor *= ambient_light;
//gl_FragColor = mix(gl_Fog.color, finalColor, fogFactor);
//finalColor.rgb = fog_Func(finalColor.rgb, fogType);
//gl_FragColor = finalColor;
float emission = dot( gl_FrontLightModelProduct.sceneColor.rgb + gl_FrontMaterial.emission.rgb, float emission = dot( gl_FrontLightModelProduct.sceneColor.rgb + gl_FrontMaterial.emission.rgb,
vec3( 0.3, 0.59, 0.11 ) ); vec3( 0.3, 0.59, 0.11 )
encode_gbuffer(N, finalColor.rgb, 1, 1.0, water_shininess, emission, gl_FragCoord.z); );
float specular = smoothstep(0.0, 3.5, cover);
encode_gbuffer(Normal, finalColor.rgb, 1, specular, 128, emission, gl_FragCoord.z);
} }

67
Shaders/water-gbuffer.vert Normal file
View file

@ -0,0 +1,67 @@
// This shader is mostly an adaptation of the shader found at
// http://www.bonzaisoftware.com/water_tut.html and its glsl conversion
// available at http://forum.bonzaisoftware.com/viewthread.php?tid=10
// © Michael Horsch - 2005
// Major update and revisions - 2011-10-07
// © Emilian Huminiuc and Vivian Meazza
#version 120
varying vec4 waterTex1;
varying vec4 waterTex2;
varying vec3 viewerdir;
varying vec3 lightdir;
varying vec3 normal;
varying vec3 VTangent;
varying vec3 VBinormal;
uniform float osg_SimulationTime;
uniform float WindE, WindN;
uniform int rembrandt_enabled;
attribute vec3 tangent;
attribute vec3 binormal;
/////// functions /////////
void rotationmatrix(in float angle, out mat4 rotmat)
{
rotmat = mat4( cos( angle ), -sin( angle ), 0.0, 0.0,
sin( angle ), cos( angle ), 0.0, 0.0,
0.0 , 0.0 , 1.0, 0.0,
0.0 , 0.0 , 0.0, 1.0 );
}
void main(void)
{
mat4 RotationMatrix;
normal = gl_NormalMatrix * gl_Normal;
VTangent = normalize(gl_NormalMatrix * tangent);
VBinormal = normalize(gl_NormalMatrix * binormal);
viewerdir = vec3(gl_ModelViewMatrixInverse[3]) - vec3(gl_Vertex);
vec4 t1 = vec4(0.0, osg_SimulationTime * 0.005217, 0.0, 0.0);
vec4 t2 = vec4(0.0, osg_SimulationTime * -0.0012, 0.0, 0.0);
float Angle;
float windFactor = sqrt(pow(abs(WindE),2)+pow(abs(WindN),2)) * 0.05;
if (WindN == 0.0 && WindE == 0.0) {
Angle = 0.0;
}else{
Angle = atan(-WindN, WindE) - atan(1.0);
}
rotationmatrix(Angle, RotationMatrix);
waterTex1 = gl_MultiTexCoord0 * RotationMatrix - t1 * windFactor;
rotationmatrix(Angle, RotationMatrix);
waterTex2 = gl_MultiTexCoord0 * RotationMatrix - t2 * windFactor;
// fog_Func(fogType);
gl_Position = ftransform();
}

69
Shaders/water.vert
View file

@ -14,60 +14,45 @@ varying vec3 viewerdir;
varying vec3 lightdir; varying vec3 lightdir;
varying vec3 normal; varying vec3 normal;
varying vec3 VTangent;
varying vec3 VBinormal;
uniform float osg_SimulationTime; uniform float osg_SimulationTime;
uniform float WindE, WindN; uniform float WindE, WindN;
uniform int rembrandt_enabled;
attribute vec3 tangent;
attribute vec3 binormal;
/////// functions ///////// /////// functions /////////
void rotationmatrix(in float angle, out mat4 rotmat) void rotationmatrix(in float angle, out mat4 rotmat)
{ {
rotmat = mat4( cos( angle ), -sin( angle ), 0.0, 0.0, rotmat = mat4( cos( angle ), -sin( angle ), 0.0, 0.0,
sin( angle ), cos( angle ), 0.0, 0.0, sin( angle ), cos( angle ), 0.0, 0.0,
0.0 , 0.0 , 1.0, 0.0, 0.0 , 0.0 , 1.0, 0.0,
0.0 , 0.0 , 0.0, 1.0 ); 0.0 , 0.0 , 0.0, 1.0 );
} }
void main(void) void main(void)
{ {
mat4 RotationMatrix; mat4 RotationMatrix;
if (rembrandt_enabled > 0){ normal = normalize(gl_Normal);
normal = gl_NormalMatrix * gl_Normal; viewerdir = vec3(gl_ModelViewMatrixInverse[3]) - vec3(gl_Vertex);
} else { lightdir = normalize(vec3(gl_ModelViewMatrixInverse * gl_LightSource[0].position));
normal = normalize(gl_Normal);
}
VTangent = normalize(gl_NormalMatrix * tangent); vec4 t1 = vec4(0.0, osg_SimulationTime * 0.005217, 0.0, 0.0);
VBinormal = normalize(gl_NormalMatrix * binormal); vec4 t2 = vec4(0.0, osg_SimulationTime * -0.0012, 0.0, 0.0);
viewerdir = vec3(gl_ModelViewMatrixInverse[3]) - vec3(gl_Vertex); float Angle;
lightdir = normalize(vec3(gl_ModelViewMatrixInverse * gl_LightSource[0].position));
vec4 t1 = vec4(0.0, osg_SimulationTime * 0.005217, 0.0, 0.0); float windFactor = sqrt(pow(abs(WindE),2)+pow(abs(WindN),2)) * 0.05;
vec4 t2 = vec4(0.0, osg_SimulationTime * -0.0012, 0.0, 0.0);
float Angle; if (WindN == 0.0 && WindE == 0.0) {
Angle = 0.0;
}else{
Angle = atan(-WindN, WindE) - atan(1.0);
}
float windFactor = sqrt(pow(abs(WindE),2)+pow(abs(WindN),2)) * 0.05; rotationmatrix(Angle, RotationMatrix);
waterTex1 = gl_MultiTexCoord0 * RotationMatrix - t1 * windFactor;
if (WindN == 0.0 && WindE == 0.0) { rotationmatrix(Angle, RotationMatrix);
Angle = 0.0; waterTex2 = gl_MultiTexCoord0 * RotationMatrix - t2 * windFactor;
}else{
Angle = atan(-WindN, WindE) - atan(1.0);
}
rotationmatrix(Angle, RotationMatrix); // fog_Func(fogType);
waterTex1 = gl_MultiTexCoord0 * RotationMatrix - t1 * windFactor; gl_Position = ftransform();
}
rotationmatrix(Angle, RotationMatrix);
waterTex2 = gl_MultiTexCoord0 * RotationMatrix - t2 * windFactor;
// fog_Func(fogType);
gl_Position = ftransform();
}

325
Shaders/water_sine-gbuffer.frag
View file

@ -10,42 +10,52 @@
#version 120 #version 120
uniform sampler2D water_normalmap; uniform sampler2D water_normalmap ;
uniform sampler2D water_reflection; uniform sampler2D water_reflection ;
uniform sampler2D water_dudvmap; uniform sampler2D water_dudvmap ;
uniform sampler2D water_reflection_grey; uniform sampler2D water_reflection_grey ;
uniform sampler2D sea_foam; uniform sampler2D sea_foam ;
uniform sampler2D perlin_normalmap; uniform sampler2D perlin_normalmap ;
uniform sampler3D Noise; uniform sampler3D Noise ;
uniform float saturation, Overcast, WindE, WindN;
uniform float CloudCover0, CloudCover1, CloudCover2, CloudCover3, CloudCover4;
uniform float osg_SimulationTime;
uniform int Status;
varying vec4 waterTex1; //moving texcoords uniform float saturation ;
varying vec4 waterTex2; //moving texcoords uniform float Overcast ;
uniform float WindE ;
uniform float WindN ;
uniform float CloudCover0 ;
uniform float CloudCover1 ;
uniform float CloudCover2 ;
uniform float CloudCover3 ;
uniform float CloudCover4 ;
uniform float osg_SimulationTime ;
uniform float WaveFreq ;
uniform float WaveAmp ;
uniform float WaveSharp ;
uniform float WaveAngle ;
uniform float WaveFactor ;
uniform float WaveDAngle ;
uniform float normalmap_dds ;
uniform int Status ;
varying vec3 viewerdir;
varying vec3 lightdir;
varying vec3 normal;
varying vec3 VTangent;
varying vec3 VBinormal;
uniform float WaveFreq ; varying vec4 waterTex1 ; //moving texcoords
uniform float WaveAmp ; varying vec4 waterTex2 ; //moving texcoords
uniform float WaveSharp ;
uniform float WaveAngle ; varying vec3 viewerdir ;
uniform float WaveFactor ; varying vec3 lightdir ;
uniform float WaveDAngle ; varying vec3 normal ;
uniform float normalmap_dds; varying vec3 Vnormal ;
varying vec3 VTangent ;
varying vec3 VBinormal ;
const vec4 AllOnes = vec4(1.0); const vec4 AllOnes = vec4(1.0);
/////// functions ///////// /////// functions /////////
void encode_gbuffer(vec3 normal, vec3 color, int mId, float specular, float shininess, float emission, float depth); void encode_gbuffer(vec3 normal, vec3 color, int mId, float specular, float shininess, float emission, float depth);
void rotationmatrix(in float angle, out mat4 rotmat) void rotationmatrix(in float angle, out mat4 rotmat)
{ {
rotmat = mat4( cos( angle ), -sin( angle ), 0.0, 0.0, rotmat = mat4( cos( angle ), -sin( angle ), 0.0, 0.0,
@ -57,104 +67,101 @@ void rotationmatrix(in float angle, out mat4 rotmat)
// wave functions /////////////////////// // wave functions ///////////////////////
struct Wave { struct Wave {
float freq; // 2*PI / wavelength float freq ; // 2*PI / wavelength
float amp; // amplitude float amp ; // amplitude
float phase; // speed * 2*PI / wavelength float phase ; // speed * 2*PI / wavelength
vec2 dir; vec2 dir ;
}; };
Wave wave0 = Wave(1.0, 1.0, 0.5, vec2(0.97, 0.25)); Wave wave0 = Wave(1.0, 1.0, 0.5, vec2(0.97, 0.25)) ;
Wave wave1 = Wave(2.0, 0.5, 1.3, vec2(0.97, -0.25)); Wave wave1 = Wave(2.0, 0.5, 1.3, vec2(0.97, -0.25)) ;
Wave wave2 = Wave(1.0, 1.0, 0.6, vec2(0.95, -0.3)); Wave wave2 = Wave(1.0, 1.0, 0.6, vec2(0.95, -0.3)) ;
Wave wave3 = Wave(2.0, 0.5, 1.4, vec2(0.99, 0.1)); Wave wave3 = Wave(2.0, 0.5, 1.4, vec2(0.99, 0.1)) ;
float evaluateWave(in Wave w, vec2 pos, float t) float evaluateWave(in Wave w, vec2 pos, float t)
{ {
return w.amp * sin( dot(w.dir, pos) * w.freq + t * w.phase); return w.amp * sin( dot(w.dir, pos) * w.freq + t * w.phase) ;
} }
// derivative of wave function // derivative of wave function
float evaluateWaveDeriv(Wave w, vec2 pos, float t) float evaluateWaveDeriv(Wave w, vec2 pos, float t)
{ {
return w.freq * w.amp * cos( dot(w.dir, pos)*w.freq + t*w.phase); return w.freq * w.amp * cos( dot(w.dir, pos)*w.freq + t*w.phase) ;
} }
// sharp wave functions // sharp wave functions
float evaluateWaveSharp(Wave w, vec2 pos, float t, float k) float evaluateWaveSharp(Wave w, vec2 pos, float t, float k)
{ {
return w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k); return w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k) ;
} }
float evaluateWaveDerivSharp(Wave w, vec2 pos, float t, float k) float evaluateWaveDerivSharp(Wave w, vec2 pos, float t, float k)
{ {
return k*w.freq*w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k - 1) * cos( dot(w.dir, pos)*w.freq + t*w.phase); return k*w.freq*w.amp * pow(sin( dot(w.dir, pos)*w.freq + t*w.phase)* 0.5 + 0.5 , k - 1) * cos( dot(w.dir, pos)*w.freq + t*w.phase) ;
} }
void sumWaves(float angle, float dangle, float windScale, float factor, out float ddx, float ddy) void sumWaves(float angle, float dangle, float windScale, float factor, out float ddx, float ddy)
{ {
mat4 RotationMatrix; mat4 RotationMatrix ;
float deriv; float deriv ;
vec4 P = waterTex1 * 1024.0; vec4 P = waterTex1 * 1024.0 ;
rotationmatrix(radians(angle + dangle * windScale + 0.6 * sin(P.x * factor)), RotationMatrix); rotationmatrix(radians(angle + dangle * windScale + 0.6 * sin(P.x * factor)), RotationMatrix) ;
P *= RotationMatrix; P *= RotationMatrix ;
P.y += evaluateWave(wave0, P.xz, osg_SimulationTime); P.y += evaluateWave(wave0, P.xz, osg_SimulationTime) ;
deriv = evaluateWaveDeriv(wave0, P.xz, osg_SimulationTime ); deriv = evaluateWaveDeriv(wave0, P.xz, osg_SimulationTime ) ;
ddx = deriv * wave0.dir.x; ddx = deriv * wave0.dir.x ;
ddy = deriv * wave0.dir.y; ddy = deriv * wave0.dir.y ;
P.y += evaluateWave(wave1, P.xz, osg_SimulationTime); P.y += evaluateWave(wave1, P.xz, osg_SimulationTime) ;
deriv = evaluateWaveDeriv(wave1, P.xz, osg_SimulationTime); deriv = evaluateWaveDeriv(wave1, P.xz, osg_SimulationTime) ;
ddx += deriv * wave1.dir.x; ddx += deriv * wave1.dir.x ;
ddy += deriv * wave1.dir.y; ddy += deriv * wave1.dir.y ;
P.y += evaluateWaveSharp(wave2, P.xz, osg_SimulationTime, WaveSharp); P.y += evaluateWaveSharp(wave2, P.xz, osg_SimulationTime, WaveSharp) ;
deriv = evaluateWaveDerivSharp(wave2, P.xz, osg_SimulationTime, WaveSharp); deriv = evaluateWaveDerivSharp(wave2, P.xz, osg_SimulationTime, WaveSharp) ;
ddx += deriv * wave2.dir.x; ddx += deriv * wave2.dir.x ;
ddy += deriv * wave2.dir.y; ddy += deriv * wave2.dir.y ;
P.y += evaluateWaveSharp(wave3, P.xz, osg_SimulationTime, WaveSharp); P.y += evaluateWaveSharp(wave3, P.xz, osg_SimulationTime, WaveSharp) ;
deriv = evaluateWaveDerivSharp(wave3, P.xz, osg_SimulationTime, WaveSharp); deriv = evaluateWaveDerivSharp(wave3, P.xz, osg_SimulationTime, WaveSharp) ;
ddx += deriv * wave3.dir.x; ddx += deriv * wave3.dir.x ;
ddy += deriv * wave3.dir.y; ddy += deriv * wave3.dir.y ;
} }
void main(void) void main(void)
{ {
const vec4 sca = vec4(0.005, 0.005, 0.005, 0.005); const vec4 sca = vec4(0.005, 0.005, 0.005, 0.005) ;
const vec4 sca2 = vec4(0.02, 0.02, 0.02, 0.02); const vec4 sca2 = vec4(0.02, 0.02, 0.02, 0.02) ;
const vec4 tscale = vec4(0.25, 0.25, 0.25, 0.25); const vec4 tscale = vec4(0.25, 0.25, 0.25, 0.25) ;
mat4 RotationMatrix; mat4 RotationMatrix ;
// compute direction to viewer // compute direction to viewer
vec3 E = normalize(viewerdir); vec3 E = normalize(viewerdir) ;
// compute direction to light source // compute direction to light source
//vec3 L = normalize(lightdir); //vec3 L = normalize(lightdir);
// half vector // half vector
//vec3 H = normalize(L + E); //vec3 H = normalize(L + E);
vec3 Normal = normalize(normal); vec3 Normal = normalize(normal) ;
vec3 vNormal = normalize(Vnormal) ;
const float water_shininess = 128.0 ;
// float range = gl_ProjectionMatrix[3].z/(gl_FragCoord.z * -2.0 + 1.0 - gl_ProjectionMatrix[2].z);
const float water_shininess = 240.0;
// float range = gl_ProjectionMatrix[3].z/(gl_FragCoord.z * -2.0 + 1.0 - gl_ProjectionMatrix[2].z);
// approximate cloud cover // approximate cloud cover
float cover = 0.0; float cover = 0.0 ;
//bool Status = true; //bool Status = true;
float windEffect = sqrt( WindE*WindE + WindN*WindN ) * 0.6; //wind speed in kt float windEffect = sqrt( WindE*WindE + WindN*WindN ) * 0.6 ; //wind speed in kt
float windScale = 15.0/(3.0 + windEffect); //wave scale float windScale = 15.0/(3.0 + windEffect) ; //wave scale
float windEffect_low = 0.3 + 0.7 * smoothstep(0.0, 5.0, windEffect); //low windspeed wave filter float windEffect_low = 0.3 + 0.7 * smoothstep(0.0, 5.0, windEffect) ; //low windspeed wave filter
float waveRoughness = 0.01 + smoothstep(0.0, 40.0, windEffect); //wave roughness filter float waveRoughness = 0.01 + smoothstep(0.0, 40.0, windEffect) ; //wave roughness filter
float mixFactor = 0.2 + 0.02 * smoothstep(0.0, 50.0, windEffect); float mixFactor = 0.2 + 0.02 * smoothstep(0.0, 50.0, windEffect);
//mixFactor = 0.2;
mixFactor = clamp(mixFactor, 0.3, 0.8); mixFactor = clamp(mixFactor, 0.3, 0.8);
// sine waves // sine waves
@ -164,92 +171,92 @@ void main(void)
//float WaveAmp = 1000.0; //float WaveAmp = 1000.0;
//float WaveSharp = 10.0; //float WaveSharp = 10.0;
vec4 ddxVec = vec4(0.0); vec4 ddxVec = vec4(0.0) ;
vec4 ddyVec = vec4(0.0); vec4 ddyVec = vec4(0.0) ;
int detailFlag = 0; int detailFlag = 0 ;
//uncomment to test //uncomment to test
//range = -20000; //range = -20000;
//if (range > -15000 || dot(Normal,H) > 0.95 ) { // if (range > -15000 || dot(Normal,H) > 0.95 ) {
float ddx = 0.0, ddy = 0.0; float ddx = 0.0, ddy = 0.0 ;
float ddx1 = 0.0, ddy1 = 0.0; float ddx1 = 0.0, ddy1 = 0.0 ;
float ddx2 = 0.0, ddy2 = 0.0; float ddx2 = 0.0, ddy2 = 0.0 ;
float ddx3 = 0.0, ddy3 = 0.0; float ddx3 = 0.0, ddy3 = 0.0 ;
float waveamp; float waveamp ;
float angle = 0.0; float angle = 0.0 ;
wave0.freq = WaveFreq ; wave0.freq = WaveFreq ;
wave0.amp = WaveAmp; wave0.amp = WaveAmp ;
wave0.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave0.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
angle -= 45; angle -= 45 ;
wave1.freq = WaveFreq * 2.0 ; wave1.freq = WaveFreq * 2.0 ;
wave1.amp = WaveAmp * 1.25; wave1.amp = WaveAmp * 1.25 ;
wave1.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave1.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
angle += 30; angle += 30;
wave2.freq = WaveFreq * 3.5; wave2.freq = WaveFreq * 3.5 ;
wave2.amp = WaveAmp * 0.75; wave2.amp = WaveAmp * 0.75 ;
wave2.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave2.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
angle -= 50; angle -= 50 ;
wave3.freq = WaveFreq * 3.0 ; wave3.freq = WaveFreq * 3.0 ;
wave3.amp = WaveAmp * 0.75; wave3.amp = WaveAmp * 0.75 ;
wave3.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave3.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
// sum waves // sum waves
ddx = 0.0, ddy = 0.0; ddx = 0.0, ddy = 0.0 ;
sumWaves(WaveAngle, -1.5, windScale, WaveFactor, ddx, ddy); sumWaves(WaveAngle, -1.5, windScale, WaveFactor, ddx, ddy) ;
ddx1 = 0.0, ddy1 = 0.0; ddx1 = 0.0, ddy1 = 0.0 ;
sumWaves(WaveAngle, 1.5, windScale, WaveFactor, ddx1, ddy1); sumWaves(WaveAngle, 1.5, windScale, WaveFactor, ddx1, ddy1) ;
//reset the waves //reset the waves
angle = 0.0; angle = 0.0 ;
waveamp = WaveAmp * 0.75; waveamp = WaveAmp * 0.75 ;
wave0.freq = WaveFreq ; wave0.freq = WaveFreq ;
wave0.amp = waveamp; wave0.amp = waveamp ;
wave0.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave0.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
angle -= 20; angle -= 20 ;
wave1.freq = WaveFreq * 2.0 ; wave1.freq = WaveFreq * 2.0 ;
wave1.amp = waveamp * 1.25; wave1.amp = waveamp * 1.25 ;
wave1.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave1.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
angle += 35; angle += 35 ;
wave2.freq = WaveFreq * 3.5; wave2.freq = WaveFreq * 3.5 ;
wave2.amp = waveamp * 0.75; wave2.amp = waveamp * 0.75 ;
wave2.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave2.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
angle -= 45; angle -= 45 ;
wave3.freq = WaveFreq * 3.0 ; wave3.freq = WaveFreq * 3.0 ;
wave3.amp = waveamp * 0.75; wave3.amp = waveamp * 0.75 ;
wave3.dir = vec2(cos(radians(angle)), sin(radians(angle))); wave3.dir = vec2(cos(radians(angle)), sin(radians(angle))) ;
// sum waves // sum waves
ddx2 = 0.0, ddy2 = 0.0; ddx2 = 0.0, ddy2 = 0.0 ;
sumWaves(WaveAngle + WaveDAngle, -1.5, windScale, WaveFactor, ddx2, ddy2); sumWaves(WaveAngle + WaveDAngle, -1.5, windScale, WaveFactor, ddx2, ddy2) ;
ddx3 = 0.0, ddy3 = 0.0; ddx3 = 0.0, ddy3 = 0.0 ;
sumWaves(WaveAngle + WaveDAngle, 1.5, windScale, WaveFactor, ddx3, ddy3); sumWaves(WaveAngle + WaveDAngle, 1.5, windScale, WaveFactor, ddx3, ddy3) ;
ddxVec = vec4(ddx, ddx1, ddx2, ddx3); ddxVec = vec4(ddx, ddx1, ddx2, ddx3) ;
ddyVec = vec4(ddy, ddy1, ddy2, ddy3); ddyVec = vec4(ddy, ddy1, ddy2, ddy3) ;
//toggle detailFlag //toggle detailFlag
detailFlag = 1; //detailFlag = 1 ;
//} // end sine stuff // } // end sine stuff
float ddxSum = dot(ddxVec, AllOnes); float ddxSum = dot(ddxVec, AllOnes) ;
float ddySum = dot(ddyVec, AllOnes); float ddySum = dot(ddyVec, AllOnes) ;
if (Status == 1){ if (Status == 1){
cover = min(min(min(min(CloudCover0, CloudCover1),CloudCover2),CloudCover3),CloudCover4); cover = min(min(min(min(CloudCover0, CloudCover1),CloudCover2),CloudCover3),CloudCover4) ;
} else { } else {
// hack to allow for Overcast not to be set by Local Weather // hack to allow for Overcast not to be set by Local Weather
if (Overcast == 0){ if (Overcast == 0){
@ -260,27 +267,27 @@ void main(void)
} }
// vec4 viewt = normalize(waterTex4); // vec4 viewt = normalize(waterTex4);
vec4 viewt = vec4(-E, 0.0) * 0.6; vec4 viewt = vec4(-E, 0.0) * 0.6 ;
vec4 disdis = texture2D(water_dudvmap, vec2(waterTex2 * tscale)* windScale) * 2.0 - 1.0; vec4 disdis = texture2D(water_dudvmap, vec2(waterTex2 * tscale)* windScale) * 2.0 - 1.0 ;
//normalmaps //normalmaps
vec4 nmap = texture2D(water_normalmap, vec2(waterTex1 + disdis * sca2) * windScale) * 2.0 - 1.0; vec4 nmap = texture2D(water_normalmap, vec2(waterTex1 + disdis * sca2) * windScale) * 2.0 - 1.0 ;
vec4 nmap1 = texture2D(perlin_normalmap, vec2(waterTex1 + disdis * sca2) * windScale) * 2.0 - 1.0; vec4 nmap1 = texture2D(perlin_normalmap, vec2(waterTex1 + disdis * sca2) * windScale) * 2.0 - 1.0 ;
rotationmatrix(radians(3.0 * sin(osg_SimulationTime * 0.0075)), RotationMatrix); rotationmatrix(radians(3.0 * sin(osg_SimulationTime * 0.0075)), RotationMatrix);
nmap += texture2D(water_normalmap, vec2(waterTex2 * RotationMatrix * tscale) * windScale) * 2.0 - 1.0; nmap += texture2D(water_normalmap, vec2(waterTex2 * RotationMatrix * tscale) * windScale) * 2.0 - 1.0 ;
nmap1 += texture2D(perlin_normalmap, vec2(waterTex2 * RotationMatrix * tscale) * windScale) * 2.0 - 1.0; nmap1 += texture2D(perlin_normalmap, vec2(waterTex2 * RotationMatrix * tscale) * windScale) * 2.0 - 1.0 ;
nmap *= windEffect_low; nmap *= windEffect_low ;
nmap1 *= windEffect_low; nmap1 *= windEffect_low ;
// mix water and noise, modulated by factor // mix water and noise, modulated by factor
vec4 vNorm = normalize(mix(nmap, nmap1, mixFactor) * waveRoughness); vec4 vNorm = normalize(mix(nmap, nmap1, mixFactor) * waveRoughness) ;
vNorm.r += ddxSum; vNorm.r += ddxSum ;
if (normalmap_dds > 0) if (normalmap_dds > 0)//dds fix
vNorm = -vNorm; //dds fix vNorm = -vNorm ;
//load reflection //load reflection
//vec4 tmp = vec4(lightdir, 0.0); //vec4 tmp = vec4(lightdir, 0.0);
@ -319,27 +326,25 @@ void main(void)
N0 += vec3(texture2D(water_normalmap, vec2(waterTex1 * RotationMatrix + disdis * sca2) * windScale) * 2.0 - 1.0); N0 += vec3(texture2D(water_normalmap, vec2(waterTex1 * RotationMatrix + disdis * sca2) * windScale) * 2.0 - 1.0);
N1 += vec3(texture2D(perlin_normalmap, vec2(waterTex1 * RotationMatrix + disdis * sca) * windScale) * 2.0 - 1.0); N1 += vec3(texture2D(perlin_normalmap, vec2(waterTex1 * RotationMatrix + disdis * sca) * windScale) * 2.0 - 1.0);
//if(detailFlag > 0) // if(detailFlag > 0)
//{ // {
N0 *= windEffect_low; N0 *= windEffect_low;
N1 *= windEffect_low; N1 *= windEffect_low;
//N0.r += (ddx + ddx1 + ddx2 + ddx3);
//N0.g += (ddy + ddy1 + ddy2 + ddy3);
N0.r += ddxSum; N0.r += ddxSum;
N0.g += ddySum; N0.g += ddySum;
vec3 N2 = normalize(mix(N0, N1, mixFactor) * waveRoughness);
Normal = normalize(mix(Normal + N0, Normal + N1, mixFactor) * waveRoughness); Normal = normalize(N2.x * VTangent + N2.y * VBinormal + N2.z * Normal);
Normal = normalize(Normal.x * VTangent + Normal.y * VBinormal + Normal.z * normal); vNormal = normalize(mix(vNormal + N0, vNormal + N1, mixFactor) * waveRoughness);
if (normalmap_dds > 0) if (normalmap_dds > 0){ //dds fix
Normal = -Normal; //dds fix Normal = -Normal;
//} vNormal = -vNormal;
}
// }
// specular // specular
// vec3 specular_color = vec3(1.0) * pow(max(0.0, dot(Normal, H)), water_shininess) * 6.0; // vec3 specular_color = vec3(1.0) * pow(max(0.0, dot(Normal, H)), water_shininess) * 6.0;
// vec4 specular = vec4(specular_color, 0.5); // vec4 specular = vec4(specular_color, 0.5);
//
//specular_color *= saturation * 0.3 ; //specular_color *= saturation * 0.3 ;
//float specular = saturation * 0.3; //float specular = saturation * 0.3;
@ -349,29 +354,21 @@ void main(void)
refl *= fres; refl *= fres;
//calculate final colour //calculate final colour
//vec4 ambient_light = gl_LightSource[0].diffuse;
vec4 finalColor = refl; vec4 finalColor = refl;
// if(cover >= 1.5){
// // specular = 0.0;
// // } else {
// finalColor.rgb = finalColor.rgb + specular_color;
// }
//add foam //add foam
vec4 foam_texel = texture2D(sea_foam, vec2(waterTex2 * tscale) * 25.0); vec4 foam_texel = texture2D(sea_foam, vec2(waterTex2 * tscale) * 25.0);
// if (range > -10000.0){ // if (range > -10000.0){
float foamSlope = 0.1 + 0.1 * windScale; float foamSlope = 0.1 + 0.1 * windScale;
//float waveSlope = mix(N0.g, N1.g, 0.25); float waveSlope = vNormal.g;
float waveSlope = Normal.g;
if (windEffect >= 8.0) if (windEffect >= 8.0)
if (waveSlope >= foamSlope){ if (waveSlope >= foamSlope){
finalColor = mix( finalColor, finalColor = mix( finalColor,
max(finalColor, finalColor + foam_texel), max(finalColor, finalColor + foam_texel),
smoothstep(0.01, 0.50, Normal.g) smoothstep(0.01, 0.50, vNormal.g)
); );
} }
@ -381,8 +378,6 @@ void main(void)
float emission = dot( gl_FrontLightModelProduct.sceneColor.rgb + gl_FrontMaterial.emission.rgb, float emission = dot( gl_FrontLightModelProduct.sceneColor.rgb + gl_FrontMaterial.emission.rgb,
vec3( 0.3, 0.59, 0.11 ) vec3( 0.3, 0.59, 0.11 )
); );
// float emission = dot( gl_FrontLightModelProduct.sceneColor.rgb + specular_color, float specular = smoothstep(0.0, 3.5, cover);
// vec3( 0.3, 0.59, 0.11 ) encode_gbuffer(Normal, finalColor.rgb, 1, specular, water_shininess, emission, gl_FragCoord.z);
// );
encode_gbuffer(Normal, finalColor.rgb, 1, 1.0, water_shininess, emission, gl_FragCoord.z);
} }