99 lines
No EOL
2.5 KiB
GLSL
99 lines
No EOL
2.5 KiB
GLSL
// Simple Water shader. (c) Victor Korsun, bitekas@gmail.com; 2012.
|
|
//
|
|
// Attribution-ShareAlike CC License.
|
|
|
|
#ifdef GL_ES
|
|
precision highp float;
|
|
#endif
|
|
|
|
const float PI = 3.1415926535897932;
|
|
|
|
// play with these parameters to custimize the effect
|
|
// ===================================================
|
|
|
|
//speed
|
|
uniform float speed = 0.15;
|
|
uniform float speed_x = 0.3;
|
|
uniform float speed_y = 0.3;
|
|
|
|
//velocity
|
|
uniform vec2 velocity = {0.0, 0.0};
|
|
|
|
// refraction
|
|
const float emboss = 2.5;
|
|
const float intensity = 3;
|
|
const int steps = 5;
|
|
const float frequency = 3;
|
|
const int angle = 7; // better when a prime
|
|
|
|
// reflection
|
|
const float delta = 50.;
|
|
const float intence = 10.;
|
|
|
|
const float reflectionCutOff = 0.012;
|
|
const float reflectionIntence = 200000.;
|
|
|
|
// ===================================================
|
|
|
|
float time = iGlobalTime*1.3;
|
|
|
|
float col(vec2 coord) {
|
|
float delta_theta = 2.0 * PI / float(angle);
|
|
float col = 0.0;
|
|
float theta = 0.0;
|
|
for (int i = 0; i < steps; i++) {
|
|
vec2 adjc = coord;
|
|
theta = delta_theta*float(i);
|
|
adjc.x += cos(theta)*time*speed + time * speed_x;
|
|
adjc.y -= sin(theta)*time*speed - time * speed_y;
|
|
col = col + cos((adjc.x*cos(theta) - adjc.y*sin(theta))*frequency)*intensity;
|
|
}
|
|
|
|
return cos(col);
|
|
}
|
|
|
|
//---------- main
|
|
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 p = (fragCoord.xy) / iResolution.xy, c1 = p, c2 = p;
|
|
|
|
float cc1 = col(c1);
|
|
|
|
c2.x += iResolution.x/delta;
|
|
float dx = emboss*(cc1-col(c2))/delta;
|
|
|
|
c2.x = p.x;
|
|
c2.y += iResolution.y / delta;
|
|
float dy = emboss*(cc1-col(c2))/delta;
|
|
|
|
c1.x += dx*2.;
|
|
c1.y = -(c1.y+dy*2.);
|
|
|
|
float alpha = 1.+dot(dx,dy)*intence;
|
|
|
|
float ddx = dx - reflectionCutOff;
|
|
float ddy = dy - reflectionCutOff;
|
|
if (ddx > 0. && ddy > 0.) {
|
|
alpha = pow(alpha, ddx * ddy * reflectionIntence);
|
|
}
|
|
//
|
|
c1 /= 4.0;
|
|
//
|
|
vec4 col = texture(iChannel0, c1) * (alpha);
|
|
fragColor = col;
|
|
}
|
|
|
|
|
|
float getProceduralColors(inout vec3 diffuse, inout vec3 specular, inout float shininess) {
|
|
vec2 position = _position.xz;
|
|
position += 0.5;
|
|
position.x += time * velocity.x;
|
|
position.y += time * velocity.y;
|
|
position.y = 1.0 - position.y;
|
|
vec4 pixelColor;
|
|
mainImage(pixelColor, position * iWorldScale.xz);
|
|
|
|
diffuse = pixelColor.rgb; // Return 0.0 and color in diffuse for a lit surface
|
|
specular = pixelColor.rgb; // or return 1.0 and color in specular for unlit surface.
|
|
return 1.0;
|
|
} |