Removed all xxx15.frag shaders and used GLSLCompat to have the same shader whatever version it's used for
Nehon
8 years ago
parent
a64594eea9
commit
f7181c38dc
@ -1,57 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
|
||||
uniform sampler2D m_NormalsTexture; |
||||
uniform vec2 g_ResolutionInverse; |
||||
|
||||
uniform vec4 m_EdgeColor; |
||||
|
||||
uniform float m_EdgeWidth; |
||||
uniform float m_EdgeIntensity; |
||||
|
||||
uniform float m_NormalThreshold; |
||||
uniform float m_DepthThreshold; |
||||
|
||||
uniform float m_NormalSensitivity; |
||||
uniform float m_DepthSensitivity; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 outFragColor; |
||||
|
||||
vec4 fetchNormalDepth(vec2 tc){ |
||||
vec4 nd; |
||||
nd.xyz = texture2D(m_NormalsTexture, tc).rgb; |
||||
nd.w = fetchTextureSample(m_DepthTexture, tc,0).r; |
||||
return nd; |
||||
} |
||||
|
||||
void main(){ |
||||
vec3 color = getColor(m_Texture, texCoord).rgb; |
||||
|
||||
vec2 edgeOffset = vec2(m_EdgeWidth) * g_ResolutionInverse; |
||||
vec4 n1 = fetchNormalDepth(texCoord + vec2(-1.0, -1.0) * edgeOffset); |
||||
vec4 n2 = fetchNormalDepth(texCoord + vec2( 1.0, 1.0) * edgeOffset); |
||||
vec4 n3 = fetchNormalDepth(texCoord + vec2(-1.0, 1.0) * edgeOffset); |
||||
vec4 n4 = fetchNormalDepth(texCoord + vec2( 1.0, -1.0) * edgeOffset); |
||||
|
||||
// Work out how much the normal and depth values are changing. |
||||
vec4 diagonalDelta = abs(n1 - n2) + abs(n3 - n4); |
||||
|
||||
float normalDelta = dot(diagonalDelta.xyz, vec3(1.0)); |
||||
float depthDelta = diagonalDelta.w; |
||||
|
||||
// Filter out very small changes, in order to produce nice clean results. |
||||
normalDelta = clamp((normalDelta - m_NormalThreshold) * m_NormalSensitivity, 0.0, 1.0); |
||||
depthDelta = clamp((depthDelta - m_DepthThreshold) * m_DepthSensitivity, 0.0, 1.0); |
||||
|
||||
// Does this pixel lie on an edge? |
||||
float edgeAmount = clamp(normalDelta + depthDelta, 0.0, 1.0) * m_EdgeIntensity; |
||||
|
||||
// Apply the edge detection result to the main scene color. |
||||
//color *= (1.0 - edgeAmount); |
||||
color = mix (color,m_EdgeColor.rgb,edgeAmount); |
||||
|
||||
outFragColor = vec4(color, 1.0); |
||||
} |
||||
@ -1,10 +1,13 @@ |
||||
uniform sampler2D m_Texture; |
||||
uniform sampler2D m_CompositeTexture; |
||||
#import "Common/ShaderLib/GLSLCompat.glsllib" |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform COLORTEXTURE m_CompositeTexture; |
||||
varying vec2 texCoord; |
||||
|
||||
void main() { |
||||
vec4 texVal = texture2D(m_Texture, texCoord); |
||||
vec4 compositeVal = texture2D(m_CompositeTexture, texCoord); |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
vec4 compositeVal = getColor(m_CompositeTexture, texCoord); |
||||
gl_FragColor = mix(compositeVal,texVal,texVal.a); |
||||
} |
||||
|
||||
|
||||
@ -1,14 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform COLORTEXTURE m_CompositeTexture; |
||||
in vec2 texCoord; |
||||
|
||||
out vec4 finalColor; |
||||
|
||||
void main() { |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
vec4 compositeVal = getColor(m_CompositeTexture, texCoord); |
||||
finalColor = mix(compositeVal,texVal,texVal.a); |
||||
} |
||||
|
||||
@ -1,55 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
in vec2 texCoord; |
||||
|
||||
uniform vec4 m_LineColor; |
||||
uniform vec4 m_PaperColor; |
||||
uniform float m_ColorInfluenceLine; |
||||
uniform float m_ColorInfluencePaper; |
||||
|
||||
uniform float m_FillValue; |
||||
uniform float m_Luminance1; |
||||
uniform float m_Luminance2; |
||||
uniform float m_Luminance3; |
||||
uniform float m_Luminance4; |
||||
uniform float m_Luminance5; |
||||
|
||||
uniform float m_LineDistance; |
||||
uniform float m_LineThickness; |
||||
|
||||
out vec4 fragColor; |
||||
|
||||
void main() { |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
float linePixel = 0; |
||||
|
||||
float lum = texVal.r*0.2126 + texVal.g*0.7152 + texVal.b*0.0722; |
||||
|
||||
if (lum < m_Luminance1){ |
||||
if (mod(gl_FragCoord.x + gl_FragCoord.y, m_LineDistance * 2.0) < m_LineThickness) |
||||
linePixel = 1; |
||||
} |
||||
if (lum < m_Luminance2){ |
||||
if (mod(gl_FragCoord.x - gl_FragCoord.y, m_LineDistance * 2.0) < m_LineThickness) |
||||
linePixel = 1; |
||||
} |
||||
if (lum < m_Luminance3){ |
||||
if (mod(gl_FragCoord.x + gl_FragCoord.y - m_LineDistance, m_LineDistance) < m_LineThickness) |
||||
linePixel = 1; |
||||
} |
||||
if (lum < m_Luminance4){ |
||||
if (mod(gl_FragCoord.x - gl_FragCoord.y - m_LineDistance, m_LineDistance) < m_LineThickness) |
||||
linePixel = 1; |
||||
} |
||||
if (lum < m_Luminance5){ // No line, make a blob instead |
||||
linePixel = m_FillValue; |
||||
} |
||||
|
||||
// Mix line color with existing color information |
||||
vec4 lineColor = mix(m_LineColor, texVal, m_ColorInfluenceLine); |
||||
// Mix paper color with existing color information |
||||
vec4 paperColor = mix(m_PaperColor, texVal, m_ColorInfluencePaper); |
||||
|
||||
fragColor = mix(paperColor, lineColor, linePixel); |
||||
} |
||||
@ -1,93 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
varying vec2 texCoord; |
||||
|
||||
uniform float m_FocusRange; |
||||
uniform float m_FocusDistance; |
||||
uniform float m_XScale; |
||||
uniform float m_YScale; |
||||
|
||||
vec2 m_NearFar = vec2( 0.1, 1000.0 ); |
||||
|
||||
out vec4 fragColor; |
||||
|
||||
void main() { |
||||
|
||||
vec4 texVal = getColor( m_Texture, texCoord ); |
||||
|
||||
float zBuffer = getDepth( m_DepthTexture, texCoord ).r; |
||||
|
||||
// |
||||
// z_buffer_value = a + b / z; |
||||
// |
||||
// Where: |
||||
// a = zFar / ( zFar - zNear ) |
||||
// b = zFar * zNear / ( zNear - zFar ) |
||||
// z = distance from the eye to the object |
||||
// |
||||
// Which means: |
||||
// zb - a = b / z; |
||||
// z * (zb - a) = b |
||||
// z = b / (zb - a) |
||||
// |
||||
float a = m_NearFar.y / (m_NearFar.y - m_NearFar.x); |
||||
float b = m_NearFar.y * m_NearFar.x / (m_NearFar.x - m_NearFar.y); |
||||
float z = b / (zBuffer - a); |
||||
|
||||
// Above could be the same for any depth-based filter |
||||
|
||||
// We want to be purely focused right at |
||||
// m_FocusDistance and be purely unfocused |
||||
// at +/- m_FocusRange to either side of that. |
||||
float unfocus = min( 1.0, abs( z - m_FocusDistance ) / m_FocusRange ); |
||||
|
||||
if( unfocus < 0.2 ) { |
||||
// If we are mostly in focus then don't bother with the |
||||
// convolution filter |
||||
fragColor = texVal; |
||||
} else { |
||||
// Perform a wide convolution filter and we scatter it |
||||
// a bit to avoid some texture look-ups. Instead of |
||||
// a full 5x5 (25-1 lookups) we'll skip every other one |
||||
// to only perform 12. |
||||
// 1 0 1 0 1 |
||||
// 0 1 0 1 0 |
||||
// 1 0 x 0 1 |
||||
// 0 1 0 1 0 |
||||
// 1 0 1 0 1 |
||||
// |
||||
// You can get away with 8 just around the outside but |
||||
// it looks more jittery to me. |
||||
|
||||
vec4 sum = vec4(0.0); |
||||
|
||||
float x = texCoord.x; |
||||
float y = texCoord.y; |
||||
|
||||
float xScale = m_XScale; |
||||
float yScale = m_YScale; |
||||
|
||||
// In order from lower left to right, depending on how you look at it |
||||
sum += getColor( m_Texture, vec2(x - 2.0 * xScale, y - 2.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x - 0.0 * xScale, y - 2.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x + 2.0 * xScale, y - 2.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x - 1.0 * xScale, y - 1.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x + 1.0 * xScale, y - 1.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x - 2.0 * xScale, y - 0.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x + 2.0 * xScale, y - 0.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x - 1.0 * xScale, y + 1.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x + 1.0 * xScale, y + 1.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x - 2.0 * xScale, y + 2.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x - 0.0 * xScale, y + 2.0 * yScale) ); |
||||
sum += getColor( m_Texture, vec2(x + 2.0 * xScale, y + 2.0 * yScale) ); |
||||
|
||||
sum = sum / 12.0; |
||||
|
||||
fragColor = mix( texVal, sum, unfocus ); |
||||
|
||||
// I used this for debugging the range |
||||
// gl_FragColor.r = unfocus; |
||||
} |
||||
} |
||||
@ -1,10 +1,13 @@ |
||||
uniform sampler2D m_Texture; |
||||
#import "Common/ShaderLib/GLSLCompat.glsllib" |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
varying vec2 texCoord; |
||||
|
||||
uniform float m_Value; |
||||
|
||||
void main() { |
||||
vec4 texVal = texture2D(m_Texture, texCoord); |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
|
||||
gl_FragColor = texVal * m_Value; |
||||
|
||||
|
||||
@ -1,12 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform float m_Value; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
void main() { |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
fragColor = texVal * m_Value; |
||||
} |
||||
@ -1,25 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
|
||||
uniform vec4 m_FogColor; |
||||
uniform float m_FogDensity; |
||||
uniform float m_FogDistance; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
const float LOG2 = 1.442695; |
||||
|
||||
void main() { |
||||
vec2 m_FrustumNearFar=vec2(1.0,m_FogDistance); |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
float fogVal = getDepth(m_DepthTexture,texCoord).r; |
||||
float depth= (2.0 * m_FrustumNearFar.x) / (m_FrustumNearFar.y + m_FrustumNearFar.x - fogVal* (m_FrustumNearFar.y-m_FrustumNearFar.x)); |
||||
|
||||
float fogFactor = exp2( -m_FogDensity * m_FogDensity * depth * depth * LOG2 ); |
||||
fogFactor = clamp(fogFactor, 0.0, 1.0); |
||||
fragColor =mix(m_FogColor,texVal,fogFactor); |
||||
|
||||
} |
||||
@ -1,16 +0,0 @@ |
||||
uniform sampler2D m_Texture; |
||||
varying vec2 texCoord; |
||||
|
||||
uniform float m_InvGamma; |
||||
|
||||
vec3 gamma(vec3 L,float invGamma){ |
||||
return pow(L, vec3(invGamma)); |
||||
} |
||||
|
||||
void main() { |
||||
vec4 texVal = texture2D(m_Texture, texCoord); |
||||
|
||||
texVal.rgb = gamma(texVal.rgb , m_InvGamma); |
||||
|
||||
gl_FragColor = texVal; |
||||
} |
||||
@ -1,31 +0,0 @@ |
||||
MaterialDef GammaCorrection { |
||||
|
||||
MaterialParameters { |
||||
Int NumSamples |
||||
Texture2D Texture |
||||
Float InvGamma |
||||
} |
||||
|
||||
Technique { |
||||
VertexShader GLSL150: Common/MatDefs/Post/Post15.vert |
||||
FragmentShader GLSL150: Common/MatDefs/Post/GammaCorrection15.frag |
||||
|
||||
WorldParameters { |
||||
} |
||||
|
||||
Defines { |
||||
RESOLVE_MS : NumSamples |
||||
} |
||||
} |
||||
|
||||
Technique { |
||||
VertexShader GLSL100: Common/MatDefs/Post/Post.vert |
||||
FragmentShader GLSL100: Common/MatDefs/Post/GammaCorrection.frag |
||||
|
||||
WorldParameters { |
||||
} |
||||
|
||||
Defines { |
||||
} |
||||
} |
||||
} |
||||
@ -1,20 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
in vec2 texCoord; |
||||
|
||||
uniform float m_InvGamma; |
||||
|
||||
vec3 gamma(vec3 L,float invGamma){ |
||||
return pow(L, vec3(invGamma)); |
||||
} |
||||
|
||||
out vec4 fragColor; |
||||
|
||||
void main() { |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
|
||||
texVal.rgb = gamma(texVal.rgb , m_InvGamma); |
||||
|
||||
fragColor = texVal; |
||||
} |
||||
@ -1,37 +1,38 @@ |
||||
uniform sampler2D m_Texture; |
||||
uniform sampler2D m_DepthTexture; |
||||
#import "Common/ShaderLib/GLSLCompat.glsllib" |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
uniform int m_NbSamples; |
||||
uniform float m_BlurStart; |
||||
uniform float m_BlurWidth; |
||||
uniform float m_LightDensity; |
||||
uniform bool m_Display; |
||||
uniform vec3 m_LightPosition; |
||||
|
||||
varying vec2 texCoord; |
||||
|
||||
void main(void) |
||||
{ |
||||
if(m_Display){ |
||||
void main(void) { |
||||
#ifdef DISPLAY |
||||
|
||||
vec4 colorRes= texture2D(m_Texture,texCoord); |
||||
float factor=(m_BlurWidth/(float(m_NbSamples)-1.0)); |
||||
vec4 colorRes = getColor(m_Texture, texCoord); |
||||
float factor = (m_BlurWidth/(float(m_NbSamples) - 1.0)); |
||||
float scale; |
||||
vec2 texCoo=texCoord - m_LightPosition.xy; |
||||
vec2 texCoo = texCoord - m_LightPosition.xy; |
||||
vec2 scaledCoord; |
||||
vec4 res = vec4(0.0); |
||||
for(int i=0; i<m_NbSamples; i++) { |
||||
scale = float(i) * factor + m_BlurStart ; |
||||
scaledCoord=texCoo*scale + m_LightPosition.xy; |
||||
if(texture2D(m_DepthTexture,scaledCoord).r==1.0){ |
||||
res += texture2D(m_Texture,scaledCoord); |
||||
scaledCoord = texCoo*scale + m_LightPosition.xy; |
||||
if(fetchTextureSample(m_DepthTexture, scaledCoord, 0).r == 1.0){ |
||||
res += fetchTextureSample(m_Texture, scaledCoord, 0); |
||||
} |
||||
} |
||||
res /= float(m_NbSamples); |
||||
|
||||
//Blend the original color with the averaged pixels |
||||
float mean = (res.r + res.g + res.b)/3.0; |
||||
gl_FragColor =mix(colorRes ,mix( colorRes, res, m_LightDensity),mean); |
||||
}else{ |
||||
gl_FragColor= texture2D(m_Texture,texCoord); |
||||
} |
||||
gl_FragColor = mix(colorRes, mix( colorRes, res, m_LightDensity), mean); |
||||
#else |
||||
gl_FragColor = getColor(m_Texture, texCoord); |
||||
#endif |
||||
} |
||||
|
||||
@ -1,41 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
|
||||
uniform int m_NbSamples; |
||||
uniform float m_BlurStart; |
||||
uniform float m_BlurWidth; |
||||
uniform float m_LightDensity; |
||||
uniform bool m_Display; |
||||
uniform vec3 m_LightPosition; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
void main(void) |
||||
{ |
||||
if(m_Display){ |
||||
|
||||
vec4 colorRes= getColor(m_Texture,texCoord); |
||||
float factor=(m_BlurWidth/(float(m_NbSamples)-1.0)); |
||||
float scale; |
||||
vec2 texCoo=texCoord - m_LightPosition.xy; |
||||
vec2 scaledCoord; |
||||
vec4 res = vec4(0.0); |
||||
for(int i=0; i<m_NbSamples; i++) { |
||||
scale = float(i) * factor + m_BlurStart ; |
||||
scaledCoord=texCoo*scale + m_LightPosition.xy; |
||||
if(fetchTextureSample(m_DepthTexture, scaledCoord,0).r==1.0){ |
||||
res += fetchTextureSample(m_Texture,scaledCoord,0); |
||||
} |
||||
} |
||||
res /= float(m_NbSamples); |
||||
|
||||
//Blend the original color with the averaged pixels |
||||
float mean = (res.r + res.g + res.b)/3.0; |
||||
fragColor =mix(colorRes ,mix( colorRes, res, m_LightDensity),mean); |
||||
}else{ |
||||
fragColor = getColor(m_Texture,texCoord); |
||||
} |
||||
} |
||||
@ -1,16 +0,0 @@ |
||||
//uniform mat4 g_WorldViewProjectionMatrix; |
||||
uniform vec2 g_Resolution; |
||||
uniform vec4 g_ViewPort; |
||||
uniform vec3 m_LightPosition; |
||||
|
||||
in vec4 inPosition; |
||||
in vec2 inTexCoord; |
||||
out vec2 texCoord; |
||||
out vec2 lightPos; |
||||
|
||||
void main() { |
||||
vec2 pos = inPosition.xy* 2.0 - 1.0; |
||||
gl_Position = vec4(pos, 0.0, 1.0); |
||||
lightPos=m_LightPosition.xy; |
||||
texCoord = inTexCoord; |
||||
} |
||||
@ -1,9 +1,12 @@ |
||||
uniform sampler2D m_Texture; |
||||
#import "Common/ShaderLib/GLSLCompat.glsllib" |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform vec4 m_Color; |
||||
varying vec2 texCoord; |
||||
|
||||
void main() { |
||||
vec4 texVal = texture2D(m_Texture, texCoord); |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
gl_FragColor = texVal * m_Color; |
||||
} |
||||
|
||||
|
||||
@ -1,12 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform vec4 m_Color; |
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
void main() { |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
fragColor = texVal * m_Color; |
||||
} |
||||
|
||||
@ -1,21 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
uniform int m_NumColors; |
||||
uniform float m_Gamma; |
||||
uniform float m_Strength; |
||||
|
||||
void main() { |
||||
vec4 texVal = getColor(m_Texture, texCoord); |
||||
|
||||
texVal = pow(texVal, vec4(m_Gamma)); |
||||
texVal = texVal * m_NumColors; |
||||
texVal = floor(texVal); |
||||
texVal = texVal / m_NumColors; |
||||
texVal = pow(texVal, vec4(1.0/m_Gamma)); |
||||
|
||||
fragColor = mix(getColor(m_Texture, texCoord), texVal, m_Strength); |
||||
} |
||||
@ -1,33 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
|
||||
uniform float m_ExposurePow; |
||||
uniform float m_ExposureCutoff; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 outFragColor; |
||||
|
||||
#ifdef HAS_GLOWMAP |
||||
uniform sampler2D m_GlowMap; |
||||
#endif |
||||
|
||||
void main(){ |
||||
vec4 color = vec4(0.0); |
||||
#ifdef DO_EXTRACT |
||||
color = getColorSingle(m_Texture, texCoord); |
||||
if ( (color.r + color.g + color.b) / 3.0 >= m_ExposureCutoff ) { |
||||
color = pow(color, vec4(m_ExposurePow)); |
||||
}else{ |
||||
color = vec4(0.0); |
||||
} |
||||
#endif |
||||
|
||||
#ifdef HAS_GLOWMAP |
||||
vec4 glowColor = texture( m_GlowMap, texCoord ); |
||||
glowColor = pow(glowColor, vec4(m_ExposurePow)); |
||||
color += glowColor; |
||||
#endif |
||||
|
||||
outFragColor = color; |
||||
} |
||||
@ -1,16 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
|
||||
uniform sampler2D m_BloomTex; |
||||
uniform float m_BloomIntensity; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
void main(){ |
||||
vec4 colorRes = getColor(m_Texture,texCoord); |
||||
vec4 bloom = texture(m_BloomTex, texCoord); |
||||
fragColor = bloom * m_BloomIntensity + colorRes; |
||||
} |
||||
|
||||
@ -1,116 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
|
||||
uniform vec2 g_ResolutionInverse; |
||||
uniform vec2 g_Resolution; |
||||
uniform vec2 m_FrustumNearFar; |
||||
uniform sampler2D m_Normals; |
||||
uniform sampler2D m_RandomMap; |
||||
uniform vec3 m_FrustumCorner; |
||||
uniform float m_SampleRadius; |
||||
uniform float m_Intensity; |
||||
uniform float m_Scale; |
||||
uniform float m_Bias; |
||||
uniform vec2[4] m_Samples; |
||||
|
||||
in vec2 texCoord; |
||||
|
||||
out vec4 fragColor; |
||||
|
||||
|
||||
|
||||
vec3 getPosition(float depthv, in vec2 uv){ |
||||
//Reconstruction from depth |
||||
float depth = (2.0 * m_FrustumNearFar.x) / (m_FrustumNearFar.y + m_FrustumNearFar.x - depthv * (m_FrustumNearFar.y-m_FrustumNearFar.x)); |
||||
|
||||
//one frustum corner method |
||||
float x = mix(-m_FrustumCorner.x, m_FrustumCorner.x, uv.x); |
||||
float y = mix(-m_FrustumCorner.y, m_FrustumCorner.y, uv.y); |
||||
|
||||
return depth* vec3(x, y, m_FrustumCorner.z); |
||||
} |
||||
|
||||
vec3 getNormal(in vec2 uv){ |
||||
return normalize(texture2D(m_Normals, uv).xyz * 2.0 - 1.0); |
||||
} |
||||
|
||||
vec3 approximateNormal(in vec3 pos,in vec2 texCoord){ |
||||
float step = g_ResolutionInverse.x ; |
||||
float stepy = g_ResolutionInverse.y ; |
||||
float depth2 = getDepth(m_DepthTexture,texCoord + vec2(step,-stepy)).r; |
||||
float depth3 = getDepth(m_DepthTexture,texCoord + vec2(-step,-stepy)).r; |
||||
vec3 pos2 = vec3(getPosition(depth2,texCoord + vec2(step,-stepy))); |
||||
vec3 pos3 = vec3(getPosition(depth3,texCoord + vec2(-step,-stepy))); |
||||
|
||||
vec3 v1 = (pos - pos2).xyz; |
||||
vec3 v2 = (pos3 - pos2).xyz; |
||||
return normalize(cross(-v1, v2)); |
||||
} |
||||
|
||||
vec2 getRandom(in vec2 uv){ |
||||
//float rand=(fract(uv.x*(g_Resolution.x/2.0))*0.25)+(fract(uv.y*(g_Resolution.y/2.0))*0.5); |
||||
vec4 rand=texture2D(m_RandomMap, g_Resolution * uv / 128.0 * 3.0)*2.0 -1.0; |
||||
|
||||
return normalize(rand.xy); |
||||
} |
||||
|
||||
float doAmbientOcclusion(in vec2 tc, in vec3 pos, in vec3 norm){ |
||||
float depthv = getDepth(m_DepthTexture, tc).r; |
||||
vec3 diff = getPosition(depthv, tc)- pos; |
||||
vec3 v = normalize(diff); |
||||
float d = length(diff) * m_Scale; |
||||
|
||||
return max(0.0, dot(norm, v) - m_Bias) * ( 1.0/(1.0 + d) ) * m_Intensity; |
||||
} |
||||
|
||||
|
||||
vec2 reflection(in vec2 v1,in vec2 v2){ |
||||
vec2 result= 2.0 * dot(v2, v1) * v2; |
||||
result=v1-result; |
||||
return result; |
||||
} |
||||
|
||||
|
||||
void main(){ |
||||
|
||||
float result; |
||||
|
||||
float depthv = getDepth(m_DepthTexture, texCoord).r; |
||||
//optimization, do not calculate AO if depth is 1 |
||||
if(depthv == 1.0){ |
||||
fragColor = vec4(1.0); |
||||
return; |
||||
} |
||||
vec3 position = getPosition(depthv, texCoord); |
||||
|
||||
#ifdef APPROXIMATE_NORMALS |
||||
vec3 normal = approximateNormal(position, texCoord); |
||||
#else |
||||
vec3 normal = getNormal(texCoord); |
||||
#endif |
||||
|
||||
vec2 rand = getRandom(texCoord); |
||||
|
||||
float ao = 0.0; |
||||
float rad =m_SampleRadius / position.z; |
||||
|
||||
|
||||
int iterations = 4; |
||||
for (int j = 0; j < iterations; ++j){ |
||||
vec2 coord1 = reflection(vec2(m_Samples[j]), rand) * vec2(rad,rad); |
||||
vec2 coord2 = vec2(coord1.x* 0.707 - coord1.y* 0.707, coord1.x* 0.707 + coord1.y* 0.707) ; |
||||
|
||||
ao += doAmbientOcclusion(texCoord + coord1.xy * 0.25, position, normal); |
||||
ao += doAmbientOcclusion(texCoord + coord2 * 0.50, position, normal); |
||||
ao += doAmbientOcclusion(texCoord + coord1.xy * 0.75, position, normal); |
||||
ao += doAmbientOcclusion(texCoord + coord2 * 1.00, position, normal); |
||||
|
||||
} |
||||
ao /= float(iterations) * 4.0; |
||||
result = 1.0-ao; |
||||
|
||||
fragColor = vec4(result,result,result, 1.0); |
||||
|
||||
} |
||||
@ -1,133 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
uniform sampler2D m_SSAOMap; |
||||
uniform bool m_UseOnlyAo; |
||||
uniform bool m_UseAo; |
||||
uniform float m_XScale; |
||||
uniform float m_YScale; |
||||
uniform vec2 m_FrustumNearFar; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 fragColor; |
||||
|
||||
vec4 getResult(vec4 color){ |
||||
|
||||
#ifdef USE_ONLY_AO |
||||
return color; |
||||
#endif |
||||
#ifdef USE_AO |
||||
return getColor(m_Texture,texCoord)* color; |
||||
#endif |
||||
|
||||
return getColor(m_Texture,texCoord); |
||||
|
||||
} |
||||
|
||||
float readDepth(in vec2 uv){ |
||||
float depthv =fetchTextureSample(m_DepthTexture,uv,0).r; |
||||
return (2.0 * m_FrustumNearFar.x) / (m_FrustumNearFar.y + m_FrustumNearFar.x - depthv* (m_FrustumNearFar.y-m_FrustumNearFar.x)); |
||||
} |
||||
|
||||
const float epsilon = 0.005; |
||||
|
||||
|
||||
vec4 convolutionFilter(){ |
||||
vec4 sum = vec4(0.0); |
||||
|
||||
float x = texCoord.x; |
||||
float y = texCoord.y; |
||||
|
||||
float xScale = m_XScale; |
||||
float yScale = m_YScale; |
||||
|
||||
float zsum = 1.0; |
||||
float Zp =readDepth(texCoord); |
||||
|
||||
|
||||
vec2 sample = vec2(x - 2.0 * xScale, y - 2.0 * yScale); |
||||
float zTmp =readDepth(sample); |
||||
float coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x - 0.0 * xScale, y - 2.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x + 2.0 * xScale, y - 2.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x - 1.0 * xScale, y - 1.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x + 1.0 * xScale, y - 1.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x - 2.0 * xScale, y - 0.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x + 2.0 * xScale, y - 0.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x - 1.0 * xScale, y + 1.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x + 1.0 * xScale, y + 1.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x - 2.0 * xScale, y + 2.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x - 0.0 * xScale, y + 2.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
sample = vec2(x + 2.0 * xScale, y + 2.0 * yScale); |
||||
zTmp =readDepth(sample); |
||||
coefZ = 1.0 / (epsilon + abs(Zp - zTmp)); |
||||
zsum += coefZ; |
||||
sum += coefZ* texture2D( m_SSAOMap, sample); |
||||
|
||||
|
||||
return sum / zsum; |
||||
} |
||||
|
||||
|
||||
void main(){ |
||||
// float depth =texture2D(m_DepthTexture,uv).r; |
||||
|
||||
fragColor=getResult(convolutionFilter()); |
||||
// gl_FragColor=getResult(bilateralFilter()); |
||||
// gl_FragColor=getColor(m_SSAOMap,texCoord); |
||||
|
||||
} |
||||
@ -1,439 +0,0 @@ |
||||
#import "Common/ShaderLib/MultiSample.glsllib" |
||||
#import "Common/ShaderLib/WaterUtil.glsllib" |
||||
|
||||
// Water pixel shader |
||||
// Copyright (C) JMonkeyEngine 3.0 |
||||
// by Remy Bouquet (nehon) for JMonkeyEngine 3.0 |
||||
// original HLSL version by Wojciech Toman 2009 |
||||
|
||||
uniform COLORTEXTURE m_Texture; |
||||
uniform DEPTHTEXTURE m_DepthTexture; |
||||
|
||||
|
||||
uniform sampler2D m_HeightMap; |
||||
uniform sampler2D m_NormalMap; |
||||
uniform sampler2D m_FoamMap; |
||||
uniform sampler2D m_CausticsMap; |
||||
uniform sampler2D m_ReflectionMap; |
||||
|
||||
uniform mat4 g_ViewProjectionMatrixInverse; |
||||
uniform mat4 m_TextureProjMatrix; |
||||
uniform vec3 m_CameraPosition; |
||||
|
||||
uniform float m_WaterHeight; |
||||
uniform float m_Time; |
||||
uniform float m_WaterTransparency; |
||||
uniform float m_NormalScale; |
||||
uniform float m_R0; |
||||
uniform float m_MaxAmplitude; |
||||
uniform vec3 m_LightDir; |
||||
uniform vec4 m_LightColor; |
||||
uniform float m_ShoreHardness; |
||||
uniform float m_FoamHardness; |
||||
uniform float m_RefractionStrength; |
||||
uniform vec3 m_FoamExistence; |
||||
uniform vec3 m_ColorExtinction; |
||||
uniform float m_Shininess; |
||||
uniform vec4 m_WaterColor; |
||||
uniform vec4 m_DeepWaterColor; |
||||
uniform vec2 m_WindDirection; |
||||
uniform float m_SunScale; |
||||
uniform float m_WaveScale; |
||||
uniform float m_UnderWaterFogDistance; |
||||
uniform float m_CausticsIntensity; |
||||
|
||||
#ifdef ENABLE_AREA |
||||
uniform vec3 m_Center; |
||||
uniform float m_Radius; |
||||
#endif |
||||
|
||||
|
||||
vec2 scale = vec2(m_WaveScale, m_WaveScale); |
||||
float refractionScale = m_WaveScale; |
||||
|
||||
// Modifies 4 sampled normals. Increase first values to have more |
||||
// smaller "waves" or last to have more bigger "waves" |
||||
const vec4 normalModifier = vec4(3.0, 2.0, 4.0, 10.0); |
||||
// Strength of displacement along normal. |
||||
uniform float m_ReflectionDisplace; |
||||
// Water transparency along eye vector. |
||||
const float visibility = 3.0; |
||||
// foam intensity |
||||
uniform float m_FoamIntensity ; |
||||
|
||||
in vec2 texCoord; |
||||
out vec4 outFragColor; |
||||
|
||||
mat3 MatrixInverse(in mat3 inMatrix){ |
||||
float det = dot(cross(inMatrix[0], inMatrix[1]), inMatrix[2]); |
||||
mat3 T = transpose(inMatrix); |
||||
return mat3(cross(T[1], T[2]), |
||||
cross(T[2], T[0]), |
||||
cross(T[0], T[1])) / det; |
||||
} |
||||
|
||||
|
||||
mat3 computeTangentFrame(in vec3 N, in vec3 P, in vec2 UV) { |
||||
vec3 dp1 = dFdx(P); |
||||
vec3 dp2 = dFdy(P); |
||||
vec2 duv1 = dFdx(UV); |
||||
vec2 duv2 = dFdy(UV); |
||||
|
||||
// solve the linear system |
||||
vec3 dp1xdp2 = cross(dp1, dp2); |
||||
mat2x3 inverseM = mat2x3(cross(dp2, dp1xdp2), cross(dp1xdp2, dp1)); |
||||
|
||||
vec3 T = inverseM * vec2(duv1.x, duv2.x); |
||||
vec3 B = inverseM * vec2(duv1.y, duv2.y); |
||||
|
||||
// construct tangent frame |
||||
float maxLength = max(length(T), length(B)); |
||||
T = T / maxLength; |
||||
B = B / maxLength; |
||||
|
||||
return mat3(T, B, N); |
||||
} |
||||
|
||||
float saturate(in float val){ |
||||
return clamp(val,0.0,1.0); |
||||
} |
||||
|
||||
vec3 saturate(in vec3 val){ |
||||
return clamp(val,vec3(0.0),vec3(1.0)); |
||||
} |
||||
|
||||
vec3 getPosition(in float depth, in vec2 uv){ |
||||
vec4 pos = vec4(uv, depth, 1.0) * 2.0 - 1.0; |
||||
pos = g_ViewProjectionMatrixInverse * pos; |
||||
return pos.xyz / pos.w; |
||||
} |
||||
|
||||
// Function calculating fresnel term. |
||||
// - normal - normalized normal vector |
||||
// - eyeVec - normalized eye vector |
||||
float fresnelTerm(in vec3 normal,in vec3 eyeVec){ |
||||
float angle = 1.0 - max(0.0, dot(normal, eyeVec)); |
||||
float fresnel = angle * angle; |
||||
fresnel = fresnel * fresnel; |
||||
fresnel = fresnel * angle; |
||||
return saturate(fresnel * (1.0 - saturate(m_R0)) + m_R0 - m_RefractionStrength); |
||||
} |
||||
|
||||
vec2 m_FrustumNearFar=vec2(1.0,m_UnderWaterFogDistance); |
||||
const float LOG2 = 1.442695; |
||||
|
||||
vec4 underWater(int sampleNum){ |
||||
|
||||
|
||||
float sceneDepth = fetchTextureSample(m_DepthTexture, texCoord, sampleNum).r; |
||||
vec3 color2 = fetchTextureSample(m_Texture, texCoord, sampleNum).rgb; |
||||
|
||||
vec3 position = getPosition(sceneDepth, texCoord); |
||||
float level = m_WaterHeight; |
||||
|
||||
vec3 eyeVec = position - m_CameraPosition; |
||||
|
||||
// Find intersection with water surface |
||||
vec3 eyeVecNorm = normalize(eyeVec); |
||||
float t = (level - m_CameraPosition.y) / eyeVecNorm.y; |
||||
vec3 surfacePoint = m_CameraPosition + eyeVecNorm * t; |
||||
|
||||
vec2 texC = vec2(0.0); |
||||
|
||||
float cameraDepth = length(m_CameraPosition - surfacePoint); |
||||
texC = (surfacePoint.xz + eyeVecNorm.xz) * scale + m_Time * 0.03 * m_WindDirection; |
||||
float bias = texture(m_HeightMap, texC).r; |
||||
level += bias * m_MaxAmplitude; |
||||
t = (level - m_CameraPosition.y) / eyeVecNorm.y; |
||||
surfacePoint = m_CameraPosition + eyeVecNorm * t; |
||||
eyeVecNorm = normalize(m_CameraPosition - surfacePoint); |
||||
|
||||
// Find normal of water surface |
||||
float normal1 = textureOffset(m_HeightMap, texC, ivec2(-1.0, 0.0)).r; |
||||
float normal2 = textureOffset(m_HeightMap, texC, ivec2( 1.0, 0.0)).r; |
||||
float normal3 = textureOffset(m_HeightMap, texC, ivec2( 0.0, -1.0)).r; |
||||
float normal4 = textureOffset(m_HeightMap, texC, ivec2( 0.0, 1.0)).r; |
||||
|
||||
vec3 myNormal = normalize(vec3((normal1 - normal2) * m_MaxAmplitude,m_NormalScale,(normal3 - normal4) * m_MaxAmplitude)); |
||||
vec3 normal = myNormal*-1.0; |
||||
float fresnel = fresnelTerm(normal, eyeVecNorm); |
||||
|
||||
vec3 refraction = color2; |
||||
#ifdef ENABLE_REFRACTION |
||||
texC = texCoord.xy *sin (fresnel+1.0); |
||||
texC = clamp(texC,0.0,1.0); |
||||
#ifdef RESOLVE_MS |
||||
ivec2 iTexC = ivec2(texC * textureSize(m_Texture)); |
||||
refraction = texelFetch(m_Texture, iTexC, sampleNum).rgb; |
||||
#else |
||||
ivec2 iTexC = ivec2(texC * textureSize(m_Texture, 0)); |
||||
refraction = texelFetch(m_Texture, iTexC, 0).rgb; |
||||
#endif |
||||
#endif |
||||
|
||||
float waterCol = saturate(length(m_LightColor.rgb) / m_SunScale); |
||||
refraction = mix(mix(refraction, m_DeepWaterColor.rgb * waterCol, m_WaterTransparency), m_WaterColor.rgb* waterCol,m_WaterTransparency); |
||||
|
||||
vec3 foam = vec3(0.0); |
||||
#ifdef ENABLE_FOAM |
||||
texC = (surfacePoint.xz + eyeVecNorm.xz * 0.1) * 0.05 + m_Time * 0.05 * m_WindDirection + sin(m_Time * 0.001 + position.x) * 0.005; |
||||
vec2 texCoord2 = (surfacePoint.xz + eyeVecNorm.xz * 0.1) * 0.05 + m_Time * 0.1 * m_WindDirection + sin(m_Time * 0.001 + position.z) * 0.005; |
||||
|
||||
if(m_MaxAmplitude - m_FoamExistence.z> 0.0001){ |
||||
foam += ((texture2D(m_FoamMap, texC) + texture2D(m_FoamMap, texCoord2)) * m_FoamIntensity * m_FoamIntensity * 0.3 * |
||||
saturate((level - (m_WaterHeight + m_FoamExistence.z)) / (m_MaxAmplitude - m_FoamExistence.z))).rgb; |
||||
} |
||||
foam *= m_LightColor.rgb; |
||||
#endif |
||||
|
||||
|
||||
|
||||
vec3 specular = vec3(0.0); |
||||
vec3 color ; |
||||
float fogFactor; |
||||
|
||||
if(position.y>level){ |
||||
#ifdef ENABLE_SPECULAR |
||||
if(step(0.9999,sceneDepth)==1.0){ |
||||
vec3 lightDir=normalize(m_LightDir); |
||||
vec3 mirrorEye = (2.0 * dot(eyeVecNorm, normal) * normal - eyeVecNorm); |
||||
float dotSpec = saturate(dot(mirrorEye.xyz, -lightDir) * 0.5 + 0.5); |
||||
specular = vec3((1.0 - fresnel) * saturate(-lightDir.y) * ((pow(dotSpec, 512.0)) * (m_Shininess * 1.8 + 0.2))); |
||||
specular += specular * 25.0 * saturate(m_Shininess - 0.05); |
||||
specular=specular * m_LightColor.rgb * 100.0; |
||||
} |
||||
#endif |
||||
float fogIntensity= 8.0 * m_WaterTransparency; |
||||
fogFactor = exp2( -fogIntensity * fogIntensity * cameraDepth * 0.03 * LOG2 ); |
||||
fogFactor = clamp(fogFactor, 0.0, 1.0); |
||||
color =mix(m_DeepWaterColor.rgb,refraction,fogFactor); |
||||
specular=specular*fogFactor; |
||||
color = saturate(color + max(specular, foam )); |
||||
}else{ |
||||
vec3 caustics = vec3(0.0); |
||||
#ifdef ENABLE_CAUSTICS |
||||
vec2 windDirection=m_WindDirection; |
||||
texC = (position.xz + eyeVecNorm.xz * 0.1) * 0.05 + m_Time * 0.05 * windDirection + sin(m_Time + position.x) * 0.01; |
||||
vec2 texCoord2 = (position.xz + eyeVecNorm.xz * 0.1) * 0.05 + m_Time * 0.05 * windDirection + sin(m_Time + position.z) * 0.01; |
||||
caustics += (texture2D(m_CausticsMap, texC)+ texture2D(m_CausticsMap, texCoord2)).rgb; |
||||
caustics=saturate(mix(m_WaterColor.rgb,caustics,m_CausticsIntensity)); |
||||
color=mix(color2,caustics,m_CausticsIntensity); |
||||
#else |
||||
color=color2; |
||||
#endif |
||||
|
||||
float fogDepth= (2.0 * m_FrustumNearFar.x) / (m_FrustumNearFar.y + m_FrustumNearFar.x - sceneDepth* (m_FrustumNearFar.y-m_FrustumNearFar.x)); |
||||
float fogIntensity= 18 * m_WaterTransparency; |
||||
fogFactor = exp2( -fogIntensity * fogIntensity * fogDepth * fogDepth * LOG2 ); |
||||
fogFactor = clamp(fogFactor, 0.0, 1.0); |
||||
color =mix(m_DeepWaterColor.rgb,color,fogFactor); |
||||
} |
||||
|
||||
return vec4(color, 1.0); |
||||
} |
||||
|
||||
|
||||
// NOTE: This will be called even for single-sampling |
||||
vec4 main_multiSample(int sampleNum){ |
||||
// If we are underwater let's call the underwater function |
||||
if(m_WaterHeight >= m_CameraPosition.y){ |
||||
#ifdef ENABLE_AREA |
||||
if(isOverExtent(m_CameraPosition, m_Center, m_Radius)){ |
||||
return fetchTextureSample(m_Texture, texCoord, sampleNum); |
||||
} |
||||
#endif |
||||
return underWater(sampleNum); |
||||
} |
||||
|
||||
float sceneDepth = fetchTextureSample(m_DepthTexture, texCoord, sampleNum).r; |
||||
vec3 color2 = fetchTextureSample(m_Texture, texCoord, sampleNum).rgb; |
||||
|
||||
vec3 color = color2; |
||||
vec3 position = getPosition(sceneDepth, texCoord); |
||||
|
||||
#ifdef ENABLE_AREA |
||||
if(isOverExtent(position, m_Center, m_Radius)){ |
||||
return vec4(color2, 1.0); |
||||
} |
||||
#endif |
||||
|
||||
float level = m_WaterHeight; |
||||
|
||||
float isAtFarPlane = step(0.99998, sceneDepth); |
||||
//#ifndef ENABLE_RIPPLES |
||||
// This optimization won't work on NVIDIA cards if ripples are enabled |
||||
if(position.y > level + m_MaxAmplitude + isAtFarPlane * 100.0){ |
||||
|
||||
return vec4(color2, 1.0); |
||||
} |
||||
//#endif |
||||
|
||||
vec3 eyeVec = position - m_CameraPosition; |
||||
float cameraDepth = m_CameraPosition.y - position.y; |
||||
|
||||
// Find intersection with water surface |
||||
vec3 eyeVecNorm = normalize(eyeVec); |
||||
float t = (level - m_CameraPosition.y) / eyeVecNorm.y; |
||||
vec3 surfacePoint = m_CameraPosition + eyeVecNorm * t; |
||||
|
||||
vec2 texC = vec2(0.0); |
||||
int samples = 1; |
||||
#ifdef ENABLE_HQ_SHORELINE |
||||
samples = 10; |
||||
#endif |
||||
|
||||
float biasFactor = 1.0 / samples; |
||||
for (int i = 0; i < samples; i++){ |
||||
texC = (surfacePoint.xz + eyeVecNorm.xz * biasFactor) * scale + m_Time * 0.03 * m_WindDirection; |
||||
|
||||
float bias = texture(m_HeightMap, texC).r; |
||||
|
||||
bias *= biasFactor; |
||||
level += bias * m_MaxAmplitude; |
||||
t = (level - m_CameraPosition.y) / eyeVecNorm.y; |
||||
surfacePoint = m_CameraPosition + eyeVecNorm * t; |
||||
} |
||||
|
||||
float depth = length(position - surfacePoint); |
||||
float depth2 = surfacePoint.y - position.y; |
||||
|
||||
// XXX: HACK ALERT: Increase water depth to infinity if at far plane |
||||
// Prevents "foam on horizon" issue |
||||
// For best results, replace the "100.0" below with the |
||||
// highest value in the m_ColorExtinction vec3 |
||||
depth += isAtFarPlane * 100.0; |
||||
depth2 += isAtFarPlane * 100.0; |
||||
|
||||
eyeVecNorm = normalize(m_CameraPosition - surfacePoint); |
||||
|
||||
// Find normal of water surface |
||||
float normal1 = textureOffset(m_HeightMap, texC, ivec2(-1.0, 0.0)).r; |
||||
float normal2 = textureOffset(m_HeightMap, texC, ivec2( 1.0, 0.0)).r; |
||||
float normal3 = textureOffset(m_HeightMap, texC, ivec2( 0.0, -1.0)).r; |
||||
float normal4 = textureOffset(m_HeightMap, texC, ivec2( 0.0, 1.0)).r; |
||||
|
||||
vec3 myNormal = normalize(vec3((normal1 - normal2) * m_MaxAmplitude,m_NormalScale,(normal3 - normal4) * m_MaxAmplitude)); |
||||
vec3 normal = vec3(0.0); |
||||
|
||||
#ifdef ENABLE_RIPPLES |
||||
texC = surfacePoint.xz * 0.8 + m_WindDirection * m_Time* 1.6; |
||||
mat3 tangentFrame = computeTangentFrame(myNormal, eyeVecNorm, texC); |
||||
vec3 normal0a = normalize(tangentFrame*(2.0 * texture(m_NormalMap, texC).xyz - 1.0)); |
||||
|
||||
texC = surfacePoint.xz * 0.4 + m_WindDirection * m_Time* 0.8; |
||||
tangentFrame = computeTangentFrame(myNormal, eyeVecNorm, texC); |
||||
vec3 normal1a = normalize(tangentFrame*(2.0 * texture(m_NormalMap, texC).xyz - 1.0)); |
||||
|
||||
texC = surfacePoint.xz * 0.2 + m_WindDirection * m_Time * 0.4; |
||||
tangentFrame = computeTangentFrame(myNormal, eyeVecNorm, texC); |
||||
vec3 normal2a = normalize(tangentFrame*(2.0 * texture(m_NormalMap, texC).xyz - 1.0)); |
||||
|
||||
texC = surfacePoint.xz * 0.1 + m_WindDirection * m_Time * 0.2; |
||||
tangentFrame = computeTangentFrame(myNormal, eyeVecNorm, texC); |
||||
vec3 normal3a = normalize(tangentFrame*(2.0 * texture(m_NormalMap, texC).xyz - 1.0)); |
||||
|
||||
normal = normalize(normal0a * normalModifier.x + normal1a * normalModifier.y +normal2a * normalModifier.z + normal3a * normalModifier.w); |
||||
// XXX: Here's another way to fix the terrain edge issue, |
||||
// But it requires GLSL 1.3 and still looks kinda incorrect |
||||
// around edges |
||||
normal = isnan(normal.x) ? myNormal : normal; |
||||
//if (position.y > level){ |
||||
// gl_FragColor = vec4(color2 + normal*0.0001, 1.0); |
||||
// return; |
||||
//} |
||||
#else |
||||
normal = myNormal; |
||||
#endif |
||||
|
||||
vec3 refraction = color2; |
||||
#ifdef ENABLE_REFRACTION |
||||
// texC = texCoord.xy+ m_ReflectionDisplace * normal.x; |
||||
texC = texCoord.xy; |
||||
texC += sin(m_Time*1.8 + 3.0 * abs(position.y))* (refractionScale * min(depth2, 1.0)); |
||||
texC = clamp(texC,vec2(0.0),vec2(0.999)); |
||||
#ifdef RESOLVE_MS |
||||
ivec2 iTexC = ivec2(texC * textureSize(m_Texture)); |
||||
refraction = texelFetch(m_Texture, iTexC, sampleNum).rgb; |
||||
#else |
||||
ivec2 iTexC = ivec2(texC * textureSize(m_Texture, 0)); |
||||
refraction = texelFetch(m_Texture, iTexC, 0).rgb; |
||||
#endif |
||||
#endif |
||||
|
||||
vec3 waterPosition = surfacePoint.xyz; |
||||
waterPosition.y -= (level - m_WaterHeight); |
||||
vec4 texCoordProj = m_TextureProjMatrix * vec4(waterPosition, 1.0); |
||||
|
||||
texCoordProj.x = texCoordProj.x + m_ReflectionDisplace * normal.x; |
||||
texCoordProj.z = texCoordProj.z + m_ReflectionDisplace * normal.z; |
||||
texCoordProj /= texCoordProj.w; |
||||
texCoordProj.y = 1.0 - texCoordProj.y; |
||||
|
||||
vec3 reflection = texture(m_ReflectionMap, texCoordProj.xy).rgb; |
||||
|
||||
float fresnel = fresnelTerm(normal, eyeVecNorm); |
||||
|
||||
float depthN = depth * m_WaterTransparency; |
||||
float waterCol = saturate(length(m_LightColor.rgb) / m_SunScale); |
||||
refraction = mix(mix(refraction, m_WaterColor.rgb * waterCol, saturate(depthN / visibility)), |
||||
m_DeepWaterColor.rgb * waterCol, saturate(depth2 / m_ColorExtinction)); |
||||
|
||||
|
||||
|
||||
|
||||
vec3 foam = vec3(0.0); |
||||
#ifdef ENABLE_FOAM |
||||
texC = (surfacePoint.xz + eyeVecNorm.xz * 0.1) * 0.05 + m_Time * 0.05 * m_WindDirection + sin(m_Time * 0.001 + position.x) * 0.005; |
||||
vec2 texCoord2 = (surfacePoint.xz + eyeVecNorm.xz * 0.1) * 0.05 + m_Time * 0.1 * m_WindDirection + sin(m_Time * 0.001 + position.z) * 0.005; |
||||
|
||||
if(depth2 < m_FoamExistence.x){ |
||||
foam = (texture2D(m_FoamMap, texC).r + texture2D(m_FoamMap, texCoord2)).rgb * vec3(m_FoamIntensity); |
||||
}else if(depth2 < m_FoamExistence.y){ |
||||
foam = mix((texture2D(m_FoamMap, texC) + texture2D(m_FoamMap, texCoord2)) * m_FoamIntensity , vec4(0.0), |
||||
(depth2 - m_FoamExistence.x) / (m_FoamExistence.y - m_FoamExistence.x)).rgb; |
||||
} |
||||
|
||||
|
||||
if(m_MaxAmplitude - m_FoamExistence.z> 0.0001){ |
||||
foam += ((texture2D(m_FoamMap, texC) + texture2D(m_FoamMap, texCoord2)) * m_FoamIntensity * m_FoamIntensity * 0.3 * |
||||
saturate((level - (m_WaterHeight + m_FoamExistence.z)) / (m_MaxAmplitude - m_FoamExistence.z))).rgb; |
||||
} |
||||
foam *= m_LightColor.rgb; |
||||
#endif |
||||
|
||||
vec3 specular = vec3(0.0); |
||||
#ifdef ENABLE_SPECULAR |
||||
vec3 lightDir=normalize(m_LightDir); |
||||
vec3 mirrorEye = (2.0 * dot(eyeVecNorm, normal) * normal - eyeVecNorm); |
||||
float dotSpec = saturate(dot(mirrorEye.xyz, -lightDir) * 0.5 + 0.5); |
||||
specular = vec3((1.0 - fresnel) * saturate(-lightDir.y) * ((pow(dotSpec, 512.0)) * (m_Shininess * 1.8 + 0.2))); |
||||
specular += specular * 25.0 * saturate(m_Shininess - 0.05); |
||||
//foam does not shine |
||||
specular=specular * m_LightColor.rgb - (5.0 * foam); |
||||
#endif |
||||
|
||||
color = mix(refraction, reflection, fresnel); |
||||
color = mix(refraction, color, saturate(depth * m_ShoreHardness)); |
||||
color = saturate(color + max(specular, foam )); |
||||
color = mix(refraction, color, saturate(depth* m_FoamHardness)); |
||||
|
||||
|
||||
// XXX: HACK ALERT: |
||||
// We trick the GeForces to think they have |
||||
// to calculate the derivatives for all these pixels by using step()! |
||||
// That way we won't get pixels around the edges of the terrain, |
||||
// Where the derivatives are undefined |
||||
return vec4(mix(color, color2, step(level, position.y)), 1.0); |
||||
} |
||||
|
||||
void main(){ |
||||
#ifdef RESOLVE_MS |
||||
vec4 color = vec4(0.0); |
||||
for (int i = 0; i < m_NumSamples; i++){ |
||||
color += main_multiSample(i); |
||||
} |
||||
outFragColor = color / m_NumSamples; |
||||
#else |
||||
outFragColor = main_multiSample(0); |
||||
#endif |
||||
} |
||||
Loading…
Reference in new issue