111 lines
3.6 KiB
GLSL
111 lines
3.6 KiB
GLSL
// credits: https://github.com/rymdlego
|
|
|
|
const float speed = 0.2;
|
|
const float cube_size = 1.0;
|
|
const float cube_brightness = 1.0;
|
|
const float cube_rotation_speed = 2.8;
|
|
const float camera_rotation_speed = 0.1;
|
|
|
|
mat3 rotationMatrix(vec3 m, float a) {
|
|
m = normalize(m);
|
|
float c = cos(a), s = sin(a);
|
|
return mat3(c + (1. - c) * m.x * m.x,
|
|
(1. - c) * m.x * m.y - s * m.z,
|
|
(1. - c) * m.x * m.z + s * m.y,
|
|
(1. - c) * m.x * m.y + s * m.z,
|
|
c + (1. - c) * m.y * m.y,
|
|
(1. - c) * m.y * m.z - s * m.x,
|
|
(1. - c) * m.x * m.z - s * m.y,
|
|
(1. - c) * m.y * m.z + s * m.x,
|
|
c + (1. - c) * m.z * m.z);
|
|
}
|
|
|
|
float sphere(vec3 pos, float radius)
|
|
{
|
|
return length(pos) - radius;
|
|
}
|
|
|
|
float box(vec3 pos, vec3 size)
|
|
{
|
|
float t = iTime;
|
|
pos = pos * 0.9 * rotationMatrix(vec3(sin(t / 4.0 * speed) * 10., cos(t / 4.0 * speed) * 12., 2.7), t * 2.4 / 4.0 * speed * cube_rotation_speed);
|
|
return length(max(abs(pos) - size, 0.0));
|
|
}
|
|
|
|
float distfunc(vec3 pos)
|
|
{
|
|
float t = iTime;
|
|
|
|
float size = 0.45 + 0.25 * abs(16.0 * sin(t * speed / 4.0));
|
|
// float size = 2.3 + 1.8*tan((t-5.4)*6.549);
|
|
size = cube_size * 0.16 * clamp(size, 2.0, 4.0);
|
|
|
|
//pos = pos * rotationMatrix(vec3(0.,-3.,0.7), 3.3 * mod(t/30.0, 4.0));
|
|
vec3 q = mod(pos, 5.0) - 2.5;
|
|
float obj1 = box(q, vec3(size));
|
|
return obj1;
|
|
}
|
|
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord)
|
|
{
|
|
float t = iTime;
|
|
vec2 screenPos = -1.0 + 2.0 * fragCoord.xy / iResolution.xy;
|
|
screenPos.x *= iResolution.x / iResolution.y;
|
|
vec3 cameraOrigin = vec3(t * 1.0 * speed, 0.0, 0.0);
|
|
// vec3 cameraOrigin = vec3(t*1.8*speed, 3.0+t*0.02*speed, 0.0);
|
|
vec3 cameraTarget = vec3(t * 100., 0.0, 0.0);
|
|
cameraTarget = vec3(t * 20.0, 0.0, 0.0) * rotationMatrix(vec3(0.0, 0.0, 1.0), t * speed * camera_rotation_speed);
|
|
|
|
vec3 upDirection = vec3(0.5, 1.0, 0.6);
|
|
|
|
vec3 cameraDir = normalize(cameraTarget - cameraOrigin);
|
|
vec3 cameraRight = normalize(cross(upDirection, cameraOrigin));
|
|
vec3 cameraUp = cross(cameraDir, cameraRight);
|
|
|
|
vec3 rayDir = normalize(cameraRight * screenPos.x + cameraUp * screenPos.y + cameraDir);
|
|
|
|
const int MAX_ITER = 16;
|
|
const float MAX_DIST = 48.0;
|
|
const float EPSILON = 0.01;
|
|
|
|
float totalDist = 0.0;
|
|
vec3 pos = cameraOrigin;
|
|
float dist = EPSILON;
|
|
|
|
for (int i = 0; i < MAX_ITER; i++)
|
|
{
|
|
if (dist < EPSILON || totalDist > MAX_DIST)
|
|
break;
|
|
dist = distfunc(pos);
|
|
totalDist += dist;
|
|
pos += dist * rayDir;
|
|
}
|
|
|
|
vec4 cubes;
|
|
|
|
if (dist < EPSILON)
|
|
{
|
|
// Lighting Code
|
|
vec2 eps = vec2(0.0, EPSILON);
|
|
vec3 normal = normalize(vec3(
|
|
distfunc(pos + eps.yxx) - distfunc(pos - eps.yxx),
|
|
distfunc(pos + eps.xyx) - distfunc(pos - eps.xyx),
|
|
distfunc(pos + eps.xxy) - distfunc(pos - eps.xxy)));
|
|
float diffuse = max(0., dot(-rayDir, normal));
|
|
float specular = pow(diffuse, 32.0);
|
|
vec3 color = vec3(diffuse + specular);
|
|
vec3 cubeColor = vec3(abs(screenPos), 0.5 + 0.5 * sin(t * 2.0)) * 0.8;
|
|
cubeColor = mix(cubeColor.rgb, vec3(0.0, 0.0, 0.0), 1.0);
|
|
color += cubeColor;
|
|
cubes = vec4(color, 1.0) * vec4(1.0 - (totalDist / MAX_DIST));
|
|
cubes = vec4(cubes.rgb * 0.02 * cube_brightness, 0.1);
|
|
}
|
|
else {
|
|
cubes = vec4(0.0);
|
|
}
|
|
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec4 terminalColor = texture(iChannel0, uv);
|
|
vec3 blendedColor = terminalColor.rgb + cubes.rgb;
|
|
fragColor = vec4(blendedColor, terminalColor.a);
|
|
}
|