122 lines
No EOL
3 KiB
GLSL
122 lines
No EOL
3 KiB
GLSL
/**
|
|
Just fooling around basicly. Some sort of bloodstream.
|
|
*/
|
|
|
|
|
|
// http://iquilezles.org/www/articles/smin/smin.htm
|
|
float smin( float a, float b, float k )
|
|
{
|
|
float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
|
|
return mix( b, a, h ) - k*h*(1.0-h);
|
|
}
|
|
|
|
float cells(vec2 uv){ // Trimmed down.
|
|
uv = mix(sin(uv + vec2(1.57, 0)), sin(uv.yx*1.4 + vec2(1.57, 0)), .75);
|
|
return uv.x*uv.y*.3 + .7;
|
|
}
|
|
|
|
/*
|
|
float cells(vec2 uv)
|
|
{
|
|
float sx = cos(uv.x);
|
|
float sy = sin(uv.y);
|
|
sx = mix(sx, cos(uv.y * 1.4), .75);
|
|
sy = mix(sy, sin(uv.x * 1.4), .75);
|
|
return .3 * (sx * sy) + .7;
|
|
}
|
|
*/
|
|
|
|
const float BEAT = 4.0;
|
|
float fbm(vec2 uv)
|
|
{
|
|
|
|
float f = 200.0;
|
|
vec2 r = (vec2(.9, .45));
|
|
vec2 tmp;
|
|
float T = 100.0 + iGlobalTime * 1.3;
|
|
T += sin(iGlobalTime * BEAT) * .1;
|
|
// layers of cells with some scaling and rotation applied.
|
|
for (int i = 1; i < 8; ++i)
|
|
{
|
|
float fi = float(i);
|
|
uv.y -= T * .5;
|
|
uv.x -= T * .4;
|
|
tmp = uv;
|
|
|
|
uv.x = tmp.x * r.x - tmp.y * r.y;
|
|
uv.y = tmp.x * r.y + tmp.y * r.x;
|
|
float m = cells(uv);
|
|
f = smin(f, m, .07);
|
|
}
|
|
return 1. - f;
|
|
}
|
|
|
|
vec3 g(vec2 uv)
|
|
{
|
|
vec2 off = vec2(0.0, .03);
|
|
float t = fbm(uv);
|
|
float x = t - fbm(uv + off.yx);
|
|
float y = t - fbm(uv + off);
|
|
float s = .0025;
|
|
vec3 xv = vec3(s, x, 0);
|
|
vec3 yv = vec3(0, y, s);
|
|
return normalize(cross(xv, -yv)).xzy;
|
|
}
|
|
|
|
vec3 ld = normalize(vec3(1.0, 2.0, 3.));
|
|
|
|
void mainImage( out vec4 fragColor, in vec2 fragCoord )
|
|
{
|
|
|
|
vec2 iResolution;
|
|
iResolution.x=7.0;
|
|
iResolution.y=7.0;
|
|
|
|
|
|
|
|
|
|
vec2 uv = fragCoord.xy / iResolution.xy;
|
|
uv -= vec2(0.5);
|
|
float a = iResolution.x / iResolution.y;
|
|
uv.y /= a;
|
|
vec2 ouv = uv;
|
|
float B = sin(iGlobalTime * BEAT);
|
|
uv = mix(uv, uv * sin(B), .035);
|
|
vec2 _uv = uv * 25.;
|
|
float f = fbm(_uv);
|
|
|
|
// base color
|
|
fragColor = vec4(f);
|
|
fragColor.rgb *= vec3(1., .3 + B * .05, 0.1 + B * .05);
|
|
|
|
vec3 v = normalize(vec3(uv, 1.));
|
|
vec3 grad = g(_uv);
|
|
|
|
// spec
|
|
vec3 H = normalize(ld + v);
|
|
float S = max(0., dot(grad, H));
|
|
S = pow(S, 4.0) * .2;
|
|
fragColor.rgb += S * vec3(.4, .7, .7);
|
|
// rim
|
|
float R = 1.0 - clamp(dot(grad, v), .0, 1.);
|
|
fragColor.rgb = mix(fragColor.rgb, vec3(.8, .8, 1.), smoothstep(-.2, 2.9, R));
|
|
// edges
|
|
fragColor.rgb = mix(fragColor.rgb, vec3(0.), smoothstep(.45, .55, (max(abs(ouv.y * a), abs(ouv.x)))));
|
|
|
|
// contrast
|
|
fragColor = smoothstep(.0, 1., fragColor);
|
|
}
|
|
|
|
float getProceduralColors(inout vec3 diffuse, inout vec3 specular, inout float shininess)
|
|
{
|
|
vec2 position = _position.xz;
|
|
position += 0.5;
|
|
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
|
|
// return 0.0;
|
|
specular = pixelColor.rgb; // or return 1.0 and color in specular for unlit surface.
|
|
return 1.0;
|
|
} |