spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

HLSL-Quelltext

// Dieser Effekt wurde automatisch vom TriBase-Tool ModelConverter generiert.
// Hinweis: um einen Tabulator einzufügen, drücken Sie <Strg+Tab>!

DWORD   NumTextures         = 1;
STRING  Texture1Filename    = "Wood_2.png";
DWORD   Texture1Type        = 1; // 1: 2D-Textur; 2: Würfel; 3: Volumen
DWORD   Texture1ColorKey    = 0x00000000;
TEXTURE Texture1;


struct  Lighting
{
float3  Position;
float4  Diffuse;
float4  Specular;
int Distance;
};

int     NumLight;
Lighting    Lights[3];

// Material
float3 CameraPos;
float4 DiffuseColor = {0.5, 0.5, 0.5, 1.0};
float4 EmissiveColor = {0.05, 0.05, 0.05, 1.0};
float4 SpecularColor = {0.5, 0.5, 0.5, 1.0};
float SpecularPower = 15.0;


// Matrizen
float4x4    World;
float4x4    View;
float4x4    Prj;


sampler Main_sp = sampler_state
{
Texture     = <Texture1>;
AddressU    = Wrap;
AddressV    = Wrap;
MIPFilter   = Linear;
MinFilter   = Linear;
MagFilter   = Linear;
};


struct VS_INPUT
{
float4 Position : POSITION;
float3 Normal   : NORMAL;
float2 TexCords : TEXCOORD0;
float4 Diffuse  : COLOR0;
};

struct VS_OUTPUT        // PS_INPUT
{
float4 Position : POSITION;
float2 TexCords : TEXCOORD0;
float3 Normal   : COLOR0;
float3 WorldPos : TEXCOORD1;
};

//  ***************************************************************************************************************
//  ************************************Vertex Shader *************************************************************

VS_OUTPUT VS_MAIN(VS_INPUT IN)
{

VS_OUTPUT OUTPUT = (VS_OUTPUT) (0);

// Matrizen herstellen
float4x4 WorldPrj = mul(World, View);
float4x4 Matrix    = mul(WorldPrj, Prj);

float4   TexCords  = {0.0, 0.0, 0.0, 0.0};
float4   OutPos    = {0.0, 0.0, 0.0, 0.0};

OUTPUT.Position = mul(IN.Position, Matrix);
OUTPUT.Normal  = mul(IN.Normal, (float3x3)World);
OUTPUT.TexCords = IN.TexCords;
OUTPUT.WorldPos = mul(IN.Position, World);

return OUTPUT;
}
//  ***************************************************************************************************************
//  ************************************Beleuchtungs Funktion *************************************************************

float4  LightFunktion(int Light, VS_OUTPUT input, float4 texel)
{

// Lichtrichtung ausrechnen
float3      LightDir = normalize(input.WorldPos - Lights[0].Position);

// Leuchtstärke berechnen
float       Diffuse_Light = saturate(input.Normal - LightDir );

// Lichtabschwäschung berechnen (Falloff)
Diffuse_Light *= (Lights[0].Distance / dot(Lights[Light].Position - input.WorldPos, Lights[0].Position - input.WorldPos));

// Specular vorberechnungen
float3 h = normalize(normalize(CameraPos - input.WorldPos) - LightDir);
float Specular_Light = pow(saturate(dot(h, input.Normal)), SpecularPower);



return float4(saturate(
    EmissiveColor +
    (texel.xyz * DiffuseColor * Lights[0].Diffuse * Diffuse_Light * 0.6) + 
    (SpecularColor * Lights[0].Specular * Specular_Light * 0.4)
    ), 1.0);


}
//  ***************************************************************************************************************
//  ************************************Pixel Shader  *************************************************************
float4 PS_MAIN(VS_OUTPUT IN) : COLOR0
{
// Farben [Oberfläschen]
float4 Texel = {0.0, 0.0, 0.0, 0.0};    // Grass

Texel = tex2D(Main_sp, IN.TexCords);

return LightFunktion(0, IN, Texel);
}

//  ***************************************************************************************************************
//  ************************************Technik - 1 **************************************************************
TECHNIQUE T1
{
    PASS P1
    {
        VertexShader = compile vs_3_0 VS_MAIN();
        PixelShader = compile ps_3_0 PS_MAIN();
    }
}