spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

BOOL Rotation()
{
    D3DXMATRIX matRotationX,matRotationY,matTranslation;

    D3DXMatrixRotationX(&matRotationX,g_angle); //x rotation ( NEW )

    //D3DXMatrixRotationY(&matRotationY,g_angle * 0.75f); //y rotation ( NEW )

    D3DXMatrixTranslation(&matTranslation,0.0f,0.0f,0.0f); //translation ( NEW )


    g_pD3DDevice->SetTransform(D3DTS_WORLD,&(matRotationX *  matTranslation));

    g_angle += 0.01f;

    //Wenn volle Drehung durchgeführt, Wert wieder auf Null zurücksetzen

    if(g_angle == 360.0f)
        g_angle = 0.0;


    return TRUE;
}

C-/C++-Quelltext

// MySelf.cpp : Definiert den Einstiegspunkt für die Anwendung.

//


#include "stdafx.h"
#include "MySelf.h"
#include <windows.h>
#include <d3dx9.h>
#include <d3d9.h>

// Globale Variablen:

HINSTANCE hInst;                                // Aktuelle Instanz

TCHAR szTitle[100] = TEXT("Titelleistentext");                  // Titelleistentext

TCHAR szWindowClass[100] = TEXT("TriBase");         // Klassenname des Hauptfensters


PDIRECT3DDEVICE9    g_pD3DDevice = NULL;
PDIRECT3D9          g_pD3D = NULL;
PDIRECT3DTEXTURE9   g_pTexture;
HWND                g_hWnd;
bool                g_bRun = TRUE;
float               g_angle = 0.0f;


Funktionen:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
//D3D Initialisieren

BOOL                InitD3D();
//Objekt drehen

BOOL                Rotation();
//Rendern des Dreiecks

BOOL                RenderTriangle();
//D3D Runterfahren

BOOL                ExitD3D();

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

#define PI                      3.14159265

struct Vertex
{
    //Positionskoordinaten

    float   x,y,z;
    //Farbe

    DWORD   color;
    //Texturkoordinaten

    float   u, v;
};

Vertex g_TriangleData[3] =
{
    {-0.0f, 0.25f, 0.0f, D3DCOLOR_XRGB(255, 255, 255), 0.0f, 0.5f},
    {-0.25f, -0.25f, 0.0f, D3DCOLOR_XRGB(255, 255, 255), -0.5f, -0.5f},
    {0.25f, -0.25f, 0.0f, D3DCOLOR_XRGB(255, 255, 255), 0.5f, -0.5f}
};

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    // TODO: Hier Code einfügen.

    MSG msg;

    MyRegisterClass(hInstance);

    // Anwendungsinitialisierung ausführen:

    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    InitD3D();

    while(g_bRun)
    {
        RenderTriangle();
        // Hauptmeldungsschleife:

        while (PeekMessage(&msg, g_hWnd, 0, 0, PM_REMOVE))
        {
            if(msg.message == WM_QUIT)
                break;
    
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
        
    ExitD3D();

    UnregisterClass(szWindowClass, hInstance);

    return (int) msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MYSELF));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_MYSELF);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   

   hInst = hInstance; // Instanzenhandle in der globalen Variablen speichern


   g_hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
                        GetSystemMetrics(SM_CXSCREEN) / 2 - (1024 / 2), GetSystemMetrics(SM_CYSCREEN) / 2 - (768 / 2),
                        1024, 768,
                        NULL, NULL, hInstance, NULL);

   if (!g_hWnd)
   {
      return FALSE;
   }

   ShowWindow(g_hWnd, nCmdShow);
   UpdateWindow(g_hWnd);

   return TRUE;
}

LRESULT CALLBACK WndProc(HWND g_hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
        break;
    case WM_KEYDOWN:
        switch(wParam)
        {
        case VK_ESCAPE:
            SendMessage(g_hWnd, WM_QUIT, 0, NULL);
            break;
        }
        break;
    case WM_CLOSE:
        SendMessage(g_hWnd, WM_QUIT, 0, NULL);
    case WM_QUIT:
        g_bRun = false;
        DestroyWindow(g_hWnd);
        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(g_hWnd, message, wParam, lParam);
    }
    return 0;
}
BOOL InitD3D()
{
    D3DPRESENT_PARAMETERS   PresentParms;
    D3DDISPLAYMODE          DisplayMode;
    //GGf. überprüfen ob GraKa die gesetzten Modien überhaupt leisten kann

    HRESULT hResult;

    g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);

    if(FAILED(g_pD3D->GetAdapterDisplayMode(0, &DisplayMode)))
    {
        MessageBox(NULL, TEXT("Error setting the display mode."), TEXT("Error!"), MB_OK);
        return false;
    }

    if(g_pD3D == NULL)
    {
        return FALSE;
    }

    memset(&PresentParms,0, sizeof(D3DPRESENT_PARAMETERS));

    PresentParms.Windowed                   = TRUE;
    PresentParms.BackBufferWidth            = 1024;
    PresentParms.BackBufferHeight           = 768;
    PresentParms.BackBufferFormat           = D3DFMT_A8R8G8B8;
    PresentParms.BackBufferCount            = 1;
    PresentParms.MultiSampleType            = D3DMULTISAMPLE_6_SAMPLES;
    PresentParms.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
    PresentParms.hDeviceWindow              = NULL;
    PresentParms.EnableAutoDepthStencil     = TRUE;
    PresentParms.AutoDepthStencilFormat     = D3DFMT_D24S8;
    PresentParms.Flags                      = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
    PresentParms.PresentationInterval       = D3DPRESENT_INTERVAL_DEFAULT;
    PresentParms.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;

    

    //Erzeugen und initialisieren des Gerätes

    if(FAILED(hResult = g_pD3D->CreateDevice(0,
                                            D3DDEVTYPE_HAL,
                                            g_hWnd,
                                            D3DCREATE_HARDWARE_VERTEXPROCESSING,
                                            &PresentParms,
                                            &g_pD3DDevice)))
    {
        MessageBox(g_hWnd, TEXT("Fehler bei CreateDevice"), TEXT("Fehler!!!"), MB_ICONERROR);
    }

    if(FAILED(hResult = g_pD3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)))
    {
        MessageBox(g_hWnd, TEXT("Fehler beim setzten der\n FlexibleVertexFormate"), TEXT("Fehler!!!"), MB_ICONERROR); 
    }

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);


    //Laden der Texture

    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice,
                                                    TEXT("Texture.bmp"),
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    D3DFMT_UNKNOWN,
                                                    D3DPOOL_MANAGED,
                                                    D3DX_FILTER_NONE,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    NULL,
                                                    NULL,
                                                    &g_pTexture)))
    {
        MessageBox(g_hWnd, TEXT("Fehler beim Laden der\n Texture"), TEXT("Fehler!!!"), MB_ICONERROR); 
    }

    
    g_pD3DDevice->SetTexture(0, g_pTexture);

    //Benutzung der Filter einstellen

    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);

    return TRUE;
}

BOOL Rotation()
{
    D3DXMATRIX matRotationX,matRotationY,matTranslation;

    D3DXMatrixRotationX(&matRotationX,g_angle);
    //D3DXMatrixRotationY(&matRotationY,g_angle * 0.75f); 

    D3DXMatrixTranslation(&matTranslation,0.0f,0.0f,0.0f); 

    g_pD3DDevice->SetTransform(D3DTS_WORLD,&matRotationX);

    g_angle += 0.1f;

    //Wenn volle Drehung durchgeführt, Wert wieder auf Null zurücksetzen

    if(g_angle >= 2* PI)
        g_angle = 0.0f;

    


    return TRUE;
}


BOOL RenderTriangle()
{
    //Buffer clearen und Hintergrundfarbe setzen

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

    //Start des Zeichnen

    g_pD3DDevice->BeginScene();

    Rotation();

    PDIRECT3DVERTEXBUFFER9 VertexBuffer;
    //Vertexbuffer anlegen

    g_pD3DDevice->CreateVertexBuffer(3 * sizeof(Vertex), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE, D3DPOOL_DEFAULT, &VertexBuffer, NULL);

    Vertex* Vertices;

    //Sperren des Speichbereichs

    if(FAILED(VertexBuffer->Lock(0, sizeof(g_TriangleData), (void**)&Vertices, 0)))
    {
        MessageBox(g_hWnd, TEXT("Fehler beim locken des VertexBuffer"), TEXT("Fehler!!!"), MB_ICONERROR); 
    }

    //Kopieren der Datei in den Buffer

    memcpy(Vertices, g_TriangleData, sizeof(g_TriangleData));

    //Bereich wieder Freigeben

    VertexBuffer->Unlock();

    g_pD3DDevice->SetStreamSource(0, VertexBuffer, 0, sizeof(Vertex));

    //Zeichnen des Dreiecks

    g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 1, g_TriangleData, sizeof(Vertex));

    //Buffer freigeben

    VertexBuffer->Release();

    g_pD3DDevice->EndScene();
    
    //Sichtbar machen

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

    return TRUE;
}

BOOL ExitD3D()
{
    if(g_pD3D != NULL)
    {
        g_pD3D->Release();
        g_pD3D = NULL;
    }

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

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

    return TRUE;
}