#include "gValue.hfx"
#include "progIN_OUT.hfx"
#include "copy.hfx"

////////////////////////////////////
//calculate distant
////////////////////////////////////
VS_DIST_OUTPUT VNShader(float3 vInPos : POSITION, float2 vInUV : TEXCOORD0)
{
  VS_DIST_OUTPUT OUT;

  OUT.pos = float4(vInPos.xyz, 1.0);

  OUT.uvzz = float4(vInUV, 1.0, 1.0);

  OUT.uv1 = vInUV + float2(0.0, fPixel);
  OUT.uv2 = vInUV + float2(0.0, -fPixel);
  OUT.uv3 = vInUV + float2(-fPixel, 0.0);
  OUT.uv4 = vInUV + float2(fPixel, 0.0);

  return OUT;
}

float4 PSCalcDist(VS_DIST_OUTPUT IN) : COLOR
{

  float4 s23, s21, s12, s32;
  float dist23Sq, dist21Sq, dist12Sq, dist32Sq;
  float4 s00 = tex2D(float_map, IN.uvzz.xy);
  clip(s00.w - 0.99);

  s23 = tex2D(float_map, IN.uv1);
  s21 = tex2D(float_map, IN.uv2);
  s12 = tex2D(float_map, IN.uv3);
  s32 = tex2D(float_map, IN.uv4);

  // расстояние от текущего пикселя до ближайшей известной ему границы
  float dist00Sq = length(IN.uvzz.xy - s00.xy);
  // расстояние от текущего пикселя до границы известной соседнему пикселю
  dist23Sq = length(IN.uvzz.xy - s23.xy);
  dist21Sq = length(IN.uvzz.xy - s21.xy);
  dist12Sq = length(IN.uvzz.xy - s12.xy);
  dist32Sq = length(IN.uvzz.xy - s32.xy);

  float2 uv;
  float4 res;
  uv = dist00Sq < 1.0 ? s00.xy : vFake;
  res = float4(uv, dist00Sq, s00.w);

  uv = dist23Sq < 1.0 ? s23.xy : vFake;
  res = res.z > dist23Sq ? float4(uv, dist23Sq, 1.0) : res;

  uv = dist21Sq < 1.0 ? s21.xy : vFake;
  res = res.z > dist21Sq ? float4(uv, dist21Sq, 1.0) : res;

  uv = dist12Sq < 1.0 ? s12.xy : vFake;
  res = res.z > dist12Sq ? float4(uv, dist12Sq, 1.0) : res;

  uv = dist32Sq < 1.0 ? s32.xy : vFake;
  res = res.z > dist32Sq ? float4(uv, dist32Sq, 1.0) : res;

  return res;
}

float4 PSCalcMedial(VS_DIST_OUTPUT IN) : COLOR
{
  float4 s00 = tex2D(float_map, IN.uvzz.xy);
  clip(s00.zw - float2(fPixel * 1.1, 0.99));

  float4 px = tex2D(float_map, IN.uv1);
  float4 nx = tex2D(float_map, IN.uv2);
  float4 py = tex2D(float_map, IN.uv3);
  float4 ny = tex2D(float_map, IN.uv4);

  float s00Dotpx = dot(s00.xy, px.xy);
  float s00Dotpy = dot(s00.xy, py.xy);
  float s00Dotnx = dot(s00.xy, nx.xy);
  float s00Dotny = dot(s00.xy, ny.xy);

  float minCosAngle = min(s00Dotpx, min(s00Dotpy, min(s00Dotnx, s00Dotny)));
  minCosAngle = 1.0 - minCosAngle;

  float scaledDist = s00.z * 200.0;

  clip(minCosAngle * scaledDist - 1.0);

  return float4(1.0, 1.0, s00.z, 1.0);
}

float4 PSCalcMedialPre(VS_OUTPUT IN) : COLOR
{
  float4 s00 = tex2D(float_map, IN.uvzz.xy);
  clip(s00.z - fPixel);

  float2 dist2 = IN.uvzz.xy - s00.xy;
  float lenDist2 = length(dist2);
  dist2 = normalize(dist2);

  return float4(dist2, lenDist2, 1.0);
}

technique T0
{
  pass P0
  {
    AlphaTestEnable = FALSE;
    AlphaFunc = ALWAYS;
    AlphaRef = 1;
    AlphaBlendEnable = FALSE;
    CullMode = NONE;
    ZEnable = FALSE;
    ZFunc = ALWAYS;
    ZWriteEnable = FALSE;
    vertexshader = compile vs_1_1 VNShader();
    pixelshader = compile ps_2_0 PSCalcDist();
  }
  pass P1
  {
    AlphaTestEnable = TRUE;
    AlphaFunc = GREATER;
    AlphaRef = 1;
    AlphaBlendEnable = FALSE;
    CullMode = NONE;
    ZEnable = FALSE;
    ZFunc = ALWAYS;
    ZWriteEnable = FALSE;
    vertexshader = compile vs_1_1 VSimpleShader();
    pixelshader = compile ps_2_0 PSCopyScr(false);
  }
  pass P2
  {
    AlphaTestEnable = TRUE;
    AlphaFunc = GREATER;
    AlphaRef = 1;
    AlphaBlendEnable = FALSE;
    CullMode = NONE;
    ZEnable = FALSE;
    ZFunc = ALWAYS;
    ZWriteEnable = FALSE;
    vertexshader = compile vs_1_1 VSimpleShader();
    pixelshader = compile ps_2_0 PSCopyScr(true);
  }
  pass P3
  {
    AlphaTestEnable = FALSE;
    AlphaFunc = ALWAYS;
    AlphaRef = 1;
    AlphaBlendEnable = FALSE;
    CullMode = NONE;
    ZEnable = FALSE;
    ZFunc = ALWAYS;
    ZWriteEnable = FALSE;
    vertexshader = compile vs_1_1 VSimpleShader();
    pixelshader = compile ps_2_0 PSCountCopy();
  }
  pass P4
  {
    AlphaTestEnable = TRUE;
    AlphaFunc = GREATER;
    AlphaRef = 1;
    AlphaBlendEnable = FALSE;
    CullMode = NONE;
    ZEnable = FALSE;
    ZFunc = ALWAYS;
    ZWriteEnable = FALSE;
    vertexshader = compile vs_1_1 VNShader();
    pixelshader = compile ps_2_0 PSCalcMedial();
  }
  pass P5
  {
    AlphaTestEnable = TRUE;
    AlphaFunc = GREATER;
    AlphaRef = 1;
    AlphaBlendEnable = FALSE;
    CullMode = NONE;
    ZEnable = FALSE;
    ZFunc = ALWAYS;
    ZWriteEnable = FALSE;
    vertexshader = compile vs_1_1 VSimpleShader();
    pixelshader = compile ps_2_0 PSCalcMedialPre();
  }
}

//////////////////////////////////////////////////////
// file "copy.hfx"
//////////////////////////////////////////////////////

VS_OUTPUT VSimpleShader(float3 vInPos : POSITION, float2 vInUV : TEXCOORD0)
{
  VS_OUTPUT OUT;
  OUT.pos = float4(vInPos.xyz, 1.0);
  OUT.uvzz = float4(vInUV, 1.0, 1.0);
  return OUT;
}

//////////////////////////////////////////////
//copy pass, if border point detected place own coord in xy, else &position
///////////////////////////////////////////////
float4 PSCountCopy(VS_OUTPUT IN) : COLOR
{
  float fHeghtTreshold = 1.0 / fAbsHeght;

  float4 s00 = tex2D(float_map, IN.uvzz.xy);
  clip(s00.w - 0.1);

  float4 down =  tex2D(float_map, IN.uvzz.xy + float2(0.0, fPixel));
  float4 up =    tex2D(float_map, IN.uvzz.xy + float2(0.0, -fPixel));
  float4 left =  tex2D(float_map, IN.uvzz.xy + float2(-fPixel, 0.0));
  float4 right =  tex2D(float_map, IN.uvzz.xy + float2(fPixel, 0.0));

  int count = 0;
  count = length(down.xyz - s00.xyz)  >= fHeghtTreshold ? count : count + 1;
  count = length(up.xyz - s00.xyz)  >= fHeghtTreshold ? count : count + 1;
  count = length(left.xyz - s00.xyz)  >= fHeghtTreshold ? count : count + 1;
  count = length(right.xyz - s00.xyz)  >= fHeghtTreshold ? count : count + 1;

  float4 res = (count < 4) ? float4(IN.uvzz.xy, -1000.0, 0.0) : float4(vFake, 0.0, 1.0);
  return res;
}

////////////////////////////////////////////////
// copy RT to screen, or other RT
////////////////////////////////////////////////
float4 PSCopyScr(VS_OUTPUT IN, uniform bool bDistantOnly) : COLOR
{
  float4 t0 = tex2D(float_map, IN.uvzz.xy);

  float dist = t0.z * fRange;

  float4 res = bDistantOnly ? float4(dist, dist, dist, t0.a) : t0;
  return res;
}