uniform float4x4 ViewProj<
	bool automatic = true;
>;
uniform float4 ViewSize<
	bool automatic = true;
>;
uniform float4 Time<
	bool automatic = true;
>;

// Camera Parameters
uniform float3 CameraPosition<
	string name = "Camera Position";
	string field_type = "slider";
	float3 minimum = {-10.0, -10.0, -10.0};
	float3 maximum = {10.0, 10.0, 10.0};
> = {0., 0., 0.};

uniform float3 CameraRotation<
	string name = "Camera Rotation";
	string suffix = " °Deg";
	string field_type = "slider";
	float3 minimum = {-180.0, -90.0, -180.0};
	float3 maximum = {180.0, 90.0, 180.0};
	float3 scale = {0.01745329251994329576923690768489, 0.01745329251994329576923690768489, 0.01745329251994329576923690768489};
> = {0., 0., 0.};

uniform float CameraFieldOfView<
	string name = "Camera Field Of View";
	string suffix = " °Deg";
	string field_type = "slider";
	float minimum = 1.0;
	float maximum = 180.0;
	float scale = 0.00872664625997164788461845384244;
> = 90.0;

uniform float2 CameraRange<
	string name = "Camera Range";
	string field_type = "slider";
	float2 minimum = {0.0, 1.00};
	float2 maximum = {10000.0, 10000.0};
	float2 scale = {0.01, 0.01};
> = {0.1, 256.0};

uniform int RayMarchAccuracy<
	string name = "Ray March Steps";
	string field_type = "slider";
	int minimum = 32;
	int maximum = 1024;
> = 256;

//----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
// Configuration
#define MAX_ACCURACY 1024

// Camera Type
//#define CAMERA_ORTHOGRAPHIC		// Orthographic projection

//----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
#define INFINITY 1.#INF

//----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
float4x4 make_rotation_matrix(float3 axis, float angle)
{
	axis = normalize(axis);
	float s = sin(angle);
	float c = cos(angle);
	float oc = 1.0 - c;

	float x_x = axis.x * axis.x;
	float x_y = axis.x * axis.y;
	float x_z = axis.x * axis.z;
	float y_x = x_y;
	float y_y = axis.y * axis.y;
	float y_z = axis.y * axis.z;
	float z_x = x_z;
	float z_y = y_z;
	float z_z = axis.z * axis.z;

	return float4x4(oc * x_x + c, 			oc * x_y - axis.z * s,	oc * z_x + axis.y * s,	0.0,
					oc * x_y + axis.z * s,	oc * y_y + c,			oc * z_y - axis.x * s,	0.0,
					oc * x_z - axis.y * s,	oc * y_z + axis.x * s,	oc * z_z + c,			0.0,
					0.0,					0.0,					0.0,					1.0);
};

float3 rotate_float3(float3 v, float3 rotation)
{
	float4x4 rz = make_rotation_matrix(float3(0., 0., 1.), rotation.z);
	float4x4 ry = make_rotation_matrix(float3(0., 1., 0.), rotation.y);
	float4x4 rx = make_rotation_matrix(float3(1., 0., 0.), rotation.x);

	float4 p = float4(v, 1.);
	float4 rtd = mul(mul(mul(p, rz), rx), ry);

	return rtd.xyz;
};

bool solve_quadratic(float a, float b, float c, out float x0, out float x1) 
{ 
	float discr = b * b - 4. * a * c; 
	if (discr < 0.) {
		return false; 
	} else if (discr == 0.) {
		x0 = x1 = - 0.5 * b / a; 
	} else { 
		float q = (b > 0.) ? 
		-0.5 * (b + sqrt(discr)) : 
		-0.5 * (b - sqrt(discr)); 
		x0 = q / a; 
		x1 = c / q; 
	} 

	if (x0 > x1) {
		float tmp = x1;
		x1 = x0;
		x0 = tmp;
	}

	return true; 
}

bool collide_point_aabb(float3 pos, float3 aabb, float3 size) {
	float3 aabb_min = aabb - size;
	float3 aabb_max = aabb + size;
	return (pos.x >= aabb_min.x)
		&& (pos.y >= aabb_min.y)
		&& (pos.z >= aabb_min.z)
		&& (pos.x <= aabb_max.x)
		&& (pos.y <= aabb_max.y)
		&& (pos.z <= aabb_max.z);
}

bool collide_aabb_aabb(float3 pos1, float3 size1, float3 pos2, float3 size2) {
	float3 min1 = pos1 - size1;
	float3 max1 = pos1 + size1;
	float3 min2 = pos2 - size2;
	float3 max2 = pos2 + size2;
	
	return (min1.x <= max2.x && max1.x >= min2.x) &&
			(min1.y <= max2.y && max1.y >= min2.y) &&
			(min1.z <= max2.z && max1.z >= min2.z);
}

bool intersect_box(float3 pos, float3 size, float3 ray_pos, float3 ray_dir, out float t) {
	float3 aabb_size = float3(max(size.x, max(size.y, size.z)), 0., 0.);
	if (!collide_aabb_aabb(ray_pos, ray_dir, pos, aabb_size.xxx))
		return false;

	t = 0.;
	return true;
}

bool intersect_sphere(float3 center, float radius, float3 orig, float3 dir, out float t)
{
	if (!collide_aabb_aabb(orig, dir, center, float3(radius, radius, radius)))
		return false;

	float t0, t1; // solutions for t if the ray intersects 
	float radius2 = radius * radius;

	// analytic solution
	float3 L = orig - center; 
	float a = dot(dir, dir); 
	float b = 2. * dot(dir, L); 
	float c = dot(L, L) - radius2; 

	if (!solve_quadratic(a, b, c, t0, t1)) {
		return false; 
	}

	if (t0 > t1) {
		float tmp = t0;
		t0 = t1;
		t1 = tmp;
	}

	if (t0 < 0.) { 
		t0 = t1; // if t0 is negative, let's use t1 instead 
		if (t0 < 0.) {
			return false; // both t0 and t1 are negative
		}
	} 

	t = t0; 
	return true; 
}

//----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
struct default_data {
	float4 pos : POSITION;
	float2 uv  : TEXCOORD0;
};

default_data default_vs(default_data data) {
	data.pos = mul(float4(data.pos.xyz, 1.0), ViewProj);
	return data;
}

//----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
struct material_data {
	float4 color;
	float metallic;
	float specular;
	float roughness;
	float4 emissive_color;
	float3 normal;
	float index_of_refraction;
};

void material_data_constructor(out material_data material)
{
	material.color = float4(0., 0., 0., 0.);
	material.metallic = 0.;
	material.specular = .5;
	material.roughness = 1.;
	material.emissive_color = float4(0., 0., 0., 0.);
	material.normal = float3(0., 0., 0.);
	material.index_of_refraction = 1.;
}

struct ray_data {
	// Status
	float3 position; // Current position.
	float3 direction; // Direction of the ray.
	int depth; // Ray Calculation Depth, limited by ACCURACY define.

	// Hit
	bool hit; // Did we hit anything?
	float3 hit_position; // If so, where?
	float4 hit_color; // What color does it have?
	float3 hit_normal; // And what is the normal for that hit?
	float hit_depth;
};

void ray_data_constructor(out ray_data ray)
{
	ray.position = float3(0., 0., 0.);
	ray.direction = float3(0., 0., 0.);
	ray.depth = 0;

	ray.hit = false;
	ray.hit_position = float3(0., 0., 0.);
	ray.hit_color = float4(0., 0., 0., 0.);
	ray.hit_normal = float3(0., 0., 0.);
	ray.hit_depth = 0.;
}

float get_view_aspect_ratio() {
	return ViewSize.x / ViewSize.y;
}

float get_raymarch_step_length() {
	return CameraRange.y / float(RayMarchAccuracy);
}

ray_data initialize_camera_ray(float2 uv) {
	ray_data ray;
	ray_data_constructor(ray);

	uv -= .5;
	//uv *= 2.;

	float aspect = get_view_aspect_ratio();

#ifdef CAMERA_ORTHOGRAPHIC
	ray.direction = rotate_float3(float3(0., 0., 1.), CameraRotation);
	ray.position = CameraPosition + float3(uv.x * ViewSize.x, uv.y * ViewSize.y, CameraRange.x);
#else
	ray.direction = rotate_float3(rotate_float3(float3(0., 0., 1.), CameraRotation), float3(
		uv.y * CameraFieldOfView / aspect,
		uv.x * CameraFieldOfView,
		0.));
	ray.position = CameraPosition + float3(-uv.x, uv.y / aspect, CameraRange.x);	
#endif
	ray.direction *= get_raymarch_step_length();

	return ray;
}

bool raymarch_box(inout ray_data ray, float3 pos, float3 rotation, float3 size, material_data material) {
	float step = 0.;
	if (!intersect_box(pos, size, ray.position, ray.direction, step))
		return false;
	
//	if (step > 1.)
//		return false;

	float depth = (step + float(ray.depth));
//	if (ray.hit && (ray.hit_depth <= depth))
//		return false;

	ray.hit = true;
	ray.hit_position = ray.position + ray.direction * step;
	ray.hit_depth = depth;
	ray.hit_color = material.color;

	return true;
}

bool raymarch_sphere(inout ray_data ray, float3 pos, float3 rotation, float radius, material_data material) {
	float step = 0.;
	if (!intersect_sphere(pos, radius, ray.position, ray.direction, step))
		return false;
		
	if (step > 1.) // Ray start to end actually did not hit.
		return false;

	float depth = (step + float(ray.depth));
	if (ray.hit && (ray.hit_depth <= depth))
		return false;

	ray.hit = true;
	ray.hit_position = ray.position + ray.direction * step;
	ray.hit_depth = depth;
	ray.hit_color = material.color;

	return true;
}

bool scene(inout ray_data ray) {	
	material_data box1;
	material_data_constructor(box1);
	box1.color = float4(0., 0., 0., 1.);
	raymarch_box(ray, float3(0., -1., 2.), float3(0., 0., 0.), float3(1., 1., 1.), box1);

	material_data sphere1;
	material_data_constructor(sphere1);
	sphere1.color = float4(1., 0., 0., 1.);
	raymarch_sphere(ray, float3(-1., 0., 1.), float3(0., 0., 0.), 0.5, sphere1);
	
	material_data sphere2;
	material_data_constructor(sphere2);
	sphere2.color = float4(0., 0., 1., 1.);
	raymarch_sphere(ray, float3(1., 0., 1.), float3(0., 0., 0.), 0.5, sphere2);

	return ray.hit;
}

bool raymarch(inout ray_data ray) {
	// Simulate hitting a sphere.
	if (ray.depth >= RayMarchAccuracy) {
		return false;
	}

	for (; (ray.depth < MAX_ACCURACY) && (ray.depth < RayMarchAccuracy); ray.depth++) {
		if (scene(ray))
			break;

		ray.position = ray.position + ray.direction;
	}

	return ray.hit;
}

float4 pass1_ps(default_data data) : TARGET {
	// Set up camera.
	ray_data ray = initialize_camera_ray(data.uv);
	// Raymarch
	raymarch(ray);
	// Finally just return the color
	//return float4(ray.hit_depth / float(CameraRange.y), float(ray.depth) / float(RayMarchAccuracy), 0., 1.);
	return ray.hit_color;
}

//----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
technique Draw {
	pass
	{
		vertex_shader = default_vs(data);
		pixel_shader  = pass1_ps(data); 
	}
}