spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// veDirect3D.cpp
//
#include "VisualEngine.h"

veRenderObjects g_RenderObjects[10000];
int             g_NumRenderObjects;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_CREATE:
        break;

        case WM_CLOSE:
        DestroyWindow(hwnd);
        PostQuitMessage(0);
        break;
    }

    return DefWindowProc(hwnd, msg, wParam, lParam);
}

veDirect3D& veDirect3D::D3DInstance()
{
    static veDirect3D TheD3D;
    return TheD3D;
}

veResult veDirect3D::Init(bool bWindowed, char * pcWindowTitle)
{
    // -----------------------------------------------------------------------------------
    // Direct3D initialisieren
    // -----------------------------------------------------------------------------------

    // Variablen deklarieren
    HRESULT                     hResult;            // Ist die Funktion erfolgreich oder nicht?
    D3DPRESENT_PARAMETERS       PresentParams;      // PresentParamters für Direct3D
    D3DDISPLAYMODE              VideoMode;          // Struktur ausfüllen
    WNDCLASSEX                  wc;                 // WNDCLASSEX-Struktur Variable um die Struktur zu füllen

    ZeroMemory(&wc, sizeof(WNDCLASSEX));

    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.hInstance = ve_g_DLLHandle;
    wc.lpfnWndProc = WndProc;
    wc.cbWndExtra = 0;
    wc.cbClsExtra = 0;
    wc.lpszClassName = "VisualEngine";
    wc.lpszMenuName = NULL;
    wc.hbrBackground = HBRUSH(GetStockObject(BLACK_BRUSH));
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

    if(!RegisterClassEx(&wc))
    {
        MessageBox(NULL, "Fehler beim Registrieren des Fensters", "Fehler aufgetreten",
                   MB_OK | MB_ICONEXCLAMATION);

        return VE_ERROR;
    }

    // Fenster erzeugen
    m_hwnd = CreateWindow("VisualEngine",
                          pcWindowTitle,
                          WS_VISIBLE | WS_OVERLAPPEDWINDOW,
                          GetSystemMetrics(SM_CXSCREEN) / 2,
                          GetSystemMetrics(SM_CYSCREEN) / 2,
                          800,
                          600,
                          NULL,
                          NULL,
                          ve_g_DLLHandle,
                          NULL);

    if(!m_hwnd)
    {
        MessageBox(NULL, "Fehler beim Erstellen des Fensters", "Fehler aufgetreten",
                   MB_OK | MB_ICONEXCLAMATION);

        return VE_ERROR;
    }

    // Direct3D Schnittstelle erzeugen
    m_pD3D = Direct3DCreate9(D3D_SDK_VERSION);

    m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &VideoMode);

    ZeroMemory(&PresentParams, sizeof(D3DPRESENT_PARAMETERS));

    // Presentations-Parameter setzen
    PresentParams.hDeviceWindow = m_hwnd;
    PresentParams.BackBufferCount = 1;
    PresentParams.BackBufferFormat = D3DFMT_X8R8G8B8;
    PresentParams.BackBufferWidth = 800;
    PresentParams.BackBufferHeight = 600;
    PresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
    PresentParams.EnableAutoDepthStencil = TRUE;
    PresentParams.AutoDepthStencilFormat = D3DFMT_D16;
    PresentParams.Windowed = TRUE;
    PresentParams.MultiSampleQuality = 0;
    PresentParams.MultiSampleType = D3DMULTISAMPLE_NONE;
    PresentParams.Flags = 0;
    PresentParams.FullScreen_RefreshRateInHz = 0;
    PresentParams.PresentationInterval = 0;


    // IDirect3DDevice-Schnittstelle erzeugen
    if(FAILED(hResult = m_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
                                             D3DDEVTYPE_REF,
                                             m_hwnd,
                                             D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                             &PresentParams,
                                             &m_pD3DDevice)))
    {
        MessageBox(NULL, "Fehler beim erstellen der IDirect3DDevice-Schnittstelle", "Fehler aufgetreten",
                   MB_OK | MB_ICONEXCLAMATION);

        return VE_ERROR;
    }

    // PresentParams der private Variable übergeben
    m_PresentParams = PresentParams;

    // Das Dreieck initialisieren
    veTriangleNormalInit();

    // Anzahl der RenderObjekte auf 0 setzen
    g_NumRenderObjects = 0;

    // Alle RenderObjekte auf false setzen
    for(int iRenderObject = 0; iRenderObject < 10000; iRenderObject++)
    {
        g_RenderObjects[iRenderObject].IsRenderObject = false;
        g_RenderObjects[iRenderObject].RenderObjectType = VE_NONE;
    }

    // Direct3D wurde initialisiert, also Variable auf True setzen.
    m_bInitialized = true;

    return VE_OK;
}

veResult veDirect3D::Exit()
{
    // -----------------------------------------------------------------------------------
    // Direct3D herunterfahren
    // -----------------------------------------------------------------------------------

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

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

    return VE_OK;
}

veResult veDirect3D::SetRenderState(D3DRENDERSTATETYPE RS, DWORD dwValue)
{
    m_pD3DDevice->SetRenderState(RS, dwValue);

    return VE_OK;
}

veResult veDirect3D::AddRenderObjectToScene(veRenderObjectList RenderObject, D3DXVECTOR3 ObjectPosition, D3DCOLOR Color)
{
    // -----------------------------------------------------------------------------------
    // Neues Objekt in die Szene einfügen
    // -----------------------------------------------------------------------------------

    g_RenderObjects[g_NumRenderObjects].RenderObjectType = RenderObject;
    g_RenderObjects[g_NumRenderObjects].Position = D3DXVECTOR3(ObjectPosition.x, ObjectPosition.y, ObjectPosition.z);
    g_RenderObjects[g_NumRenderObjects].Color = Color;
    g_RenderObjects[g_NumRenderObjects].NumberofObject = g_NumRenderObjects;
    g_RenderObjects[g_NumRenderObjects].IsRenderObject = true;

    // Anzahl der RenderObjekte um eins erhöhen
    g_NumRenderObjects++;

    return VE_OK;
}

veResult veDirect3D::RenderScene()
{
    // -----------------------------------------------------------------------------------
    // Die Render-Funktion von VisualEngine
    // -----------------------------------------------------------------------------------

    m_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 100), 1.0f, 0);

    m_pD3DDevice->BeginScene();

    for(int iRenderObjects = 0; iRenderObjects < 10000; iRenderObjects++)
    {
        if(g_RenderObjects[iRenderObjects].IsRenderObject == true)
        {
            if(g_RenderObjects[iRenderObjects].RenderObjectType == VE_TRIANGLE)
            {
                // Ein Dreieck rendern
                veRenderTriangle();
            }
        }
    }

    m_pD3DDevice->EndScene();

    m_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return VE_OK;
}

// veVertexModels.h
//
#pragma once


// Triangle FVF and Vertex
struct veTriangleVertex
{
    float       x, y, z, rhw;
    DWORD       Color;
};

#define veTriangleFVF (D3DFVF_XYZRHW | D3DFVF_DIFFUSE)

VE_API veResult veTriangleNormalInit();
VE_API veResult veRenderTriangle();
VE_API veResult veClearTriangle(veRenderObjects RenderObject);

// veVertexModels.cpp
//
#include "VisualEngine.h"

PDIRECT3D9                          g_pD3D;             // Globaler Zeiger von der IDirect3D-Schnittstelle
VE_API PDIRECT3DVERTEXBUFFER9       vTriangle = NULL;   // Vertex-Buffer für das Dreieck

VE_API veResult veTriangleNormalInit()
{
    // -----------------------------------------------------------------------------------
    // Das normale Dreieck von der VisualEngine initialisieren
    // -----------------------------------------------------------------------------------

    HRESULT hResult;

    veTriangleVertex TriangleVertices[] =
    {
        { 400.0f, 62.5f, 0.5f, 1.0f, D3DCOLOR_XRGB(0, 0, 255), },
        { 650.0f, 500.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(0, 255, 0), },
        { 150.0f, 500.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(255, 0, 0), },
    };

    // Vertex-Buffer erzeugen für das Dreieck
    if(FAILED(hResult = veDirect3D::D3DInstance()->CreateVertexBuffer(3*sizeof(veTriangleVertex),
                                                                    0,
                                                                    veTriangleFVF,
                                                                    D3DPOOL_MANAGED,
                                                                    &vTriangle,
                                                                    NULL)))
    {
        MessageBox(NULL, "Fehler beim Erstellen des Dreieck-Vertex-Buffers", "Fehler aufgetreten",
                   MB_OK | MB_ICONEXCLAMATION);

        return VE_ERROR;
    }

    // Void-Zeiger
    VOID * pVoid;

    // Nun die Vertices auf den Buffer kopieren, deshalb zuerst den VertexBuffer schliessen.
    vTriangle->Lock(0, 0, (void**)&pVoid, 0); // Hier wird der VertexBuffer geschlossen.
    memcpy(pVoid, TriangleVertices, sizeof(TriangleVertices)); // Hier wird kopiert.
    vTriangle->Unlock(); // Nun wird der VertexBuffer wieder aufgemacht.

    MessageBox(NULL, "Der VertexBuffer für das Dreieck wurde erstellt", "Erfogreich",
               MB_OK | MB_ICONEXCLAMATION);

    return VE_OK;
}

VE_API veResult veRenderTriangle()
{
    // Das FVF setzen für das Dreieck
    veDirect3D::D3DInstance()->SetFVF(veTriangleFVF);

    // Den Vertexbuffer angeben
    veDirect3D::D3DInstance()->SetStreamSource(0, vTriangle, 0, sizeof(veTriangleVertex));

    // Das Dreieck rendern
    veDirect3D::D3DInstance()->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1); 

    MessageBox(NULL, "Das Dreieck wurde gerendert", "Erfogreich",
               MB_OK | MB_ICONEXCLAMATION);

    return VE_OK;
}

C-/C++-Quelltext

// Klasse für ein Dreieck definieren
class VE_API veTriangle
{
private:

PDIRECT3DVERTEXBUFFER9vTriangle;// Vertex-Buffer für das Dreieck
veTriangleVertex m_TriangleVertices[3];// Die Vertices für das Dreieck

public:

veResult veNormalTriangleInit(veTriangleVertex (&TriangleVertices)[3]);
veResult veTriangleRender();

};

veResult veTriangle::veNormalTriangleInit(veTriangleVertex (&TriangleVertices)[3])
{
HRESULT hResult;

// Vertex-Buffer erzeugen für das Dreieck
if(FAILED(hResult = veDirect3D::D3DInstance()->CreateVertexBuffer(3*sizeof(veTriangleVertex),
                              0,
                              veTriangleFVF,
                              D3DPOOL_DEFAULT,
                              &vTriangle,
                              NULL)))
{
MessageBox(NULL, "Fehler beim Erstellen des Dreieck-Vertex-Buffers", "Fehler aufgetreten",
   MB_OK | MB_ICONEXCLAMATION);

return VE_ERROR;
}

VOID* pVoid;// a void pointer

// lock v_buffer and load the vertices into it
vTriangle->Lock(0, 0, (void**)&pVoid, 0);
memcpy(pVoid, TriangleVertices, sizeof(TriangleVertices));
vTriangle->Unlock();

MessageBox(NULL, "Funktioniert", "Erfolgreich",
   MB_OK | MB_ICONEXCLAMATION);

m_TriangleVertices[3] = TriangleVertices[3];

return VE_OK;
}

veResult veTriangle::veTriangleRender()
{
// Das FVF setzen für das Dreieck
veDirect3D::D3DInstance()->SetFVF(veTriangleFVF);

// Den Vertexbuffer angeben
veDirect3D::D3DInstance()->SetStreamSource(0, vTriangle, 0, sizeof(veTriangleVertex));

// Das Dreieck rendern
veDirect3D::D3DInstance()->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

return VE_OK;
}

C-/C++-Quelltext

veTriangle * pTriangle;
    pTriangle = new veTriangle();

    veInit();

    D3D.Init(true, "VisualEngine");

    veTriangleVertex TriangleVertices[] =
    {
        { 400.0f, 62.5f, 0.5f, 1.0f, D3DCOLOR_XRGB(0, 0, 255), },
        { 650.0f, 500.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(0, 255, 0), },
        { 150.0f, 500.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(255, 0, 0), },
    };

    pTriangle->veNormalTriangleInit(TriangleVertices);

    pTriangle->veTriangleRender();