ZFX + Developia

Code: Alles auswählen

float4 LightColor;
float4 LightDir;

//position of the camera, for specular light
float3 view_position; 

//this is used to compute the world-position
matrix InvertViewProjection; 


Texture2D colorMap; 
Texture2D normalMap;
Texture2D depthMap;


struct PS_INPUT
{
float4 Pos : SV_POSITION;
float2 Tex : TEXCOORD0;
};

SamplerState samLinear2
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Clamp;
    AddressV = Clamp;
};


////////////////////////////////////////////////
// Vertex Shader - Main Function
///////////////////////////////////////////////
PS_INPUT VS(float3 Pos : POSITION, float2 Tex :TEXCOORD)
{
	PS_INPUT psInput;

    psInput.Pos = float4(Pos,1);
    psInput.Tex = Tex;
    return psInput;
}

///////////////////////////////////////////////
// Pixel Shader
///////////////////////////////////////////////
float4 PS(PS_INPUT psInput) : SV_Target
{
    float4 normalData = normalMap.Sample(samLinear2, psInput.Tex);
    //tranform normal back into [-1,1] range
    float3 normal = 2.0f * normalData.xyz - 1.0f;
    //get specular power, and get it into [0,255] range]
    float specularPower = normalData.a * 255;
    //get specular intensity from the colorMap
    float specularIntensity = colorMap.Sample(samLinear2, psInput.Tex).a;
	
	   //read depth
    float depthVal = depthMap.Sample(samLinear2, psInput.Tex).r;
        
    //compute screen-space position
    float4 position;
    position.x = psInput.Tex.x * 2.0f - 1.0f;
    position.y = -(psInput.Tex.x * 2.0f - 1.0f);
    position.z = depthVal;
    position.w = 1.0f;
        
    //transform to world space
    position = mul(position, InvertViewProjection);
    position /= position.w;
	
	
	float3 nLightDirection = normalize(LightDir);
	float3 directionToCamera = normalize(view_position - position);

	// Lichtanteil Directional berechnen
	float4 I_Directional = min(saturate(dot(normalize(normal), nLightDirection)), 1.0f);

	// Sepcular Directional Werte berechnen
	float3 Reflect_Directional = normalize(2*I_Directional*normal - nLightDirection);
	float4 Specular_Directional = pow(saturate(dot(Reflect_Directional, directionToCamera)), 16);

	float DiffuseAttn = clamp(0, 1, dot(normal, LightDir));

	return LightColor*(I_Directional*(Specular_Directional+DiffuseAttn));
}

Code: Alles auswählen

// Im VertexShader mach ich das:
	psInput.Norm = normalize(mul(Norm, (float3x3)World));

// Im PixelShader das hier (output.Norm ist float4 Norm : SV_TARGET1; )
    output.Norm.rgb = 0.5f * (psInput.Norm + 1.0f); 
    output.Norm.a = specularPower;