prj/tech/libsrc/gameshel/wgshelmt.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // $Source: x:/prj/tech/libsrc/gameshel/RCS/wgshelmt.cpp $
   3 // $Author: TOML $
   4 // $Date: 1997/09/10 14:01:42 $
   5 // $Revision: 1.18 $
   6 //
   7 // - Because the priority is so high in this thread, it is important
   8 //   that any code in here be coded with an eye on performance (toml 10-29-96)
   9 //
  10 // - When activation switches away from the app, the shell blocks
  11 //   the app from using the display.  Because Full screen DD, GDI and
  12 //   windowed DD all have slightly different interactions with
  13 //   activation change, the blocking code is repeated both in the
  14 //   pretranslate hook and the window proc hook to cover all cases.
  15 //
  16
  17 #include <windows.h>
  18 #include <lg.h>
  19 #include <coremutx.h>
  20 #include <comtools.h>
  21
  22 #include <dispapi.h>
  23
  24 #include <wgshell.h>
  25 #include <wgshelmt.h>
  26
  27 ///////////////////////////////////////////////////////////////////////////////
  28 //
  29 // CLASS: cMTWinGameShell
  30 //
  31
  32 cMTWinGameShell::cMTWinGameShell(int fFlags, IUnknown * pOuterUnknown)
  33   : cWinGameShell(fFlags, pOuterUnknown),
  34     m_fMasterBlockedFromDisplay(FALSE),
  35     m_fState(kStartup),
  36     m_fInGame(FALSE),
  37     m_WorkerThreadId(0),
  38     m_MasterThreadId(0)
  39 {
  40     Verify(DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &m_hMasterThread, 0, FALSE, DUPLICATE_SAME_ACCESS));
  41     SetBlockInactive(FALSE);
  42     gm_pfnPreviousCritMsgNotificationHandler = CritMsgSetHandler(CritMsgNotificationHandler);
  43 }
  44
  45 ////////////////////////////////////////
  46
  47 cMTWinGameShell::~cMTWinGameShell()
  48 {
  49     CritMsgSetHandler(gm_pfnPreviousCritMsgNotificationHandler);
  50     AssertInMaster();
  51     if (ThreadExists())
  52     {
  53         CallWorker(kGSWTExit);
  54         WaitForClose();
  55     }
  56
  57     if (m_hMasterThread)
  58         CloseHandle(m_hMasterThread);
  59 }
  60
  61 ////////////////////////////////////////
  62
  63 inline BOOL cMTWinGameShell::OkToBlock()
  64 {
  65     return m_fInGame && !gm_fInAssert && DisplayIsExclusive();
  66 }
  67
  68 ////////////////////////////////////////
  69
  70 inline void cMTWinGameShell::BlockDisplay()
  71 {
  72     if (!m_fMasterBlockedFromDisplay)
  73     {
  74         m_fMasterBlockedFromDisplay = TRUE;
  75         m_pWinDisplayDevice->WaitForMutex();
  76     }
  77 }
  78
  79 ////////////////////////////////////////
  80
  81 inline void cMTWinGameShell::UnblockDisplay()
  82 {
  83     if (m_fMasterBlockedFromDisplay)
  84     {
  85         m_fMasterBlockedFromDisplay = FALSE;
  86         m_pWinDisplayDevice->ReleaseMutex();
  87     }
  88 }
  89
  90 ////////////////////////////////////////
  91
  92 STDMETHODIMP_(void) cMTWinGameShell::BeginFrame()
  93 {
  94     // If this is the first frame, set properties of normal operation
  95     if (!m_fInGame)
  96     {
  97         m_fInGame = TRUE;
  98         SetPriority(THREAD_PRIORITY_HIGHEST);
  99     }
 100     cWinGameShell::BeginFrame();
 101 }
 102
 103 ////////////////////////////////////////
 104 //
 105 // Message pump
 106 //
 107 // Only called from master, this function handles requests to exit
 108 // from the worker
 109 //
 110
 111 STDMETHODIMP_(void) cMTWinGameShell::PumpEvents(int fPumpFlags)
 112 {
 113     AssertInMaster();
 114
 115     switch (m_fState)
 116     {
 117         case kStartup:
 118         case kActive:
 119         {
 120             cWinGameShell::PumpEvents(fPumpFlags);
 121             break;
 122         }
 123
 124         case kClosed:
 125             break;
 126
 127         default:
 128             CriticalMsg("Unknown state");
 129     }
 130 }
 131
 132 ////////////////////////////////////////
 133 //
 134 // Window procedure
 135 //
 136
 137 long cMTWinGameShell::WndProc(UINT msg, WPARAM wParam, LPARAM lParam)
 138 {
 139     HWND hWnd = GetHwnd();
 140     long retVal;
 141
 142     switch (msg)
 143     {
 144         case WM_NCACTIVATE:
 145         {
 146             if (!wParam && !IsWindowVisible(hWnd))
 147                 return FALSE;
 148             break;
 149         }
 150
 151         case WM_DESTROY:
 152             m_fState = kClosed;
 153             break;
 154     }
 155
 156
 157     retVal = cWinGameShell::WndProc(msg, wParam, lParam);
 158
 159     // We yield our timeslice to feed any starving threads
 160     Sleep(0);
 161
 162     return retVal;
 163 }
 164
 165 ////////////////////////////////////////
 166
 167 void cMTWinGameShell::CreateGameWindow()
 168 {
 169     m_MasterThreadId = GetCurrentThreadId();
 170
 171     Create();
 172     CallWorker(kGSWTCreateWindow);
 173     SetForegroundWindow(GetHwnd());
 174 }
 175
 176 ////////////////////////////////////////
 177
 178 void cMTWinGameShell::DestroyGameWindow()
 179 {
 180     AssertInMaster();
 181     if (ThreadExists())
 182     {
 183         CallWorker(kGSWTExit);
 184         WaitForClose();
 185     }
 186     cWinGameShell::DestroyGameWindow();
 187
 188     m_MasterThreadId = 0;
 189 }
 190
 191 ////////////////////////////////////////
 192
 193 void cMTWinGameShell::NotifyDisplayOnActivateApp(BOOL fActive)
 194 {
 195     AssertInWorker();
 196     if (!fActive)
 197     {
 198         SetThreadPriority(m_hMasterThread, THREAD_PRIORITY_NORMAL);
 199         SetPriority(THREAD_PRIORITY_NORMAL);
 200         if (OkToBlock())
 201         {
 202             BlockDisplay();
 203         }
 204     }
 205
 206     cWinGameShell::NotifyDisplayOnActivateApp(fActive);
 207
 208     if (fActive)
 209     {
 210         SetThreadPriority(m_hMasterThread, THREAD_PRIORITY_ABOVE_NORMAL);
 211         SetPriority(THREAD_PRIORITY_HIGHEST);
 212         UnblockDisplay();
 213     }
 214 }
 215
 216 ////////////////////////////////////////
 217
 218 void cMTWinGameShell::OnQuit()
 219 {
 220     AssertInWorker();
 221     CriticalMsg("Abnormal termination -- no WM_CLOSE received!");
 222     ExitProcess(1);
 223 }
 224
 225 ////////////////////////////////////////
 226
 227 void cMTWinGameShell::OnActivateApp(BOOL fActive)
 228 {
 229     AssertInWorker();
 230
 231     if (!fActive && OkToBlock())
 232         BlockDisplay();
 233
 234     cWinGameShell::OnActivateApp(fActive);
 235
 236     if (fActive)
 237         UnblockDisplay();
 238 }
 239
 240 ////////////////////////////////////////
 241
 242 #define kSleepLimit 500
 243
 244 DWORD cMTWinGameShell::ThreadProc()
 245 {
 246     m_WorkerThreadId = GetCurrentThreadId();
 247
 248     enum eMTGameShellEvent
 249     {
 250         kCallFromMaster,
 251         kWindowMessage
 252     };
 253
 254     // Wait for either a call from the master thread, or an item in the queue...
 255     DWORD   fWaitResult;
 256     BOOL    fFailedLastWait;
 257     HANDLE  waitHandles[1];
 258
 259     m_fState = kActive;
 260
 261     waitHandles[kCallFromMaster] = GetCallHandle();
 262
 263     while (m_fState != kClosed)
 264     {
 265         // Wait for a message either from the master thread or in the queue...
 266         fWaitResult = MsgWaitForMultipleObjects(1, waitHandles, FALSE, kSleepLimit, QS_ALLINPUT);
 267
 268         if (gm_fInAssert)
 269         {
 270             // Wait until assertion dialog is dealt with
 271             Sleep(50);
 272             continue;
 273         }
 274
 275         // It apperars MsgWaitForMultipleObjects() fails, seemingly harmlessly, immediately
 276         // following a coninuance after a breakpoint is hit.  Everything appears fine
 277         // on the next iteration.  So, what we do is ignore the failure, and blow up
 278         // only if the exception repeats on the next wait. (toml 09-23-96)
 279         if (fWaitResult == WAIT_FAILED)
 280         {
 281             AssertMsg1(!fFailedLastWait, "Error in multi-threaded game shell message pump: 0x%x", GetLastError());
 282             Sleep(0);
 283             fFailedLastWait = TRUE;
 284             continue;
 285         }
 286         else
 287             fFailedLastWait = FALSE;
 288
 289         // If we hit the sleep limit, peek for a message to inhibit non-critical OS cleanup code from activating
 290         if (fWaitResult == WAIT_TIMEOUT)
 291         {
 292             MSG msg;
 293             PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
 294             continue;
 295         }
 296
 297         // Handle the message...
 298         switch (fWaitResult - WAIT_OBJECT_0)
 299         {
 300             // It's a call from the master thread...
 301             case kCallFromMaster:
 302             {
 303                 switch (GetCallParam())
 304                 {
 305                     case kGSWTExit:
 306                         m_fState = kClosed;
 307                         Reply(S_OK);
 308                         break;
 309 #if 0
 310                     case kGSWTSuspend:
 311                         Reply(S_OK);
 312                         Suspend();
 313                         break;
 314 #endif
 315
 316                     case kGSWTCreateWindow:
 317                         cWinGameShell::CreateGameWindow();
 318                         SetThreadPriority(m_hMasterThread, THREAD_PRIORITY_ABOVE_NORMAL);
 319                         Reply(S_OK);
 320                         break;
 321
 322                     default:
 323                         CriticalMsg("Unknown call to game shell worker thread");
 324                         Reply((DWORD)E_FAIL);
 325                         break;
 326                 }
 327                 break;
 328             }
 329
 330             // Otherwise, if there's a someting in the message queue...
 331             case kWindowMessage:
 332             {
 333                 m_pWinDisplayDevice->WaitForMutex();
 334                 CoreThreadLock();
 335                 DoPumpEvents();
 336                 CoreThreadUnlock();
 337                 m_pWinDisplayDevice->ReleaseMutex();
 338                 break;
 339             }
 340
 341             default:
 342                 CriticalMsg("There was nothing to do!");
 343         }
 344
 345         // We yield our timeslice to feed any starving threads
 346         Sleep(0);
 347     }
 348
 349     m_WorkerThreadId = 0;
 350
 351     return S_OK;
 352 }
 353
 354 ////////////////////////////////////////
 355 //
 356 // Critical message handling -- don't block the display if we're trying to assert
 357 //
 358
 359 BOOL                        cMTWinGameShell::gm_fInAssert;
 360 tCritMsgNotificationHandler cMTWinGameShell::gm_pfnPreviousCritMsgNotificationHandler;
 361
 362 void LGAPI cMTWinGameShell::CritMsgNotificationHandler(eCritMsgNotification notification)
 363 {
 364     switch (notification)
 365     {
 366         case kCritMsgEnter:
 367             gm_fInAssert = TRUE;
 368             if (gm_pfnPreviousCritMsgNotificationHandler)
 369                 (*gm_pfnPreviousCritMsgNotificationHandler)(notification);
 370             break;
 371
 372         case kCritMsgExit:
 373             if (gm_pfnPreviousCritMsgNotificationHandler)
 374                 (*gm_pfnPreviousCritMsgNotificationHandler)(notification);
 375             gm_fInAssert = FALSE;
 376             break;
 377
 378         default:
 379             if (gm_pfnPreviousCritMsgNotificationHandler)
 380                 (*gm_pfnPreviousCritMsgNotificationHandler)(notification);
 381     }
 382
 383 }
 384
 385 ///////////////////////////////////////////////////////////////////////////////
 386