// include files ////////////////////////////////////////////////////////////


#include <windows.h> // needed for windows 
#include <d3d8.h>    // needed for direct 3d


class CEngine {
	// declare data members

private:
	char *g_strAppName;
	LPDIRECT3D8 g_pD3D;
	LPDIRECT3DDEVICE8 g_pd3dDevice;
	HWND              g_hWnd;

public:
	char* GetAppName();
	CEngine();
	void InitD3D();	
	void UnInitD3D();
	void PaintWindow(HDC hdc);
};
CEngine::CEngine() {	
	g_strAppName = "Dark Age: Rise of The Underworld";	
	g_pD3D = NULL;
	g_pd3dDevice = NULL;
	g_hWnd = NULL;
}
void CEngine::InitD3D() {
// create a Direct3D device

  g_pD3D = Direct3DCreate8( D3D_SDK_VERSION );
  if(g_pD3D == NULL) {
    throw("Direct3DCreate8 failed.");
  }

  // Get the current desktop display mode

  D3DDISPLAYMODE d3ddm;
  if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))) {
    throw("GetAdapterDisplayMode failed.");
  }
  
  D3DPRESENT_PARAMETERS d3dpp; 
  ZeroMemory( &d3dpp, sizeof(d3dpp) ); // this will set all members to zero

  
  // setting zero for width and height will tell windows to use window

  // dimensions for backbuffer dimensions.

  d3dpp.BackBufferWidth = 0;
  d3dpp.BackBufferHeight = 0;

  // request a back buffer format that matches the current desktop display 

  // format.

  d3dpp.BackBufferFormat = d3ddm.Format;

  // we want 1 back buffer

  d3dpp.BackBufferCount = 1;

  // no multisampling

  d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;

  // "discard" swap effect.  This means that we should never care about

  // the contents of the front buffer - we should always re-render the

  // entire screen on the back buffer each frame.  This is the most

  // efficient method of presenting the back buffer.

  d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

  // use our window as the device window

  d3dpp.hDeviceWindow = g_hWnd;

  // we want to do D3D in a window

  d3dpp.Windowed = TRUE; 

  // we don''t want Direct3D to manage depth buffers for us

  // (that''s because we don''t use any right now)

  d3dpp.EnableAutoDepthStencil = false;
  d3dpp.AutoDepthStencilFormat = D3DFMT_UNKNOWN;

  // no special flags

  d3dpp.Flags = 0;

  // default refresh rate

  d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;

  // default presentation interval (we must use this because we''re in

  // a window)

  d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
  
  // Create the Direct3D device. 

  if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, 
                                 D3DDEVTYPE_HAL, g_hWnd,
                                 D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                 &d3dpp, &g_pd3dDevice)))
  {
    throw("CreateDevice failed.");
  }
}
void CEngine::UnInitD3D(void) {
  // first, release any devices we''ve created.

  if(g_pd3dDevice != NULL) {
    g_pd3dDevice->Release();
    g_pd3dDevice = NULL; // just to be safe

  }

  // next, release the direct3d interface.

  if(g_pD3D != NULL) {
    g_pD3D->Release();
    g_pD3D = NULL; // just to be safe

  }
}

void CEngine::PaintWindow(HDC hdc) {
  // most directX games don''t really use WM_PAINT.

  // instead, they run their own animation loop, and flip (aka "present") 

  // their backbuffers several times per second.


  // the following code clears the backbuffer black, then displays it.

  g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 
    D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
    
  // Present the backbuffer contents to the display

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

}
char *CEngine::GetAppName() {  
	return g_strAppName;
}

CEngine* g_MyEngine;
LRESULT CALLBACK WindowProc(
  HWND hwnd,      // handle to window

  UINT uMsg,      // message identifier

  WPARAM wParam,  // first message parameter

  LPARAM lParam   // second message parameter

) 
{
    switch(uMsg) {	
	case WM_PAINT:
      {
	  PAINTSTRUCT ps;

      // get the DC we''re supposed to use from Windows

      BeginPaint(hwnd, &ps);
      HDC hdc = ps.hdc;
      
      // paint our window (function is defined above)

      g_MyEngine->PaintWindow(hdc);
      
      // tell Windows we''re done painting.

      EndPaint(hwnd, &ps);
	  }
    // we processed the message, so return 0.

    return(0);

    case WM_DESTROY: // our window is being destroyed!  quit!

		g_MyEngine->UnInitD3D();
    	PostQuitMessage(0);
        return(0);
	}


  // all the other messages, we don''t care about, so we let DefWindowProc

  // handle them.

  return(DefWindowProc(hwnd, uMsg, wParam, lParam));
}
   int WINAPI WinMain(HINSTANCE g_hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
   {
	   //Allocate memory for engine (IMPORTANT)  

	   g_MyEngine = new CEngine;
	   // set up and register window class	

	   HWND hwnd;
	   WNDCLASSEX wc;	
	   memset(&wc, 0, sizeof(wc)); // clear everything	

	   wc.cbSize = sizeof(wc);
	   wc.style = CS_HREDRAW | CS_VREDRAW;	
	   wc.lpfnWndProc = WindowProc;	
	   wc.cbClsExtra = 0;
	   wc.cbWndExtra = 0;
	   wc.hInstance = g_hInstance;	
	   wc.hIcon = NULL;
	   wc.hIconSm = NULL;
	   wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	   wc.hbrBackground = NULL;
	   wc.lpszMenuName = NULL;
	   wc.lpszClassName = "GameMainWindow";
	   RegisterClassEx(&wc);
	   
	   // create a window with a width of 640 pixels wide and a height of 480 pixels

	   hwnd = CreateWindowEx(0, "GameMainWindow", g_MyEngine->GetAppName(), 
		   WS_OVERLAPPEDWINDOW, 10, 10, 640, 480, NULL, NULL, g_hInstance, NULL);
	   if (!hwnd)    {
		   ::MessageBox(NULL, "Create window failed!", g_MyEngine->GetAppName(), MB_ICONSTOP);
	   }	//After you get a handle to your window then I would create

	   //an instance of your CEngine classg_MyEngine = new CEngine();

	   //Now you can use this object in your wndproc function

	   ShowWindow(hwnd,SW_SHOW);
	   try {
	   g_MyEngine->InitD3D();
	   } catch(const char *errmsg) {

    // if we threw any const char *''s, catch them here, display the error,

    // then exit.

    MessageBox(hwnd, errmsg, g_MyEngine->GetAppName(), 0);
  }
  catch(...) {
    // catch unhandled exceptions.

    MessageBox(hwnd, "An unknown error occurred.", g_MyEngine->GetAppName(), 0);
  }
       // message pump	

	   // message pump

  while (1) {
    MSG msg;
    if (PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE))
    {
      int result = GetMessage(&msg, 0, 0, 0);
      if (!result) return(msg.wParam);

      TranslateMessage(&msg); 
      DispatchMessage(&msg);
    }
  }

	   //delete the Engine object  

	   delete g_MyEngine;
	   return 0;
   }