spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <d3dx9.h>
#include <d3d9.h>
#include "main.hpp"
#include <iostream>
#include <windows.h>
#include "CApplication.hpp"
#include "vector3.hpp"
#include "Matrix.hpp"
#include "Color.hpp"
#include <DXErr9.h>

IDirect3D9* pD3D;
IDirect3DDevice9* pDevice;
D3DPRESENT_PARAMETERS PP;
HWND hWnd;

int width = 800;
int height = 600;

float elapsed = 0.0f;



#define DEG_TO_RAD(x)       ((x) * 0.0174532925199432957692369076848f)  // Grad -> Bogenmaß




struct Vertex
{
    Vector3 pos;
    DWORD color;
};

Vertex gVertizes[3];


using namespace std;

void initPP();
bool initD3D();
void render( float seconds);
void move( float seconds);
bool initScene();





int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmdLine, int showCmd)
{
    WNDCLASSEX wndClass;
    TCHAR name[] = TEXT("TEST");
    MSG msg;
    



    wndClass.cbSize         = sizeof(WNDCLASSEX);
    wndClass.style          = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
    wndClass.lpfnWndProc    = MsgProc;
    wndClass.cbClsExtra     = 0;
    wndClass.cbWndExtra     = 0;
    wndClass.hInstance      = hInstance;
    wndClass.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
    wndClass.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wndClass.hbrBackground  = (HBRUSH)(COLOR_WINDOW);
    wndClass.lpszMenuName   = NULL;
    wndClass.lpszClassName  = name;
    wndClass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);

    if(RegisterClassEx(&wndClass) == 0)
    {
        MessageBox(hWnd, "Error: RegisterClassEx()", "Error!", MB_OK | MB_ICONERROR);
        return 0;
    }
    hWnd = CreateWindowEx(NULL, name, "Demo!", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
            GetSystemMetrics(SM_CXSCREEN)/2-(width/2),
            GetSystemMetrics(SM_CYSCREEN)/2-(height/2),
            width, 
            height, 
            NULL, NULL, hInstance,
            NULL);

    if(hWnd == NULL)
    {
        MessageBox(hWnd, "CreateWindowEx() failed", "Error!", MB_OK | MB_ICONERROR);
        return 0;
    }



        initPP();
    if(!initD3D())
         return 0;

    initScene();



    ShowWindow(hWnd, SW_SHOW);

    RECT Rect;
    SetRect(&Rect, 0, 0, width, height);
    AdjustWindowRect(&Rect, WS_VISIBLE | WS_OVERLAPPEDWINDOW, FALSE);
    width = Rect.right - Rect.left;
    height = Rect.bottom - Rect.top;

    while(GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);

        render(elapsed);
        move( 0.1f );
    }

    UnregisterClass(name, hInstance);

    if(pD3D != NULL)
        pD3D->Release();

    if(pDevice != NULL)
        pDevice->Release();


    return (int) msg.wParam;

}


LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case (WM_PAINT):
        {
            //PAINTSTRUCT paint;


            //BeginPaint(hWnd, &paint);

            //FillRect(paint.hdc, &paint.rcPaint, reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));

            //EndPaint(hWnd, &paint);

        }break;
    case (WM_KEYDOWN):
        {
            switch(wParam)
            {
            case VK_ESCAPE:
                PostMessage(hWnd, WM_CLOSE, 0, 0);
                return 0;
                break;
            }
        }break;
    case (WM_DESTROY):
        {
            PostQuitMessage(0);
            return 1;
        }break;
        

    default:
        break;
    }

    return DefWindowProc(hWnd, msg, wParam, lParam);
} 
bool initD3D()
{
    if(FAILED(pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        MessageBox(hWnd, "Fehler beim Erstellen der D3D-Schnittstelle!", "", MB_OK | MB_ICONERROR);
        return false;
    }
    HRESULT hr;

    if(FAILED(hr = pD3D->CreateDevice(
        D3DADAPTER_DEFAULT,
        D3DDEVTYPE_HAL,
        hWnd,
        D3DCREATE_SOFTWARE_VERTEXPROCESSING,
        &PP,
        &pDevice)))
    {
        MessageBox(hWnd, "CreateDevice() failed!", "", MB_OK | MB_ICONERROR);
        MessageBox(hWnd, DXGetErrorDescription9(hr), "", MB_OK | MB_ICONERROR);
        return false;
    }


    return true;
}
void render( float seconds)
{
    Matrix mRotation(matrixRotationZ(DEG_TO_RAD(elapsed*90.0f)));
    Matrix mTranslation(matrixTranslation(Vector3(0.0f, 0.0f, 2.0f)));

    //Beide Matrizen kombinieren und als Weltmatrix einsetzen

    pDevice->SetTransform(D3DTS_WORLD, reinterpret_cast<D3DMATRIX*>(&(mRotation*mTranslation)));


    if(FAILED(pDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 63), 1.0f, 0)))
    {
        MessageBox(hWnd, "Fehler beim clearen!", "", MB_OK | MB_ICONERROR);
        return;
    }



    pDevice->BeginScene();

    if(FAILED(pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 1, gVertizes, sizeof(Vertex))))
    {
        MessageBox(hWnd, "Fehler beim Rendern des Dreiecks!", "", MB_OK | MB_ICONERROR);
        return;
    }

    pDevice->EndScene();
    pDevice->Present(NULL, NULL, NULL, NULL);


}

void move(float seconds)
{
    elapsed += seconds;
}
void initPP()
{
    PP.Windowed                     = true;
    PP.hDeviceWindow                = hWnd;
    PP.SwapEffect                   = D3DSWAPEFFECT_DISCARD;
    PP.BackBufferFormat             = D3DFMT_UNKNOWN;
    PP.BackBufferWidth              = width;
    PP.BackBufferHeight             = height;
    PP.BackBufferCount              = 1;
    PP.MultiSampleType              = D3DMULTISAMPLE_4_SAMPLES;
    PP.MultiSampleQuality           = 0; 
    PP.EnableAutoDepthStencil       = false;
    PP.AutoDepthStencilFormat       = D3DFMT_D16;
    PP.Flags                        = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
    PP.FullScreen_RefreshRateInHz   = D3DPRESENT_RATE_DEFAULT;
    PP.PresentationInterval         = PP.Windowed ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE;

}
bool initScene()
{
    if(FAILED(pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE)))
    {
        MessageBox(hWnd, "setFVF() failed!", "", MB_OK | MB_ICONERROR);
        return false;
    }
    pDevice->SetRenderState(D3DRS_LIGHTING, false); 
    pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

    float aspect = static_cast<float>(width) / static_cast<float>(height);
    
    Matrix mProjection = matrixProjection(DEG_TO_RAD(90.0f), aspect, 0.1f, 100.0f);

    //Einsetzen

    pDevice->SetTransform(D3DTS_PROJECTION, reinterpret_cast<D3DMATRIX*>(&mProjection));


    gVertizes[0].pos   = Vector3(0.0f, 1.0f, 0.0f);
    gVertizes[1].pos   = Vector3(1.0f, -1.0f, 0.0f);
    gVertizes[2].pos   = Vector3(-1.0f, -1.0f, 0.0f);

    gVertizes[0].color = Color(1.0f, 0.0f, 0.0f);
    gVertizes[1].color = Color(0.0f, 1.0f, 0.0f);
    gVertizes[2].color = Color(0.0f, 0.0f, 1.0f);






    return true;
}