spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// Konstanten
float4x4   g_mComboMatrix;
float4x4   g_mWorldMatrix;
TEXTURE    g_Texture;

float3     g_DirLightDir;
float3     g_DirLightAmbient;
float3     g_CamPos;

float4     g_Diffuse;
float3     g_Emissive;
float3     g_Specular;
float1     g_Power;

// Sampler
sampler Texture_Sampler = sampler_state 
{
    texture = <g_Texture>;
};

// Vertexshader Input
struct VS_INPUT
{
    float4 Pos : POSITION;
    float3 Norm : NORMAL;
    float2 Tex0 : TEXCOORD0;
};

// Vertexshader Output
struct VS_OUTPUT
{
    float4 Pos          : POSITION;
    float2 Tex0         : TEXCOORD0;
    float1 LightIntens  : TEXCOORD1;
    float3 Normal       : TEXCOORD2;
    float3 ViewDir      : TEXCOORD3;
};

// Vertexshader
VS_OUTPUT vs_StdDirLightingSpec(VS_INPUT In)
{
    VS_OUTPUT Out;
    
    // Normalenvektor transformieren
    In.Norm = mul(In.Norm, g_mWorldMatrix);

    // Texturkoordinaten übernehmen
    Out.Tex0 = In.Tex0;
    
    // Position
    Out.Pos = mul(In.Pos, g_mComboMatrix);

    // Lichtinensität
    Out.LightIntens = dot(In.Norm, -g_DirLightDir);

    // Vektor zur Kamera
    float3 PosWorld = normalize(mul(In.Pos, g_mWorldMatrix));
    Out.ViewDir = normalize(g_CamPos - PosWorld);

    // Normalenvektor weitergeben
    Out.Normal = In.Norm;
    
    return Out;
}

// Pixelshader
float4 ps_StdDirLightingSpec(VS_OUTPUT In) : COLOR 
{
    // Textur sampeln
    float4 Texture = tex2D(Texture_Sampler, In.Tex0);
    
    // Diffuse, Ambient und Textur 
    float3 Color =  Texture.rgb * 
                   (mul(g_Diffuse.rgb, In.LightIntens) + 
                    g_DirLightAmbient);

    // Emissive hinzufügen
    Color += g_Emissive;

    // Specular hinzufügen
    float3 Reflect = normalize(2 * In.LightIntens * In.Normal - g_DirLightDir);
    Color += pow(dot(Reflect, In.ViewDir), g_Power) * g_Specular;    

    // Zurückgeben
    return float4(Color.rgb, g_Diffuse.a);
}

////////////////////////////////////
TECHNIQUE T0
{
    PASS P0
    {
        VertexShader = compile vs_1_1 vs_StdDirLightingSpec();
        PixelShader = compile ps_2_0 ps_StdDirLightingSpec();
    }
}

Quellcode

// Globale Konstanten
float4x4   g_mComboMatrix;
float3x3   g_mWorldMatrix;
TEXTURE    g_Texture;

float3     g_DirLightDir;
float3     g_DirLightAmbient;

float4     g_Diffuse;
float3     g_Emissive;


// Sampler
sampler Texture_Sampler = sampler_state 
{
    texture = <g_Texture>;
};

// Vertexdefinitionen
// Vertexshader Input
struct VS_INPUT
{
    float4 Pos : POSITION;
    float3 Norm : NORMAL;
    float2 Tex0 : TEXCOORD0;
};

// Vertexshader Output
struct VS_OUTPUT
{
    float4 Pos : POSITION;
    float2 Tex0 : TEXCOORD0;
    float3 Norm : TEXCOORD1;
};

// Vertexshader
VS_OUTPUT vs_StdDirLighting(VS_INPUT In)
{
    VS_OUTPUT Out;
    
    // Normalenvektor
    Out.Norm = mul(In.Norm, g_mWorldMatrix);

    // Texturkoordinaten übernehmen
    Out.Tex0 = In.Tex0;
    
    // Position
    Out.Pos = mul(In.Pos, g_mComboMatrix);

    return Out;

}

// Pixelshader
float4 ps_StdDirLighting(VS_OUTPUT In) : COLOR 
{
    // Normalisieren, da durch Shading böse geworden
    In.Norm = normalize(In.Norm);

    // Lichtintensität
    float1 LightIntens = dot(In.Norm, -g_DirLightDir);

    // Textur samplen
    float4 Texture = tex2D(Texture_Sampler, In.Tex0);
    
     // Diffuse, Ambient und Textur 
    float3 Color =  Texture.rgb * 
                   (mul(g_Diffuse.rgb, LightIntens) + g_DirLightAmbient);

    // Emissive hinzufügen
    Color += g_Emissive;

    return float4(Color.rgb, g_Diffuse.a+Texture.a-1.0f);
}

////////////////////////////////////
TECHNIQUE T0
{
    PASS P0
    {
        VertexShader = compile vs_1_1 vs_StdDirLighting();
        PixelShader = compile ps_2_0 ps_StdDirLighting();
    }
}

C-/C++-Quelltext

gve::Matrix mTranspInversWorld = gve::MatrixInvert(pCurEntry->Data->mTransScaleRotMatrix);
mTranspInversWorld = gve::MatrixTranspose(mTranspInversWorld);

gve::Vector3 vRelDirLightDir; // = gve::Vector3TransformNormal(vRelDirLightDir, mTranspInversWorld);

vRelDirLightDir.x = vDirLightDir.x * mTranspInversWorld.m11 + vDirLightDir.y * mTranspInversWorld.m21 + vDirLightDir.z * mTranspInversWorld.m31;
vRelDirLightDir.y = vDirLightDir.x * mTranspInversWorld.m12 + vDirLightDir.y * mTranspInversWorld.m22 + vDirLightDir.z * mTranspInversWorld.m32;
vRelDirLightDir.z = vDirLightDir.x * mTranspInversWorld.m13 + vDirLightDir.y * mTranspInversWorld.m23 + vDirLightDir.z * mTranspInversWorld.m33;
vRelDirLightDir = gve::Vector3Normalize(vRelDirLightDir);           

m_pStdDirLightingShader->GetEffect()->SetVector("g_RelDirLightDir", &D3DXVECTOR4(vRelDirLightDir.x, vRelDirLightDir.y, vRelDirLightDir.z, 1.0f));

Quellcode

// Globale Konstanten
float4x4   g_mComboMatrix;
TEXTURE    g_Texture;

float3     g_RelDirLightDir;
float3     g_DirLightAmbient;

float4     g_cDiffuse;
float3     g_cEmissive;

// Sampler
sampler Texture_Sampler = sampler_state 
{
    texture = <g_Texture>;
};

// Vertexshader Input
struct VS_INPUT
{
    float4 Pos : POSITION;
    float3 Norm : NORMAL;
    float2 Tex0 : TEXCOORD0;
};

// Vertexshader Output
struct VS_OUTPUT
{
    float4 Pos : POSITION;
    float2 Tex0 : TEXCOORD0;
    float3 Norm : TEXCOORD1;
};

// Vertexshader
VS_OUTPUT vs_StdDirLighting(VS_INPUT In)
{
    VS_OUTPUT Out;
    Out.Norm = In.Norm;
    Out.Tex0 = In.Tex0;
    Out.Pos = mul(In.Pos, g_mComboMatrix);

    return Out;

}

// Pixelshader
float4 ps_StdDirLighting(VS_OUTPUT In) : COLOR 
{
    In.Norm = normalize(In.Norm);
    float1 LightIntens = saturate(dot(In.Norm, -g_RelDirLightDir));
    float4 Texture = tex2D(Texture_Sampler, In.Tex0);
    float3 Color =  Texture.rgb * 
                   (mul(g_cDiffuse.rgb, LightIntens) + g_DirLightAmbient);
    Color += g_cEmissive;

    
    return float4(Color.rgb, g_cDiffuse.a+Texture.a-1.0f);
}

////////////////////////////////////
TECHNIQUE T0
{
    PASS P0
    {
        VertexShader = compile vs_1_1 vs_StdDirLighting();
        PixelShader = compile ps_2_0 ps_StdDirLighting();
    }
}

C-/C++-Quelltext

gve::Vector3 vRelDirLightDir = gve::Vector3TransformNormal(gve::Vector3Normalize(vDirLightDir), gve::MatrixTranspose(gve::MatrixInvert(pCurEntry->Data->mTransScaleRotMatrix)));