spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

struct VS_INPUT
{
    float4 PositionIn : POSITION;
    float3 NormalIn   : NORMAL;
    float4 DiffuseIn  : COLOR0;
};

struct VS_OUTPUT
{
    float4 PositionOut : POSITION;
    float4 DiffuseOut   : COLOR0;
};

float4x4 ShaderMatrix : register(c0);
float4x4 WorldMatrix : register(c4);
float4   DiffuseLightColor : register(c10);
float4   LightDirection : register(c12);

VS_OUTPUT main(const VS_INPUT VertexIn)
{
    VS_OUTPUT VertexOut;
    float3 transformedNormal = normalize(mul(VertexIn.NormalIn,WorldMatrix));
    float dp = dot(transformedNormal, -LightDirection);
    if(dp < 0.0f)
        dp = 0.0f;
    float4 diffuse = mul(dp, VertexIn.DiffuseIn);
    VertexOut.DiffuseOut = diffuse * DiffuseLightColor;
    VertexOut.PositionOut = mul(VertexIn.PositionIn, ShaderMatrix);
    
    return VertexOut;
}

C-/C++-Quelltext

#include "Framework.h"

CGame::CGame()
{
    Trans = D3DXVECTOR3(0.0f,0.0f,0.0f);
}
HRESULT CGame::Load()
{
    LPD3DXBUFFER pMtrlBuffer;

    if(FAILED(D3DXCreateTeapot(framework.init.GetDevice(),&Player,&pMtrlBuffer)))
    {
        framework.log.WriteToLog("Fehler beim Laden des Mesh:");
    }

    framework.vshader[0].Create(framework.init.GetDevice(), TEXT("Diff_DirLight.hlsl"));

    framework.DirLight.SetAmbientColor(D3DXCOLOR(1.0f,0.0f,0.0f,0.0f));
    framework.DirLight.SetDiffuseColor(D3DXCOLOR(1.0f,0.0f,0.0f,0.0f));
    framework.DirLight.SetSpecularColor(D3DXCOLOR(1.0f,0.0f,0.0f,0.0f), 10.0f);

    return 0;
}

CGame::~CGame()
{
    SAFE_RELEASE(Player);
}

HRESULT CGame::Move(float Secs)
{
    return 0;
}
HRESULT CGame::Render(float Secs)
{
    D3DXMATRIX ProjectionMatrix;
    D3DXMATRIX TranslationMatrix;
    D3DXMATRIX WorldMatrix;
    D3DXMATRIX Rotation;
    D3DXMATRIX Cam;

    D3DXMatrixPerspectiveFovLH(&ProjectionMatrix, D3DXToRadian(60.f),1.f,1.f,100.f); 

    D3DXMatrixTranslation(&TranslationMatrix,Trans.x,Trans.y,Trans.z);
    D3DXMatrixRotationX(&Rotation,0.0f);

    WorldMatrix = TranslationMatrix*Rotation;

    D3DXMatrixLookAtLH(&Cam, 
                       &D3DXVECTOR3(0.0f,0.0f,-8.0f),
                       &D3DXVECTOR3(0.0f,0.0f,1.0f),
                       &D3DXVECTOR3(0.0f,1.0f,0.0f));

    framework.init.GetDevice()->SetTransform(D3DTS_VIEW, &Cam); 
    framework.init.GetDevice()->SetTransform(D3DTS_PROJECTION, &ProjectionMatrix);
    framework.init.GetDevice()->SetTransform(D3DTS_WORLD, &WorldMatrix);

    //Gesamtmatrix fuer den Shader berechnen
    D3DXMATRIX ShaderMatrix =  WorldMatrix * Cam;

    //und diese transponieren.
    D3DXMatrixTranspose(&ShaderMatrix, &ShaderMatrix);

    //uebergeben der Konstanten an den Shader
    framework.init.GetDevice()->SetVertexShaderConstantF( 0, (float*)&ShaderMatrix, 4 );
    D3DXMATRIX TransposedWorldMatrix;
    D3DXMatrixTranspose(&TransposedWorldMatrix, &WorldMatrix);
    framework.init.GetDevice()->SetVertexShaderConstantF( 4, (float*)&TransposedWorldMatrix, 4 );



    framework.dxFuncs.BeginRendering(framework.init.GetDevice(),0xFF00FF00);

    //Bewegen der Lichtrichtung
    D3DXVECTOR3 LightDirection = D3DXVECTOR3(0.0f,0.0f,0.0f);
    //Normalisieren fuer den Shader
    D3DXVec3Normalize(&LightDirection,&LightDirection);
    //uebergeben an die Lichtquelle
    framework.DirLight.SetDirection(LightDirection);

    //Nun das Licht einschalten
    framework.Lighting.TurnLightOn(framework.init.GetDevice(),&framework.DirLight);

    framework.init.GetDevice()->SetFVF(UT_FVF);
    
    framework.init.GetDevice()->SetVertexShader(framework.vshader[0].Get());
    Player->DrawSubset(0);

    framework.dxFuncs.EndRendering(framework.init.GetDevice());

    return 0;
}

C-/C++-Quelltext

CVertexShader::CVertexShader()
{

    m_lpShader = NULL;
    m_bUsingHLSL = false;

}

HRESULT CVertexShader::Create(LPDIRECT3DDEVICE9 lpD3DDevice, PTCHAR ptcFilename)
{
    ID3DXBuffer* pShaderBuffer = NULL;
    ID3DXBuffer* pShaderErrors = NULL;

    //Den Pfad mit der Datei verbinden
    _stprintf_s(m_tcFilepath,TEXT("%s"),ptcFilename);
    //Lnge bis zur Datei extension
    int iToExt = int(_tcslen(ptcFilename))-4;
    //Vergleichen ob extension = "hlsl" 
    int iComp = _tcscmp(ptcFilename+iToExt,TEXT("hlsl"));
    if(iComp == 0)  //wenn ja, dann HLSL
        m_bUsingHLSL = true;
    else            //ansonsten Assembler Shader
        m_bUsingHLSL = false;

    if(m_bUsingHLSL)
    {
        LPCSTR prof = framework.init.VertexShaderVersion;
        //Kompilieren des HLSL Shader
        if (FAILED(D3DXCompileShaderFromFile(m_tcFilepath, NULL, NULL, "main", prof, D3DXSHADER_DEBUG|D3DXSHADER_SKIPOPTIMIZATION, &pShaderBuffer, &pShaderErrors, NULL)))
        {
            framework.log.WriteToLog(TEXT("Fehler beim erstellen des HLSL Shaders!"));
            return 1;
        }
    }
    else
    {
        //Assemblen des Assembler Shader
        if (FAILED(D3DXAssembleShaderFromFile(m_tcFilepath, NULL, NULL, D3DXSHADER_DEBUG, &pShaderBuffer, &pShaderErrors)))
        {
            framework.log.WriteToLog(TEXT("Fehler beim erstellen des Assembler Shaders!"));
            return 1;
        }
    }
    //Vertex Shader erstellen
    if (FAILED(lpD3DDevice->CreateVertexShader((DWORD *)pShaderBuffer->GetBufferPointer(),
                                   &m_lpShader)))
    {
        framework.log.WriteToLog(TEXT("Fehler beim laden des Shaders!"));
        return E_FAIL;
    }

    //Puffer freigeben
    if(pShaderBuffer != NULL)
    {
        pShaderBuffer->Release();
        pShaderBuffer = NULL;
    }
    if(pShaderErrors != NULL)
    {
        pShaderErrors->Release();
        pShaderErrors = NULL;
    }

    return 0;
}


LPDIRECT3DVERTEXSHADER9 CVertexShader::Get()
{
    return m_lpShader;
}


HRESULT CVertexShader::Destroy()
{
    //Shader freigeben
    if(m_lpShader != NULL)
    {
        m_lpShader->Release();
        m_lpShader = NULL;
    }

    return S_OK;
}

CVertexShader::~CVertexShader()
{
    Destroy();
}