spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

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

#include "stdafx.h"
#include "Engine.h"

#include <d3d9.h>
#include <d3dx9.h>
#include <strsafe.h>
#include <mmsystem.h>
#define MAX_LOADSTRING 100

// Globale Variablen:


HINSTANCE hInst;                                // Aktuelle Instanz
TCHAR szTitle[MAX_LOADSTRING];                  // Titelleistentext
TCHAR szWindowClass[MAX_LOADSTRING];            // Klassenname des Hauptfensters


LPDIRECT3D9         g_pD3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9   g_pd3dDevice = NULL; // Our rendering device
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // Buffer to hold vertices

// Vorwärtsdeklarationen der in diesem Codemodul enthaltenen Funktionen:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
 
//bool InitDirect3D(HWND hWnd);
 void Render();

HWND hWnd;
 

 D3DCOLOR ClearColor=D3DCOLOR_XRGB(100,0,50);

D3DXMATRIXA16 matProj;
    D3DXMATRIXA16 matView;

    D3DXVECTOR3 vEyePt( 0.0f, 3.0f,-5.0f );
    D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
    D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );
    
    D3DXMATRIXA16 matWorld;


    FLOAT fAngle = 0;
    


struct CUSTOMVERTEX
{
    FLOAT x, y, z;      // The untransformed, 3D position for the vertex
    DWORD color;        // The vertex color
};


 #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)


//-----------------------------------------------------------------------

HRESULT InitD3D(HWND hWnd)

{

  g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ;    

D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory (&d3dpp, sizeof(d3dpp));
d3dpp.Windowed=TRUE;
d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat=D3DFMT_UNKNOWN;
//d3dpp.BackBufferFormat=D3DFMT_A8R8G8B8;

d3dpp.hDeviceWindow=hWnd;


    g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                     &d3dpp,&g_pd3dDevice);
    
    
    g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    g_pd3dDevice->SetRenderState(D3DRS_LIGHTING,FALSE);


return S_OK;

}


//-----------------------------------------------------------------------

HRESULT InitGeometry()
{

 CUSTOMVERTEX g_vertices[] =
    {
        { -1.0f,-1.0f, 0.0f, 0xffff0000, },
        {  1.0f,-1.0f, 0.0f, 0xff0000ff, },
        {  0.0f, 1.0f, 0.0f, 0xffffffff, },
    
   };


    if( FAILED( g_pd3dDevice->CreateVertexBuffer( 3 * sizeof( CUSTOMVERTEX ),D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX,
                                                  D3DPOOL_DEFAULT, &g_pVB, NULL 
                                                 ) 
              ) 
      )
   
    
    {
        return E_FAIL;
    }

  // Now we fill the vertex buffer. To do this, we need to Lock() the VB to
    // gain access to the vertices. This mechanism is required becuase vertex
    // buffers may be in device memory.
    VOID* pVertices;
    if( FAILED( g_pVB->Lock( 0, sizeof( g_vertices ), ( void** )&pVertices, 0 ) ) )
        return E_FAIL;
    memcpy( pVertices, g_vertices, sizeof( g_vertices ) );
    g_pVB->Unlock();
 return S_OK;
}


//---------------------------------------------------------------------------------


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

    // TODO: Hier Code einfügen.
    MSG msg;
     ZeroMemory(&msg,sizeof(msg));

     // HACCEL hAccelTable;
   
    // Globale Zeichenfolgen initialisieren
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_ENGINE, szWindowClass, MAX_LOADSTRING);
    
    MyRegisterClass(hInstance);

    MessageBox(0, L"Willkommen",L"Überschrift",MB_OK);
    
    // Anwendungsinitialisierung ausführen:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

     
    //hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_ENGINE));
 

  InitD3D(hWnd);
    
  InitGeometry();
 

    // Hauptnachrichtenschleife:


  while(msg.message != WM_QUIT)

  {
        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
                     
               TranslateMessage(&msg);
               DispatchMessage(&msg);
            
            
        }
        else
        {
                
        //  Render();

        //obiger Render-Aufruf wird nicht angenommen! Wieso?
        //aus der Callback-Fkt funktioniert es hingegen problemlos!
        }

   }

    return (int) msg.wParam;
}


//---------------------------------------------------------------------------------

//
//  FUNKTION: MyRegisterClass()
//
//  ZWECK: Registriert die Fensterklasse.

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_ENGINE));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    //wcex.lpszMenuName = MAKEINTRESOURCE(IDC_ENGINE);
    
    wcex.lpszMenuName   = 0;
    
    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, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
 //  UpdateWindow(hWnd);
//MessageBox(hWnd, L"bla",L"Überschrift",MB_OK);
    
   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)
{

    
    UINT iTime = timeGetTime() % 10000000;

    fAngle = iTime * ( 2.0f * D3DX_PI ) /1000.0f;
    

    
    switch (message)
    
    {

    case WM_KEYDOWN:

     switch(wParam)
       {
        case VK_F1:

         g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
         break;

        case VK_F2:

         g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
         break;

        case VK_F3:

         g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_POINT);
         break;
            
        }

    case WM_PAINT:
               if(NULL==g_pd3dDevice)
               MessageBox(0, L"kein Wert in Variable",L"Überschrift",MB_OK);
      
 
               
               //jetzt besagter Aufruf von Render(), welchen ich gerne in die MainFkt verschieben möchte
               
               
               Render();
    

        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return S_OK;
}


void Render()
{
    
    
    g_pd3dDevice->Clear(0,0, D3DCLEAR_TARGET,ClearColor,0,0);   
        g_pd3dDevice->BeginScene();
            
        D3DXMatrixRotationY( &matWorld, fAngle );
        g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
  
        D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
        g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
        D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI / 4, 1.0f, 1.0f, 100.0f );
        g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

        g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof( CUSTOMVERTEX ) );
        g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
        g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 1 );
      
        g_pd3dDevice->EndScene();
    g_pd3dDevice->Present(0,0,0,0);


}