Collaborative Control

//transformation matrix
uniform extern float4x4 fx_World;
uniform extern float4x4 fx_WVP;
uniform extern float3    fx_ViewPosition;
uniform extern float3    fx_LocalViewPosition;

//directional lights
uniform extern bool fx_Enabled_DL0;
uniform extern float3 fx_Direction_DL0;
uniform extern float3 fx_DiffuseColor_DL0;

//ambient light
uniform extern float4 fx_AmbientColor;

//specular
uniform extern bool fx_SpecularOn;
uniform extern float4 fx_SpecularColor;
uniform extern float fx_SpecularPower;

//incandesence
uniform extern bool fx_LightMaskEnabled;
//incandesence texture for shader
uniform extern texture fx_LightMaskTexture;        

//diffuse
uniform extern float4 fx_DiffuseColor;
uniform extern bool fx_DiffuseEnabled;
// diffuse texture for shader
uniform extern texture fx_DiffuseTexture;

//reflection
uniform extern bool fx_ReflectionEnabled;
uniform extern float fx_ReflectionIntensity;
// reflection texture for shader
uniform extern texture fx_ReflectionTexture;

// diffuse texture filter
sampler2D diffuseSampler = sampler_state
{
    Texture = <fx_DiffuseTexture>;
    magfilter = LINEAR; // magfilter, bigger than real size
    minfilter = LINEAR; // minfilter, smaller than real size
    mipfilter = LINEAR;
};

// incandesence texture filter
sampler2D lightMaskSampler = sampler_state
{
    Texture = <fx_LightMaskTexture>;
    magfilter = LINEAR; // magfilter, bigger than real size
    minfilter = LINEAR; // minfilter, smaller than real size
    mipfilter = LINEAR;
};

// reflection texture filter
samplerCUBE reflectionSampler = sampler_state
{
    Texture = <fx_ReflectionTexture>;
};

// input to vertex shader
struct VS_INPUT
{
    float4 f4Position            : POSITION0;
    float4 f4Normal            : NORMAL;
    float2 textureCoordinate        : TEXCOORD0;
};

// vertex shader output
struct VS_OUTPUT
{
    float4 f4Position                : POSITION0;
    float4 f4WorldPos                : TEXCOORD0;
    float3 f3Normal                : TEXCOORD1;
    float4 f4Incident                : TEXCOORD2;
    float3 f3Reflection                : TEXCOORD3;
    float3 f3LocalReflection            : TEXCOORD4;
    float2 textureCoordinate            : TEXCOORD5;
    float  grazingRatio                : TEXCOORD6;
};


// alter vertex inputs
void vertex_shader(in VS_INPUT IN, out VS_OUTPUT OUT)
{
    //raster output positions
    OUT.f4Position = mul(IN.f4Position, fx_WVP);
    //world vertex position
    OUT.f4WorldPos = mul(IN.f4Position, fx_World);
    //world normal
    OUT.f3Normal = normalize(mul(float4(IN.f4Normal.x, IN.f4Normal.y, IN.f4Normal.z, 0.0),
								fx_World ).xyz);
    OUT.f4Incident = normalize(OUT.f4WorldPos - float4(fx_ViewPosition.xyz, 0.0));
    
    if(fx_SpecularOn)
    {
        OUT.f3Reflection = normalize( reflect( OUT.f4Incident, OUT.f3Normal )).xyz;
    }
    if(fx_ReflectionEnabled)
    {
        float4 localIncident = normalize(IN.f4Position - float4(fx_LocalViewPosition,0.0));
        OUT.f3LocalReflection = normalize( reflect( -localIncident , IN.f4Normal)).xyz;
        
        OUT.grazingRatio = max(0.2, 1 - pow(saturate(dot( OUT.f3LocalReflection,
					normalize(IN.f4Normal.xyz)) ), 2));
    }
    
    //UV texture coordinates
    OUT.textureCoordinate = IN.textureCoordinate;
}

// alter vertex shader output and send to hardware one pixel at a time
float4 pixel_shader(in VS_OUTPUT IN) : COLOR
{
    float4 diffuseColor = fx_DiffuseColor;
    
    if(fx_DiffuseEnabled)
    {
        diffuseColor = tex2D(diffuseSampler, IN.textureCoordinate);
    }
    
    float3 diffuseLight = float3(0,0,0);
    float specularIntensity = 0;
    
    if(fx_Enabled_DL0)
    {
        diffuseLight = diffuseLight + (dot(IN.f3Normal, fx_Direction_DL0) 
                * fx_DiffuseColor_DL0);
				
        if(fx_SpecularOn)
            specularIntensity = specularIntensity
                + pow(saturate(dot(IN.f3Reflection, fx_Direction_DL0)), fx_SpecularPower);
    }
        
    //incandesence
    float4 lightMaskContribution = float4(0,0,0,0);
    if(fx_LightMaskEnabled)
    {
      lightMaskContribution = tex2D(lightMaskSampler, IN.textureCoordinate) *
            (1 - min(0.85, max(max(diffuseLight.r, diffuseLight.g),diffuseLight.b)));
    }
    
    //reflections
    float4 reflectionContribution = float4(0,0,0,0);
    if(fx_ReflectionEnabled)
    {
      reflectionContribution = fx_ReflectionIntensity * IN.grazingRatio *
            texCUBE(reflectionSampler, IN.f3LocalReflection) * fx_SpecularColor;
    }
    
    return (diffuseColor * (lightMaskContribution + float4(diffuseLight.xyz, 1.0)
           + fx_AmbientColor)) + reflectionContribution
           + (fx_SpecularColor * specularIntensity);
}

//technique, main entry
technique t0
{
    pass p0
    {
        // declare and initialize vs
        vertexshader = compile vs_1_1 vertex_shader();    

        // declare and initialize ps
        pixelshader = compile ps_3_0 pixel_shader();    
    }
}