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