//=============================================================================
  // d3dApp.h by Frank Luna (C) 2005 All Rights Reserved.
  //=============================================================================
  
  include <d3dApp.h>
  
  D3DApp* gd3dApp              = 0;
  IDirect3DDevice9* gd3dDevice = 0;
  
  LRESULT CALLBACK
  MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  {
          // Don't start processing messages until the application has been created.
          if( gd3dApp != 0 )
                  return gd3dApp->msgProc(msg, wParam, lParam);
          else
                  return DefWindowProc(hwnd, msg, wParam, lParam);
  }
  
  D3DApp::D3DApp(HINSTANCE hInstance, std::string winCaption, D3DDEVTYPE devType, DWORD requestedVP)
  {
          mMainWndCaption = winCaption;
          mDevType        = devType;
          mRequestedVP    = requestedVP;
          
          mhAppInst   = hInstance;
          mhMainWnd   = 0;
          md3dObject  = 0;
          mAppPaused  = false;
          ZeroMemory(&md3dPP, sizeof(md3dPP));
  
          initMainWindow();
          initDirect3D();
  }
  
  D3DApp::~D3DApp()
  {
          ReleaseCOM(md3dObject);
          ReleaseCOM(gd3dDevice);
  }
  
  HINSTANCE D3DApp::getAppInst()
  {
          return mhAppInst;
  }
  
  HWND D3DApp::getMainWnd()
  {
          return mhMainWnd;
  }
  
  void D3DApp::initMainWindow()
  {
          WNDCLASS wc;
          wc.style         = CS_HREDRAW | CS_VREDRAW;
          wc.lpfnWndProc   = MainWndProc; 
          wc.cbClsExtra    = 0;
          wc.cbWndExtra    = 0;
          wc.hInstance     = mhAppInst;
          wc.hIcon         = LoadIcon(0, IDI_APPLICATION);
          wc.hCursor       = LoadCursor(0, IDC_ARROW);
          wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
          wc.lpszMenuName  = 0;
          wc.lpszClassName = "D3DWndClassName";
  
          if( !RegisterClass(&wc) )
          {
                  MessageBox(0, "RegisterClass FAILED", 0, 0);
                  PostQuitMessage(0);
          }
  
          // Default to a window with a client area rectangle of 800x600.
  
          RECT R = {0, 0, 800, 600};
          AdjustWindowRect(&R, WS_OVERLAPPEDWINDOW, false);
          mhMainWnd = CreateWindow("D3DWndClassName", mMainWndCaption.c_str(), 
                  WS_OVERLAPPEDWINDOW, 100, 100, R.right, R.bottom, 
                  0, 0, mhAppInst, 0); 
  
          if( !mhMainWnd )
          {
                  MessageBox(0, "CreateWindow FAILED", 0, 0);
                  PostQuitMessage(0);
          }
  
          ShowWindow(mhMainWnd, SW_SHOW);
          UpdateWindow(mhMainWnd);
  }
  
  void D3DApp::initDirect3D()
  {
          // Step 1: Create the IDirect3D9 object.
  
      md3dObject = Direct3DCreate9(D3D_SDK_VERSION);
          if( !md3dObject )
          {
                  MessageBox(0, "Direct3DCreate9 FAILED", 0, 0);
                  PostQuitMessage(0);
          }
  
          // Step 2: Verify hardware support for specified formats in windowed and full screen modes.
          
          D3DDISPLAYMODE mode;
          md3dObject->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &mode);
          HR(md3dObject->CheckDeviceType(D3DADAPTER_DEFAULT, mDevType, mode.Format, mode.Format, true));
          HR(md3dObject->CheckDeviceType(D3DADAPTER_DEFAULT, mDevType, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, false));
  
          // Step 3: Check for requested vertex processing and pure device.
  
          D3DCAPS9 caps;
          HR(md3dObject->GetDeviceCaps(D3DADAPTER_DEFAULT, mDevType, &caps));
  
          DWORD devBehaviorFlags = 0;
          if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
                  devBehaviorFlags |= mRequestedVP;
          else
                  devBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
  
          // If pure device and HW T&L supported
          if( caps.DevCaps & D3DDEVCAPS_PUREDEVICE &&
                  devBehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING)
                          devBehaviorFlags |= D3DCREATE_PUREDEVICE;
  
          // Step 4: Fill out the D3DPRESENT_PARAMETERS structure.
  
          md3dPP.BackBufferWidth            = 0; 
          md3dPP.BackBufferHeight           = 0;
          md3dPP.BackBufferFormat           = D3DFMT_UNKNOWN;
          md3dPP.BackBufferCount            = 1;
          md3dPP.MultiSampleType            = D3DMULTISAMPLE_NONE;
          md3dPP.MultiSampleQuality         = 0;
          md3dPP.SwapEffect                 = D3DSWAPEFFECT_DISCARD; 
          md3dPP.hDeviceWindow              = mhMainWnd;
          md3dPP.Windowed                   = true;
          md3dPP.EnableAutoDepthStencil     = true; 
          md3dPP.AutoDepthStencilFormat     = D3DFMT_D24S8;
          md3dPP.Flags                      = 0;
          md3dPP.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
          md3dPP.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;
  
          // Step 5: Create the device.
  
          HR(md3dObject->CreateDevice(
                  D3DADAPTER_DEFAULT, // primary adapter
                  mDevType,           // device type
                  mhMainWnd,          // window associated with device
                  devBehaviorFlags,   // vertex processing
              &md3dPP,            // present parameters
              &gd3dDevice));      // return created device
  }
  
  int D3DApp::run()
  {
          MSG  msg;
      msg.message = WM_NULL;
  
          __int64 cntsPerSec = 0;
          QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);
          float secsPerCnt = 1.0f / (float)cntsPerSec;
  
          __int64 prevTimeStamp = 0;
          QueryPerformanceCounter((LARGE_INTEGER*)&prevTimeStamp);
  
          while(msg.message != WM_QUIT)
          {
                  // If there are Window messages then process them.
                  if(PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
                  {
              TranslateMessage( &msg );
              DispatchMessage( &msg );
                  }
                  // Otherwise, do animation/game stuff.
                  else
          {        
                          // If the application is paused then free some CPU cycles to other 
                          // applications and then continue on to the next frame.
                          if( mAppPaused )
                          {
                                  Sleep(20);
                                  continue;
                          }
  
                          if( !isDeviceLost() )
                          {
                                  __int64 currTimeStamp = 0;
                                  QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);
                                  float dt = (currTimeStamp - prevTimeStamp)*secsPerCnt;
  
                                  updateScene(dt);
                                  drawScene();
  
                                  // Prepare for next iteration: The current time stamp becomes
                                  // the previous time stamp for the next iteration.
                                  prevTimeStamp = currTimeStamp;
                          }
          }
      }
          return (int)msg.wParam;
  }
  
  LRESULT D3DApp::msgProc(UINT msg, WPARAM wParam, LPARAM lParam)
  {
          // Is the application in a minimized or maximized state?
          static bool minOrMaxed = false;
  
          RECT clientRect = {0, 0, 0, 0};
          switch( msg )
          {
  
          // WM_ACTIVE is sent when the window is activated or deactivated.
          // We pause the game when the main window is deactivated and 
          // unpause it when it becomes active.
          case WM_ACTIVATE:
                  if( LOWORD(wParam) == WA_INACTIVE )
                          mAppPaused = true;
                  else
                          mAppPaused = false;
                  return 0;
  
          // WM_SIZE is sent when the user resizes the window.  
          case WM_SIZE:
                  if( gd3dDevice )
                  {
                          md3dPP.BackBufferWidth  = LOWORD(lParam);
                          md3dPP.BackBufferHeight = HIWORD(lParam);
  
                          if( wParam == SIZE_MINIMIZED )
                          {
                                  mAppPaused = true;
                                  minOrMaxed = true;
                          }
                          else if( wParam == SIZE_MAXIMIZED )
                          {
                                  mAppPaused = false;
                                  minOrMaxed = true;
                                  onLostDevice();
                                  HR(gd3dDevice->Reset(&md3dPP));
                                  onResetDevice();
                          }
                          // Restored is any resize that is not a minimize or maximize.
                          // For example, restoring the window to its default size
                          // after a minimize or maximize, or from dragging the resize
                          // bars.
                          else if( wParam == SIZE_RESTORED )
                          {
                                  mAppPaused = false;
  
                                  // Are we restoring from a mimimized or maximized state, 
                                  // and are in windowed mode?  Do not execute this code if 
                                  // we are restoring to full screen mode.
                                  if( minOrMaxed && md3dPP.Windowed )
                                  {
                                          onLostDevice();
                                          HR(gd3dDevice->Reset(&md3dPP));
                                          onResetDevice();
                                  }
                                  else
                                  {
                                          // No, which implies the user is resizing by dragging
                                          // the resize bars.  However, we do not reset the device
                                          // here because as the user continuously drags the resize
                                          // bars, a stream of WM_SIZE messages is sent to the window,
                                          // and it would be pointless (and slow) to reset for each
                                          // WM_SIZE message received from dragging the resize bars.
                                          // So instead, we reset after the user is done resizing the
                                          // window and releases the resize bars, which sends a
                                          // WM_EXITSIZEMOVE message.
                                  }
                                  minOrMaxed = false;
                          }
                  }
                  return 0;
  
          // WM_EXITSIZEMOVE is sent when the user releases the resize bars.
          // Here we reset everything based on the new window dimensions.
          case WM_EXITSIZEMOVE:
                  GetClientRect(mhMainWnd, &clientRect);
                  md3dPP.BackBufferWidth  = clientRect.right;
                  md3dPP.BackBufferHeight = clientRect.bottom;
                  onLostDevice();
                  HR(gd3dDevice->Reset(&md3dPP));
                  onResetDevice();
  
                  return 0;
  
          // WM_CLOSE is sent when the user presses the 'X' button in the
          // caption bar menu.
          case WM_CLOSE:
                  DestroyWindow(mhMainWnd);
                  return 0;
  
          // WM_DESTROY is sent when the window is being destroyed.
          case WM_DESTROY:
                  PostQuitMessage(0);
                  return 0;
  
          case WM_KEYDOWN:
                  if( wParam == VK_ESCAPE )
                          enableFullScreenMode(false);
                  else if( wParam == 'F' )
                          enableFullScreenMode(true);
                  return 0;
          }
          return DefWindowProc(mhMainWnd, msg, wParam, lParam);
  }
  
  void D3DApp::enableFullScreenMode(bool enable)
  {
          // Switch to fullscreen mode.
          if( enable )
          {
                  // Are we already in fullscreen mode?
                  if( !md3dPP.Windowed ) 
                          return;
  
                  int width  = GetSystemMetrics(SM_CXSCREEN);
                  int height = GetSystemMetrics(SM_CYSCREEN);
  
                  md3dPP.BackBufferFormat = D3DFMT_X8R8G8B8;
                  md3dPP.BackBufferWidth  = width;
                  md3dPP.BackBufferHeight = height;
                  md3dPP.Windowed         = false;
  
                  // Change the window style to a more fullscreen friendly style.
                  SetWindowLongPtr(mhMainWnd, GWL_STYLE, WS_POPUP);
  
                  // If we call SetWindowLongPtr, MSDN states that we need to call
                  // SetWindowPos for the change to take effect.  In addition, we 
                  // need to call this function anyway to update the window dimensions.
                  SetWindowPos(mhMainWnd, HWND_TOP, 0, 0, width, height, SWP_NOZORDER | SWP_SHOWWINDOW);        
          }
          // Switch to windowed mode.
          else
          {
                  // Are we already in windowed mode?
                  if( md3dPP.Windowed ) 
                          return;
  
                  RECT R = {0, 0, 800, 600};
                  AdjustWindowRect(&R, WS_OVERLAPPEDWINDOW, false);
                  md3dPP.BackBufferFormat = D3DFMT_UNKNOWN;
                  md3dPP.BackBufferWidth  = 800;
                  md3dPP.BackBufferHeight = 600;
                  md3dPP.Windowed         = true;
          
                  // Change the window style to a more windowed friendly style.
                  SetWindowLongPtr(mhMainWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW);
  
                  // If we call SetWindowLongPtr, MSDN states that we need to call
                  // SetWindowPos for the change to take effect.  In addition, we 
                  // need to call this function anyway to update the window dimensions.
                  SetWindowPos(mhMainWnd, HWND_TOP, 100, 100, R.right, R.bottom, SWP_NOZORDER | SWP_SHOWWINDOW);
          }
  
          // Reset the device with the changes.
          onLostDevice();
          HR(gd3dDevice->Reset(&md3dPP));
          onResetDevice();
  }
  
  bool D3DApp::isDeviceLost()
  {
          // Get the state of the graphics device.
          HRESULT hr = gd3dDevice->TestCooperativeLevel();
  
          // If the device is lost and cannot be reset yet then
          // sleep for a bit and we'll try again on the next 
          // message loop cycle.
          if( hr == D3DERR_DEVICELOST )
          {
                  Sleep(20);
                  return true;
          }
          // Driver error, exit.
          else if( hr == D3DERR_DRIVERINTERNALERROR )
          {
                  MessageBox(0, "Internal Driver Error...Exiting", 0, 0);
                  PostQuitMessage(0);
                  return true;
          }
          // The device is lost but we can reset and restore it.
          else if( hr == D3DERR_DEVICENOTRESET )
          {
                  onLostDevice();
                  HR(gd3dDevice->Reset(&md3dPP));
                  onResetDevice();
                  return false;
          }
          else
                  return false;
  }