spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

    g_Triangle[0].pos = tbVector3(0.0f,1.0f,0.0f);
    g_Triangle[0].col = tbColor(1.0f,1.0f,1.0f);
    g_Triangle[0].uv = tbVector2 (0.5f,0.0f);

    g_Triangle[1].pos = tbVector3(1.0f,-1.0f,0.0f);
    g_Triangle[1].col = tbColor(1.0f,1.0f,1.0f);
    g_Triangle[1].uv = tbVector2 (1.0f,1.0f);

    g_Triangle[2].pos = tbVector3(-1.0f,-1.0f,0.0f);
    g_Triangle[2].col = tbColor(1.0f,1.0f,1.0f);
    g_Triangle[2].uv = tbVector2 (0.0f,1.0f);

C-/C++-Quelltext

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

#include "stdafx.h"
#include "InitDevice2.h"
#include <d3d9.h>
#include <d3dx9math.h>
#include <TriBase.h>

#define MAX_LOADSTRING 100

struct SVertex
{
    D3DVECTOR pos;
    tbVector2 uv;
    DWORD col;
};

// Globale Variablen:
HINSTANCE hInst;                                // Aktuelle Instanz
TCHAR szTitle[MAX_LOADSTRING];                  // Titelleistentext
TCHAR szWindowClass[MAX_LOADSTRING];            // Klassenname des Hauptfensters
HWND g_hwnd;                                    // Handle des Fensters
D3DPRESENT_PARAMETERS g_d3dPp;                  // pp

LPDIRECT3D9 g_D3D;                              // Direct3DObject
LPDIRECT3DDEVICE9 g_D3DDevice;                  // Direct3D Gerät
SVertex g_Triangle[3];                          // Mein erstes Dreieck <3

//Texturen
PDIRECT3DTEXTURE9 g_pTexBricks;                 // Stein-Texture

// Vorwärtsdeklarationen der in diesem Codemodul enthaltenen Funktionen:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
int DoMessageLoop();
bool InitDirectX();
bool InitScene();

float g_time = 0;
tbResult Render (float secPassed);
tbResult Move (float secPassed);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    

    // Globale Zeichenfolgen initialisieren
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_INITDEVICE2, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // Anwendungsinitialisierung ausführen:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    if(InitDirectX()) // DirectX Gerät initialisieren
        return 1;
    if(InitScene()) // ...
        return 1;

    //Texturen laden
    HRESULT hRes;
    hRes = D3DXCreateTextureFromFileEx(g_D3DDevice,
                                     L"bricks.jpg",
                                     D3DX_DEFAULT,
                                     D3DX_DEFAULT,
                                     D3DX_DEFAULT,
                                     0,
                                     D3DFMT_UNKNOWN,
                                     D3DPOOL_MANAGED,
                                     D3DX_FILTER_NONE,
                                     D3DX_DEFAULT,
                                     0,
                                     NULL,
                                     NULL,
                                     &g_pTexBricks);
    if (FAILED(hRes))
        return 1;

    tbDoMessageLoop (Move,Render);

    //Texturen freigeben
    g_D3DDevice->SetTexture (0,NULL);
    g_pTexBricks->Release();

     //DX Schnittstellen wieder freigeben
    g_D3D->Release();
    g_D3DDevice->Release();

    return 1;
    
}

tbResult Move (float secPassed)
{
    g_time += 0.005;
    return  TB_OK;
}

tbResult Render(float secPassed)
{
    HRESULT hRes;

    tbMatrix tbmRot = tbMatrixRotationY (TB_DEG_TO_RAD (45 * g_time))*tbMatrixRotationX(TB_DEG_TO_RAD(10*g_time));
    tbMatrix tbmTransl = tbMatrixTranslation (tbVector3(0.0f,0.0f,4.0f));
    tbMatrix tbmWorld = tbmRot * tbmTransl;
    g_D3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&tbmWorld));

    g_D3DDevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB (0,0,100),1.0f,0);
    g_D3DDevice->BeginScene();
    
    hRes = g_D3DDevice->SetTexture (0, g_pTexBricks);
    if (FAILED(hRes))
        return tbResult::TB_ERROR;

    g_D3DDevice->SetSamplerState (0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    g_D3DDevice->SetSamplerState (0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    g_D3DDevice->SetSamplerState (0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

    g_D3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 1, g_Triangle, sizeof(SVertex));

    g_D3DDevice->EndScene();
    g_D3DDevice->Present(NULL,NULL,NULL,NULL);
    return TB_OK;
}
 

bool InitDirectX()
{
    //D3D objekt erstellen
    g_D3D = Direct3DCreate9 (D3D_SDK_VERSION);

    //Present Paramaters
    D3DPRESENT_PARAMETERS d3dPp;

    ZeroMemory (&d3dPp, sizeof(d3dPp));
    d3dPp.Windowed = true;
    d3dPp.SwapEffect = D3DSWAPEFFECT_COPY;
    d3dPp.hDeviceWindow = g_hwnd;
    //Global verfügbar machen
    g_d3dPp = d3dPp;

    if (FAILED (g_D3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dPp,&g_D3DDevice)))
        return 1;

    return 0;
}

bool InitScene()
{
    if (FAILED(g_D3DDevice->SetFVF (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)))
        return 1;

    g_D3DDevice->SetRenderState (D3DRS_LIGHTING, false);
    g_D3DDevice->SetRenderState (D3DRS_CULLMODE, D3DCULL_NONE);
    g_D3DDevice->SetRenderState (D3DRS_DITHERENABLE, true);

    float fAspectRatio = 1;
    tbMatrix tbmProjection = tbMatrixProjection (TB_DEG_TO_RAD (45), fAspectRatio, 0.01, 100.0f);
    g_D3DDevice->SetTransform (D3DTS_PROJECTION, (D3DMATRIX*)(&tbmProjection));

    g_Triangle[0].pos = tbVector3(0.0f,1.0f,0.0f);
    g_Triangle[0].col = tbColor(1.0f,1.0f,1.0f);
    g_Triangle[0].uv = tbVector2 (0.5f,0.0f);

    g_Triangle[1].pos = tbVector3(1.0f,-1.0f,0.0f);
    g_Triangle[1].col = tbColor(1.0f,1.0f,1.0f);
    g_Triangle[1].uv = tbVector2 (1.0f,1.0f);

    g_Triangle[2].pos = tbVector3(-1.0f,-1.0f,0.0f);
    g_Triangle[2].col = tbColor(1.0f,1.0f,1.0f);
    g_Triangle[2].uv = tbVector2 (0.0f,1.0f);

    return 0;
}



//
//  FUNKTION: MyRegisterClass()
//
//  ZWECK: Registriert die Fensterklasse.
//
//  KOMMENTARE:
//
//    Sie müssen die Funktion verwenden,  wenn Sie möchten, dass der Code
//    mit Win32-Systemen kompatibel ist, bevor die RegisterClassEx-Funktion
//    zu Windows 95 hinzugefügt wurde. Der Aufruf der Funktion ist wichtig,
//    damit die kleinen Symbole, die mit der Anwendung verknüpft sind,
//    richtig formatiert werden.
//
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_INITDEVICE2));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_INITDEVICE2);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassEx(&wcex);
}

//
//   FUNKTION: InitInstance(HINSTANCE, int)
//
//   ZWECK: Speichert das Instanzenhandle und erstellt das Hauptfenster.
//
//   KOMMENTARE:
//
//        In dieser Funktion wird das Instanzenhandle in einer globalen Variablen gespeichert, und das
//        Hauptprogrammfenster wird erstellt und angezeigt.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

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

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT,0,1600, 900, NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   g_hwnd = hWnd;
   return TRUE;
}

//
//  FUNKTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  ZWECK:  Verarbeitet Meldungen vom Hauptfenster.
//
//  WM_COMMAND  - Verarbeiten des Anwendungsmenüs
//  WM_PAINT    - Zeichnen des Hauptfensters
//  WM_DESTROY  - Beenden-Meldung anzeigen und zurückgeben
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    switch (message)
    {
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}