git.mutantstargoat.com Git - demo_prior/blob - sdr/whitted.p.glsl

   1 struct Ray {
   2         vec3 org, dir;
   3         float energy, ior;
   4 };
   5
   6 struct Material {
   7         vec3 diffuse, specular;
   8         float shin;
   9         float refl, refr;
  10         float ior;
  11 };
  12
  13 struct HitPoint {
  14         float dist;
  15         vec3 pos, norm;
  16         vec2 surfpos;
  17         Material mtl;
  18         float shadow;   /* opacity along the line of sight up to dist=1 */
  19 };
  20
  21 varying vec3 v_rorg, v_rdir;
  22
  23
  24 vec3 shade(in vec3 ro, in vec3 rd, in HitPoint hit);
  25 vec3 backdrop(in vec3 dir);
  26
  27 bool isect_scene(in vec3 ro, in vec3 rd, out HitPoint hit);
  28
  29 bool isect_floor(in vec3 ro, in vec3 rd, in vec2 sz, out HitPoint hit);
  30 bool isect_plane(in vec3 ro, in vec3 rd, in vec4 plane, out HitPoint hit);
  31 bool isect_sphere(in vec3 ro, in vec3 rd, in vec3 pos, float rad, out HitPoint hit);
  32
  33 /* schlick's approximation: [5.0, 1.0, R(0deg)] */
  34 float hack_fresnel(vec3 i, vec3 n, vec3 fresnel_val);
  35
  36 vec3 tex_chess(in vec3 col1, in vec3 col2, in vec2 spos);
  37
  38 #define GREY(x) vec3(x, x, x)
  39
  40 const Material mtl_sph = Material(vec3(0.05, 0.15, 0.08), GREY(0.8), 80.0, 0.8, 0.0, 0.0);
  41 const Material mtl_glass = Material(GREY(0.02), GREY(0.8), 80.0, 0.99, 0.99, 1.52);
  42 const Material mtl_air = Material(GREY(0.0), GREY(0.8), 80.0, 0.99, 0.99, 1.0);
  43 const Material mtl_floor = Material(GREY(0.5), GREY(0.0), 1.0, 0.0, 0.0, 0.0);
  44
  45 const vec3 light_pos = vec3(-10, 50, 30);
  46
  47 bool cast_ray(in Ray ray, inout vec3 color, out HitPoint hit)
  48 {
  49         if(isect_scene(ray.org, ray.dir, hit)) {
  50                 color += shade(ray.org, ray.dir, hit) * ray.energy;
  51                 return true;
  52         }
  53         color += backdrop(ray.dir) * ray.energy;
  54         return false;
  55 }
  56
  57 #define MAX_LEVEL       8
  58
  59 struct StackFrame {
  60         int op;
  61         Ray ray;
  62         HitPoint hit;
  63 };
  64
  65 void main()
  66 {
  67         StackFrame stack[MAX_LEVEL];
  68
  69         vec3 color = vec3(0.0, 0.0, 0.0);
  70
  71         stack[0].op = 0;
  72         stack[0].ray.org = v_rorg;
  73         stack[0].ray.dir = normalize(v_rdir);
  74         stack[0].ray.energy = stack[0].ray.ior = 1.0;
  75
  76         int top = 0;
  77         while(top >= 0) {
  78                 if(top >= MAX_LEVEL - 1) {
  79                         color += backdrop(stack[top].ray.dir) * stack[top].ray.energy;
  80                         top--;
  81                         continue;
  82                 }
  83                 if(stack[top].ray.energy < 1e-3) {
  84                         top--;
  85                         continue;
  86                 }
  87
  88                 if(!cast_ray(stack[top].ray, color, stack[top].hit)) {
  89                         /* no hit, return */
  90                         top--;
  91                         continue;
  92                 }
  93
  94                 /* found a hit, recurse for reflection/refraction */
  95                 HitPoint hit = stack[top].hit;
  96
  97                 // 1.0 when entering, 0.0 when leaving
  98                 float entering = step(0.0, dot(-stack[top].ray.dir, hit.norm));
  99                 vec3 norm = faceforward(hit.norm, stack[top].ray.dir, hit.norm);
 100
 101                 float fr = hack_fresnel(-stack[top].ray.dir, norm, vec3(5.0, 2.0, 0.01));
 102                 // fr = 1 everywhere when ior < 0.5 to avoid affecting the metal sphere
 103                 fr = min(1.0, (1.0 - step(0.5, hit.mtl.ior)) + fr);
 104
 105                 int op = stack[top].op++;
 106                 if(op == 0) {
 107                         // reflection
 108                         float energy = stack[top].ray.energy * hit.mtl.refl * fr;
 109                         if(energy > 1e-4) {
 110                                 int next = top + 1;
 111                                 stack[next].op = 0;
 112                                 stack[next].ray.org = hit.pos + norm * 1e-5;
 113                                 stack[next].ray.dir = reflect(stack[top].ray.dir, norm);
 114                                 stack[next].ray.energy = energy;
 115                                 top = next;
 116                         }
 117                 } else if(op == 1) {
 118                         // refraction
 119                         float energy = stack[top].ray.energy * hit.mtl.refr * (1.0 - fr);
 120                         if(energy > 1e-4) {
 121                                 float next_ior = mix(stack[top - 1].ray.ior, hit.mtl.ior, entering);
 122                                 float ior = stack[top].ray.ior / next_ior;
 123                                 int next = top + 1;
 124                                 stack[next].op = 0;
 125                                 stack[next].ray.org = hit.pos - norm * 1e-5;
 126                                 stack[next].ray.dir = refract(stack[top].ray.dir, norm, ior);
 127                                 stack[next].ray.energy = energy;
 128                                 stack[next].ray.ior = next_ior;
 129                                 top = next;
 130                         }
 131                 } else if(op == 2) {
 132                         // return
 133                         top--;
 134                 }
 135         }
 136
 137         gl_FragColor = vec4(color, 1.0);
 138 }
 139
 140 vec3 shade(in vec3 ro, in vec3 rd, in HitPoint hit)
 141 {
 142         HitPoint shadow_hit;
 143         vec3 norm = faceforward(hit.norm, rd, hit.norm);
 144         vec3 ldir = light_pos - hit.pos;
 145
 146         vec3 amb = hit.mtl.diffuse * 0.01;
 147
 148         isect_scene(hit.pos + norm * 0.01, ldir, shadow_hit);
 149
 150         vec3 l = normalize(ldir);
 151         vec3 v = normalize(-rd);
 152         vec3 h = normalize(v + l);
 153         float ndotl = max(dot(norm, l), 0.0);
 154         float ndoth = max(dot(norm, h), 0.0);
 155
 156         vec3 lit = hit.mtl.diffuse * ndotl + hit.mtl.specular * pow(ndoth, hit.mtl.shin);
 157
 158         return amb + lit * shadow_hit.shadow;
 159 }
 160
 161 #define M_PI    3.1415926
 162 #define M_2PI   (M_PI * 2.0)
 163
 164 vec3 backdrop(in vec3 dir)
 165 {
 166         return vec3(0.02, 0.38, 0.6) * 0.9;
 167 }
 168
 169 #define FLOOR_OFFS      vec3(3.0, 0.0, -9.0)
 170 #define FLOOR_SIZE      vec2(5.5, 12.0)
 171
 172 #define REFL_POS        vec3(1.36, -0.5, 0.0)
 173 #define GLASS_POS       vec3(0.0, 0.2, 1.2)
 174
 175 bool isect_scene(in vec3 ro, in vec3 rd, out HitPoint hit_res)
 176 {
 177         float opacity = 1.0;
 178         HitPoint hit, nearest;
 179
 180         nearest.dist = 10000.0;
 181
 182         if(isect_sphere(ro, rd, REFL_POS, 0.85, hit)) {
 183                 nearest = hit;
 184                 nearest.mtl = mtl_sph;
 185                 if(hit.dist < 1.0) {
 186                         opacity *= mtl_sph.refr;
 187                 }
 188         }
 189
 190         if(isect_sphere(ro, rd, GLASS_POS, 0.9, hit)) {
 191                 if(hit.dist < nearest.dist) {
 192                         nearest = hit;
 193                         nearest.mtl = mtl_glass;
 194                 }
 195                 if(hit.dist < 1.0) {
 196                         opacity *= mtl_glass.refr * 0.25;       // XXX hack quarter the refr, fresnel would reduce it drastically
 197                 }
 198         }
 199
 200         if(isect_sphere(ro, rd, GLASS_POS, 0.86, hit)) {
 201                 if(hit.dist < nearest.dist) {
 202                         nearest = hit;
 203                         nearest.mtl = mtl_air;
 204                 }
 205         }
 206
 207         if(isect_floor(ro, rd, FLOOR_SIZE, hit) && hit.dist < nearest.dist) {
 208                 nearest = hit;
 209                 nearest.mtl = mtl_floor;
 210                 nearest.mtl.diffuse = tex_chess(vec3(0.25, 0.01, 0.01), vec3(0.3, 0.3, 0.1), hit.surfpos);
 211         }
 212
 213         if(nearest.dist >= 9999.0) {
 214                 hit_res.shadow = 1.0;
 215                 return false;
 216         }
 217
 218         hit_res = nearest;
 219         hit_res.shadow = opacity;
 220         return true;
 221 }
 222
 223 bool isect_floor(in vec3 ro, in vec3 rd, in vec2 sz, out HitPoint hit)
 224 {
 225         if(!isect_plane(ro - FLOOR_OFFS, rd, vec4(0.0, 1.0, 0.0, -1.8), hit)) {
 226                 return false;
 227         }
 228
 229         if(abs(hit.pos.x) >= sz.x || abs(hit.pos.z) >= sz.y) {
 230                 return false;
 231         }
 232
 233         hit.pos += FLOOR_OFFS;
 234         hit.surfpos /= sz * 2.0;
 235         return true;
 236 }
 237
 238 bool isect_plane(in vec3 ro, in vec3 rd, in vec4 plane, out HitPoint hit)
 239 {
 240         float ndotrd = dot(rd, plane.xyz);
 241
 242         if(abs(ndotrd) < 1e-6) {
 243                 return false;
 244         }
 245
 246         vec3 pp = plane.xyz * plane.w;
 247         vec3 pdir = pp - ro;
 248         float t = dot(pdir, plane.xyz) / ndotrd;
 249
 250         if(t < 1e-6) {
 251                 return false;
 252         }
 253
 254         hit.dist = t;
 255         hit.pos = ro + rd * t;
 256         hit.norm = plane.xyz;
 257         hit.surfpos = hit.pos.xz;       /* XXX */
 258         return true;
 259 }
 260
 261 bool isect_sphere(in vec3 ro, in vec3 rd, in vec3 pos, float rad, out HitPoint hit)
 262 {
 263         float a = dot(rd, rd);
 264         float b = dot(rd * 2.0, (ro - pos));
 265         float c = dot(ro, ro) + dot(pos, pos) - 2.0 * dot(ro, pos) - rad * rad;
 266
 267         float d = b * b - 4.0 * a * c;
 268         if(d < 1e-6) {
 269                 return false;
 270         }
 271
 272         float t0 = (-b + sqrt(d)) / (2.0 * a);
 273         float t1 = (-b - sqrt(d)) / (2.0 * a);
 274
 275         if(t0 < 0.0) t0 = t1;
 276         if(t1 < 0.0) t1 = t0;
 277         float t = min(t0, t1);
 278
 279         if(t < 1e-6) {
 280                 return false;
 281         }
 282
 283         hit.dist = t;
 284         hit.pos = ro + rd * t;
 285         hit.norm = normalize(hit.pos - pos);
 286         hit.surfpos.x = atan(hit.norm.z, hit.norm.x);
 287         hit.surfpos.y = acos(hit.norm.y);
 288         return true;
 289 }
 290
 291 /* schlick's approximation: [5.0, 1.0, R(0deg)] */
 292 float hack_fresnel(vec3 i, vec3 n, vec3 fresnel_val)
 293 {
 294         return fresnel_val.z + pow(1.0 - dot(i, n), fresnel_val.x) * fresnel_val.y;
 295 }
 296
 297 vec3 tex_chess(in vec3 col1, in vec3 col2, in vec2 spos)
 298 {
 299         float foo = step(0.5, mod(spos.x * 8.0, 1.0)) * 2.0 - 1.0;
 300         float bar = step(0.5, mod(spos.y * 12.0, 1.0)) * 2.0 - 1.0;
 301
 302         float xor = (foo * bar) * 0.5 + 0.5;
 303
 304         return mix(col1, col2, xor);
 305 }