X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=sdr%2Fwhitted.p.glsl;h=1c40d1da28a07c074f990c28c979807773fe8afe;hb=7f33f4df3bdd41375f215548adc8016a55f03472;hp=567f127694bf39c5de5e5c0ec92bc34a97ebfd11;hpb=a89e74326444df1da625ad9614919bb7ad2352cb;p=demo_prior

diff --git a/sdr/whitted.p.glsl b/sdr/whitted.p.glsl
index 567f127..1c40d1d 100644
--- a/sdr/whitted.p.glsl
+++ b/sdr/whitted.p.glsl
@@ -1,43 +1,305 @@
+struct Ray {
+	vec3 org, dir;
+	float energy, ior;
+};
+
+struct Material {
+	vec3 diffuse, specular;
+	float shin;
+	float refl, refr;
+	float ior;
+};
+
+struct HitPoint {
+	float dist;
+	vec3 pos, norm;
+	vec2 surfpos;
+	Material mtl;
+	float shadow;	/* opacity along the line of sight up to dist=1 */
+};
+
 varying vec3 v_rorg, v_rdir;
 
-vec3 shade(in vec3 pos, in vec3 norm);
+
+vec3 shade(in vec3 ro, in vec3 rd, in HitPoint hit);
 vec3 backdrop(in vec3 dir);
-float isect_plane(in vec3 ro, in vec3 rd, out vec3 norm_ret);
+
+bool isect_scene(in vec3 ro, in vec3 rd, out HitPoint hit);
+
+bool isect_floor(in vec3 ro, in vec3 rd, in vec2 sz, out HitPoint hit);
+bool isect_plane(in vec3 ro, in vec3 rd, in vec4 plane, out HitPoint hit);
+bool isect_sphere(in vec3 ro, in vec3 rd, in vec3 pos, float rad, out HitPoint hit);
+
+/* schlick's approximation: [5.0, 1.0, R(0deg)] */
+float hack_fresnel(vec3 i, vec3 n, vec3 fresnel_val);
+
+vec3 tex_chess(in vec3 col1, in vec3 col2, in vec2 spos);
+
+#define GREY(x)	vec3(x, x, x)
+
+const Material mtl_sph = Material(vec3(0.05, 0.15, 0.08), GREY(0.8), 80.0, 0.8, 0.0, 0.0);
+const Material mtl_glass = Material(GREY(0.02), GREY(0.8), 80.0, 0.99, 0.99, 1.52);
+const Material mtl_air = Material(GREY(0.0), GREY(0.8), 80.0, 0.99, 0.99, 1.0);
+const Material mtl_floor = Material(GREY(0.5), GREY(0.0), 1.0, 0.0, 0.0, 0.0);
+
+const vec3 light_pos = vec3(-10, 50, 30);
+
+bool cast_ray(in Ray ray, inout vec3 color, out HitPoint hit)
+{
+	if(isect_scene(ray.org, ray.dir, hit)) {
+		color += shade(ray.org, ray.dir, hit) * ray.energy;
+		return true;
+	}
+	color += backdrop(ray.dir) * ray.energy;
+	return false;
+}
+
+#define MAX_LEVEL	8
+
+struct StackFrame {
+	int op;
+	Ray ray;
+	HitPoint hit;
+};
 
 void main()
 {
-	vec3 rdir = normalize(v_rdir);
+	StackFrame stack[MAX_LEVEL];
+
+	vec3 color = vec3(0.0, 0.0, 0.0);
+
+	stack[0].op = 0;
+	stack[0].ray.org = v_rorg;
+	stack[0].ray.dir = normalize(v_rdir);
+	stack[0].ray.energy = stack[0].ray.ior = 1.0;
 
-	float t = isect_floor(v_rorg, rdir);
-	if(t >= 0.0) {
-		gl_FragColor.rgb = shade(v_rorg + rdir * t, vec3(0.0, 1.0, 0.0));
-	} else {
-		gl_FragColor.rgb = backdrop(rdir);
+	int top = 0;
+	while(top >= 0) {
+		if(top >= MAX_LEVEL - 1) {
+			color += backdrop(stack[top].ray.dir) * stack[top].ray.energy;
+			top--;
+			continue;
+		}
+		if(stack[top].ray.energy < 1e-3) {
+			top--;
+			continue;
+		}
+
+		if(!cast_ray(stack[top].ray, color, stack[top].hit)) {
+			/* no hit, return */
+			top--;
+			continue;
+		}
+
+		/* found a hit, recurse for reflection/refraction */
+		HitPoint hit = stack[top].hit;
+
+		// 1.0 when entering, 0.0 when leaving
+		float entering = step(0.0, dot(-stack[top].ray.dir, hit.norm));
+		vec3 norm = faceforward(hit.norm, stack[top].ray.dir, hit.norm);
+
+		float fr = hack_fresnel(-stack[top].ray.dir, norm, vec3(5.0, 2.0, 0.01));
+		// fr = 1 everywhere when ior < 0.5 to avoid affecting the metal sphere
+		fr = min(1.0, (1.0 - step(0.5, hit.mtl.ior)) + fr);
+
+		int op = stack[top].op++;
+		if(op == 0) {
+			// reflection
+			float energy = stack[top].ray.energy * hit.mtl.refl * fr;
+			if(energy > 1e-4) {
+				int next = top + 1;
+				stack[next].op = 0;
+				stack[next].ray.org = hit.pos + norm * 1e-5;
+				stack[next].ray.dir = reflect(stack[top].ray.dir, norm);
+				stack[next].ray.energy = energy;
+				top = next;
+			}
+		} else if(op == 1) {
+			// refraction
+			float energy = stack[top].ray.energy * hit.mtl.refr * (1.0 - fr);
+			if(energy > 1e-4) {
+				float next_ior = mix(stack[top - 1].ray.ior, hit.mtl.ior, entering);
+				float ior = stack[top].ray.ior / next_ior;
+				int next = top + 1;
+				stack[next].op = 0;
+				stack[next].ray.org = hit.pos - norm * 1e-5;
+				stack[next].ray.dir = refract(stack[top].ray.dir, norm, ior);
+				stack[next].ray.energy = energy;
+				stack[next].ray.ior = next_ior;
+				top = next;
+			}
+		} else if(op == 2) {
+			// return
+			top--;
+		}
 	}
-	gl_FragColor.a = 1.0;
+
+	gl_FragColor = vec4(color, 1.0);
 }
 
-vec3 shade(in vec3 pos, in vec3 norm)
+vec3 shade(in vec3 ro, in vec3 rd, in HitPoint hit)
 {
+	HitPoint shadow_hit;
+	vec3 norm = faceforward(hit.norm, rd, hit.norm);
+	vec3 ldir = light_pos - hit.pos;
+
+	vec3 amb = hit.mtl.diffuse * 0.01;
+
+	isect_scene(hit.pos + norm * 0.01, ldir, shadow_hit);
+
+	vec3 l = normalize(ldir);
+	vec3 v = normalize(-rd);
+	vec3 h = normalize(v + l);
+	float ndotl = max(dot(norm, l), 0.0);
+	float ndoth = max(dot(norm, h), 0.0);
+
+	vec3 lit = hit.mtl.diffuse * ndotl + hit.mtl.specular * pow(ndoth, hit.mtl.shin);
+
+	return amb + lit * shadow_hit.shadow;
 }
 
+#define M_PI	3.1415926
+#define M_2PI	(M_PI * 2.0)
+
 vec3 backdrop(in vec3 dir)
 {
+	return vec3(0.02, 0.38, 0.6) * 0.9;
 }
 
-float isect_floor(in vec3 ro, in vec3 rd)
+#define FLOOR_OFFS	vec3(3.0, 0.0, -9.0)
+#define FLOOR_SIZE	vec2(5.5, 12.0)
+
+#define REFL_POS	vec3(1.36, -0.5, 0.0)
+#define GLASS_POS	vec3(0.0, 0.2, 1.2)
+
+bool isect_scene(in vec3 ro, in vec3 rd, out HitPoint hit_res)
 {
-	float t = isect_plane(ro, rd, vec4(0.0, 1.0, 0.0, -1.0));
-	if(t < 0.0) return t;
+	float opacity = 1.0;
+	HitPoint hit, nearest;
 
-	vec3 p = ro + rd * t;
-	float d = max(abs(p.x), max(abs(p.y), abs(p.z)));
-	if(d >= 1.0) return -1.0;
+	nearest.dist = 10000.0;
+
+	if(isect_sphere(ro, rd, REFL_POS, 0.85, hit)) {
+		nearest = hit;
+		nearest.mtl = mtl_sph;
+		if(hit.dist < 1.0) {
+			opacity *= mtl_sph.refr;
+		}
+	}
+
+	if(isect_sphere(ro, rd, GLASS_POS, 0.9, hit)) {
+		if(hit.dist < nearest.dist) {
+			nearest = hit;
+			nearest.mtl = mtl_glass;
+		}
+		if(hit.dist < 1.0) {
+			opacity *= mtl_glass.refr * 0.25;	// XXX hack quarter the refr, fresnel would reduce it drastically
+		}
+	}
 
-	return t;
+	if(isect_sphere(ro, rd, GLASS_POS, 0.86, hit)) {
+		if(hit.dist < nearest.dist) {
+			nearest = hit;
+			nearest.mtl = mtl_air;
+		}
+	}
+
+	if(isect_floor(ro, rd, FLOOR_SIZE, hit) && hit.dist < nearest.dist) {
+		nearest = hit;
+		nearest.mtl = mtl_floor;
+		nearest.mtl.diffuse = tex_chess(vec3(0.25, 0.01, 0.01), vec3(0.3, 0.3, 0.1), hit.surfpos);
+	}
+
+	if(nearest.dist >= 9999.0) {
+		hit_res.shadow = 1.0;
+		return false;
+	}
+
+	hit_res = nearest;
+	hit_res.shadow = opacity;
+	return true;
+}
+
+bool isect_floor(in vec3 ro, in vec3 rd, in vec2 sz, out HitPoint hit)
+{
+	if(!isect_plane(ro - FLOOR_OFFS, rd, vec4(0.0, 1.0, 0.0, -1.8), hit)) {
+		return false;
+	}
+
+	if(abs(hit.pos.x) >= sz.x || abs(hit.pos.z) >= sz.y) {
+		return false;
+	}
+
+	hit.pos += FLOOR_OFFS;
+	hit.surfpos /= sz * 2.0;
+	return true;
+}
+
+bool isect_plane(in vec3 ro, in vec3 rd, in vec4 plane, out HitPoint hit)
+{
+	float ndotrd = dot(rd, plane.xyz);
+
+	if(abs(ndotrd) < 1e-6) {
+		return false;
+	}
+
+	vec3 pp = plane.xyz * plane.w;
+	vec3 pdir = pp - ro;
+	float t = dot(pdir, plane.xyz) / ndotrd;
+
+	if(t < 1e-6) {
+		return false;
+	}
+
+	hit.dist = t;
+	hit.pos = ro + rd * t;
+	hit.norm = plane.xyz;
+	hit.surfpos = hit.pos.xz;	/* XXX */
+	return true;
+}
+
+bool isect_sphere(in vec3 ro, in vec3 rd, in vec3 pos, float rad, out HitPoint hit)
+{
+	float a = dot(rd, rd);
+	float b = dot(rd * 2.0, (ro - pos));
+	float c = dot(ro, ro) + dot(pos, pos) - 2.0 * dot(ro, pos) - rad * rad;
+
+	float d = b * b - 4.0 * a * c;
+	if(d < 1e-6) {
+		return false;
+	}
+
+	float t0 = (-b + sqrt(d)) / (2.0 * a);
+	float t1 = (-b - sqrt(d)) / (2.0 * a);
+
+	if(t0 < 0.0) t0 = t1;
+	if(t1 < 0.0) t1 = t0;
+	float t = min(t0, t1);
+
+	if(t < 1e-6) {
+		return false;
+	}
+
+	hit.dist = t;
+	hit.pos = ro + rd * t;
+	hit.norm = normalize(hit.pos - pos);
+	hit.surfpos.x = atan(hit.norm.z, hit.norm.x);
+	hit.surfpos.y = acos(hit.norm.y);
+	return true;
 }
 
-float isect_plane(in vec3 ro, in vec3 rd, in vec4 plane)
+/* schlick's approximation: [5.0, 1.0, R(0deg)] */
+float hack_fresnel(vec3 i, vec3 n, vec3 fresnel_val)
 {
+	return fresnel_val.z + pow(1.0 - dot(i, n), fresnel_val.x) * fresnel_val.y;
+}
+
+vec3 tex_chess(in vec3 col1, in vec3 col2, in vec2 spos)
+{
+	float foo = step(0.5, mod(spos.x * 8.0, 1.0)) * 2.0 - 1.0;
+	float bar = step(0.5, mod(spos.y * 12.0, 1.0)) * 2.0 - 1.0;
+
+	float xor = (foo * bar) * 0.5 + 0.5;
 
+	return mix(col1, col2, xor);
 }