uniform float4x4 ViewProj;
uniform texture2d image;
uniform float2 uv_size;
uniform int draw_cursor;
uniform float2 uv_mouse;
uniform float2 uv_mouse_previous;
uniform float2 select_from;
uniform float2 select_to;
uniform float4 cursor_color;
uniform float cursor_size;
uniform texture2d cursor_image;
uniform int tool;
uniform texture2d tool_image;
uniform float4 tool_color;
uniform float tool_size;
uniform int tool_mode;
uniform bool shift_down;

sampler_state def_sampler {
	Filter   =
Linear;
	AddressU = Clamp;
	AddressV =
Clamp;
};

struct VertInOut
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

VertInOut VSDefault(VertInOut vert_in)
{
	VertInOut vert_out;
	vert_out.pos = mul(float4(vert_in.pos.xyz, 1.0), ViewProj);
	vert_out.uv = vert_in.uv;
	return vert_out;
}

float4 apply_color(float4 color, float4 orig)
{
	if (color.a == 0.0)
		return orig;
	if (color.a < 0.0)
		return float4(lerp(orig.rgb, color.rgb, (1.0 + color.a) / ((1.0 + color.a) + orig.a)), min((1.0 + color.a), orig.a));
		//return float4(0, 0, 0, 0);
		//return float4(orig.rgb * (1.0 + color.a), min((1.0 + color.a), orig.a));

	return float4(lerp(orig.rgb, color.rgb, color.a / (color.a + orig.a)), max(color.a, orig.a));
}

float4 draw_line(float2 coord, float2 from, float2 to, float4 color, float distance_factor, float4 orig)
{
	float d = distance(coord, to);
	float effective_alpha = 0.0;
	if (d <= tool_size)
	{
		effective_alpha = color.a - (color.a * (d / tool_size) * distance_factor);
	}
	if (from.x >= 0.0 && from.y >= 0.0 && (from.x != 0.0 || from.y != 0.0))
	{
		float2 lineDir = from - to;
		float2 perpDir = float2(lineDir.y, -lineDir.x);
		float2 dirToPt1 = to - coord;
		float ld = abs(dot(normalize(perpDir), dirToPt1));
		if (ld <= tool_size)
		{
			float dp = distance(coord, from);
			if (dp <= tool_size)
			{
				if (color.a < 0.0)
					effective_alpha = min(color.a - (color.a * (dp / tool_size) * distance_factor), effective_alpha);
				else
					effective_alpha = max(color.a - (color.a * (dp / tool_size) * distance_factor), effective_alpha);
			}
			float md = distance(from, to);
			if (dp < md && d < md)
			{
				if (color.a < 0.0)
					effective_alpha = min(color.a - (color.a * (ld / tool_size) * distance_factor), effective_alpha);
				else
					effective_alpha = max(color.a - (color.a * (ld / tool_size) * distance_factor), effective_alpha);
			}
		}
	}
	return apply_color(float4(color.rgb, effective_alpha), orig);
}

float4 draw_dot_line(float2 coord, float2 from, float2 to, float4 orig)
{
	float d = distance(coord, to);
	float effective_alpha = 0.0;
	float3 color = float3(1, 1, 1);
	if (d <= tool_size)
	{
		effective_alpha = 1.0;
	}
	else if (from.x >= 0.0 && from.y >= 0.0)
	{
		float2 lineDir = from - to;
		float2 perpDir = float2(lineDir.y, -lineDir.x);
		float2 dirToPt1 = to - coord;
		float ld = abs(dot(normalize(perpDir), dirToPt1));
		if (ld <= tool_size)
		{
			float dp = distance(coord, from);
			if (dp <= tool_size)
			{
				effective_alpha = max(1.0, effective_alpha);
			}
			else
			{
				float md = distance(from, to);
				if (dp < md && d < md)
				{
					effective_alpha = max(1.0, effective_alpha);

					float v = md - d;
					float v2 = v - (tool_size * 8.0) * floor(v / (tool_size * 8.0));
					if (d > dp && v2 >= tool_size * 4.0)
					{
						color = float3(0, 0, 0);
					}
					else
					{
						v = md - dp;
						v2 = v - (tool_size * 8.0) * floor(v / (tool_size * 8.0));
						if (d < dp && v2 >= tool_size * 4.0)
						{
							color = float3(0, 0, 0);
						}
					}
				}
			}
		}
	}
	return apply_color(float4(color, effective_alpha), orig);
}

float4 PSDraw(VertInOut vert_in) : TARGET
{
	float4 orig = image.Sample(def_sampler, vert_in.uv);
	float2 coord = vert_in.uv * uv_size;
	float effective_cursor_size = cursor_size <= 0.0f ? tool_size : cursor_size;
	if (draw_cursor == 1)
	{
		float d = distance(coord, uv_mouse);
		if (d < effective_cursor_size)
			return cursor_color;
	}
	else if (draw_cursor == 2)
	{
		if (abs(coord.x - uv_mouse.x) < effective_cursor_size && abs(coord.y - uv_mouse.y) < effective_cursor_size)
		{
			float2 cursor_pos = (coord - uv_mouse) / float2(effective_cursor_size * 2.0, effective_cursor_size * 2.0) + float2(0.5, 0.5);
			float4 cc = cursor_image.Sample(def_sampler, cursor_pos);
			if (cc.a > 0.0)
				return cc;
		}
	}
	if (tool_mode == 0)
	{ // tool up
		if (select_from.x != select_to.x || select_from.y != select_to.y)
		{
		
			if (tool == 8) // select rectangle
			{
				orig = draw_dot_line(coord, select_from, float2(select_from.x, select_to.y), orig);
				orig = draw_dot_line(coord, float2(select_from.x, select_to.y), select_to, orig);
				orig = draw_dot_line(coord, select_to, float2(select_to.x, select_from.y), orig);
				orig = draw_dot_line(coord, float2(select_to.x, select_from.y), select_from, orig);
			}
			else if (tool == 9) // select ellipse
			{
				float2 center = (select_from + select_to) / 2.0;
				float2 diff = abs(select_from - center);
				float2 inside = diff - tool_size;
				float2 outside = diff + tool_size;
				float2 temp = float2(pow(coord.x - center.x, 2), pow(coord.y - center.y, 2));
				if ((temp.x / pow(inside.x, 2.0)) + (temp.y / pow(inside.y, 2.0)) >= 1.0 && (temp.x / pow(outside.x, 2.0)) + (temp.y / pow(outside.y, 2.0)) <= 1.0)
				{
					float r = atan2(coord.y - center.y, coord.x - center.x) + 3.14;
					float v = r * 50.0 / 3.14;
					float v2 = v - 2.0 * floor(v / 2.0);
					if (v2 >= 1.0)
					{
						return apply_color(float4(0, 0, 0, 1), orig);
					}
					else
					{
						return apply_color(float4(1, 1, 1, 1), orig);
					}
				
				}
			}
		}
		return orig;
	}

	if (tool_mode == 2)
	{ // tool drag
		if (select_from.x != select_to.x || select_from.y != select_to.y)
		{
		
			if (tool == 8) // select rectangle
			{
				if (coord.x >= min(select_from.x, select_to.x) && coord.x <= max(select_from.x, select_to.x) && coord.y >= min(select_from.y, select_to.y) && coord.y <= max(select_from.y, select_to.y))
				{
					orig = float4(0, 0, 0, 0);
				}
				float2 diff = uv_mouse - uv_mouse_previous;
				if (coord.x >= min(select_from.x, select_to.x) + diff.x && coord.x <= max(select_from.x, select_to.x) + diff.x && coord.y >= min(select_from.y, select_to.y) + diff.y && coord.y <= max(select_from.y, select_to.y) + diff.y)
				{
					orig = apply_color(image.Sample(def_sampler, (coord - diff) / uv_size), orig);
				}
			}
			else if (tool == 9) // select ellipse
			{
				float2 center = (select_from + select_to) / 2.0;
				float2 diff = float2(pow(select_from.x - center.x, 2.0), pow(select_from.y - center.y, 2.0));
				float p = (pow(coord.x - center.x, 2) / diff.x) + (pow(coord.y - center.y, 2) / diff.y);
				if (p <= 1.0)
				{
					orig = float4(0, 0, 0, 0);
				}
				float2 diff2 = uv_mouse - uv_mouse_previous;
				p = (pow(coord.x - diff2.x - center.x, 2) / diff.x) + (pow(coord.y - diff2.y - center.y, 2) / diff.y);
				if (p <= 1.0)
				{
					orig = apply_color(image.Sample(def_sampler, (coord - diff2) / uv_size), orig);
				}
			}

		}
		return orig;
	}
	
	if (tool == 1) // pencil
	{
		return draw_line(coord, uv_mouse_previous, uv_mouse, tool_color, 0.0, orig);
	}
	else if (tool == 2) // brush
	{
		return draw_line(coord, uv_mouse_previous, uv_mouse, tool_color, 1.0, orig);
	}
	else if (tool == 3)//line
	{
		if (shift_down)
		{
			if (abs(uv_mouse_previous.x - uv_mouse.x) < abs(uv_mouse_previous.y - uv_mouse.y))
			{
				return draw_line(coord, uv_mouse_previous, float2(uv_mouse_previous.x, uv_mouse.y), tool_color, 0.0, orig);
			}
			else
			{
				return draw_line(coord, uv_mouse_previous, float2(uv_mouse.x, uv_mouse_previous.y), tool_color, 0.0, orig);
			}
		}
		return draw_line(coord, uv_mouse_previous, uv_mouse, tool_color, 0.0, orig);
	}
	else if (tool == 4) // rectangle outline
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		orig = draw_line(coord, from, float2(from.x, to.y), tool_color, 0.0, orig);
		orig = draw_line(coord, float2(from.x, to.y), to, tool_color, 0.0, orig);
		orig = draw_line(coord, to, float2(to.x, from.y), tool_color, 0.0, orig);
		orig = draw_line(coord, float2(to.x, from.y), from, tool_color, 0.0, orig);
		return orig;
	}
	else if (tool == 5) // rectangle
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		float2 min_mouse = min(to, from);
		float2 max_mouse = max(to, from);
		if (coord.x >= min_mouse.x && coord.x <= max_mouse.x && coord.y >= min_mouse.y && coord.y <= max_mouse.y)
			return apply_color(tool_color, orig);
	}
	else if (tool == 6) // ellipse outline
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		float2 center = (from + to) / 2.0;
		float2 diff = abs(from - center);
		float2 inside = diff - tool_size;
		float2 outside = diff + tool_size;
		float2 temp = float2(pow(coord.x - center.x, 2), pow(coord.y - center.y, 2));
		if ((temp.x / pow(inside.x, 2.0)) + (temp.y / pow(inside.y, 2.0)) >= 1.0 && (temp.x / pow(outside.x, 2.0)) + (temp.y / pow(outside.y, 2.0)) <= 1.0)
			return apply_color(tool_color, orig);
	}
	else if (tool == 7) // ellipse
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		float2 center = (from + to) / 2.0;
		float2 diff = float2(pow(from.x - center.x, 2.0), pow(from.y - center.y, 2.0));
		float p = (pow(coord.x - center.x, 2) / diff.x) + (pow(coord.y - center.y, 2) / diff.y);
		if (p <= 1.0)
			return apply_color(tool_color, orig);
	}
	else if (tool == 8) // select rectangle
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		orig = draw_dot_line(coord, from, float2(from.x, to.y), orig);
		orig = draw_dot_line(coord, float2(from.x, to.y), to, orig);
		orig = draw_dot_line(coord, to, float2(to.x, from.y), orig);
		orig = draw_dot_line(coord, float2(to.x, from.y), from, orig);
		return orig;
	}
	else if (tool == 9) // select ellipse
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		float2 center = (from + to) / 2.0;
		float2 diff = abs(from - center);
		float2 inside = diff - tool_size;
		float2 outside = diff + tool_size;
		float2 temp = float2(pow(coord.x - center.x, 2), pow(coord.y - center.y, 2));
		if ((temp.x / pow(inside.x, 2.0)) + (temp.y / pow(inside.y, 2.0)) >= 1.0 && (temp.x / pow(outside.x, 2.0)) + (temp.y / pow(outside.y, 2.0)) <= 1.0)
		{
			float r = atan2(coord.y - center.y, coord.x - center.x) + 3.14;
			float v = r * 50.0 / 3.14;
			float v2 = v - 2.0 * floor(v / 2.0);
			if (v2 >= 1.0)
			{
				return apply_color(float4(0, 0, 0, 1), orig);
			}
			else
			{
				return apply_color(float4(1, 1, 1, 1), orig);
			}
				
		}
	}
	else if (tool == 10) // stamp
	{
		if (coord.x >= uv_mouse.x - tool_size && coord.x <= uv_mouse.x + tool_size && coord.y >= uv_mouse.y - tool_size && coord.y <= uv_mouse.y + tool_size)
		{
			float2 uv = (coord - uv_mouse + float2(tool_size, tool_size)) / (tool_size * 2.0);
			return apply_color(tool_image.Sample(def_sampler, uv), orig);
		}
	}
	else if (tool == 11) // image
	{
		float2 from = uv_mouse_previous;
		float2 to = uv_mouse;
		if (shift_down)
		{
			if (abs(from.x - to.x) > abs(from.y - to.y))
			{
				to.x = from.x + (to.x - from.x) / abs(from.x - to.x) * abs(from.y - to.y);
			}
			else
			{
				to.y = from.y + (to.y - from.y) / abs(from.y - to.y) * abs(from.x - to.x);
			}
		}
		float2 min_mouse = min(to, from);
		float2 max_mouse = max(to, from);
		if (coord.x >= min_mouse.x && coord.x <= max_mouse.x && coord.y >= min_mouse.y && coord.y <= max_mouse.y)
		{
			float2 uv = (coord - from) / (to - from);
			return apply_color(tool_image.Sample(def_sampler, uv), orig);
		}
	}
	
	return orig;
}

technique Draw
{
	pass
	{
		vertex_shader = VSDefault(vert_in);
		pixel_shader = PSDraw(vert_in);
	}
}