precision highp float;
uniform vec2 resolution;
uniform float time;
out vec4 outColor;

#define MATERIAL_DISH 0.0
#define MATERIAL_DESK 1.0
#define MATERIAL_CANDLE 2.0
#define MATERIAL_CAKE 3.0
#define MATERIAL_ROOM 4.0
#define MATERIAL_DESK_FOOT 5.0
#define MATERIAL_STRAWBERRY 6.0
#define MATERIAL_FLAME 7.0
#define MATERIAL_SPOTLIGHT 8.0
#define MATERIAL_PARTICLE 9.0
#define MATERIAL_BOARD 10.0

float pi = acos(-1.0);
float jitter = 0.0;
float ft;
float pAt = 0.0;

float random1d1d(float v)
{
   return fract(sin(v * 924.5326) * 12457.214);
}

float random1d2d(vec2 p){
   return fract(sin(dot(p.xy, vec2(12.575, 78.2356)))*43578.2356);
}

float random3d1d(vec3 v) {
       return fract(sin(dot(v, vec3(12.9898, 78.233, 19.8321))) * 43758.5453);
}

float valueNoise(vec3 v) {
       vec3 i = floor(v);
       vec3 f = smoothstep(0.0, 1.0, fract(v));
       return  mix(
               mix(
                       mix(random3d1d(i), random3d1d(i + vec3(1.0, 0.0, 0.0)), f.x),
                       mix(random3d1d(i + vec3(0.0, 1.0, 0.0)), random3d1d(i + vec3(1.0, 1.0, 0.0)), f.x),
                       f.y
               ),
               mix(
                       mix(random3d1d(i + vec3(0.0, 0.0, 1.0)), random3d1d(i + vec3(1.0, 0.0, 1.0)), f.x),
                       mix(random3d1d(i + vec3(0.0, 1.0, 1.0)), random3d1d(i + vec3(1.0, 1.0, 1.0)), f.x),
                       f.y
               ),
               f.z
       );
}

float fbm(vec3 v) {
       float n = 0.0;
       float a = 0.5;
       for (int i = 0; i < 5; i++) {
               n += a * valueNoise(v);
               v *= 2.0;
               a *= 0.5;
       }
       return n;
}

vec3 hsv2rgb(float h, float s, float v){
   vec3 rgb = clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
   rgb = rgb * rgb * (3.0 - 2.0 * rgb);
   return v * mix(vec3(1.0), rgb, s);
}

vec2 random2dPolar(float n){
   float x = fract(sin(n*546.25)*222.223)*pi*2.0;
   float y = (fract(sin(n*222.25)*622.223) - 0.5)*5.0;

   return vec2(cos(x), sin(x))*y;
}

vec2 random2d(float n){
   float x = (fract(sin(n*246.25)*422.223) - 0.5)*2.0;
   float y = (fract(sin(n*522.25)*722.223) - 0.5)*2.0;

   return vec2(x, y);
}

// Coding a fireworks effect : https://www.youtube.com/watch?v=xDxAnguEOn8
float explode(vec2 pos, float t, float coef){
   float c = 0.0;

   for(float i = 0.0; i <= 10.0; i+=1.0){
       vec2 dir = random2dPolar(i+floor(t)+coef*100.0);
       vec2 p = pos - dir*t;
       float d = dot(p, p);
       float b = mix(0.0, 0.0005, smoothstep(1.0, 0.0, t));
       c += b/d;
   }

   return c;
}


mat2 rotate(float a)
{
   float c = cos(a);
   float s = sin(a);
   return mat2(c, -s, s, c);
}


float bounceOut(float t) {
       const float a = 4.0 / 11.0;
       const float b = 8.0 / 11.0;
       const float c = 9.0 / 10.0;

       const float ca = 4356.0 / 361.0;
       const float cb = 35442.0 / 1805.0;
       const float cc = 16061.0 / 1805.0;

       float t2 = t * t;

       return t < a
               ? 7.5625 * t2
               : t < b
               ? 9.075 * t2 - 9.9 * t + 3.4
               : t < c
               ? ca * t2 - cb * t + cc
               : 10.8 * t * t - 20.52 * t + 10.72;
}

float bounceIn(float t) {
 return 1.0 - bounceOut(1.0 - t);
}

float easeInOutExpo(float t) {
   if (t == 0.0 || t == 1.0) {
       return t;
   }
   if ((t *= 2.0) < 1.0) {
       return 0.5 * pow(2.0, 10.0 * (t - 1.0));
   } else {
       return 0.5 * (-pow(2.0, -10.0 * (t - 1.0)) + 2.0);
   }
}

float linearStep(float start, float end, float t){
   return clamp((t - start)/(end - start), 0.0, 1.0);
}

vec2 polarMod(vec2 p, float r)
{
   float a =  pi / r - atan(p.x, p.y);
   float n = (pi * 2.0) / r;
   a = floor(a/n)*n;
   return p * rotate(-a);
}

vec2 optionMin(vec2 a, vec2 b)
{
   return (a.x < b.x) ? a : b;
}

float smoothMin(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 sdCappedCylinder(vec3 p, float h, float r)
{
   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 sdBox(vec3 p, vec3 s)
{
   vec3 q = abs(p) - s;
   return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0);
}

float sdSphere(vec3 p, float r)
{
   return length(p) - r;
}

// https://neort.io/art/c78r3o43p9f3hsjeassg
float sdSphere(vec3 iPos, vec3 fPos, vec3 c){
   float r = random3d1d(iPos + c);
   if(r > 0.95){
       r = fract(sin(r)) * 0.01;
   }
   else{
       r =- 0.5;
   }

   return length(fPos - c) - r;
}

// https://neort.io/art/c78r3o43p9f3hsjeassg
float sdSphereR(vec3 p){
   float d = 0.0;
   p.y += time * 2.4;
   vec3 iPos = floor(p);
   vec3 fPos = fract(p);

   d += sdSphere(iPos, fPos, vec3(0.0, 0.0, 0.0));
   d = min(d, sdSphere(iPos, fPos, vec3(0.0, 0.0, 1.0)));
   d = min(d, sdSphere(iPos, fPos, vec3(0.0, 1.0, 0.0)));
   d = min(d, sdSphere(iPos, fPos, vec3(1.0, 0.0, 0.0)));
   d = min(d, sdSphere(iPos, fPos, vec3(1.0, 1.0, 0.0)));
   d = min(d, sdSphere(iPos, fPos, vec3(1.0, 0.0, 1.0)));
   d = min(d, sdSphere(iPos, fPos, vec3(0.0, 1.0, 1.0)));
   d = min(d, sdSphere(iPos, fPos, vec3(1.0, 1.0, 1.0)));

   return d;
}

vec2 sdDish(vec3 p){
   p.y += 0.2;
   float d = sdCappedCylinder(p, 0.01, 1.5);
   d = smoothMin(d, sdCappedCylinder(p - vec3(0.0, 0.2, 0.0), 0.04, 3.0), 0.25);

   vec3 p1 = p;
   p1.xz = polarMod(p1.xz, 40.0);
   d = smoothMin(d, sdSphere(p1 - vec3(0.0, 0.2, 3.0), 0.02), 0.3);

   vec3 p2 = p;
   p2.xz *= rotate(pi*0.025);
   p2.xz = polarMod(p2.xz, 10.0);
   d = smoothMin(d, sdSphere(p2 - vec3(0.0, 0.3, 3.0), 0.02), 0.3);
   return vec2(d, MATERIAL_DISH);
}

vec2 sdCake(vec3 p){
   p.y -= 1.0;
   float d = sdCappedCylinder(p, 1.0, 2.0);

   vec3 p1 = p;
   p1.xz = polarMod(p1.xz, 120.0);
   d = smoothMin(d, sdSphere(p1 - vec3(0.0, 0.7, 2.0), 0.2), 0.6);
   vec3 p2 = p;
   p2.xz *= rotate(pi*0.25);
   p2.xz = polarMod(p2.xz, 100.0);
   d = smoothMin(d, sdSphere(p2 - vec3(0.0, -0.6, 2.0), 0.4), 0.8);

   p.y -= 1.0;
   d = smoothMin(d, sdCappedCylinder(p, 1.0, 1.0), 0.6);

   vec3 p3 = p;
   p2.xz *= rotate(pi*0.25);
   p3.xz = polarMod(p3.xz, 100.0);
   d = smoothMin(d, sdSphere(p3 - vec3(0.0, 0.8, 0.8), 0.2), 0.5);

   vec3 p4 = p;
   p4.xz *= rotate(pi*0.025);
   p4.xz = polarMod(p4.xz, 12.0);
   p4.z -= 1.7;
   p4.xz = polarMod(p4.xz, 12.0);
   p4 -= vec3(0.0, 0.2, 0.1);

   d = smoothMin(d, sdSphere(p4, 0.1), 0.2);

   return vec2(d, MATERIAL_CAKE);
}

vec2 sdCakeDecorate(vec3 p)
{
   vec2 d = vec2(10e8);
   vec3 p1 = p;
   p1.xz *= rotate(pi*0.025);
   p1.xz = polarMod(p1.xz, 12.0);
   float berry = 10e8;
   berry = min(berry, sdSphere(p1 - vec3(0.0, 2.3, 1.7), 0.2));
   berry = smoothMin(berry, sdSphere(p1 - vec3(0.0, 2.6, 1.7), 0.01), 0.3);
   d = optionMin(d, vec2(berry, MATERIAL_STRAWBERRY));

   return d;
}

vec2 sdFlame(vec3 p)
{
   vec2 d = vec2(10e8);
   vec3 p1 = p;

   float tF = linearStep(27.0, 28.0, ft);
   float fRadius1 = 0.12 - mix(0.0, 0.12, easeInOutExpo(tF));
   float fRadius2 = 0.06 - mix(0.0, 0.06, easeInOutExpo(tF));
   float flame1 = 10e8;
   flame1 = min(flame1, sdSphere(p1 - vec3(0.0, 3.85, 0.0), fRadius1));
   flame1 = smoothMin(flame1, sdSphere(p1 - vec3(sin(time + floor(length(p1.x)))*0.1, 3.9 + (fract(time*2.0)*0.2 + 0.1)*0.8, 0.0), fRadius2  * (1.0 - fract(time*1.0))), 0.2 * (1.0 - fract(time*1.0)));
   d = optionMin(d, vec2(flame1, MATERIAL_FLAME));

   vec3 p2 = p;
   p2.xz *= rotate(pi*0.025);
   p2.xz = polarMod(p2.xz, 6.0);
   float flame2 = 10e8;
   float fRadius3 = 0.05 - mix(0.0, 0.05, easeInOutExpo(tF));
   float fRadius4 = 0.04 - mix(0.0, 0.04, easeInOutExpo(tF));
   flame2 = min(flame2, sdSphere(p2 - vec3(0.0, 3.45, 0.8), fRadius3));
   flame2 = smoothMin(flame2, sdSphere(p2 - vec3(sin(time + random1d1d(floor(p2.x) * 100.0))*0.05, 3.55 + (fract(time*2.0 + floor(p2.x))*0.2 + 0.1)*0.4, 0.8), fRadius4 * (1.0 - fract(time*1.0))), 0.2  * (1.0 - fract(time*1.0)));
   d = optionMin(d, vec2(flame2, MATERIAL_FLAME));
   return d;
}

vec2 sdCandle(vec3 p){
   p.y -= 2.0;
   float d = sdCappedCylinder(p, 1.8, 0.1);

   vec3 p1 = p;
   p1.xz *= rotate(pi*0.025);
   p1.xz = polarMod(p1.xz, 6.0);
   d = min(d, sdCappedCylinder(p1 - vec3(0.0, 0.0, 0.8), 1.4, 0.06));

   return vec2(d, MATERIAL_CANDLE);
}

vec2 sdDesk(vec3 p){
   p.y += 0.4;
   float d = sdBox(p, vec3(4.8, 0.05, 4.8));
   return vec2(d, MATERIAL_DESK);
}

vec2 sdDeskFoot(vec3 p)
{
   float d = 10e8;
   p.y += 3.4;
   d = smoothMin(d, sdBox(p - vec3(4.5, 0.0, 4.5), vec3(0.5, 3.0, 0.5)), 0.2);
   d = smoothMin(d, sdBox(p - vec3(4.5, 0.0, -4.5), vec3(0.5, 3.0, 0.5)), 0.2);
   d = smoothMin(d, sdBox(p - vec3(-4.5, 0.0, 4.5), vec3(0.5, 3.0, 0.5)), 0.2);
   d = smoothMin(d, sdBox(p - vec3(-4.5, 0.0, -4.5), vec3(0.5, 3.0, 0.5)), 0.2);

   d = smoothMin(d, sdBox(p - vec3(0.0, 2.6, -4.5), vec3(5.0, 0.5, 0.5)), 0.2);
   d = smoothMin(d, sdBox(p - vec3(0.0, 2.6, 4.5), vec3(5.0, 0.5, 0.5)), 0.2);
   d = smoothMin(d, sdBox(p - vec3(-4.5, 2.6, 0.0), vec3(0.5, 0.5, 5.0)), 0.2);
   d = smoothMin(d, sdBox(p - vec3(4.5, 2.6, 0.0), vec3(0.5, 0.5, 5.0)), 0.2);

   return vec2(d, MATERIAL_DESK_FOOT);
}

vec2 sdSpotLight(vec3 p, vec3 offset)
{
   vec2 d = vec2(10e8);

   float lightLen = 30.0;
   vec3 p1 = p - offset;
   float fR = easeInOutExpo(linearStep(1.0, 2.0, ft));
   float r = mix(0.0, 0.3 + length(p1) * 0.3, fR);
   d = optionMin(d, vec2(sdCappedCylinder(p1 + vec3(0.0, lightLen, 0.0), lightLen, r), MATERIAL_SPOTLIGHT));

   return d;
}

vec2 sdBoard(vec3 p)
{
   float tB= linearStep(7.0, 17.0, ft);
   vec2 d = vec2(10e8);

   p.y -= 40.0;
   float yPos = 40.0 * tB;
   p.y += yPos;
   float bFrame = 10e8;
   bFrame = min(bFrame, sdBox(p - vec3(0.0, 5.0, 15.0), vec3(20.0, 10.0, 1.5)));
   bFrame = min(bFrame, sdBox(p - vec3(10.0, 40.0, 15.0), vec3(0.5, 40.0, 1.5)));
   bFrame = min(bFrame, sdBox(p - vec3(-10.0, 40.0, 15.0), vec3(0.5, 40.0, 0.5)));
   bFrame = max(bFrame, -sdBox(p - vec3(0.0, 5.0, 15.0), vec3(20.0, 10.0, 1.7)));
   d = optionMin(d, vec2(bFrame, MATERIAL_DESK_FOOT));

   d = optionMin(d, vec2(sdBox(p - vec3(0.0, 5.0, 15.0), vec3(20.0, 10.0, 0.8)), MATERIAL_BOARD));

   return d;
}

vec2 distanceFunction(vec3 p)
{
   vec2 d = vec2(10e8, 0.0);
   d = optionMin(d, sdDish(p));
   d = optionMin(d, sdCake(p));
   d = optionMin(d, sdCandle(p));
   d = optionMin(d, sdFlame(p));
   d = optionMin(d, sdCakeDecorate(p));
   d = optionMin(d, sdDesk(p));
   d = optionMin(d, sdDeskFoot(p));
   d = optionMin(d, sdBoard(p));

   vec2 b3 = vec2(-sdBox(p - vec3(0.0, 20.0, 0.0), vec3(60.0, 30.0, 60.0)), MATERIAL_ROOM);
   d = optionMin(d, b3);

   d = optionMin(d, vec2(sdSphereR(p), MATERIAL_PARTICLE));

   pAt += 0.01/(0.01 + abs(sdSphereR(p)));

   return d;
}

vec3 getNormal(vec3 p)
{
   vec2 err = vec2(0.001, 0.0);
   return normalize(vec3(
       distanceFunction(p + err.xyy).x - distanceFunction(p - err.xyy).x,
       distanceFunction(p + err.yxy).x - distanceFunction(p - err.yxy).x,
       distanceFunction(p + err.yyx).x - distanceFunction(p - err.yyx).x
   ));
}

vec3 volumetric(vec3 p){
   vec3 col = vec3(0.0);
   col += fbm(p + vec3(time*0.92, 0.0, 0.0)) * 0.02;
   return col;
}

vec3 roomVolumetric(vec3 p){
   vec2 uv = p.xz * 1.0;

   vec3 col = vec3(0.0);
   vec2 grid = smoothstep(0.45, 0.4, fract(uv) - 0.5);
   vec2 cell = floor(uv);
   col += min(grid.x, grid.y);
   col *= vec3(random1d2d(cell + 78.214), random1d2d(cell + 38.214), random1d2d(cell + 57.214));
   return col;
}

float getAO(vec3 p, vec3 n){
   float occ = 0.0;
   float sca = 1.0;

   for(int i = 0; i < 5; i++){
       float h = 0.01 + 0.12 * float(i) / 4.0;
       float d = distanceFunction(p + h * n).x;
       occ += (h - d) * sca;
       if(occ > 0.35){
           break;
       }
   }

   return clamp(1.0 - 3.0 * occ, 0.0, 1.0) * (0.5 + 0.5 * n.y);
}

float getSoftShadow(vec3 camPos, vec3 rayDir, float tMin, float tMax){
   float tp = (0.8 - camPos.y) / rayDir.y;
   if(tp > 0.0){
       tMax = min(tMax, tp);
   }

   float res = 1.0;
   float t = tMin;
   for(int i = 0; i < 24; i++){
       float h = distanceFunction(camPos + rayDir * t).x;
       float s = clamp(8.0 * h / t, 0.0, 1.0);
       res = min(res, s * s * (3.0 - 2.0 * s));
       t += clamp(h, 0.02, 0.2);
       if(res < 0.004 || tMax < t){
           break;
       }
   }

   return clamp(res, 0.0, 1.0);
}

vec3 material(vec3 p, vec3 n, vec3 rayDir, vec2 df, float fog){
   vec3 color = vec3(0.0);
   vec3 roomColor = vec3(1.0);
   float metalic = 0.0;
   vec3 albedo = vec3(0.0);
   vec3 emissive = vec3(0.0);

   if(df.y == MATERIAL_DISH){
       albedo = mix(vec3(0.6549, 0.6784, 0.5059), vec3(1.0, 1.0, 1.0), fbm(vec3(length(p)*100.0)));
       metalic = 0.3;
       emissive = vec3(0.6)*pow(length(p.xz * 0.37), 10.0);
   }
   if(df.y == MATERIAL_DESK){
       albedo = mix(vec3(0.0, 0.0, 0.0), vec3(0.8745, 0.4549, 0.1098), fbm(vec3(p.x, p.yy)));
   }
   if(df.y == MATERIAL_CANDLE){
       albedo = vec3(0.7294, 0.8745, 0.8353);
       emissive = vec3(0.4);
   }
   if(df.y == MATERIAL_CAKE){
       albedo = vec3(1.0);
       emissive = vec3(0.4);
   }
   if(df.y == MATERIAL_ROOM){
       vec3 rp = p * 0.25;
       albedo += roomVolumetric(rp);
       albedo += 2.0 / (2.0 + length(p.xz));
       metalic = 0.8;
   }
   if(df.y == MATERIAL_DESK_FOOT){
       albedo = vec3(1.0);
       metalic = 0.9;
       emissive = vec3(0.4);
   }
   if(df.y == MATERIAL_STRAWBERRY){
       albedo = vec3(0.9294, 0.0863, 0.0863);
       metalic = 0.1;
       emissive = vec3(0.4039, 0.0275, 0.0275);
   }
   if(df.y == MATERIAL_FLAME){
       albedo = mix(vec3(0.9765, 0.7333, 0.2392), vec3(0.9098, 0.5098, 0.5098), smoothstep(3.85, 4.0, p.y));
       metalic = 0.1;
       emissive = vec3(0.9098, 0.0706, 0.0706);
   }
   if(df.y == MATERIAL_PARTICLE){
       albedo += pAt * 0.2;
   }
   if(df.y == MATERIAL_BOARD){
       float t8 = easeInOutExpo(linearStep(19.0, 21.0, ft));
       float tF = easeInOutExpo(linearStep(27.0, 28.0, ft));
       vec2 uv2 = vec2(((p.xy + vec2(10.0, 5.2)) / vec2(20.0, 20.0)) - 0.5);
       for(float i = 0.0; i <= 50.0; i+=1.0){
           float t = time+i/50.0;
           float ft = floor(t);
           vec2 offset = random2d(i+2.0+ft);
           float coef = random1d1d(i+2.0+ft+ft);
           albedo += explode(uv2 - offset, fract(t), coef)*hsv2rgb(coef, 1.0, 1.0);
       }
       albedo *= (t8 - tF);
   }

   vec3 lightDir = normalize(vec3(1.0, 2.0, -3.0));

   float diff = clamp(dot(n, lightDir), 0.0, 1.0);
   float specular = pow(clamp(dot(reflect(lightDir, n), rayDir), 0.0, 1.0), 10.0);
   float ao = getAO(p, n);
   float shadow = getSoftShadow(p, lightDir, 0.22, 4.0);
   color += albedo * diff * shadow * (1.0 - metalic);
   color += albedo * specular * shadow * metalic;
   color += albedo * clamp(0.5 + 0.5 * n.y, 0.0, 1.0) * 0.2;
   color += albedo * ao * roomColor;
   color += emissive;
   return color;
}

vec3 acesFilm(vec3 col){
   float a = 2.51;
   float b = 0.03;
   float c = 2.43;
   float d = 0.59;
   float e = 0.14;
   return clamp((col * (a * col + b)) / (col * (c * col + d) + e), 0.0, 1.0);
}

float lightDistanceFunction(vec3 p)
{
   float lightDF = 1.0 - sdSpotLight(p,  vec3(0.0, 30.0, 0.0)).x;
       return min(max(0.0, lightDF), 1.0);
}

vec3 renderingFunc(vec2 uv){
   ft = mod(time, 30.0);

   float t1 = linearStep(1.0, 2.0, ft);
   float t2 = linearStep(4.0, 5.0, ft);

   float t3 = linearStep(7.0, 8.0, ft);
   float t4 = linearStep(9.0, 10.0, ft);
   float t5 = linearStep(11.0, 12.0, ft);
   float t6 = linearStep(13.0, 14.0, ft);
   float t7 = linearStep(15.0, 16.0, ft);
   float camZ = -25.0 + mix(0.0, 6.0, t3) + mix(0.0, 5.0, t4) + mix(0.0, 4.0, t5) + mix(0.0, 3.0, t6) + mix(0.0, 2.0, t7);

   float t33 = bounceIn(linearStep(11.0, 12.0, ft));
   float t44 = bounceIn(linearStep(13.0, 14.0, ft));
   float t55 = bounceIn(linearStep(15.0, 16.0, ft));
   float t66 = bounceIn(linearStep(13.0, 14.0, ft));
   float t77 = bounceIn(linearStep(15.0, 16.0, ft));
   float camY = 7.0 + mix(0.0, -0.8, t33) + mix(0.0, -0.6, t44) + mix(0.0, -0.4, t55) + mix(0.0, -0.2, t66) + mix(0.0, -0.1, t77);

   vec3 color = vec3(0.0);
   vec3 camPos = vec3(0.0, camY, camZ);;
   vec3 lookPos = vec3(0.0, 3.0, 0.0);
   vec3 up = vec3(0.0, 1.0, 0.0);
   vec3 forward = normalize(lookPos - camPos);
   vec3 right = normalize(cross(up, forward));
   up = normalize(cross(forward, right));
   float fov = 1.0;//0.2 + tick(time*1.2, 1.8, 10.0)*0.8;
   vec3 rayDir = normalize(uv.x * right + uv.y * up + fov * forward);
   float rand = random1d2d(uv);

   float t8 = easeInOutExpo(linearStep(18.0, 20.0, ft));
   float t9 = easeInOutExpo(linearStep(22.0, 24.0, ft));
   float camAngle = mix(0.0, -0.5, t8 - t9);
   camPos.yz *= rotate(camAngle);
   rayDir.yz *= rotate(camAngle);

   vec3 p = camPos;
   vec2 df = vec2(0.0);
   float d = 0.0;
   bool isHit = false;
   float dd = 0.0;
   for(int i = 0; i < 200; i++){
       p = camPos + rayDir * d;
       df = distanceFunction(p);
       if(df.x > 100.0){
           dd = 100.0;
           break;
       }
       if(df.x <= 0.0001){
           isHit = true;
           break;
       }
       d += df.x;
       dd += df.x;
   }

   float density = 0.;
   float stepSize = 0.1;
   vec3 stepRay = stepSize * rayDir;
   vec3 p2 = camPos+stepRay*rand;
   float stepDist = rand*stepSize;
   float stepLength = 0.8;
   vec4 sum = vec4(0.0, 0.0, 0.0, 1.0);
   vec3 at = vec3(0.0);
   for(int i = 0; i < 100; i++){
       if(stepDist > d){
           break;
       }

       at += pow(volumetric(p2) * 4.2, vec3(2.0));
       stepDist += stepSize;
       p2 += stepRay;
   }

   // Referenct : https://www.shadertoy.com/view/WdXGRj
   vec3 p3 = camPos + rayDir * rand * stepLength;
   for (int i = 0; i < 100; i++)
   {
       if (sum.a < 0.1) {
               break;
       }
       float d = lightDistanceFunction(p3);

       if( d > 0.001)
       {
           density = clamp((d / 100.0)*10.0, 0.0, 1.0);
           sum.rgb += vec3(density);
           sum.a *= 1.0 - density;
       }
       p3 += rayDir * stepLength;
   }

   if(isHit){
       vec3 normal = getNormal(p);
       float fogRangeCoef = mix(10.0, 50.0, easeInOutExpo(t1));
       float fog = 1.0 - clamp(dd/fogRangeCoef, 0.0, 1.0);
       vec3 mat = material(p, normal, rayDir, df, fog);
       color += mat;
       color *= fog;
       color *= sum.rgb * (sum.a * 30.0) * at * t1;
       color = mix(color, mat * fog + sum.rgb * (sum.a * 3.0) * at, t2);
       float t9 = linearStep(29.0, 30.0, ft);
       color = mix(color, vec3(0.0), easeInOutExpo(t9));
   }

   color = acesFilm(color * 0.8);
   color = pow(color, vec3(1.0/2.2));

   return color;
}

void main(){
   vec2 uv = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
   vec3 color = vec3(0.0);
   jitter = random1d1d(uv.x + uv.y * 57.0);

   color += renderingFunc(uv);

   outColor = vec4(color, 1.0);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.