Merge pull request #1 from clayjohn/windows

Windows version

Author: clayjohn

assets/shaders/atmo.frag

@@ -1,83 +1,61 @@
 #version 330 core
-in vec3 ourColor;
-in vec3 TexCoords;
 
-//uniform vec2 resolution;
-const vec2 resolution = vec2(512.0);
+uniform vec2 resolution;
 uniform float time;
 uniform mat4 MVPM;
-uniform int check;
-out vec4 color;
 
-// ----------------------------------------------------------------------------
-// Rayleigh and Mie scattering atmosphere system
-//
-// implementation of the techniques described here:
-// http://www.scratchapixel.com/old/lessons/3d-advanced-lessons/simulating-the-colors-of-the-sky/atmospheric-scattering/
-// ----------------------------------------------------------------------------
+out vec4 color;
 
-#define _in(T) const in T
-#define _inout(T) inout T
-#define _out(T) out T
-#define _begin(type) type (
-#define _end )
-#define mul(a, b) (a) * (b)
+/*
+Atmospheric scattering based off of: 
+*/
 
 #define PI 3.14159265359
+#define BIAS 1e-4 // small offset to avoid self-intersections
+
+// scattering coefficients at sea level (m)
+const vec3 betaR = vec3(5.5e-6, 13.0e-6, 22.4e-6); // Rayleigh 
+const vec3 betaM = vec3(21e-6); // Mie
+
+// scale height (m)
+// thickness of the atmosphere if its density were uniform
+const float hR = 7994.0; // Rayleigh
+const float hM = 1200.0; // Mie
+
+const float earth_radius = 6360e3; // (m)
+const float atmosphere_radius = 6420e3; // (m)
+
+vec3 sun_dir = vec3(0, 1, 0);
+const float sun_power = 30.0;
+
+
+const int num_samples = 16;
+const int num_samples_light = 8;
+
 
-// Shadertoy specific uniforms
-#define u_res resolution
-#define u_time time
 
 struct ray_t {
 	vec3 origin;
 	vec3 direction;
 };
-#define BIAS 1e-4 // small offset to avoid self-intersections
 
 struct sphere_t {
 	vec3 origin;
 	float radius;
-	int material;
 };
 
-struct plane_t {
-	vec3 direction;
-	float distance;
-	int material;
-};
+const sphere_t atmosphere = sphere_t(vec3(0, 0, 0), atmosphere_radius);
 
-int check_pos(vec2 x, float size) {
-	return int(mod(floor(x.x), size) + mod(floor(x.y), size)*size);
-}
 
-mat3 rotate_around_x(_in(float) angle_degrees)
+mat3 rotate_around_x(const in float angle_degrees)
 {
 	float angle = radians(angle_degrees);
 	float _sin = sin(angle);
 	float _cos = cos(angle);
 	return mat3(1, 0, 0, 0, _cos, -_sin, 0, _sin, _cos);
 }
 
-
-ray_t get_primary_ray(
-	_in(vec3) cam_local_point,
-	_inout(vec3) cam_origin,
-	_inout(vec3) cam_look_at
-){
-	vec3 fwd = normalize(cam_look_at - cam_origin);
-	vec3 up = vec3(0, 1, 0);
-	vec3 right = cross(up, fwd);
-	up = cross(fwd, right);
-
-	ray_t r = _begin(ray_t)
-		cam_origin,
-		normalize(fwd + up * cam_local_point.y + right * cam_local_point.x)
-		_end;
-	return r;
-}
-
-bool isect_sphere(_in(ray_t) ray, _in(sphere_t) sphere, _inout(float) t0, _inout(float) t1)
+bool isect_sphere(const in ray_t ray, const in sphere_t sphere, inout float t0, inout float t1)
 {
 	vec3 rc = sphere.origin - ray.origin;
 	float radius2 = sphere.radius * sphere.radius;
@@ -91,15 +69,6 @@ bool isect_sphere(_in(ray_t) ray, _in(sphere_t) sphere, _inout(float) t0, _inout
 	return true;
 }
 
-// scattering coefficients at sea level (m)
-const vec3 betaR = vec3(5.5e-6, 13.0e-6, 22.4e-6); // Rayleigh 
-const vec3 betaM = vec3(21e-6); // Mie
-
-// scale height (m)
-// thickness of the atmosphere if its density were uniform
-const float hR = 7994.0; // Rayleigh
-const float hM = 1200.0; // Mie
-
 float rayleigh_phase_func(float mu)
 {
 	return
@@ -112,43 +81,19 @@ float rayleigh_phase_func(float mu)
 // represents the average cosine of the scattered directions
 // 0 is isotropic scattering
 // > 1 is forward scattering, < 1 is backwards
-const float g = 0.76;
 float henyey_greenstein_phase_func(float mu)
 {
+const float g = 0.76;
 	return
 						(1. - g*g)
 	/ //---------------------------------------------
 		((4. + PI) * pow(1. + g*g - 2.*g*mu, 1.5));
 }
 
-// Schlick Phase Function factor
-// Pharr and  Humphreys [2004] equivalence to g above
-const float k = 1.55*g - 0.55 * (g*g*g);
-float schlick_phase_func(float mu)
-{
-	return
-					(1. - k*k)
-	/ //-------------------------------------------
-		(4. * PI * (1. + k*mu) * (1. + k*mu));
-}
-
-const float earth_radius = 6360e3; // (m)
-const float atmosphere_radius = 6420e3; // (m)
-
-vec3 sun_dir = vec3(0, 1, 0);
-const float sun_power = 20.0;
-
-const sphere_t atmosphere = _begin(sphere_t)
-	vec3(0, 0, 0), atmosphere_radius, 0
-_end;
-
-const int num_samples = 16;
-const int num_samples_light = 8;
-
 bool get_sun_light(
-	_in(ray_t) ray,
-	_inout(float) optical_depthR,
-	_inout(float) optical_depthM
+	const in ray_t ray,
+	inout float optical_depthR,
+	inout float optical_depthM
 ){
 	float t0 = 0.0;
 	float t1 = 0.0;
@@ -174,7 +119,7 @@ bool get_sun_light(
 	return true;
 }
 
-vec3 get_incident_light(_in(ray_t) ray)
+vec3 get_incident_light(const in ray_t ray)
 {
 	// "pierce" the atmosphere with the viewing ray
 	float t0 = 0.0;
@@ -197,11 +142,7 @@ vec3 get_incident_light(_in(ray_t) ray)
 	// * integrates to 1 over the entire sphere of directions
 	float phaseR = rayleigh_phase_func(mu);
 	float phaseM =
-#if 1
-		henyey_greenstein_phase_func(mu);
-#else
-		schlick_phase_func(mu);
-#endif
+	henyey_greenstein_phase_func(mu);
 
 	// optical depth (or "average density")
 	// represents the accumulated extinction coefficients
@@ -226,10 +167,7 @@ vec3 get_incident_light(_in(ray_t) ray)
 		optical_depthM += hm;
 
 		// gather the sunlight
-		ray_t light_ray = _begin(ray_t)
-			s,
-			sun_dir
-		_end;
+		ray_t light_ray = ray_t(s, sun_dir);
 		float optical_depth_lightR = 0.;
 		float optical_depth_lightM = 0.;
 		bool overground = get_sun_light(
@@ -256,64 +194,38 @@ vec3 get_incident_light(_in(ray_t) ray)
 		sumM * phaseM * betaM);
 }
 
-vec3 ACESFilm( vec3 x )
-{
-    float a = 2.51f;
-    float b = 0.03f;
-    float c = 2.43f;
-    float d = 0.59f;
-    float e = 0.14f;
-    return clamp((x*(a*x+b))/(x*(c*x+d)+e), 0.0, 1.0);
+vec3 U2Tone(vec3 x) {
+	const float A = 0.15;
+	const float B = 0.50;
+	const float C = 0.10;
+	const float D = 0.20;
+	const float E = 0.02;
+	const float F = 0.30;
+
+   return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;
 }
 
 void main()
 {
-	vec2 aspect_ratio = vec2(u_res.x / u_res.y, 1);
-	float fov = tan(radians(45.0));
-	vec2 point_ndc = gl_FragCoord.xy / u_res.xy;
-	vec3 point_cam = vec3((2.0 * point_ndc - 1.0) * aspect_ratio * fov, 1.0);
+	vec2 aspect_ratio = vec2(resolution.x / resolution.y, 1);
+	vec2 point_ndc = gl_FragCoord.xy / resolution.xy;
+	vec3 point_cam = vec3((2.0 * point_ndc - 1.0) * aspect_ratio, 1.0);
 
 	vec4 worldPos = (inverse((MVPM))*vec4(point_cam, 1.0));
 	worldPos.xyz /= worldPos.w;
 	point_cam = normalize(worldPos.xyz);
 
-
-	if (check_pos(gl_FragCoord.xy/4.0, 4.0)!=check){
-		//reprojection from http://john-chapman-graphics.blogspot.ca/2013/01/what-is-motion-blur-motion-pictures-are.html
-		//look into running all this on cpu
-		discard;
-		/*
-		vec4 current = vec4((2.0 * point_ndc - 1.0) * aspect_ratio * fov, 1.0, 1.0);
-    current = inverse(MVPM) * current;
-    vec4 previous = LFMVPM * current;
-    previous.xyz /= previous.w;
-    previous.xy = previous.xy * 0.5 + 0.5;
-    vec2 blurVec = previous.xy - TexCoords.xy;
-		vec2 lookup = TexCoords.xy+blurVec;
-		float mip = 0.0;
-		if (lookup.x<0.0||lookup.x>1.0||lookup.y<0.0||lookup.y>1.0) {
-			lookup = clamp(lookup, 0.0, 1.0);
-			lookup = TexCoords.xy;
-			mip = 1.0;
-		}
-		color = texture(lastFrame, lookup, mip);
-		*/
-	} else {
-
-		vec3 col = vec3(0);
-		if (point_cam.y>0.0) {
-	// sun
-			mat3 rot = rotate_around_x(-abs(sin(u_time / 20.)) * 90.);
+		vec3 col = vec3(0.4);
+		if (point_cam.y>-0.05) {
+			// sun
+			mat3 rot = rotate_around_x(-abs(sin(time / 20.)) * 90.);
 			sun_dir *= rot;
-
-      vec3 eye = vec3 (0, earth_radius + 1., 0);
-      vec3 look_at = vec3 (0, earth_radius + 1.0, -1);
 
-      //ray_t ray = get_primary_ray(point_cam, eye, look_at);
 			ray_t ray = ray_t(vec3(0.0, earth_radius+1.0, 0.0), point_cam);
       col = get_incident_light(ray);
 		}
-		col = ACESFilm(col);
+		col = U2Tone(col);
+		col /= U2Tone(vec3(2.5));
+		col = sqrt(col);
 		color = vec4(col, 1);
-	}
 }

assets/shaders/atmo.vert

@@ -1,19 +1,7 @@
 #version 330 core
-in vec3 position;
-in vec3 color;
-in vec3 texCoords;
-
-out vec3 ourColor;
-out vec3 TexCoords;
-out vec4 fragPos;
-
-uniform mat4 MVPM;
+layout (location = 0) in vec2 position;
 
 void main()
 {
-
-    gl_Position = vec4(position.xy, 0.0, 1.0);
-    ourColor = color;
-    TexCoords = texCoords;
-		fragPos = gl_Position;
+    gl_Position = vec4(position, 0.0, 1.0);
 }