spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "CApplication.hpp"
#include <d3dx9.h>


#define FVF_VERTEX (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)




CApplication::CApplication()
{
    pD3D    = NULL;
    pDevice = NULL;
    pLog    = NULL;

    memset(&PP, 0, sizeof(PP));
}
CApplication::~CApplication()
{
    release();
}

//clean up all

void CApplication::release()
{
    SAFE_RELEASE(pDevice);
    SAFE_RELEASE(pD3D);
}   


HRESULT CApplication::init(const GLOBALS &g)
{
    D3DFORMAT D3Dfmt;

    pLog = g.pLog;

    if(g.bWindowed)
        D3Dfmt = D3DFMT_UNKNOWN;
    else
        D3Dfmt = D3DFMT_X8R8G8B8;

    if(FAILED(pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        fprintf(pLog, "Error: Direct3DCreate9() failed!\n");
        return E_FAIL;
    }
    PP.Windowed                 = g.bWindowed;
    PP.hDeviceWindow            = g.hWnd;
    PP.SwapEffect               = D3DSWAPEFFECT_DISCARD;
    PP.BackBufferFormat         = D3Dfmt;
    PP.BackBufferWidth          = GetSystemMetrics(SM_CXSCREEN);
    PP.BackBufferHeight         = GetSystemMetrics(SM_CYSCREEN);
    PP.EnableAutoDepthStencil   = true;
    PP.AutoDepthStencilFormat   = D3DFMT_D16;






    if(FAILED(pD3D->CreateDevice(0,D3DDEVTYPE_HAL, g.hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &PP, &pDevice)))
    {
        fprintf(pLog, "Error: CreateDevice() failed\n");
        return E_FAIL;
    }   

    


    return oneTimeSceneInit();
}


HRESULT CApplication::tick(float dt)
{
    pDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 255, 0), 1, 0);


    //adjust device settings

    pDevice->SetMaterial(&material);
    pDevice->SetTexture(0, pTexture);

    pDevice->BeginScene();

    //render here

    renderRect(true);
     
    pDevice->EndScene();

    if(FAILED(pDevice->Present(NULL, NULL, NULL, NULL)))
        return E_FAIL;

    return S_OK;
}

HRESULT CApplication::oneTimeSceneInit()
{
    D3DCOLORVALUE clr = {1.0f, 1.0f, 1.0f, 1.0f};
    D3DXMATRIX xmat;


    //Set material colors

    memset(&material, 0, sizeof(material));
    //material = new D3DMATERIAL9;


    material.Diffuse = clr;
    material.Ambient = clr;

    //set ambient light level

    pDevice->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(255, 255, 255));
    
    //Create perspective projection matrix

    D3DXMatrixPerspectiveFovLH(&xmat, 0.8f, 800/600, 0.5f, 1000.0f);

    //Activate perspective projection

    pDevice->SetTransform(D3DTS_PROJECTION, &xmat);

    if(FAILED(D3DXCreateTextureFromFile(
        pDevice, "Texture.bmp", &pTexture )))
    {
        fprintf(pLog, "Error: D3DXCreateTextureFromFile() failed!\n");
        return E_FAIL;
    }

    return createRect();
}

HRESULT CApplication::createRect()
{
    void *pVertices = NULL;
    WORD *pIndices  = NULL;
    WORD i[6] = {0, 1, 2, 2, 3, 0};

    VERTEX v2[4] = {
        // X      Y     Z    NX    NY     NZ    TU    TV

        {-1.0f, -1.2f, 4.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f},
        {-1.0f,  1.2f, 4.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f},
        { 1.0f,  1.2f, 4.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f},
        { 1.0f, -1.2f, 4.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f},
    };
    memcpy(v, v2, sizeof(v2));

    //Create VB

    if(FAILED(pDevice->CreateVertexBuffer(
        sizeof(v2), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, 
        &pVB, NULL)))
    return E_FAIL;

    //betanke VB

    if(FAILED(pVB->Lock(0, sizeof(v2), (void**)&pVertices, 0)))
        return E_FAIL;
    
    memcpy(pVertices, v, sizeof(v2));
    pVB->Unlock();

    //Create IB

    if(FAILED(pDevice->CreateIndexBuffer(
        sizeof(i), D3DUSAGE_WRITEONLY,
        D3DFMT_INDEX16,
        D3DPOOL_DEFAULT,
        &pIB, NULL)))
        return E_FAIL;

    //betanke IB

    if(FAILED(pIB->Lock(0, sizeof(i), (void**)&pIndices, 0)))
        return E_FAIL;

    memcpy(pIndices, i, sizeof(i));
    pIB->Unlock();

    return S_OK;
}

HRESULT CApplication::renderRect(bool bStatic)
{
    WORD i[6] = {0, 1, 2, 2, 3, 0};
    pDevice->SetFVF(FVF_VERTEX);

    if(bStatic)
    {
        pDevice->SetIndices(pIB);
        pDevice->SetStreamSource(0, pVB, 0, sizeof(VERTEX));

        if(FAILED(pDevice->DrawIndexedPrimitive(
            D3DPT_TRIANGLELIST, 0, 0, 4, 0, 2)))
            return E_FAIL;

    }
    else
    {
        if(FAILED(pDevice->DrawIndexedPrimitiveUP(
            D3DPT_TRIANGLELIST, 
            0, 4, 2, i, D3DFMT_INDEX16, 
            v, sizeof(VERTEX))))
            return E_FAIL;
    }


    return S_OK;
    
}

C-/C++-Quelltext

#ifndef C_HPP
#define C_HPP

#include <D3D9.h>
#include "main.hpp"

#define SAFE_RELEASE(p) { if(p!=NULL) { (p)->Release(); (p)=NULL; } }

class CApplication
{
public:
    CApplication();
    virtual ~CApplication();
    HRESULT init(const GLOBALS &g);
    HRESULT tick(float dt=1);
    void release();
    HRESULT oneTimeSceneInit();
    HRESULT createRect();
    HRESULT renderRect(bool bStatic);

private:
    LPDIRECT3D9 pD3D;
    LPDIRECT3DDEVICE9 pDevice;
    D3DPRESENT_PARAMETERS PP;
    FILE *pLog;
    D3DMATERIAL9 material;
    LPDIRECT3DTEXTURE9 pTexture;
    LPDIRECT3DVERTEXBUFFER9 pVB;
    LPDIRECT3DINDEXBUFFER9 pIB;
    VERTEX v[4];
};

#endif