开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
system.cpp
资源名称：hge181.rar　[点击查看]
上传用户：jnfxsk
上传日期：2022-06-16
资源大小：3675k
文件大小：20k
源码类别：

游戏引擎

开发平台：

Visual C++

system.cpp：源码内容
  1. /*
  2. ** Haaf's Game Engine 1.8
  3. ** Copyright (C) 2003-2007, Relish Games
  4. ** hge.relishgames.com
  5. **
  6. ** Core system functions
  7. */
  10. #include "hge_impl.h"
  13. #define LOWORDINT(n) ((int)((signed short)(LOWORD(n))))
  14. #define HIWORDINT(n) ((int)((signed short)(HIWORD(n))))
  17. const char *WINDOW_CLASS_NAME = "HGE__WNDCLASS";
  19. LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
  22. int nRef=0;
  23. HGE_Impl* pHGE=0;
  27. BOOL APIENTRY DllMain(HANDLE, DWORD, LPVOID)
  28. {
  29.     return TRUE;
  30. }
  33. HGE* CALL hgeCreate(int ver)
  34. {
  35. if(ver==HGE_VERSION)
  36. return (HGE*)HGE_Impl::_Interface_Get();
  37. else
  38. return 0;
  39. }
  42. HGE_Impl* HGE_Impl::_Interface_Get()
  43. {
  44. if(!pHGE) pHGE=new HGE_Impl();
  46. nRef++;
  48. return pHGE;
  49. }
  52. void CALL HGE_Impl::Release()
  53. {
  54. nRef--;
  56. if(!nRef)
  57. {
  58. if(pHGE->hwnd) pHGE->System_Shutdown();
  59. Resource_RemoveAllPacks();
  60. delete pHGE;
  61. pHGE=0;
  62. }
  63. }
  66. bool CALL HGE_Impl::System_Initiate()
  67. {
  68. OSVERSIONINFO os_ver;
  69. SYSTEMTIME tm;
  70. MEMORYSTATUS mem_st;
  71. WNDCLASS winclass;
  72. int width, height;
  74. // Log system info
  76. System_Log("HGE Started..n");
  78. System_Log("HGE version: %X.%X", HGE_VERSION>>8, HGE_VERSION & 0xFF);
  79. GetLocalTime(&tm);
  80. System_Log("Date: %02d.%02d.%d, %02d:%02d:%02dn", tm.wDay, tm.wMonth, tm.wYear, tm.wHour, tm.wMinute, tm.wSecond);
  82. System_Log("Application: %s",szWinTitle);
  83. os_ver.dwOSVersionInfoSize=sizeof(os_ver);
  84. GetVersionEx(&os_ver);
  85. System_Log("OS: Windows %ld.%ld.%ld",os_ver.dwMajorVersion,os_ver.dwMinorVersion,os_ver.dwBuildNumber);
  87. GlobalMemoryStatus(&mem_st);
  88. System_Log("Memory: %ldK total, %ldK freen",mem_st.dwTotalPhys/1024L,mem_st.dwAvailPhys/1024L);
  91. // Register window class
  93. winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
  94. winclass.lpfnWndProc = WindowProc;
  95. winclass.cbClsExtra = 0;
  96. winclass.cbWndExtra = 0;
  97. winclass.hInstance = hInstance;
  98. winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  99. winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
  100. winclass.lpszMenuName = NULL; 
  101. winclass.lpszClassName = WINDOW_CLASS_NAME;
  102. if(szIcon) winclass.hIcon = LoadIcon(hInstance, szIcon);
  103. else winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  105. if (!RegisterClass(&winclass)) {
  106. _PostError("Can't register window class");
  107. return false;
  108. }
  110. // Create window
  112. width=nScreenWidth + GetSystemMetrics(SM_CXFIXEDFRAME)*2;
  113. height=nScreenHeight + GetSystemMetrics(SM_CYFIXEDFRAME)*2 + GetSystemMetrics(SM_CYCAPTION);
  115. rectW.left=(GetSystemMetrics(SM_CXSCREEN)-width)/2;
  116. rectW.top=(GetSystemMetrics(SM_CYSCREEN)-height)/2;
  117. rectW.right=rectW.left+width;
  118. rectW.bottom=rectW.top+height;
  119. styleW=WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_VISIBLE; //WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX;
  121. rectFS.left=0;
  122. rectFS.top=0;
  123. rectFS.right=nScreenWidth;
  124. rectFS.bottom=nScreenHeight;
  125. styleFS=WS_POPUP|WS_VISIBLE; //WS_POPUP
  127. if(hwndParent)
  128. {
  129. rectW.left=0;
  130. rectW.top=0;
  131. rectW.right=nScreenWidth;
  132. rectW.bottom=nScreenHeight;
  133. styleW=WS_CHILD|WS_VISIBLE; 
  134. bWindowed=true;
  135. }
  137. if(bWindowed)
  138. hwnd = CreateWindowEx(0, WINDOW_CLASS_NAME, szWinTitle, styleW,
  139. rectW.left, rectW.top, rectW.right-rectW.left, rectW.bottom-rectW.top,
  140. hwndParent, NULL, hInstance, NULL);
  141. else
  142. hwnd = CreateWindowEx(WS_EX_TOPMOST, WINDOW_CLASS_NAME, szWinTitle, styleFS,
  143. 0, 0, 0, 0,
  144. NULL, NULL, hInstance, NULL);
  145. if (!hwnd)
  146. {
  147. _PostError("Can't create window");
  148. return false;
  149. }
  151. ShowWindow(hwnd, SW_SHOW);
  153. // Init subsystems
  155. timeBeginPeriod(1);
  156. Random_Seed();
  157. _InitPowerStatus();
  158. _InputInit();
  159. if(!_GfxInit()) { System_Shutdown(); return false; }
  160. if(!_SoundInit()) { System_Shutdown(); return false; }
  162. System_Log("Init done.n");
  164. fTime=0.0f;
  165. t0=t0fps=timeGetTime();
  166. dt=cfps=0;
  167. nFPS=0;
  169. // Show splash
  171. #ifdef DEMO
  173. bool (*func)();
  174. bool (*rfunc)();
  175. HWND hwndTmp;
  177. if(pHGE->bDMO)
  178. {
  179. Sleep(200);
  180. func=(bool(*)())pHGE->System_GetStateFunc(HGE_FRAMEFUNC);
  181. rfunc=(bool(*)())pHGE->System_GetStateFunc(HGE_RENDERFUNC);
  182. hwndTmp=hwndParent; hwndParent=0;
  183. pHGE->System_SetStateFunc(HGE_FRAMEFUNC, DFrame);
  184. pHGE->System_SetStateFunc(HGE_RENDERFUNC, 0);
  185. DInit();
  186. pHGE->System_Start();
  187. DDone();
  188. hwndParent=hwndTmp;
  189. pHGE->System_SetStateFunc(HGE_FRAMEFUNC, func);
  190. pHGE->System_SetStateFunc(HGE_RENDERFUNC, rfunc);
  191. }
  193. #endif
  195. // Done
  197. return true;
  198. }
  200. void CALL HGE_Impl::System_Shutdown()
  201. {
  202. System_Log("nFinishing..");
  204. timeEndPeriod(1);
  205. if(hSearch) { FindClose(hSearch); hSearch=0; }
  206. _ClearQueue();
  207. _SoundDone();
  208. _GfxDone();
  209. _DonePowerStatus();
  211. if(hwnd)
  212. {
  213. //ShowWindow(hwnd, SW_HIDE);
  214. //SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_TOOLWINDOW);
  215. //ShowWindow(hwnd, SW_SHOW);
  216. DestroyWindow(hwnd);
  217. hwnd=0;
  218. }
  220. if(hInstance) UnregisterClass(WINDOW_CLASS_NAME, hInstance);
  222. System_Log("The End.");
  223. }
  226. bool CALL HGE_Impl::System_Start()
  227. {
  228. MSG msg;
  230. if(!hwnd)
  231. {
  232. _PostError("System_Start: System_Initiate wasn't called");
  233. return false;
  234. }
  236. if(!procFrameFunc) {
  237. _PostError("System_Start: No frame function defined");
  238. return false;
  239. }
  241. bActive=true;
  243. // MAIN LOOP
  245. for(;;)
  246. {
  248. // Process window messages if not in "child mode"
  249. // (if in "child mode" the parent application will do this for us)
  251. if(!hwndParent)
  252. {
  253. if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
  254. { 
  255. if (msg.message == WM_QUIT) break;
  256. // TranslateMessage(&msg);
  257. DispatchMessage(&msg);
  258. continue;
  259. }
  260. }
  262. // Check if mouse is over HGE window for Input_IsMouseOver
  264. _UpdateMouse();
  266. // If HGE window is focused or we have the "don't suspend" state - process the main loop
  268. if(bActive || bDontSuspend)
  269. {
  270. // Ensure we have at least 1ms time step
  271. // to not confuse user's code with 0
  273. do { dt=timeGetTime() - t0; } while(dt < 1);
  275. // If we reached the time for the next frame
  276. // or we just run in unlimited FPS mode, then
  277. // do the stuff
  279. if(dt >= nFixedDelta)
  280. {
  281. // fDeltaTime = time step in seconds returned by Timer_GetDelta
  283. fDeltaTime=dt/1000.0f;
  285. // Cap too large time steps usually caused by lost focus to avoid jerks
  287. if(fDeltaTime > 0.2f)
  288. {
  289. fDeltaTime = nFixedDelta ? nFixedDelta/1000.0f : 0.01f;
  290. }
  292. // Update time counter returned Timer_GetTime
  294. fTime += fDeltaTime;
  296. // Store current time for the next frame
  297. // and count FPS
  299. t0=timeGetTime();
  300. if(t0-t0fps <= 1000) cfps++;
  301. else
  302. {
  303. nFPS=cfps; cfps=0; t0fps=t0;
  304. _UpdatePowerStatus();
  305. }
  307. // Do user's stuff
  309. if(procFrameFunc()) break;
  310. if(procRenderFunc) procRenderFunc();
  312. // If if "child mode" - return after processing single frame
  314. if(hwndParent) break;
  316. // Clean up input events that were generated by
  317. // WindowProc and weren't handled by user's code
  319. _ClearQueue();
  321. // If we use VSYNC - we could afford a little
  322. // sleep to lower CPU usage
  324. // if(!bWindowed && nHGEFPS==HGEFPS_VSYNC) Sleep(1);
  325. }
  327. // If we have a fixed frame rate and the time
  328. // for the next frame isn't too close, sleep a bit
  330. else
  331. {
  332. if(nFixedDelta && dt+3 < nFixedDelta) Sleep(1);
  333. }
  334. }
  336. // If main loop is suspended - just sleep a bit
  337. // (though not too much to allow instant window
  338. // redraw if requested by OS)
  340. else Sleep(1);
  341. }
  343. _ClearQueue();
  345. bActive=false;
  347. return true;
  348. }
  350. void CALL HGE_Impl::System_SetStateBool(hgeBoolState state, bool value)
  351. {
  352. switch(state)
  353. {
  354. case HGE_WINDOWED: if(VertArray || hwndParent) break;
  355. if(pD3DDevice && bWindowed != value)
  356. {
  357. if(d3dppW.BackBufferFormat==D3DFMT_UNKNOWN || d3dppFS.BackBufferFormat==D3DFMT_UNKNOWN) break;
  359. if(bWindowed) GetWindowRect(hwnd, &rectW);
  360. bWindowed=value;
  361. if(bWindowed) d3dpp=&d3dppW;
  362. else d3dpp=&d3dppFS;
  364. if(_format_id(d3dpp->BackBufferFormat) < 4) nScreenBPP=16;
  365. else nScreenBPP=32;
  367. _GfxRestore();
  368. _AdjustWindow();
  369. }
  370. else bWindowed=value;
  371. break;
  373. case HGE_ZBUFFER: if(!pD3DDevice) bZBuffer=value;
  374. break;
  376. case HGE_TEXTUREFILTER: bTextureFilter=value;
  377. if(pD3DDevice)
  378. {
  379. _render_batch();
  380. if(bTextureFilter)
  381. {
  382. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
  383. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
  384. }
  385. else
  386. {
  387. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_POINT);
  388. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_POINT);
  389. }
  390. }
  391. break;
  393. case HGE_USESOUND: if(bUseSound!=value)
  394. {
  395. bUseSound=value;
  396. if(bUseSound && hwnd) _SoundInit();
  397. if(!bUseSound && hwnd) _SoundDone();
  398. }
  399. break;
  401. case HGE_HIDEMOUSE: bHideMouse=value; break;
  403. case HGE_DONTSUSPEND: bDontSuspend=value; break;
  405. #ifdef DEMO
  406. case HGE_SHOWSPLASH: bDMO=value; break;
  407. #endif
  408. }
  409. }
  411. void CALL HGE_Impl::System_SetStateFunc(hgeFuncState state, hgeCallback value)
  412. {
  413. switch(state)
  414. {
  415. case HGE_FRAMEFUNC:  procFrameFunc=value; break;
  416. case HGE_RENDERFUNC:  procRenderFunc=value; break;
  417. case HGE_FOCUSLOSTFUNC:  procFocusLostFunc=value; break;
  418. case HGE_FOCUSGAINFUNC:  procFocusGainFunc=value; break;
  419. case HGE_GFXRESTOREFUNC: procGfxRestoreFunc=value; break;
  420. case HGE_EXITFUNC:  procExitFunc=value; break;
  421. }
  422. }
  424. void CALL HGE_Impl::System_SetStateHwnd(hgeHwndState state, HWND value)
  425. {
  426. switch(state)
  427. {
  428. case HGE_HWNDPARENT: if(!hwnd) hwndParent=value; break;
  429. }
  430. }
  432. void CALL HGE_Impl::System_SetStateInt(hgeIntState state, int value)
  433. {
  434. switch(state)
  435. {
  436. case HGE_SCREENWIDTH: if(!pD3DDevice) nScreenWidth=value; break;
  438. case HGE_SCREENHEIGHT: if(!pD3DDevice) nScreenHeight=value; break;
  440. case HGE_SCREENBPP: if(!pD3DDevice) nScreenBPP=value; break;
  442. case HGE_SAMPLERATE: if(!hBass) nSampleRate=value;
  443. break;
  445. case HGE_FXVOLUME: nFXVolume=value;
  446. _SetFXVolume(nFXVolume);
  447. break;
  449. case HGE_MUSVOLUME: nMusVolume=value;
  450. _SetMusVolume(nMusVolume);
  451. break;
  453. case HGE_STREAMVOLUME: nStreamVolume=value;
  454. _SetStreamVolume(nStreamVolume);
  455. break;
  457. case HGE_FPS: if(VertArray) break;
  459. if(pD3DDevice)
  460. {
  461. if((nHGEFPS>=0 && value <0) || (nHGEFPS<0 && value>=0))
  462. {
  463. if(value==HGEFPS_VSYNC)
  464. {
  465. d3dppW.SwapEffect = D3DSWAPEFFECT_COPY_VSYNC;
  466. d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
  467. }
  468. else
  469. {
  470. d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
  471. d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
  472. }
  473. //if(procFocusLostFunc) procFocusLostFunc();
  474. _GfxRestore();
  475. //if(procFocusGainFunc) procFocusGainFunc();
  476. }
  477. }
  478. nHGEFPS=value;
  479. if(nHGEFPS>0) nFixedDelta=int(1000.0f/value);
  480. else nFixedDelta=0;
  481. break;
  482. }
  483. }
  485. void CALL HGE_Impl::System_SetStateString(hgeStringState state, const char *value)
  486. {
  487. FILE *hf;
  489. switch(state)
  490. {
  491. case HGE_ICON: szIcon=value;
  492. if(pHGE->hwnd) SetClassLong(pHGE->hwnd, GCL_HICON, (LONG)LoadIcon(pHGE->hInstance, szIcon));
  493. break;
  494. case HGE_TITLE: strcpy(szWinTitle,value);
  495. if(pHGE->hwnd) SetWindowText(pHGE->hwnd, szWinTitle);
  496. break;
  497. case HGE_INIFILE: if(value) strcpy(szIniFile,Resource_MakePath(value));
  498. else szIniFile[0]=0;
  499. break;
  500. case HGE_LOGFILE: if(value)
  501. {
  502. strcpy(szLogFile,Resource_MakePath(value));
  503. hf=fopen(szLogFile, "w");
  504. if(!hf) szLogFile[0]=0;
  505. else fclose(hf);
  506. }
  507. else szLogFile[0]=0;
  508. break;
  509. }
  510. }
  512. bool CALL HGE_Impl::System_GetStateBool(hgeBoolState state)
  513. {
  514. switch(state)
  515. {
  516. case HGE_WINDOWED: return bWindowed;
  517. case HGE_ZBUFFER: return bZBuffer;
  518. case HGE_TEXTUREFILTER: return bTextureFilter;
  519. case HGE_USESOUND: return bUseSound;
  520. case HGE_DONTSUSPEND: return bDontSuspend;
  521. case HGE_HIDEMOUSE: return bHideMouse;
  523. #ifdef DEMO
  524. case HGE_SHOWSPLASH: return bDMO;
  525. #endif
  526. }
  528. return false;
  529. }
  531. hgeCallback CALL HGE_Impl::System_GetStateFunc(hgeFuncState state)
  532. {
  533. switch(state)
  534. {
  535. case HGE_FRAMEFUNC: return procFrameFunc;
  536. case HGE_RENDERFUNC: return procRenderFunc;
  537. case HGE_FOCUSLOSTFUNC: return procFocusLostFunc;
  538. case HGE_FOCUSGAINFUNC: return procFocusGainFunc;
  539. case HGE_EXITFUNC: return procExitFunc;
  540. }
  542. return NULL;
  543. }
  545. HWND CALL HGE_Impl::System_GetStateHwnd(hgeHwndState state)
  546. {
  547. switch(state)
  548. {
  549. case HGE_HWND: return hwnd;
  550. case HGE_HWNDPARENT: return hwndParent;
  551. }
  553. return 0;
  554. }
  556. int CALL HGE_Impl::System_GetStateInt(hgeIntState state)
  557. {
  558. switch(state)
  559. {
  560. case HGE_SCREENWIDTH: return nScreenWidth;
  561. case HGE_SCREENHEIGHT: return nScreenHeight;
  562. case HGE_SCREENBPP: return nScreenBPP;
  563. case HGE_SAMPLERATE: return nSampleRate;
  564. case HGE_FXVOLUME: return nFXVolume;
  565. case HGE_MUSVOLUME: return nMusVolume;
  566. case HGE_STREAMVOLUME: return nStreamVolume;
  567. case HGE_FPS: return nHGEFPS;
  568. case HGE_POWERSTATUS: return nPowerStatus;
  569. }
  571. return 0;
  572. }
  574. const char* CALL HGE_Impl::System_GetStateString(hgeStringState state) {
  575. switch(state) {
  576. case HGE_ICON: return szIcon;
  577. case HGE_TITLE: return szWinTitle;
  578. case HGE_INIFILE: if(szIniFile[0]) return szIniFile;
  579. else return 0;
  580. case HGE_LOGFILE: if(szLogFile[0]) return szLogFile;
  581. else return 0;
  582. }
  584. return NULL;
  585. }
  587. char* CALL HGE_Impl::System_GetErrorMessage()
  588. {
  589. return szError;
  590. }
  592. void CALL HGE_Impl::System_Log(const char *szFormat, ...)
  593. {
  594. FILE *hf = NULL;
  595. va_list ap;
  597. if(!szLogFile[0]) return;
  599. hf = fopen(szLogFile, "a");
  600. if(!hf) return;
  602. va_start(ap, szFormat);
  603. vfprintf(hf, szFormat, ap);
  604. va_end(ap);
  606. fprintf(hf, "n");
  608. fclose(hf);
  609. }
  611. bool CALL HGE_Impl::System_Launch(const char *url)
  612. {
  613. if((DWORD)ShellExecute(pHGE->hwnd, NULL, url, NULL, NULL, SW_SHOWMAXIMIZED)>32) return true;
  614. else return false;
  615. }
  617. void CALL HGE_Impl::System_Snapshot(const char *filename)
  618. {
  619. LPDIRECT3DSURFACE8 pSurf;
  620. char *shotname, tempname[_MAX_PATH];
  621. int i;
  623. if(!filename)
  624. {
  625. i=0;
  626. shotname=Resource_EnumFiles("shot???.bmp");
  627. while(shotname)
  628. {
  629. i++;
  630. shotname=Resource_EnumFiles();
  631. }
  632. sprintf(tempname, "shot%03d.bmp", i);
  633. filename=Resource_MakePath(tempname);
  634. }
  636. if(pD3DDevice)
  637. {
  638. pD3DDevice->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pSurf);
  639. D3DXSaveSurfaceToFile(filename, D3DXIFF_BMP, pSurf, NULL, NULL);
  640. pSurf->Release();
  641. }
  642. }
  644. //////// Implementation ////////
  647. HGE_Impl::HGE_Impl()
  648. {
  649. hInstance=GetModuleHandle(0);
  650. hwnd=0;
  651. bActive=false;
  652. szError[0]=0;
  654. pD3D=0;
  655. pD3DDevice=0;
  656. d3dpp=0;
  657. pTargets=0;
  658. pCurTarget=0;
  659. pScreenSurf=0;
  660. pScreenDepth=0;
  661. pVB=0;
  662. pIB=0;
  663. VertArray=0;
  664. textures=0;
  666. hBass=0;
  667. bSilent=false;
  668. streams=0;
  670. hSearch=0;
  671. res=0;
  673. queue=0;
  674. Char=VKey=Zpos=0;
  675. Xpos=Ypos=0.0f;
  676. bMouseOver=false;
  677. bCaptured=false;
  679. nHGEFPS=HGEFPS_UNLIMITED;
  680. fTime=0.0f;
  681. fDeltaTime=0.0f;
  682. nFPS=0;
  684. procFrameFunc=0;
  685. procRenderFunc=0;
  686. procFocusLostFunc=0;
  687. procFocusGainFunc=0;
  688. procGfxRestoreFunc=0;
  689. procExitFunc=0;
  690. szIcon=0;
  691. strcpy(szWinTitle,"HGE");
  692. nScreenWidth=800;
  693. nScreenHeight=600;
  694. nScreenBPP=32;
  695. bWindowed=false;
  696. bZBuffer=false;
  697. bTextureFilter=true;
  698. szLogFile[0]=0;
  699. szIniFile[0]=0;
  700. bUseSound=true;
  701. nSampleRate=44100;
  702. nFXVolume=100;
  703. nMusVolume=100;
  704. nStreamVolume=100;
  705. nFixedDelta=0;
  706. bHideMouse=true;
  707. bDontSuspend=false;
  708. hwndParent=0;
  710. nPowerStatus=HGEPWR_UNSUPPORTED;
  711. hKrnl32 = NULL;
  712. lpfnGetSystemPowerStatus = NULL;
  714. #ifdef DEMO
  715. bDMO=true;
  716. #endif
  719. GetModuleFileName(GetModuleHandle(NULL), szAppPath, sizeof(szAppPath));
  720. int i;
  721. for(i=strlen(szAppPath)-1; i>0; i--) if(szAppPath[i]=='\') break;
  722. szAppPath[i+1]=0;
  723. }
  725. void HGE_Impl::_PostError(char *error)
  726. {
  727. System_Log(error);
  728. strcpy(szError,error);
  729. }
  731. void HGE_Impl::_FocusChange(bool bAct)
  732. {
  733. bActive=bAct;
  735. if(bActive)
  736. {
  737. if(procFocusGainFunc) procFocusGainFunc();
  738. }
  739. else
  740. {
  741. if(procFocusLostFunc) procFocusLostFunc();
  742. }
  743. }
  745. LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
  746. {
  747. bool bActivating;
  749. switch(msg)
  750. {
  751. case WM_CREATE: 
  752. return FALSE;
  754. case WM_PAINT:
  755. if(pHGE->pD3D && pHGE->procRenderFunc && pHGE->bWindowed) pHGE->procRenderFunc();
  756. break;
  758. case WM_DESTROY:
  759. PostQuitMessage(0);
  760. return FALSE;
  762. /*
  763. case WM_ACTIVATEAPP:
  764. bActivating = (wparam == TRUE);
  765. if(pHGE->pD3D && pHGE->bActive != bActivating) pHGE->_FocusChange(bActivating);
  766. return FALSE;
  767. */
  768. case WM_ACTIVATE:
  769. // tricky: we should catch WA_ACTIVE and WA_CLICKACTIVE,
  770. // but only if HIWORD(wParam) (fMinimized) == FALSE (0)
  771. bActivating = (LOWORD(wparam) != WA_INACTIVE) && (HIWORD(wparam) == 0);
  772. if(pHGE->pD3D && pHGE->bActive != bActivating) pHGE->_FocusChange(bActivating);
  773. return FALSE;
  776. case WM_SETCURSOR:
  777. if(pHGE->bActive && LOWORD(lparam)==HTCLIENT && pHGE->bHideMouse) SetCursor(NULL);
  778. else SetCursor(LoadCursor(NULL, IDC_ARROW));
  779. return FALSE;
  781. case WM_SYSKEYDOWN:
  782. if(wparam == VK_F4)
  783. {
  784. if(pHGE->procExitFunc && !pHGE->procExitFunc()) return FALSE;
  785. return DefWindowProc(hwnd, msg, wparam, lparam);
  786. }
  787. else if(wparam == VK_RETURN)
  788. {
  789. pHGE->System_SetState(HGE_WINDOWED, !pHGE->System_GetState(HGE_WINDOWED));
  790. return FALSE;
  791. }
  792. else
  793. {
  794. pHGE->_BuildEvent(INPUT_KEYDOWN, wparam, HIWORD(lparam) & 0xFF, (lparam & 0x40000000) ? HGEINP_REPEAT:0, -1, -1);
  795. return FALSE;
  796. }
  798. case WM_KEYDOWN:
  799. pHGE->_BuildEvent(INPUT_KEYDOWN, wparam, HIWORD(lparam) & 0xFF, (lparam & 0x40000000) ? HGEINP_REPEAT:0, -1, -1);
  800. return FALSE;
  801. case WM_SYSKEYUP:
  802. pHGE->_BuildEvent(INPUT_KEYUP, wparam, HIWORD(lparam) & 0xFF, 0, -1, -1);
  803. return FALSE;
  804. case WM_KEYUP:
  805. pHGE->_BuildEvent(INPUT_KEYUP, wparam, HIWORD(lparam) & 0xFF, 0, -1, -1);
  806. return FALSE;
  808. case WM_LBUTTONDOWN:
  809. SetFocus(hwnd);
  810. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_LBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  811. return FALSE;
  812. case WM_MBUTTONDOWN:
  813. SetFocus(hwnd);
  814. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_MBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  815. return FALSE;
  816. case WM_RBUTTONDOWN:
  817. SetFocus(hwnd);
  818. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_RBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  819. return FALSE;
  821. case WM_LBUTTONDBLCLK:
  822. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_LBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
  823. return FALSE;
  824. case WM_MBUTTONDBLCLK:
  825. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_MBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
  826. return FALSE;
  827. case WM_RBUTTONDBLCLK:
  828. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_RBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
  829. return FALSE;
  831. case WM_LBUTTONUP:
  832. pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_LBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  833. return FALSE;
  834. case WM_MBUTTONUP:
  835. pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_MBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  836. return FALSE;
  837. case WM_RBUTTONUP:
  838. pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_RBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  839. return FALSE;
  841. case WM_MOUSEMOVE:
  842. pHGE->_BuildEvent(INPUT_MOUSEMOVE, 0, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  843. return FALSE;
  844. case 0x020A: // WM_MOUSEWHEEL, GET_WHEEL_DELTA_WPARAM(wparam);
  845. pHGE->_BuildEvent(INPUT_MOUSEWHEEL, short(HIWORD(wparam))/120, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  846. return FALSE;
  848. case WM_SIZE:
  849. if(pHGE->pD3D && wparam==SIZE_RESTORED) pHGE->_Resize(LOWORD(lparam), HIWORD(lparam));
  850. //return FALSE;
  851. break;
  853. case WM_SYSCOMMAND:
  854. if(wparam==SC_CLOSE)
  855. {
  856. if(pHGE->procExitFunc && !pHGE->procExitFunc()) return FALSE;
  857. pHGE->bActive=false;
  858. return DefWindowProc(hwnd, msg, wparam, lparam);
  859. }
  860. break;
  861. }
  863. return DefWindowProc(hwnd, msg, wparam, lparam);
  864. }