spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//Engine wird eingebunden

#include <tribase.h>
#include <iostream>
using namespace std;
//Variable

D3DPRESENT_PARAMETERS PresentParams;
PDIRECT3D9 g_pD3D;
PDIRECT3DDEVICE9 g_pD3DDevice;
HINSTANCE hInstance;
PDIRECT3DTEXTURE9 g_pTexture;
float fCameraAngle = 0.0f;
float fFOV = TB_DEG_TO_RAD(90.0f);
float fZeit=0;
tbVector3 vCameraPosition = tbVector3(0,0,1);
float fAspect;
tbMatrix    mProjection;
#define IDI_ICON1                       101

// Variablen

HWND g_hWindow;
struct SVertex
{
    tbVector3 vPosition;
    DWORD dwColor;
    tbVector2 vTexture;
};

SVertex Dreieck[3];
SVertex Test[3];



//Verschiedene Funktionen

int macheFenster(int iWidth,
                    int iHeight,
                    char* pcName,
                    HICON hIcon);
int Start();
int Rendere(float Zeitanfang);
LRESULT WINAPI  WindowProc(HWND hWindow, unsigned int uiMessage, WPARAM WParam, LPARAM LParam);
int Move(float ftime);






//Hauptfunktion

int main ()
{
    int Gedrueckt=0;
    int Auswahl=0;
    printf("Lade...\nZum dieser Anwendung druecken sie einfach die Leertaste!!\n");
    int Differenz;
    float  ZeitAnfang, ZeitEnde;

        

    Gedrueckt = 0;
    macheFenster(1024, 768, "Test", LoadIcon(hInstance,MAKEINTRESOURCE(IDI_ICON1)));

    Dreieck[1].vPosition = tbVector3(  0.0,  1.0, 0.0);
    Dreieck[2].vPosition = tbVector3(  -0.50, -1.0, 0.0);
    Dreieck[3].vPosition = tbVector3( -3.0, -1.0, -1.0);
    Dreieck[1].dwColor = tbColor( 100.0f, 100.0f, 100.0f);
    Dreieck[2].dwColor = tbColor( 100.0f, 100.0f, 100.0f);
    Dreieck[3].dwColor = tbColor( 100.0f, 100.0f, 100.0f);

    Start();
    //Einstellungen



    //Texturen laden u. einsetzen

    D3DXCreateTextureFromFileEx(g_pD3DDevice,
        "Steine.jpg", 
        D3DX_DEFAULT,
        D3DX_DEFAULT,
        D3DX_DEFAULT,
        0,
        D3DFMT_UNKNOWN,
        D3DPOOL_MANAGED,
        D3DX_FILTER_NONE,
        D3DX_DEFAULT,
        0,
        NULL,
        NULL,
        &g_pTexture);

    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAXANISOTROPY,4);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
    g_pD3DDevice->SetTexture(0, g_pTexture);

    
    
    //Schleife1

    while(Gedrueckt != 1)
    {
    ZeitAnfang = timeGetTime();
    fZeit += ZeitAnfang;
    //Spielframe Anfang

    Rendere(fZeit);

    
    if(GetAsyncKeyState(VK_SPACE))
    {
        Gedrueckt = 1;
    }

    //Anfang zeichnen

    Move(ZeitAnfang);

    












    //Anfang Ende

    //Spielframe Ende

    ZeitEnde = timeGetTime();
    Differenz = ZeitEnde - ZeitAnfang ;
    while (Differenz < 40)
    {
        ZeitEnde = timeGetTime();
            Differenz = ZeitEnde - ZeitAnfang;

    }
    }

    //Schleife1

    g_pD3D ->Release();
    return 0;
}
//ENDE HAUPTFUNKTION









int macheFenster(int iWidth,
                    int iHeight,
                    char* pcName,
                    HICON hIcon)
{
    // Fensterklassenstruktur ausfüllen

    WNDCLASSEX WindowClass = {sizeof(WNDCLASSEX), CS_CLASSDC, WindowProc, 0, 0,
                              GetModuleHandle(NULL), hIcon, LoadCursor (NULL, MAKEINTRESOURCE(IDC_ARROW)), NULL,
                              NULL, "Direct3D window", NULL};
    // Klasse registrieren

    if(!RegisterClassEx(&WindowClass))
    {
        TB_ERROR("Fensterklassenregistrierung fehlgeschlagen!", TB_ERROR);
    }


    TB_INFO("Fensterklasse wurde registriert!");

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

    // Fenster erstellen und prüfen

    g_hWindow = CreateWindow("Direct3D window",
                             pcName,
                             WS_VISIBLE | WS_OVERLAPPEDWINDOW,
                             GetSystemMetrics(SM_CXSCREEN) / 2 - iWidth / 2,
                             GetSystemMetrics(SM_CYSCREEN) / 2 - iHeight / 2,
                             iWidth,
                             iHeight,
                             NULL,
                             NULL,
                             GetModuleHandle(NULL),
                             NULL);
    if(g_hWindow == NULL)
    {
        TB_ERROR("Erstellung des Fensters ist fehlgeschlagen!\n", TB_ERROR);
    }

    // Alles OK!

    TB_INFO("Fenster wurde erstellt!");

    return TB_OK;
}

int Move(float ftime)
{

    if(GetAsyncKeyState(VK_LEFT))
        fCameraAngle -= TB_DEG_TO_RAD(45.0f) * ftime;

    if(GetAsyncKeyState(VK_RIGHT))
        fCameraAngle += TB_DEG_TO_RAD(45.0f) * ftime;
    
    tbVector3 vCameraDirection = tbVector3(sinf(fCameraAngle), 0.0f,
        cosf(fCameraAngle));

    if(GetAsyncKeyState(VK_UP))
        vCameraPosition += vCameraDirection * 10.0f * ftime;


    if(GetAsyncKeyState(VK_DOWN))
        vCameraPosition -= vCameraDirection* 10.0f * ftime;
    
    if(GetAsyncKeyState(VK_PRIOR))
        fFOV -= TB_DEG_TO_RAD(15.0f) * ftime;

    if(GetAsyncKeyState(VK_NEXT))
        fFOV += TB_DEG_TO_RAD(15.0f) * ftime;

    if(fFOV>= TB_DEG_TO_RAD(180.0f))
        fFOV = TB_DEG_TO_RAD(179.9f);

    if(fFOV>= TB_DEG_TO_RAD(0.0f))
        fFOV = TB_DEG_TO_RAD(0.1f);

    return 0;
}







int Start()
{
        //Schnittstelle erstellen

    if (!(g_pD3D = Direct3DCreate9 (D3D_SDK_VERSION)))
        MessageBox(NULL,"Adapter konnte nicht\nerstellt werden!\nHaben sie DirectX9 installiert?","Adapterfehler",MB_OK);
    ZeroMemory(&PresentParams, sizeof(D3DPRESENT_PARAMETERS));
    PresentParams.BackBufferWidth           = 1024;
    PresentParams.BackBufferHeight          = 768;
    PresentParams.BackBufferFormat          = D3DFMT_X8R8G8B8;
    PresentParams.BackBufferCount           = 1;
    PresentParams.MultiSampleType           = D3DMULTISAMPLE_NONE;
    PresentParams.MultiSampleQuality        = 0;
    PresentParams.SwapEffect                = D3DSWAPEFFECT_DISCARD;
    PresentParams.hDeviceWindow             = g_hWindow;
    PresentParams.Windowed                  = FALSE;
    PresentParams.EnableAutoDepthStencil    = TRUE;
    PresentParams.AutoDepthStencilFormat    = D3DFMT_D24S8;
    PresentParams.Flags                     = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER | D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
    PresentParams.FullScreen_RefreshRateInHz= D3DPRESENT_RATE_DEFAULT;
    PresentParams.PresentationInterval      = D3DPRESENT_INTERVAL_DEFAULT;
    
    g_pD3D -> CreateDevice(D3DADAPTER_DEFAULT,
                                D3DDEVTYPE_HAL,
                                g_hWindow,
                                D3DCREATE_MULTITHREADED|D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                &PresentParams,
                                &g_pD3DDevice);
    ShowCursor(FALSE);
    g_pD3DDevice -> SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
    g_pD3DDevice -> SetRenderState(D3DRS_LIGHTING , FALSE);
    g_pD3DDevice -> SetRenderState(D3DRS_CULLMODE , D3DCULL_NONE);
    g_pD3DDevice -> SetRenderState(D3DRS_DITHERENABLE , TRUE);
    g_pD3DDevice -> SetRenderState(D3DRS_ZENABLE , D3DZB_USEW);
    g_pD3DDevice -> SetRenderState(D3DRS_SHADEMODE , D3DSHADE_GOURAUD);


    

    return 0;
}


LRESULT WINAPI WindowProc(HWND hWindow,
                          unsigned int uiMessage,
                          WPARAM WParam,
                          LPARAM LParam)
{
    PAINTSTRUCT Paint;

    switch(uiMessage)
    {
    case WM_CREATE:
        break;

    case WM_PAINT:
        // Das Fenster mit Schwarz füllen

        BeginPaint(hWindow, &Paint);
        FillRect(Paint.hdc, &Paint.rcPaint, (HBRUSH)(GetStockObject(BLACK_BRUSH)));
        EndPaint(hWindow, &Paint);
        break;

    case WM_CLOSE:
        DestroyWindow(hWindow);
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hWindow, uiMessage, WParam, LParam);
    }

    return TRUE;
}


int Rendere(float ZeitAnfang)
{

    fAspect =   (float) (1024) / (float) (768);
    // Die Projektionsmatrix erzeugen und einsetzen.

    // Das geschieht hier einmal pro Bild, weil das Sichtfeld variabel ist.

    mProjection = tbMatrixProjection(fFOV,  // Sichtfeld

                                     fAspect,   // Bildseitenverhältnis

                                     0.1f,      // Nahe Clipping-Ebene

                                     1000.0f);  // Ferne Clipping-Ebene

    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));


        g_pD3DDevice->Clear(0,NULL,
    D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL,
    D3DCOLOR_XRGB( 0, 0, 0),
    1.0f,0);

    tbMatrix    mCamera;
    tbMatrix    mWorld;

    fAspect =   (float) (1024) / (float) (768);


    
    mCamera = tbMatrixCamera(vCameraPosition,
                             vCameraPosition + tbVector3(sinf(fCameraAngle),
                                                           1.0f,
                                                           cosf(fCameraAngle)),
                                                            tbVector3(0,0,0));
    g_pD3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)(&mCamera));

    
    // Die Projektionsmatrix erzeugen und einsetzen.

    // Das geschieht hier einmal pro Bild, weil das Sichtfeld variabel ist.

    
    mProjection = tbMatrixProjection(fFOV,  // Sichtfeld

                                     fAspect,   // Bildseitenverhältnis

                                     0.1f,      // Nahe Clipping-Ebene

                                     1000.0f);  // Ferne Clipping-Ebene

    
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));
    
    
    


    


    //In Bildpuffer zeichnen 1

    g_pD3DDevice->BeginScene();
    g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST,
        1,
        Dreieck,
        sizeof(SVertex));
    
    g_pD3DDevice->EndScene();


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


    return 0;
}