0d14e5a379
Needs a lot of cleanup. Data has been de-duplicated, and where identical copies existed, one of them has been replaced with a symlink. Some files have been excluded, such as binaries, installers and debug dumps. Some of that may still be present.
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 = vec2(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;
|
|
} |