jealosy rage fury.....

float3 fvLightPosition;
float3 fvEyePosition;
float4x4 matView;
float4x4 matViewProjection;

struct VS_INPUT
{
   float4 Position : POSITION0;
   float2 Texcoord : TEXCOORD0;
   float3 Normal :   NORMAL0;
   float3 Binormal : NORMAL0;
   float3 Tangent :  TANGENT0;
  
  
};

struct VS_OUTPUT
{
   float4 Position :        POSITION0;
   float2 Texcoord :        TEXCOORD0;
   float3 ViewDirection :   TEXCOORD1;
   float3 LightDirection :  TEXCOORD2;
  
};

VS_OUTPUT vs_main( VS_INPUT Input )
{
   VS_OUTPUT Output;

   Output.Position         = mul( Input.Position, matViewProjection );
   Output.Texcoord         = Input.Texcoord;
  
   float3 fvObjectPosition = mul( Input.Position, matView );
  
/*   Output.ViewDirection    = fvEyePosition - fvObjectPosition;
   Output.LightDirection   = fvLightPosition - fvObjectPosition;
   Output.Normal           = mul( Input.Normal, matView );
*/

   float3 fvViewDirection = fvEyePosition - fvObjectPosition;
   float3 fvLightDirection = fvLightPosition - fvObjectPosition;
  
   float3 fvNormal = mul(matView, Input.Normal);
   float3 fvBinormal = mul(matView, Input.Binormal);
   float3 fvTangent = mul(matView, Input.Tangent);
  
   Output.ViewDirection.x = dot(fvTangent, fvViewDirection);
   Output.ViewDirection.y = dot(fvBinormal, fvViewDirection);
   Output.ViewDirection.z = dot(fvNormal, fvViewDirection);
  
   Output.LightDirection.x = dot(fvTangent, fvLightDirection);
   Output.LightDirection.y = dot(fvBinormal, fvLightDirection);
   Output.LightDirection.z = dot(fvNormal, fvLightDirection);
    
   return( Output );
  
}

float4 fvAmbient;
float4 fvSpecular;
float4 fvDiffuse;
float fSpecularPower;

sampler2D baseMap;
sampler2D bumpMap;

struct PS_INPUT
{
   float2 Texcoord :        TEXCOORD0;
   float3 ViewDirection :   TEXCOORD1;
   float3 LightDirection:   TEXCOORD2; 
};

float4 ps_main( PS_INPUT Input ) : COLOR0
{     
   float3 fvLightDirection = normalize( Input.LightDirection );
   float3 fvNormal         = normalize((tex2D(bumpMap,Input.Texcoord).xyz*2.0f)-1.0f);
   float  fNDotL           = dot( fvNormal, fvLightDirection );
  
   float3 fvReflection     = normalize( ( ( 2.0f * fvNormal ) * ( fNDotL ) ) - fvLightDirection );
   float3 fvViewDirection  = normalize( Input.ViewDirection );
   float  fRDotV           = max( 0.0f, dot( fvReflection, fvViewDirection));
  
   float4 fvBaseColor      = tex2D( baseMap, Input.Texcoord );
  
   float4 fvTotalAmbient   = fvAmbient * fvBaseColor;
   float4 fvTotalDiffuse   = fvDiffuse * fNDotL * fvBaseColor;
   float4 fvTotalSpecular  = fvSpecular * pow( fRDotV, fSpecularPower );
  
   return( saturate( fvTotalAmbient + fvTotalDiffuse + fvTotalSpecular ) );
     
}

float3 fvLightPosition;
float3 fvEyePosition;
float4x4 matView;
float4x4 matViewProjection;

struct VS_INPUT
{
   float4 Position : POSITION0;
   float2 Texcoord : TEXCOORD0;
   float3 Normal :   NORMAL0;
   float3 Binormal : BINORMAL0;
   float3 Tangent :  TANGENT0;
  
};

struct VS_OUTPUT
{
   float4 Position :        POSITION0;
   float2 Texcoord :        TEXCOORD0;
   float3 ViewDirection :   TEXCOORD1;
   float3 LightDirection :  TEXCOORD2;
  
};

VS_OUTPUT vs_main( VS_INPUT Input )
{
   VS_OUTPUT Output;

   Output.Position         = mul( Input.Position, matViewProjection );
   Output.Texcoord         = Input.Texcoord;
  
   float3 fvObjectPosition = mul( Input.Position, matView );
  
   float3 fvViewDirection = fvEyePosition - fvObjectPosition;
   float3 fvLightDirection= fvLightPosition - fvObjectPosition;
  
   float3 fvNormal = mul(matView, Input.Normal);
   float3 fvBinormal = mul(matView, Input.Binormal);
   float3 fvTangent = mul(matView, Input.Tangent);
  
   Output.ViewDirection.x = dot(fvTangent, fvViewDirection);
   Output.ViewDirection.y = dot(fvBinormal, fvViewDirection);
   Output.ViewDirection.z = dot(fvNormal, fvViewDirection);
  
   Output.LightDirection.x = dot(fvTangent, fvLightDirection);
   Output.LightDirection.y = dot(fvBinormal, fvLightDirection);
   Output.LightDirection.z = dot(fvNormal, fvLightDirection);
  
 /*  Output.ViewDirection    = fvEyePosition - fvObjectPosition;
   Output.LightDirection   = fvLightPosition - fvObjectPosition;
   Output.Normal           = mul( Input.Normal, matView );
      */
   return( Output );
  
}

float4 fvAmbient;
float4 fvSpecular;
float4 fvDiffuse;
float fSpecularPower;
float fParallax;

sampler2D baseMap;
sampler2D bumpMap;

struct PS_INPUT
{
   float2 Texcoord :        TEXCOORD0;
   float3 ViewDirection :   TEXCOORD1;
   float3 LightDirection:   TEXCOORD2; 
};

float4 ps_main( PS_INPUT Input ) : COLOR0
{ 
   float h = tex2D (bumpMap, Input.Texcoord).w;
   float2 E = normalize(-Input.ViewDirection).xy;
   float2 Tex = Input.Texcoord + fParallax*h*E;
  
  
   float3 fvLightDirection = normalize( Input.LightDirection );
   float3 fvNormal         = normalize((tex2D(bumpMap,Tex).xyz* 2.0f)-1.0f);
   float  fNDotL           = dot( fvNormal, fvLightDirection );
  
   float3 fvReflection     = normalize( ( ( 2.0f * fvNormal ) * ( fNDotL ) ) - fvLightDirection );
   float3 fvViewDirection  = normalize( Input.ViewDirection );
   float  fRDotV           = max( 0.0f, dot( fvReflection, fvViewDirection ) );
  
   float4 fvBaseColor      = tex2D( baseMap,Tex);
  
   float4 fvTotalAmbient   = fvAmbient * fvBaseColor;
   float4 fvTotalDiffuse   = fvDiffuse * fNDotL * fvBaseColor;
   float4 fvTotalSpecular  = fvSpecular * pow( fRDotV, fSpecularPower );
  
   return( saturate( fvTotalAmbient + fvTotalDiffuse + fvTotalSpecular ) );
     
}

//float4x4 matViewProjection;
float4x4 view_proj_matrix: register(c0);
float4x4 view_matrix;
float4 lightDir;

struct VS_INPUT
{
   float4 Position : POSITION0;
   float3 Normal   :NORMAL0;
     
};

struct VS_OUTPUT
{
   float4 Position : POSITION0;
   float2 TexCoord : TEXCOORD0;
     
};

VS_OUTPUT vs_main( VS_INPUT In )
{
   VS_OUTPUT Out;
  
   Out.Position= mul(view_proj_matrix, In.Position);
  
   float3 PosW = mul(view_matrix, In.Position);
   float3 normalW = mul((float3x3)view_matrix, In.Normal );
  
   float diffuse = max(0,dot(-lightDir, normalW));
   Out.TexCoord.x = diffuse;
   Out.TexCoord.y = 0.5f;
  
  
   //Output.Position = mul( Input.Position, matViewProjection );
  
   return( Out );
  
}

sampler ToonShaderTexture;
struct PS_INPUT
{
   float2 TexCoord : TEXCOORD0;
};

struct PS_OUTPUT
{
   float4 Color :COLOR0;
};

PS_OUTPUT ps_main (PS_INPUT In)
{
   PS_OUTPUT Out;
  
   Out.Color = tex2D(ToonShaderTexture, In.TexCoord);
    
   return Out;
}

float4x4 view_proj_matrix : register(c0);
struct VS_INPUT
{
   float4 Pos :POSITION;
   float2 TexCoord : TEXCOORD0;
  
};

struct VS_OUTPUT
{
   float4 Pos : POSITION;
   float2 TexCoord : TEXCOORD0 ;
};

VS_OUTPUT vs_main (VS_INPUT In)
{
   VS_OUTPUT Out;
  
   In.Pos.xy = sign(In.Pos.xy);
   Out.Pos = float4(In.Pos.xy, 0.0, 1.0);
   Out.TexCoord.x = 0.5 * (1 + In.Pos.x);
   Out.TexCoord.y = 0.5 * (1 - In.Pos.y);
  
   return Out; 
}

sampler RT;

float mask[9] =
   {-1, -1, -1,
    -1,  8, -1,
    -1, -1, -1};
   
float coord[3] =  {-1, 0, +1};
float divider = 1;
float MAP_CX = 512;
float MAP_CY = 512;

struct PS_INPUT
{
   float2 TexCoord : TEXCOORD0;
};

struct PS_OUTPUT
{
   float4 Color : COLOR0;
};

float4 ps_main(float2 Tex : TEXCOORD0) : COLOR
{
   float4 Color = 0;
   float4 Ret;
  
   for (int i= 0 ; i<9 ; i++)
      Color += mask[i] * ( tex2D(RT, Tex + float2(coord[i%3]/MAP_CX, coord[i/3]/MAP_CY)));
     
      float gray =  1 -(Color.r*0.3 + Color.g*0.59 + Color.b *0.11);
     
      Ret = float4(gray, gray, gray, 1)/divider;
     
      return Ret;

}

float4x4 view_proj_matrix : register(c0);
float4x4 view_matrix;

struct VS_INPUT
{
   float4 Position : POSITION0;
   float3 Normal : NORMAL;
  
  
};

struct VS_OUTPUT
{
   float4 Position : POSITION0;
   float4 C0 : COLOR0;
  
  
};

VS_OUTPUT vs_main( VS_INPUT Input )
{
   VS_OUTPUT Output = (VS_OUTPUT) 0;
   Output.Position = mul ( view_proj_matrix, Input.Position);
   float3 Normal = mul (view_matrix, Input.Normal);
   Output.C0= float4(Normal,1);
  
      
   return( Output );
   }
  
float4 ps_main(float4 C0: COLOR0): COLOR
{
   float4 c;
   c[0] = 1.0;
   c[1] = 0;
   c[2] = 0;
   c[3] = 0;
  
   return C0;
}