port from perforce

uc16-4k/mark.fs

@@ -0,0 +1,139 @@
+#version 120
+
+// Parameters from our host
+// x: Scene+Zeit
+// y: Hoehe
+// z: Aspec
+uniform vec4 Y; 
+
+vec3 L;
+
+#define saturate(x) clamp(x, 0, 1)
+
+// Maximum/minumum elements of a vector
+float vmax(vec2 v) {
+	return max(v.x, v.y);
+}
+
+float vmax(vec3 v) {
+	return max(max(v.x, v.y), v.z);
+}
+
+float vmax(vec4 v) {
+	return max(max(v.x, v.y), max(v.z, v.w));
+}
+
+float vmin(vec2 v) {
+	return min(v.x, v.y);
+}
+
+float vmin(vec3 v) {
+	return min(min(v.x, v.y), v.z);
+}
+
+float vmin(vec4 v) {
+	return min(min(v.x, v.y), min(v.z, v.w));
+}
+
+void pR(inout vec2 p, float a) {
+	p = cos(a)*p + sin(a)*vec2(p.y, -p.x);
+}
+
+float fSphere(vec3 p, float r) {
+	return length(p) - r;
+}
+
+// Plane with normal n (n is normalized) at some distance from the origin
+float fPlane(vec3 p, vec3 n, float distanceFromOrigin) {
+	return dot(p, n) + distanceFromOrigin;
+}
+
+// Cheap Box: distance to corners is overestimated
+float fBoxCheap(vec3 p, vec3 b) { //cheap box
+	return vmax(abs(p) - b);
+}
+
+// Box: correct distance to corners
+float fBox(vec3 p, vec3 b) {
+	vec3 d = abs(p) - b;
+	return length(max(d, vec3(0))) + vmax(min(d, vec3(0)));
+}
+
+// Same as above, but in two dimensions (an endless box)
+float fBox2Cheap(vec2 p, vec2 b) {
+	return vmax(abs(p)-b);
+}
+
+float fBox2(vec2 p, vec2 b) {
+	vec2 d = abs(p) - b;
+	return length(max(d, vec2(0))) + vmax(min(d, vec2(0)));
+}
+
+vec4 mcol = vec4(0);
+float DE(in vec3 z0){
+	float r = sqrt(2.0) * 0.5;
+	mcol = vec4(0.8, 0.8, 0.8, 0.7);
+	float d1 = fSphere(z0 + vec3( 0.5, -0.5,  0.5), r);
+	float d2 = fSphere(z0 + vec3( 0.5,  0.5, -0.5), r);
+	float d3 = fSphere(z0 + vec3(-0.5,  0.5,  0.5), r);
+	float d4 = fSphere(z0 + vec3(-0.5, -0.5, -0.5), r);
+	
+	return min(min(min(d1, d2), d3), d4);
+}
+float linstep(float a, float b, float t){float v=(t-a)/(b-a);return clamp(v,0.,1.);}//from knighty
+
+float rand(vec2 co){// implementation found at: lumina.sourceforge.net/Tutorials/Noise.html
+	return fract(sin(dot(co*0.123,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+float FuzzyShadow(vec3 ro, vec3 rd, float coneGrad, vec2 fragCoord){
+	float t=0.0,d=1.0,s=1.0;
+	ro+=rd*0.01;
+	for(int i=0;i<16;i++){
+		//if(s<0.1)continue;//uncommenting this makes shadows and reflections disappear - WTF?
+		float r=t*coneGrad;//radius of cone
+		d=DE(ro+rd*t)+r*0.5;
+		s*=linstep(-r,r,d);
+		t+=abs(d)*(0.5+0.5*rand(fragCoord.xy*vec2(i)))+0.005;
+	}
+	return clamp(s*0.8+0.2,0.0,1.0);
+}
+vec3 Background(vec3 rd){return vec3(0.2)*(0.3+0.7*pow(max(0.0,dot(rd,L)),2.0));}
+
+void main() {
+
+	vec3 ro=vec3(0.5,0.7,-0.5)*(0.19+Y.x*0.1) + vec3(-0.2, -0.2, 0.2);
+	vec3 rd = vec3((gl_FragCoord.xy / Y.y - 0.5), 1.0);
+	rd = normalize(vec3(rd.x - Y.z, rd.y, rd.z));
+	pR(rd.xy,Y.x);
+	pR(rd.yz,-0.717);
+	pR(rd.xz,-0.717);
+	L=normalize(vec3(0.5,0.5,-0.5));
+
+	vec3 col=Background(rd);
+	float refl = 1.0;
+	for (int r = 0; r < 12; ++r)
+	{
+		float t=0.0002,d=1.0;
+		for(int i=0;i<48;i++){
+			if(t>10.0 || d<0.0001) break;
+			t+=d=DE(ro+rd*t);
+		}
+		if(d>0.02)
+			break;
+
+		ro+=rd*t;
+		mcol=vec4(0.0);
+		const vec2 v=vec2(0.001,0.0);
+		vec3 N=normalize(vec3(-DE(ro-v.xyy)+DE(ro+v.xyy),-DE(ro-v.yxy)+DE(ro+v.yxy),-DE(ro-v.yyx)+DE(ro+v.yyx)));
+		rd=reflect(rd,N);
+		refl*=mcol.w;
+		vec3 scol=mcol.rgb*saturate(dot(N,L));
+		scol += 4*pow(saturate(dot(rd,normalize(N+L))), 128);
+		float shadowConeGrad = 0.15;
+		scol*=refl*FuzzyShadow(ro,L,shadowConeGrad,gl_FragCoord.xy);//the cone grad could be calculated for each lights position
+		col=mix(scol,col,refl);
+	}
+	col=pow(col,vec3(1.0/2.2));
+	gl_FragColor = vec4(saturate(col),1.0);
+}