spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include<d3d9.h>
#include<d3dx9.h>
#include<string>



using namespace std;

#define D3D_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)

class CDirect3D
{
    public:
    CDirect3D();
    ~CDirect3D();

    void BeginScene();
    void EndScene();
    void DrawTriangle();

    bool Init(HWND hwnd, int height, int width, bool windowed = true);

    LPDIRECT3DDEVICE9 GetDevice();
    LPDIRECT3DSURFACE9 GetBackBuffer();

    void CreateScreenshot(char* FILE_NAME);
    void Rotate(float x, float y, float z);

    void CleanUp();

    protected:

    LPDIRECT3D9       D_lpD3D;
    LPDIRECT3DDEVICE9 D_Device;

    int D_Width;
    int D_Height;
    HWND D_Hwnd;

    LPDIRECT3DSURFACE9 D_BackBuffer;

    LPDIRECT3DVERTEXBUFFER9 VB_Triangle;

    struct CUSTOMVERTEX
    {
        float x, y, z;
        DWORD color;
    };



    float RotationX;
    float RotationY;
    float RotationZ;

    float TranslationX;
    float TranslationY;
    float TranslationZ;

};

C-/C++-Quelltext

#include "Direct3D.h"

#include <dxerr9.h>



CDirect3D::CDirect3D()
{
    D_lpD3D        = NULL;
    D_Device       = NULL;
    D_BackBuffer   = NULL;
    VB_Triangle    = NULL;

    RotationX      = 0;
    RotationY      = 0;
    RotationZ      = 0;

    TranslationX   = 0;
    TranslationY   = 0;
    TranslationZ   = 0;
}

CDirect3D::~CDirect3D()
{
    CleanUp();
}

// Direct3D initialisieren

bool CDirect3D::Init(HWND hwnd, int width, int height, bool windowed)
{
    // Direct3D-Objekt erzeugen

    D_lpD3D = Direct3DCreate9(D3D_SDK_VERSION);

    if(NULL == D_lpD3D)
    {
        // Fehler, D3D-Objekt wurde nicht erzeugt

        return FALSE;
    }

    // Parameter fuer den Modus festlegen

    D3DPRESENT_PARAMETERS PParams;
    ZeroMemory(&PParams, sizeof(PParams));

    PParams.SwapEffect       = D3DSWAPEFFECT_DISCARD;
    PParams.hDeviceWindow    = hwnd;
    PParams.Windowed         = windowed;

    PParams.BackBufferWidth  = width;
    PParams.BackBufferHeight = height;
    PParams.BackBufferFormat = D3DFMT_A8R8G8B8;

    // Z-Buffer erzeugen

    PParams.AutoDepthStencilFormat = D3DFMT_D16;
    PParams.EnableAutoDepthStencil = TRUE;

    HRESULT hr;

    // Direct3D-Geraet anlegen

    if(FAILED(hr = D_lpD3D->CreateDevice(
                                 D3DADAPTER_DEFAULT,
                                 D3DDEVTYPE_HAL,
                                 hwnd,
                                 D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                 &PParams,
                                 &D_Device)))
    {
        // Fehler, Geraet kann nicht angelegt werden

        const char* Err = DXGetErrorDescription9(hr);

        DXTRACE_MSG(Err);

        return FALSE;
    }

    // Zeiger auf dem Hintergrundpuffer holen

    D_Device->GetBackBuffer(0, 0,
                                 D3DBACKBUFFER_TYPE_MONO,
                                 &D_BackBuffer);


    // Aktivieren des Z-Buffers

    D_Device->SetRenderState(D3DRS_ZENABLE, TRUE);

    CUSTOMVERTEX Triangle[]=
    {
        { -.0f, 1.0f, 0.0f, 0xFF00FF00 },  // Vorne

        { 1.0f, 1.0f, 0.0f, 0xFF00FF00 },
        { 1.0f, 0.0f, 0.0f, 0xFF00FF00 },
    };


    BYTE* VertexBufferStart;

    D_Device->CreateVertexBuffer(sizeof(Triangle),
                                    D3DUSAGE_WRITEONLY,
                                    D3D_CUSTOMVERTEX,
                                    D3DPOOL_MANAGED,
                                    &VB_Triangle,
                                    NULL);

    // Vertex Buffer sperren

    VB_Triangle->Lock(0, 0, reinterpret_cast<void**>(&VertexBufferStart), 0);

    // Daten des Dreiecks in der Buffer kopieren

    memcpy(VertexBufferStart, Triangle, 3);

    // Vertex Buffer wieder freigeben

    VB_Triangle->Unlock();

    // Das Vertex-Format festlegen

    D_Device->SetFVF(D3D_CUSTOMVERTEX);


    // Die Kamera wird an der Position (0.0f, 0.0f, -10.0f) aufgestellt

    D3DXMATRIX ViewMatrix;
    D3DXMatrixLookAtLH(&ViewMatrix,
                       &D3DXVECTOR3(0.0f, 0.0f, -10.0f),
                       &D3DXVECTOR3(0.0f, 0.0f, 0.0f),
                       &D3DXVECTOR3(0.0f, 1.0f, 0.0f));

    D_Device->SetTransform(D3DTS_VIEW, &ViewMatrix);


    // Sichtkegel definieren

    D3DXMATRIX ProjMatrix;
    D3DXMatrixPerspectiveFovLH(&ProjMatrix,
                               D3DX_PI/4,
                               static_cast<float>(width) / static_cast<float>(height),
                               1.0f,
                               100.0f );

    D_Device->SetTransform(D3DTS_PROJECTION, &ProjMatrix);

    // Beleuchtung abschalten

    D_Device->SetRenderState(D3DRS_LIGHTING, FALSE);

    return TRUE;
}

// Zeiger auf den Hintergrundbuffer zurueckgeben

LPDIRECT3DSURFACE9 CDirect3D::GetBackBuffer(void)
{
    return D_BackBuffer;
}


// Methoden zum Start/Beenden der Szene

void CDirect3D::BeginScene(void)
{
    // Z-Buffer löschen

    D_Device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(255, 255, 255), 1.0f, 0);

    D_Device->BeginScene();
}

void CDirect3D::DrawTriangle()
{
    D3DXMATRIX WorldMatrix;
    D3DXMATRIX RotationMatrix;
    D3DXMATRIX TranslationMatrix;

    D_Device->SetStreamSource(0, VB_Triangle, 0, sizeof(CUSTOMVERTEX));

    D3DXMatrixRotationX(&RotationMatrix, RotationX);
    D3DXMatrixRotationY(&RotationMatrix, RotationY);
    D3DXMatrixRotationZ(&RotationMatrix, RotationZ);

    D3DXMatrixTranslation(&TranslationMatrix, TranslationX, TranslationY, TranslationZ);

    D3DXMatrixMultiply(&WorldMatrix, &RotationMatrix, &TranslationMatrix);

    D_Device->SetTransform(D3DTS_WORLD, &WorldMatrix);
    D_Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 3);
}


void CDirect3D::EndScene(void)
{
    D_Device->EndScene();

    D_Device->Present(0, 0, 0, 0);
}

// Screenshot erzeugen

void CDirect3D::CreateScreenshot(char* FILE_NAME)
{
    // temporaere Oberflaeche fuer den Screenshot anlegen

    LPDIRECT3DSURFACE9 lpSurface;

    D_Device->CreateOffscreenPlainSurface(
                                  1024, 768,
                                  D3DFMT_A8R8G8B8,
                                  D3DPOOL_SYSTEMMEM,
                                  &lpSurface, 0);

    // Inhalt des Frontbuffer in die Oberflaeche kopieren

    D_Device->GetFrontBufferData(0, lpSurface);

    // Oberflaeche in Datei speichern

    D3DXSaveSurfaceToFile(FILE_NAME, D3DXIFF_BMP,
                          lpSurface, 0, NULL);

    // temporaere Oberflaeche wieder freigeben

    lpSurface->Release();
}

// das Direct3D-Device zurueckgeben

LPDIRECT3DDEVICE9 CDirect3D::GetDevice(void)
{
    return D_Device;
}


// Freigeben der Objekte

void CDirect3D::CleanUp(void)
{
    // testen, ob die Objekt angelegt

    // wurden und ggf. freigeben


    if(NULL != D_BackBuffer)
    {
        D_BackBuffer->Release();
        D_BackBuffer = NULL;
    }

    if(NULL != D_Device)
    {
        D_Device->Release();
        D_Device = NULL;
    }

    if(NULL != D_lpD3D)
    {
        D_lpD3D->Release();
        D_lpD3D = NULL;
    }
}

void CDirect3D::Rotate(float x, float y, float z)
{
    RotationX += x;
    RotationY += y;
    RotationZ += z;
}

C-/C++-Quelltext

void CDirect3D::DrawTriangle()
{

    D_Device->SetStreamSource(0, VB_Triangle, 0, sizeof(CUSTOMVERTEX));

    D_Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 3);
}