#extension OES_standard_derivatives : enable precision highp float; uniform vec2 resolution; uniform float time; uniform vec2 mouse; uniform sampler2D backbuffer; #define iTime time #define iResolution resolution //#define AA /******************** 3D toolkit ********************/ const float PI = 3.141592653; struct Camera { vec3 position; vec3 direction; vec3 up_direction; // not require dot(direction, up_direction) == 0 float fov; float aspect; // x / y }; struct Ray { vec3 origin; vec3 direction; }; Camera newCamera(vec3 position, vec3 direction, vec3 up_direction, float fov, float aspect) { Camera camera; camera.position = position; camera.direction = direction; camera.up_direction = up_direction; camera.fov = fov; camera.aspect = aspect; return camera; } // perspective camera ray, uv = fragCoord / iResolution.xy // cf: https://qiita.com/aa_debdeb/items/301dfc54788f1219b554 Ray cameraRay(in Camera camera, in vec2 uv) { uv = uv * 2.0 - 1.0; float h = tan(camera.fov * 0.5); float w = h * camera.aspect; vec3 right = normalize(cross(camera.direction, camera.up_direction)); vec3 up = normalize(cross(right, camera.direction)); vec3 direction = normalize(right * w * uv.x + up * h * uv.y + camera.direction); Ray ray; ray.origin = camera.position; ray.direction = direction; return ray; } float microfacet(vec3 normal, vec3 cameraDir, vec3 lightDir, float metal, float roughness) { vec3 middle = normalize(cameraDir + lightDir); float dotCN = clamp(-dot(cameraDir, normal), 0.0, 1.0); float dotLN = clamp(-dot(lightDir, normal), 0.0, 1.0); float dotNM = clamp(-dot(normal, middle), 0.0, 1.0); float dotCM = clamp(dot(cameraDir, middle), 0.0, 1.0); float alpha = roughness * roughness; // diffuse BRDF float diffuse = 1.0 - metal; // microfacet distribution float alpha2 = alpha * alpha; float tmp = 1.0 - dotNM * dotNM * (1.0 - alpha2); float distribution = alpha2 / (tmp * tmp); // schlick approxy & geometric decay float alp = alpha * 0.5; float sal = dotLN / (dotLN * (1.0 - alp) + alp); float sac = dotCN / (dotCN * (1.0 - alp) + alp); float decay = sal * sac; // fresnel float c = 1.0 - dotCM; c = c * c * c * c * c; float fresnel = metal + (1.0 - metal) * c; // specular BRDF tmp = 4.0 * dotCN * dotLN; float specular = distribution * decay / tmp * fresnel; if (tmp < 0.0001) specular = 0.0; return (diffuse + specular) * dotLN; } /******************** Basic Math ********************/ #define rotate3D(axis, angle) mat3(\ axis[0] * axis[0] * (1.0 - cos(angle)) + cos(angle),\ axis[0] * axis[1] * (1.0 - cos(angle)) + axis[2] * sin(angle),\ axis[0] * axis[2] * (1.0 - cos(angle)) - axis[1] * sin(angle),\ axis[0] * axis[1] * (1.0 - cos(angle)) - axis[2] * sin(angle),\ axis[1] * axis[1] * (1.0 - cos(angle)) + cos(angle),\ axis[1] * axis[2] * (1.0 - cos(angle)) + axis[0] * sin(angle),\ axis[0] * axis[2] * (1.0 - cos(angle)) + axis[1] * sin(angle),\ axis[1] * axis[2] * (1.0 - cos(angle)) - axis[0] * sin(angle),\ axis[2] * axis[2] * (1.0 - cos(angle)) + cos(angle)\ ) mat3 transpose(mat3 mat) { float a = mat[0][1]; mat[0][1] = mat[1][0]; mat[1][0] = a; a = mat[0][2]; mat[0][2] = mat[2][0]; mat[2][0] = a; a = mat[1][2]; mat[1][2] = mat[2][1]; mat[2][1] = a; return mat; } /******************** hash & noise ********************/ // Hash without Sine https://www.shadertoy.com/view/4djSRW float hash11(float p) { p = fract(p * .1031); p *= p + 33.33; p *= p + p; return fract(p); } float hash12(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * .1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); } vec3 hash31(float p) { vec3 p3 = fract(vec3(p) * vec3(.1031, .1030, .0973)); p3 += dot(p3, p3.yzx+33.33); return fract((p3.xxy+p3.yzz)*p3.zyx); } vec3 hash32(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973)); p3 += dot(p3, p3.yxz+33.33); return fract((p3.xxy+p3.yzz)*p3.zyx); } #define three_mix(a0, a1, a2, t) (\ a0 * (1.0 - t) * (1.0 - t) * 0.5\ + a1 * ((t + 1.0) * (1.0 - t) + t * (2.0 - t)) * 0.5\ + a2 * t * t * 0.5\ ) #define DEFINE_ONE_DIM_NOISE(type, noise, smoothnoise, hash) \ type noise(float p) { \ float t = fract(p); \ p = floor(p) + 1.465; \ return mix(hash(p), hash(p + 1.0), t); \ } \ type smoothnoise(float p) { \ float t = fract(p); \ p = floor(p) + 1.465; \ return three_mix(hash(p - 2.0), hash(p - 1.0), hash(p), t); \ } DEFINE_ONE_DIM_NOISE(float, noise11, smoothnoise11, hash11) DEFINE_ONE_DIM_NOISE(vec3, noise31, smoothnoise31, hash31) #define DEFINE_TWO_DIM_NOISE(type, noise, smoothnoise, hash) \ type noise(vec2 p) { \ vec2 t = fract(p); \ p = floor(p) + vec2(1.365, -0.593); \ vec2 e = vec2(0, 1); \ return mix( \ mix(hash(p + e.xx), hash(p + e.yx), t.x), \ mix(hash(p + e.yx), hash(p + e.yy), t.x), \ t.y \ ); \ } \ type smoothnoise(vec2 p) { \ vec2 t = fract(p); \ p = floor(p) + vec2(1.365, -0.593); \ vec3 e = vec3(0, 1, 2); \ return three_mix( \ three_mix(hash(p - e.zz), hash(p - e.yz), hash(p - e.xz), t.x), \ three_mix(hash(p - e.zy), hash(p - e.yy), hash(p - e.xy), t.x), \ three_mix(hash(p - e.zx), hash(p - e.yx), hash(p - e.xx), t.x), \ t.y \ ); \ } DEFINE_TWO_DIM_NOISE(float, noise12, smoothnoise12, hash12) DEFINE_TWO_DIM_NOISE(vec3, noise32, smoothnoise32, hash32) float fbm113( in float x, in float H ) { float G = exp2(-H); float f = 1.0; float a = 1.0; float t = 0.0; for( int i = 0; i < 3; i++ ) { t += a*noise11(f*x); f *= 2.0; a *= G; } return t; } float smoothfbm125( in vec2 x, in float H ) { float G = exp2(-H); float f = 1.0; float a = 1.0; float t = 0.0; for( int i=0; i < 5; i++ ) { t += a*smoothnoise12(f*x); f *= 2.0; a *= G; } return t; } /******************** Primitive SDF ********************/ // https://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm float sdBox( vec3 p, vec3 b ) { vec3 q = abs(p) - b; return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0); } float sdCylinder( vec3 p, float r, float h ) { vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(r,h); return min(max(d.x,d.y),0.0) + length(max(d,0.0)); } float sdCone( in vec3 p, in float angle, float h ) { vec2 q = h*vec2(tan(angle),-1.0); vec2 w = vec2( length(p.xz), p.y ); vec2 a = w - q*clamp( dot(w,q)/dot(q,q), 0.0, 1.0 ); vec2 b = w - q*vec2( clamp( w.x/q.x, 0.0, 1.0 ), 1.0 ); float k = sign( q.y ); float d = min(dot( a, a ),dot(b, b)); float s = max( k*(w.x*q.y-w.y*q.x),k*(w.y-q.y) ); return sqrt(d)*sign(s); } // r0 > r1 float sdTrape(in vec3 p, in float r0, in float r1, in float h) { float theta = atan((r0 - r1), h); float x = r0 * h / (r0 - r1); return max(sdCone(p - vec3(0, x, 0), theta, x), p.y - h); } float opSmoothUnion( float d1, float d2, float k ) { float h = clamp( 0.5 + 0.5*(d2-d1)/k, 0.0, 1.0 ); return mix( d2, d1, h ) - k*h*(1.0-h); } // Copyright © 2021 IWBTShyGuy // Attribution 4.0 International (CC BY 4.0) /******************** Config ********************/ const vec3 CAMERA_POSITION = vec3(-2, -2, 6); const vec3 CAMERA_DIRECTION = vec3(0.5, 0.25, -1.5); // <- will normalized const float CAMERA_AMP = 0.005; const float FAR = length(CAMERA_POSITION) * 2.0; // the main wall is always the plane z = 0 // light const float LIGHT_SCALE = 1.5; const mat3 LIGHT_ROTATE = rotate3D(vec3(1, 0, 0), PI/2.0); // LIGHT_DISP does not exist. Light is always at the origin. // shower base const float BASE_SCALE = 0.5; const mat3 BASE_ROTATE = rotate3D(vec3(0, 0, 1), PI / 2.0) * rotate3D(vec3(1, 0, 0), PI / 2.0); const vec3 BASE_DISP = vec3(-1.2, -1.7, 0); // shower const float SHOWER_SCALE = 0.6; const mat3 SHOWER_ROTATE = rotate3D(vec3(1, 0, 0), PI / 6.0) * rotate3D(vec3(0, 0, 1), -PI / 2.0) * rotate3D(vec3(1, 0, 0), -PI / 2.0); const vec3 SHOWER_DISP = vec3(-1.2, -1.4, 0.21); const float SHOWER_HOLE_RADIUS = 6.0; const float SHOWER_HOLE_THETA = 20.0; // mirror const vec3 MIRROR_DISP = vec3(2, -3.5, 0); // Mirror is easy to model and directly tweak the SDF for scale and rotation. // hanger const float HANGER_SCALE = 1.0; const mat3 HANGER_ROTATE = rotate3D(vec3(0, 0, 1), PI / 2.0) * rotate3D(vec3(0, 1, 0), PI / 2.0); const vec3 HANGER_DISP = vec3(4.5, -2.2, 2.5); // after effect const float LIGHT_FLICKER = 0.1; const float STEAM = 0.025; /******************** Object SDFs ********************/ float sdWall(in vec3 p) { return p.z; } float sdLight(in vec3 p) { vec3 q; // temporary q = p - vec3(0, 0.05, 0.0); float base = sdCylinder(q, 0.3, 0.05); q = p - vec3(0, 0.3, 0.0); float head = sdCylinder(q, 0.4, 0.15) - 0.05; return min(base, head); } float sdShowerBase(in vec3 p) { vec3 q; // temporary float dist = sdTrape(p, 0.4, 0.3, 0.5); q = rotate3D(vec3(0, 0, 1), PI / 2.0) * (p - vec3(0, 0.35, 0)); dist = max(dist, -sdCylinder(q, 0.2, 1.0)); return dist - 0.005; } float sdShower(in vec3 p) { vec3 q; // temporary // shower head q = p + vec3(0.3, 0, 0); float head = sdCylinder(q, 0.5, 0.1) - 0.1; // shower nozzle q = rotate3D(vec3(0,0,1), PI/1.5) * (p - vec3(0.15, 0, 0)); float nozzle = sdTrape(q, 0.2, 0.1, 0.4); q = rotate3D(vec3(0, 0, 1), PI / 1.5) * (p - vec3(0.9, -0.43, 0)) - vec3(0, 1, 0); float hose = sdCylinder(q, 0.1, 2.0); return opSmoothUnion(opSmoothUnion(head, nozzle, 0.05), hose, 0.05); } float sdMirror(in vec3 p) { float dist = sdBox(p, vec3(1, 2, 0.1)) - 0.1; dist = max(dist, p.z - 0.1); return dist; } float sdRightWall(in vec3 p) { return 4.5 - p.x; } float sdHanger(in vec3 p) { vec3 q; // temporary float dist = 100.0; q = p - vec3(-2, 0, 0); dist = min(dist, sdCylinder(q, 0.1, 0.3) - 0.1); q = p - vec3(2, 0, 0); dist = min(dist, sdCylinder(q, 0.1, 0.3) - 0.1); q = rotate3D(vec3(0, 0, 1), PI / 2.0) * (p - vec3(0, 0.2, 0)); dist = min(dist, sdCylinder(q, 0.1, 2.0)); return dist; } /******************** Macro utility ********************/ #define DEF_RAYMARCHING(raymarch, sDist, LOOP_MAX) \ float raymarch(in Ray ray) {\ float dist = 0.0;\ for (int i = 0; i < LOOP_MAX; i++) {\ vec3 p = ray.origin + dist * ray.direction;\ float dist0 = sDist(p);\ if (dist0 < 1.0e-6 || dist > FAR) break;\ dist += dist0;\ }\ return dist;\ } // Take a sample point from the surface of the light and average it. #define DEF_SURFACE_LIGHTING(color, colorOneLight) \ vec3 color(in vec3 p, in Ray ray, in vec3 normal) {\ int index = objectIndex(p);\ float lightRadius = 0.4 * LIGHT_SCALE;\ float lightDistance = length(p.xy);\ float theta = acos(lightRadius / lightDistance);\ vec3 col = vec3(0);\ const int U_SAMPLE = 5;\ const int V_SAMPLE = 3;\ for (int i = 0; i < U_SAMPLE; i++) {\ float u = float(i) / float(U_SAMPLE - 1);\ u = theta * (2.0 * u - 1.0);\ float cu = cos(u), su = sin(u);\ mat2 mat = mat2(cu, su, -su, cu);\ vec2 lpb = mat * normalize(p.xy) * lightRadius;\ for (int j = 0; j < V_SAMPLE; j++) {\ float h = float(j) / float(V_SAMPLE - 1);\ h = (0.1 + 0.4 * h) * LIGHT_SCALE;\ col += colorOneLight(p, ray, normal, vec3(lpb, h));\ }\ }\ return col / float(U_SAMPLE * V_SAMPLE);\ } /******************** Global SDF ********************/ float sDist(in vec3 p) { vec3 q; // temporary float dist = sdWall(p); q = transpose(LIGHT_ROTATE) * p / LIGHT_SCALE; dist = min(dist, sdLight(q) * LIGHT_SCALE); q = transpose(BASE_ROTATE) * (p - BASE_DISP) / BASE_SCALE; dist = min(dist, sdShowerBase(q) * BASE_SCALE); q = transpose(SHOWER_ROTATE) * (p - SHOWER_DISP) / SHOWER_SCALE; dist = min(dist, sdShower(q) * SHOWER_SCALE); q = p - MIRROR_DISP; dist = min(dist, sdMirror(q)); dist = min(dist, sdRightWall(p)); q = transpose(HANGER_ROTATE) * (p - HANGER_DISP) / HANGER_SCALE; dist = min(dist, sdHanger(q) * HANGER_SCALE); return dist; } DEF_RAYMARCHING(raymarch, sDist, 256) vec3 calcNormal(in vec3 p) { const vec2 e = vec2(0, 1.0e-4); return normalize(vec3( sDist(p + e.yxx) - sDist(p - e.yxx), sDist(p + e.xyx) - sDist(p - e.xyx), sDist(p + e.xxy) - sDist(p - e.xxy) )); } /******************** coloring ********************/ int objectIndex(in vec3 p) { vec3 q; float dist = sdWall(p); if (dist < 1.0e-5) return 0; q = transpose(LIGHT_ROTATE) * p / LIGHT_SCALE; dist = sdLight(q) * LIGHT_SCALE; if (dist < 1.0e-5) return 1; q = transpose(BASE_ROTATE) * (p - BASE_DISP) / BASE_SCALE; dist = sdShowerBase(q) * BASE_SCALE; if (dist < 1.0e-5) return 2; q = transpose(SHOWER_ROTATE) * (p - SHOWER_DISP) / SHOWER_SCALE; dist = sdShower(q) * SHOWER_SCALE; if (dist < 1.0e-5) return 3; q = p - MIRROR_DISP; dist = sdMirror(q); if (dist < 1.0e-5) return 4; dist = sdRightWall(p); if (dist < 1.0e-5) return 5; q = transpose(HANGER_ROTATE) * (p - HANGER_DISP) / HANGER_SCALE; dist = sdHanger(q) * HANGER_SCALE; if (dist < 1.0e-5) return 6; return 7; } vec3 colWallOneLight(in vec3 p, in Ray ray, in vec3 normal, in vec3 lightPos) { vec3 lightDir = normalize(p - lightPos); float c = microfacet(normal, ray.direction, lightDir, 0.1, 0.8); float shadow = 1.0, dist = 0.01, lightDist = distance(p, lightPos), k = 2.0; for (int i = 0; i < 32; i++) { vec3 p0 = p - dist * lightDir; float dist0; vec3 q; q = transpose(BASE_ROTATE) * (p0 - BASE_DISP) / BASE_SCALE; dist0 = sdShowerBase(q) * BASE_SCALE; q = transpose(SHOWER_ROTATE) * (p0 - SHOWER_DISP) / SHOWER_SCALE; dist0 = min(dist0, sdShower(q) * SHOWER_SCALE); if (dist0 < 1.0e-2) { shadow = 0.0; break; } else if (dist > lightDist) break; shadow = min(shadow, k * dist0 / dist); dist += dist0; } return vec3(c * (shadow + 0.1) / 1.1); } DEF_SURFACE_LIGHTING(colWall, colWallOneLight) vec3 colShowerBaseOneLight(in vec3 p, in Ray ray, in vec3 normal, in vec3 lightPos) { vec3 lightDir = normalize(p - lightPos); float c = microfacet(normal, ray.direction, lightDir, 0.2, 0.5) * 0.9; c += microfacet(normal, ray.direction, ray.direction, 0.0, 0.5) * 0.1; float shadow = 1.0, dist = 0.01, lightDist = distance(p, lightPos), k = 2.0; for (int i = 0; i < 64; i++) { vec3 p0 = p - dist * lightDir; float dist0 = 100.0; vec3 q; q = transpose(BASE_ROTATE) * (p0 - BASE_DISP) / BASE_SCALE; dist0 = sdShowerBase(q) * BASE_SCALE; q = transpose(SHOWER_ROTATE) * (p0 - SHOWER_DISP) / SHOWER_SCALE; dist0 = min(dist0, sdShower(q) * SHOWER_SCALE); if (dist0 < 1.0e-3) { shadow = 0.0; break; } else if (dist > lightDist) break; shadow = min(shadow, k * dist0 / dist); dist += dist0; } return vec3(c * (shadow + 0.1) / 1.1); } DEF_SURFACE_LIGHTING(colShowerBase, colShowerBaseOneLight) vec3 colShowerOneLight(in vec3 p, in Ray ray, in vec3 normal, in vec3 lightPos) { float shadow = 1.0, dist = 0.05, lightDist = distance(p, lightPos), k = 2.0; vec3 lightDir = normalize(p - lightPos); for (int i = 0; i < 64; i++) { vec3 p0 = p - dist * lightDir; float dist0 = 100.0; vec3 q; q = transpose(BASE_ROTATE) * (p0 - BASE_DISP) / BASE_SCALE; dist0 = sdShowerBase(q) * BASE_SCALE; q = transpose(SHOWER_ROTATE) * (p0 - SHOWER_DISP) / SHOWER_SCALE; dist0 = min(dist0, sdShower(q) * SHOWER_SCALE); if (dist0 < 1.0e-3) { shadow = 0.0; break; } else if (dist > lightDist) break; shadow = min(shadow, k * dist0 / dist); dist += dist0; } mat3 mat = transpose(SHOWER_ROTATE); p = mat * (p - SHOWER_DISP) / SHOWER_SCALE; normal = mat * normal; lightPos = mat * (lightPos - SHOWER_DISP) / SHOWER_SCALE; ray.direction = mat * ray.direction; lightDir = normalize(p - lightPos); k = length(p.zx + vec2(0.0, 0.3)); vec3 q = rotate3D(vec3(0, 0, 1), PI / 1.5) * (p - vec3(0.9, -0.43, 0)); float c; if (p.y < 0.00001 && k < 0.5) { vec2 r = (p.zx + vec2(0.0, 0.3)) / 0.5; float r_int = (floor(length(r) * SHOWER_HOLE_RADIUS) + 0.5) / SHOWER_HOLE_RADIUS; float theta = acos(clamp(normalize(r).x, -1.0, 1.0)) * sign(r.y); c = 1.0; k = length(r); if ((theta < PI * 0.4 || PI * 0.6 < theta || k < 0.5) && k > 0.2) { float theta_int = (floor(theta / (2.0 * PI) * SHOWER_HOLE_THETA) + 0.5); theta_int *= 2.0 * PI / SHOWER_HOLE_THETA; vec2 center = r_int * vec2(cos(theta_int), sin(theta_int)); c = clamp(distance(r, center) / 0.025, 0.0, 1.0); } c = microfacet(normal, ray.direction, ray.direction, 0.2, 0.8) * c * c * 0.3; } else if (q.y < -0.43) { c = microfacet(normal, ray.direction, lightDir, 0.2, 0.45) * 0.8; c += microfacet(normal, ray.direction, ray.direction, 0.0, 0.5) * 0.2; } else { c = microfacet(normal, ray.direction, lightDir, 0.2, 1.0); } c = min(c, 1.0); return vec3(c * (shadow + 0.1) / 1.1); } DEF_SURFACE_LIGHTING(colShower, colShowerOneLight) vec3 colMirrorSideOneLight(in vec3 p, in Ray ray, in vec3 normal, in vec3 lightPos) { vec3 lightDir = normalize(p - lightPos); float c = microfacet(normal, ray.direction, lightDir, 0.9, 0.3); return vec3(c); } DEF_SURFACE_LIGHTING(colMirrorSide, colMirrorSideOneLight) // It is far enough away from the viewpoint and lights. The light is considered a point source. vec3 colRightWall(in vec3 p, in Ray ray, in vec3 normal) { vec3 lightPos = vec3(0, 0, 0.4); vec3 lightDir = normalize(p - lightPos); float lightDist = distance(p, lightPos); float c = microfacet(normal, ray.direction, lightDir, 0.1, 0.8) / (lightDist * lightDist * 0.05); float shadow = 1.0, dist = 0.01, k = 2.0; for (int i = 0; i < 32; i++) { vec3 p0 = p - dist * lightDir; float dist0; vec3 q; q = transpose(HANGER_ROTATE) * (p0 - HANGER_DISP) / HANGER_SCALE; dist0 = sdHanger(q) * HANGER_SCALE; if (dist0 < 1.0e-2) { shadow = 0.0; break; } else if (dist > lightDist) break; shadow = min(shadow, k * dist0 / dist); dist += dist0; } return vec3(c * (shadow + 0.1) / 1.1); } vec3 colHanger(in vec3 p, in Ray ray, in vec3 normal) { vec3 lightPos = vec3(0, 0, 0.4); vec3 lightDir = normalize(p - lightPos); float lightDist = distance(p, lightPos); vec3 q = transpose(HANGER_ROTATE) * (p - HANGER_DISP) / HANGER_SCALE; vec3 col; if (q.y > 0.3001) { col = vec3(0.7, 0.8, 0.9); col *= microfacet(normal, ray.direction, lightDir, 0.5, 0.2); } else if (length(abs(q.zx) - vec2(0, 2)) > 0.2001) { col = vec3(1.0); col *= microfacet(normal, ray.direction, lightDir, 0.7, 0.5); } else { col = vec3(1.0); col *= microfacet(normal, ray.direction, lightDir, 0.5, 0.2); } return col; } float sdInMirror(in vec3 p) { vec3 q; float dist = sdRightWall(p); q = transpose(HANGER_ROTATE) * (p - HANGER_DISP) / HANGER_SCALE; dist = min(dist, sdHanger(q) * HANGER_SCALE); return dist; } DEF_RAYMARCHING(raymarchInMirror, sdInMirror, 128) vec3 colInMirror(in vec3 p, in Ray ray, in vec3 normal) { int index = objectIndex(p); if (index == 5) return colRightWall(p, ray, normal); else return colHanger(p, ray, normal); } vec3 colMirror(in vec3 p, in Ray ray, in vec3 normal) { if (normal.z < 1.0e-4) { return colMirrorSide(p, ray, normal); } Ray refRay; refRay.origin = p; refRay.direction = reflect(ray.direction, normal); float dist = raymarchInMirror(refRay); vec3 refPos = refRay.origin + dist * refRay.direction; vec3 refNormal = calcNormal(refPos); return colInMirror(refPos, refRay, refNormal); } vec3 color(in vec3 p, in Ray ray, in vec3 normal) { int index = objectIndex(p); if (index == 0) return colWall(p, ray, normal); else if (index == 1) { float c = -dot(ray.direction, normal); return vec3(1.0 - (1.0 - c) * (1.0 - c)); } else if (index == 2) return colShowerBase(p, ray, normal); else if (index == 3) return colShower(p, ray, normal); else return colMirror(p, ray, normal); } /******************* main function ********************/ void mainImage3D(out vec4 fragColor, in vec2 fragCoord) { vec3 disp = smoothnoise31(iTime * 0.05); disp = 2.0 * CAMERA_AMP * disp - CAMERA_AMP; Camera camera = newCamera( CAMERA_POSITION + disp, normalize(CAMERA_DIRECTION - disp), vec3(0, 1, 0), PI / 5.0, 1.0 ); Ray ray = cameraRay(camera, fragCoord / iResolution.y); vec2 xy = ray.origin.xy - ray.direction.xy * ray.origin.z / ray.direction.z; float a = 0.9 * LIGHT_SCALE, b = 0.5 * LIGHT_SCALE; bool lightDomain = (xy.x * xy.x) / (a * a) + (xy.y * xy.y) / (b * b) < 1.0 || xy.y > 0.0; bool showerDomain = xy.x < 0.0; float dist = raymarch(ray); vec3 p = ray.origin + dist * ray.direction; vec3 normal = calcNormal(p); vec3 col = color(p, ray, normal) * pow(vec3(1, 1, 0.9), vec3(2.2)); fragColor = vec4(col, 1); } // smart anti-aliasing // reference: https://shadertoyunofficial.wordpress.com/2021/03/09/advanced-tricks/ void mainImage3DAA(out vec4 O, in vec2 U) { mainImage3D(O, U); #ifdef AA if (fwidth(length(O.xyz)) > 0.1) { vec4 o; for (int k = 0; k < 4; k++) { mainImage3D(o,U + (vec2(k - (k / 2) * 2, k / 2) - 0.5) / 1.5); O += o; } O /= 5.0; // If defined, visualize anti-aliased pixels. //#define VISUALIZE_AA #ifdef VISUALIZE_AA O = vec4(1); } else { O = vec4(0,0,0,1); #endif } #endif } void mainImage(out vec4 fragColor, in vec2 fragCoord) { fragCoord.x -= (iResolution.x - iResolution.y) / 2.0; if (fragCoord.x < 0.0 || fragCoord.x > iResolution.y) { fragColor = vec4(0, 0, 0, 1); return; } mainImage3DAA(fragColor, fragCoord); vec2 uv = fragCoord / iResolution.y; fragColor.xyz *= 1.0 - LIGHT_FLICKER * (1.0 - fbm113(iTime * 30.0, 0.0) / 3.0); float br = smoothfbm125(uv * vec2(sqrt(2.0), sqrt(5.0)) * 10.0 - vec2(0, iTime * 0.5), 0.0); br = (1.0 - br / 5.0) * STEAM; fragColor.xyz = 1.0 - (1.0 - fragColor.xyz) * (1.0 - br); fragColor.xyz = pow(fragColor.xyz, vec3(0.4545)); fragColor.w = 1.0; } void main(void) { mainImage(gl_FragColor, gl_FragCoord.xy); }