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

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

游戏引擎

开发平台：

Visual C++

system.cpp：源码内容
  1. /*
  2. ** Haaf's Game Engine 1.5
  3. ** Copyright (C) 2003-2004, 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";
  18. LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
  21. int nRef=0;
  22. HGE_Impl* pHGE=0;
  25. BOOL APIENTRY DllMain(HANDLE, DWORD, LPVOID)
  26. {
  27.     return TRUE;
  28. }
  30. HGE* CALL hgeCreate(int ver)
  31. {
  32. if(ver==HGE_VERSION) return (HGE*)HGE_Impl::_Interface_Get();
  33. else return 0;
  34. }
  36. HGE_Impl* HGE_Impl::_Interface_Get()
  37. {
  38. if(!pHGE) pHGE=new HGE_Impl();
  39. nRef++;
  40. return pHGE;
  41. }
  43. void CALL HGE_Impl::Release()
  44. {
  45. nRef--;
  46. if(!nRef)
  47. {
  48. if(pHGE->hwnd) pHGE->System_Shutdown();
  49. Resource_RemoveAllPacks();
  50. delete pHGE;
  51. pHGE=0;
  52. }
  53. }
  56. bool CALL HGE_Impl::System_Initiate()
  57. {
  58. OSVERSIONINFO os_ver;
  59. SYSTEMTIME tm;
  60. MEMORYSTATUS mem_st;
  61. WNDCLASS winclass;
  62. int width, height;
  64. System_Log("HGE Started..n");
  66. System_Log("HGE version: %X.%X", HGE_VERSION>>8, HGE_VERSION & 0xFF);
  67. GetLocalTime(&tm);
  68. System_Log("Date: %02d.%02d.%d, %02d:%02d:%02dn", tm.wDay, tm.wMonth, tm.wYear, tm.wHour, tm.wMinute, tm.wSecond);
  70. System_Log("Application: %s",szWinTitle);
  71. os_ver.dwOSVersionInfoSize=sizeof(os_ver);
  72. GetVersionEx(&os_ver);
  73. System_Log("OS: Windows %ld.%ld.%ld",os_ver.dwMajorVersion,os_ver.dwMinorVersion,os_ver.dwBuildNumber);
  75. GlobalMemoryStatus(&mem_st);
  76. System_Log("Memory: %ldK total, %ldK freen",mem_st.dwTotalPhys/1024L,mem_st.dwAvailPhys/1024L);
  78. winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
  79. winclass.lpfnWndProc = WindowProc;
  80. winclass.cbClsExtra = 0;
  81. winclass.cbWndExtra = 0;
  82. winclass.hInstance = hInstance;
  83. winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  84. winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
  85. winclass.lpszMenuName = NULL; 
  86. winclass.lpszClassName = WINDOW_CLASS_NAME;
  87. if(szIcon) winclass.hIcon = LoadIcon(hInstance, szIcon);
  88. else winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  90. if (!RegisterClass(&winclass)) {
  91. _PostError("Can't register window class");
  92. return false;
  93. }
  95. width=nScreenWidth + GetSystemMetrics(SM_CXFIXEDFRAME)*2;
  96. height=nScreenHeight + GetSystemMetrics(SM_CYFIXEDFRAME)*2 + GetSystemMetrics(SM_CYCAPTION);
  98. rectW.left=(GetSystemMetrics(SM_CXSCREEN)-width)/2;
  99. rectW.top=(GetSystemMetrics(SM_CYSCREEN)-height)/2;
  100. rectW.right=rectW.left+width;
  101. rectW.bottom=rectW.top+height;
  102. styleW=WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_VISIBLE; //WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX;
  104. rectFS.left=0;
  105. rectFS.top=0;
  106. rectFS.right=nScreenWidth;
  107. rectFS.bottom=nScreenHeight;
  108. styleFS=WS_POPUP|WS_VISIBLE; //WS_POPUP
  110. if(hwndParent)
  111. {
  112. rectW.left=0;
  113. rectW.top=0;
  114. rectW.right=nScreenWidth;
  115. rectW.bottom=nScreenHeight;
  116. styleW=WS_CHILD|WS_VISIBLE; 
  117. bWindowed=true;
  118. }
  120. if(bWindowed)
  121. hwnd = CreateWindowEx(0, WINDOW_CLASS_NAME, szWinTitle, styleW,
  122. rectW.left, rectW.top, rectW.right-rectW.left, rectW.bottom-rectW.top,
  123. hwndParent, NULL, hInstance, NULL);
  124. else
  125. hwnd = CreateWindowEx(WS_EX_TOPMOST, WINDOW_CLASS_NAME, szWinTitle, styleFS,
  126. 0, 0, 0, 0,
  127. NULL, NULL, hInstance, NULL);
  128. if (!hwnd)
  129. {
  130. _PostError("Can't create window");
  131. return false;
  132. }
  134. ShowWindow(hwnd, SW_SHOW);
  136. timeBeginPeriod(1);
  137. Random_Seed();
  138. if(!_GfxInit()) { System_Shutdown(); return false; }
  139. if(!_SoundInit()) { System_Shutdown(); return false; }
  141. System_Log("Init done.n");
  143. fTime=0.0f;
  144. t0=t0fps=timeGetTime();
  145. dt=cfps=0;
  146. nFPS=0;
  148. #ifdef DEMO
  150. bool (*func)();
  151. bool (*rfunc)();
  152. HWND hwndTmp;
  154. if(~pHGE->nDMO != ~0xFACE0FF) // Commercial version magic
  155. {
  156. Sleep(200);
  157. func=(bool(*)())pHGE->System_GetStateFunc(HGE_FRAMEFUNC);
  158. rfunc=(bool(*)())pHGE->System_GetStateFunc(HGE_RENDERFUNC);
  159. hwndTmp=hwndParent; hwndParent=0;
  160. pHGE->System_SetStateFunc(HGE_FRAMEFUNC, DFrame);
  161. pHGE->System_SetStateFunc(HGE_RENDERFUNC, 0);
  162. DInit();
  163. pHGE->System_Start();
  164. DDone();
  165. hwndParent=hwndTmp;
  166. pHGE->System_SetStateFunc(HGE_FRAMEFUNC, func);
  167. pHGE->System_SetStateFunc(HGE_RENDERFUNC, rfunc);
  168. }
  170. #endif
  172. return true;
  173. }
  175. void CALL HGE_Impl::System_Shutdown()
  176. {
  177. System_Log("nFinishing..");
  179. timeEndPeriod(1);
  180. _ClearQueue();
  181. _SoundDone();
  182. _GfxDone();
  183. if(hwnd)
  184. {
  185. //ShowWindow(hwnd, SW_HIDE);
  186. //SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_TOOLWINDOW);
  187. //ShowWindow(hwnd, SW_SHOW);
  188. DestroyWindow(hwnd);
  189. hwnd=0;
  190. }
  191. if(hInstance) UnregisterClass(WINDOW_CLASS_NAME, hInstance);
  193. System_Log("The End.");
  194. }
  197. bool CALL HGE_Impl::System_Start()
  198. {
  199. MSG msg;
  200. POINT pt;
  201. RECT rc;
  203. if(!hwnd)
  204. {
  205. _PostError("System_Start: System_Initiate wasn't called");
  206. return false;
  207. }
  209. if(!procFrameFunc)
  210. {
  211. _PostError("System_Start: No frame function defined");
  212. return false;
  213. }
  215. bActive=true;
  217. for(;;)
  218. {
  220. if(!hwndParent)
  221. {
  222. if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
  223. { 
  224. if (msg.message == WM_QUIT)
  225. break;
  226. // TranslateMessage(&msg);
  227. DispatchMessage(&msg);
  228. continue;
  229. }
  230. }
  232. GetCursorPos(&pt);
  233. GetClientRect(hwnd, &rc);
  234. MapWindowPoints(hwnd, NULL, (LPPOINT)&rc, 2);
  235. if(bCaptured || (PtInRect(&rc, pt) && WindowFromPoint(pt)==hwnd))
  236. bMouseOver=true;
  237. else
  238. bMouseOver=false;
  240. if(bActive || bDontSuspend)
  241. {
  242. do
  243. {
  244. dt=timeGetTime() - t0;
  245. } while(dt < 1);
  246. if(dt >= nFixedDelta)
  247. {
  248. fDeltaTime=dt/1000.0f;
  249. if(fDeltaTime > 0.2f)
  250. {
  251. if(nFixedDelta)
  252. fDeltaTime=nFixedDelta/1000.0f;
  253. else
  254. fDeltaTime=0.01f;
  255. }
  256. fTime+=fDeltaTime;
  258. t0=timeGetTime();
  259. if(t0-t0fps < 1000)
  260. cfps++;
  261. else
  262. {
  263. nFPS=cfps;
  264. cfps=0;
  265. t0fps=t0;
  266. }
  267. if(procFrameFunc())
  268. break;
  269. if(procRenderFunc)
  270. procRenderFunc();
  271. if(hwndParent)
  272. break;
  273. _ClearQueue();
  274. if(!bWindowed && nHGEFPS==HGEFPS_VSYNC)
  275. Sleep(1);
  276. }
  277. else
  278. {
  279. if(nFixedDelta && dt+3 < nFixedDelta)
  280. Sleep(1);
  281. }
  282. }
  283. else Sleep(1);
  284. }
  285. _ClearQueue();
  286. bActive=false;
  287. return true;
  288. }
  290. void CALL HGE_Impl::System_SetStateBool(hgeBoolState state, bool value)
  291. {
  292. switch(state) {
  293. case HGE_WINDOWED: if(VertArray || hwndParent) break;
  294. if(pD3DDevice && bWindowed != value)
  295. {
  296. if(d3dppW.BackBufferFormat==D3DFMT_UNKNOWN || d3dppFS.BackBufferFormat==D3DFMT_UNKNOWN) break;
  298. if(procFocusLostFunc) procFocusLostFunc();
  300. if(bWindowed) GetWindowRect(hwnd, &rectW);
  301. bWindowed=value;
  302. if(bWindowed) d3dpp=&d3dppW;
  303. else d3dpp=&d3dppFS;
  305. if(_format_id(d3dpp->BackBufferFormat) < 4) nScreenBPP=16;
  306. else nScreenBPP=32;
  308. _GfxRestore();
  309. _AdjustWindow();
  311. if(procFocusGainFunc) procFocusGainFunc();
  312. }
  313. else bWindowed=value;
  314. break;
  315. case HGE_ZBUFFER: if(!pD3DDevice) bZBuffer=value;
  316. break;
  317. case HGE_TEXTUREFILTER: bTextureFilter=value;
  318. if(pD3DDevice)
  319. {
  320. _render_batch();
  321. if(bTextureFilter)
  322. {
  323. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
  324. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
  325. }
  326. else
  327. {
  328. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_POINT);
  329. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_POINT);
  330. }
  331. }
  332. break;
  333. case HGE_USESOUND: if(bUseSound!=value)
  334. {
  335. bUseSound=value;
  336. if(bUseSound && hwnd) _SoundInit();
  337. if(!bUseSound && hwnd) _SoundDone();
  338. }
  339. break;
  340. case HGE_HIDEMOUSE: bHideMouse=value; break;
  341. case HGE_DONTSUSPEND: bDontSuspend=value; break;
  342. }
  343. }
  345. void CALL HGE_Impl::System_SetStateFunc(hgeFuncState state, hgeCallback value)
  346. {
  347. switch(state) {
  348. case HGE_FRAMEFUNC: procFrameFunc=value; break;
  349. case HGE_RENDERFUNC: procRenderFunc=value; break;
  350. case HGE_FOCUSLOSTFUNC: procFocusLostFunc=value; break;
  351. case HGE_FOCUSGAINFUNC: procFocusGainFunc=value; break;
  352. case HGE_EXITFUNC: procExitFunc=value; break;
  353. }
  354. }
  356. void CALL HGE_Impl::System_SetStateHwnd(hgeHwndState state, HWND value)
  357. {
  358. switch(state) {
  359. case HGE_HWNDPARENT: if(!hwnd) hwndParent=value; break;
  360. }
  361. }
  363. void CALL HGE_Impl::System_SetStateInt(hgeIntState state, int value)
  364. {
  365. switch(state) {
  366. case HGE_SCREENWIDTH: if(!pD3DDevice) nScreenWidth=value; break;
  367. case HGE_SCREENHEIGHT: if(!pD3DDevice) nScreenHeight=value; break;
  368. case HGE_SCREENBPP: if(!pD3DDevice) nScreenBPP=value; break;
  369. case HGE_SAMPLERATE: if(!hBass) nSampleRate=value;
  370. break;
  371. case HGE_FXVOLUME: nFXVolume=value;
  372. _SetFXVolume(nFXVolume);
  373. break;
  374. case HGE_MUSVOLUME: nMusVolume=value;
  375. _SetMusVolume(nMusVolume);
  376. break;
  377. case HGE_FPS: if(VertArray) break;
  378. if(pD3DDevice)
  379. {
  380. if((nHGEFPS>=0 && value <0) || (nHGEFPS<0 && value>=0))
  381. {
  382. if(value==HGEFPS_VSYNC)
  383. {
  384. d3dppW.SwapEffect = D3DSWAPEFFECT_COPY_VSYNC;
  385. d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
  386. }
  387. else
  388. {
  389. d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
  390. d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
  391. }
  392. if(procFocusLostFunc) procFocusLostFunc();
  393. _GfxRestore();
  394. if(procFocusGainFunc) procFocusGainFunc();
  395. }
  396. }
  397. nHGEFPS=value;
  398. if(nHGEFPS>0) nFixedDelta=int(1000.0f/value);
  399. else nFixedDelta=0;
  400. break;
  401. #ifdef DEMO
  402. case (hgeIntState)14: nDMO=value; break;
  403. #endif
  404. }
  405. }
  407. void CALL HGE_Impl::System_SetStateString(hgeStringState state, const char *value)
  408. {
  409. FILE *hf;
  411. switch(state) {
  412. case HGE_ICON: szIcon=value;
  413. if(pHGE->hwnd) SetClassLong(pHGE->hwnd, GCL_HICON, (LONG)LoadIcon(pHGE->hInstance, szIcon));
  414. break;
  415. case HGE_TITLE: strcpy(szWinTitle,value);
  416. if(pHGE->hwnd) SetWindowText(pHGE->hwnd, szWinTitle);
  417. break;
  418. case HGE_INIFILE: if(value) strcpy(szIniFile,Resource_MakePath(value));
  419. else szIniFile[0]=0;
  420. break;
  421. case HGE_LOGFILE: if(value)
  422. {
  423. strcpy(szLogFile,Resource_MakePath(value));
  424. hf=fopen(szLogFile, "w");
  425. if(!hf) szLogFile[0]=0;
  426. else fclose(hf);
  427. }
  428. else szLogFile[0]=0;
  429. break;
  430. }
  431. }
  433. bool CALL HGE_Impl::System_GetStateBool(hgeBoolState state)
  434. {
  435. switch(state) {
  436. case HGE_WINDOWED: return bWindowed;
  437. case HGE_ZBUFFER: return bZBuffer;
  438. case HGE_TEXTUREFILTER: return bTextureFilter;
  439. case HGE_USESOUND: return bUseSound;
  440. case HGE_DONTSUSPEND: return bDontSuspend;
  441. case HGE_HIDEMOUSE: return bHideMouse;
  442. }
  443. return false;
  444. }
  446. hgeCallback CALL HGE_Impl::System_GetStateFunc(hgeFuncState state)
  447. {
  448. switch(state) {
  449. case HGE_FRAMEFUNC: return procFrameFunc;
  450. case HGE_RENDERFUNC: return procRenderFunc;
  451. case HGE_FOCUSLOSTFUNC: return procFocusLostFunc;
  452. case HGE_FOCUSGAINFUNC: return procFocusGainFunc;
  453. case HGE_EXITFUNC: return procExitFunc;
  454. }
  455. return NULL;
  456. }
  458. HWND CALL HGE_Impl::System_GetStateHwnd(hgeHwndState state)
  459. {
  460. switch(state) {
  461. case HGE_HWND: return hwnd;
  462. case HGE_HWNDPARENT: return hwndParent;
  463. }
  464. return 0;
  465. }
  467. int CALL HGE_Impl::System_GetStateInt(hgeIntState state)
  468. {
  469. switch(state) {
  470. case HGE_SCREENWIDTH: return nScreenWidth;
  471. case HGE_SCREENHEIGHT: return nScreenHeight;
  472. case HGE_SCREENBPP: return nScreenBPP;
  473. case HGE_SAMPLERATE: return nSampleRate;
  474. case HGE_FXVOLUME: return nFXVolume;
  475. case HGE_MUSVOLUME: return nMusVolume;
  476. case HGE_FPS: return nHGEFPS;
  477. }
  478. return 0;
  479. }
  481. const char* CALL HGE_Impl::System_GetStateString(hgeStringState state) {
  482. switch(state) {
  483. case HGE_ICON: return szIcon;
  484. case HGE_TITLE: return szWinTitle;
  485. case HGE_INIFILE: if(szIniFile[0]) return szIniFile;
  486. else return 0;
  487. case HGE_LOGFILE: if(szLogFile[0]) return szLogFile;
  488. else return 0;
  489. }
  490. return NULL;
  491. }
  493. char* CALL HGE_Impl::System_GetErrorMessage()
  494. {
  495. return szError;
  496. }
  498. void CALL HGE_Impl::System_Log(const char *szFormat, ...)
  499. {
  500. FILE *hf = NULL;
  501. char tmp[256];
  503. if(!szLogFile[0]) return;
  505. hf = fopen(szLogFile, "a");
  506. if(!hf) return;
  508. vsprintf(tmp, szFormat, (char *)&szFormat+sizeof(szFormat));
  510. fprintf(hf, tmp);
  511. fprintf(hf, "n");
  513. fclose(hf);
  514. }
  516. bool CALL HGE_Impl::System_Launch(const char *url)
  517. {
  518. if((DWORD)ShellExecute(pHGE->hwnd, NULL, url, NULL, NULL, SW_SHOWMAXIMIZED)>32) return true;
  519. else return false;
  520. }
  522. void CALL HGE_Impl::System_Snapshot(const char *filename)
  523. {
  524. LPDIRECT3DSURFACE8 pSurf;
  525. char *shotname, tempname[_MAX_PATH];
  526. int i;
  528. if(!filename)
  529. {
  530. i=0;
  531. shotname=Resource_EnumFiles("shot???.bmp");
  532. while(shotname)
  533. {
  534. i++;
  535. shotname=Resource_EnumFiles();
  536. }
  537. sprintf(tempname, "shot%03d.bmp", i);
  538. filename=Resource_MakePath(tempname);
  539. }
  541. if(pD3DDevice)
  542. {
  543. pD3DDevice->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pSurf);
  544. D3DXSaveSurfaceToFile(filename, D3DXIFF_BMP, pSurf, NULL, NULL);
  545. pSurf->Release();
  546. }
  547. }
  549. //////// Implementation ////////
  552. HGE_Impl::HGE_Impl()
  553. {
  554. hInstance=GetModuleHandle(0);
  555. hwnd=0;
  556. bActive=true;
  557. szError[0]=0;
  559. pD3D=0;
  560. pD3DDevice=0;
  561. d3dpp=0;
  562. pTargets=0;
  563. pCurTarget=0;
  564. pScreenSurf=0;
  565. pScreenDepth=0;
  566. pVB=0;
  567. pIB=0;
  568. VertArray=0;
  569. textures=0;
  571. hBass=0;
  572. bSilent=false;
  573. streams=0;
  575. hSearch=0;
  576. res=0;
  578. queue=0;
  579. Char=VKey=Zpos=0;
  580. Xpos=Ypos=0.0f;
  581. bMouseOver=false;
  582. bCaptured=false;
  584. nHGEFPS=HGEFPS_UNLIMITED;
  585. fTime=0.0f;
  586. fDeltaTime=0.0f;
  587. nFPS=0;
  589. procFrameFunc=0;
  590. procRenderFunc=0;
  591. procFocusLostFunc=0;
  592. procFocusGainFunc=0;
  593. procExitFunc=0;
  594. szIcon=0;
  595. strcpy(szWinTitle,"HGE");
  596. nScreenWidth=800;
  597. nScreenHeight=600;
  598. nScreenBPP=32;
  599. bWindowed=false;
  600. bZBuffer=false;
  601. bTextureFilter=true;
  602. szLogFile[0]=0;
  603. szIniFile[0]=0;
  604. bUseSound=true;
  605. nSampleRate=44100;
  606. nFXVolume=100;
  607. nMusVolume=100;
  608. nFixedDelta=0;
  609. bHideMouse=true;
  610. bDontSuspend=false;
  611. hwndParent=0;
  613. #ifdef DEMO
  614. nDMO=0;
  615. #endif
  618. GetModuleFileName(GetModuleHandle(NULL), szAppPath, sizeof(szAppPath));
  619. int i;
  620. for(i=strlen(szAppPath)-1; i>0; i--) if(szAppPath[i]=='\') break;
  621. szAppPath[i+1]=0;
  622. }
  624. void HGE_Impl::_PostError(char *error) {
  625. System_Log(error);
  626. strcpy(szError,error);
  627. }
  629. void HGE_Impl::_FocusChange(bool bAct) {
  630. bActive=bAct;
  631. if(bActive) {
  632. _GfxRestore();
  633. if(procFocusGainFunc) procFocusGainFunc();
  634. }
  635. else {
  636. if(procFocusLostFunc) procFocusLostFunc();
  637. }
  638. }
  640. LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
  642. switch(msg) {
  643. case WM_CREATE: 
  644. return FALSE;
  646. case WM_PAINT:
  647. if(pHGE->procRenderFunc) pHGE->procRenderFunc();
  648. break;
  650. case WM_DESTROY:
  651. PostQuitMessage(0);
  652. return FALSE;
  654. case WM_ACTIVATEAPP:
  655. if(pHGE->pD3D && pHGE->bActive != (wparam == TRUE)) pHGE->_FocusChange(wparam == TRUE);
  656. return FALSE;
  658. case WM_SETCURSOR:
  659. if(pHGE->bActive && LOWORD(lparam)==HTCLIENT && pHGE->bHideMouse) SetCursor(NULL);
  660. else SetCursor(LoadCursor(NULL, IDC_ARROW));
  661. return FALSE;
  663. case WM_SYSKEYDOWN:
  664. if(wparam==VK_F4)
  665. {
  666. if(pHGE->procExitFunc)
  667. {
  668. if(pHGE->procExitFunc())
  669. return DefWindowProc(hwnd, msg, wparam, lparam);
  670. else
  671. return FALSE;
  672. }
  673. else
  674. return DefWindowProc(hwnd, msg, wparam, lparam);
  675. }
  676. else
  677. {
  678. pHGE->_BuildEvent(INPUT_KEYDOWN, wparam, HIWORD(lparam) & 0xFF, (lparam & 0x40000000) ? HGEINP_REPEAT:0, -1, -1);
  679. return FALSE;
  680. }
  682. case WM_CHAR:
  683. case WM_KEYDOWN:
  684. pHGE->_BuildEvent(INPUT_KEYDOWN, wparam, HIWORD(lparam) & 0xFF, (lparam & 0x40000000) ? HGEINP_REPEAT:0, -1, -1);
  685. return FALSE;
  686. case WM_SYSKEYUP:
  687. pHGE->_BuildEvent(INPUT_KEYUP, wparam, HIWORD(lparam) & 0xFF, 0, -1, -1);
  688. return FALSE;
  689. case WM_KEYUP:
  690. pHGE->_BuildEvent(INPUT_KEYUP, wparam, HIWORD(lparam) & 0xFF, 0, -1, -1);
  691. return FALSE;
  693. case WM_LBUTTONDOWN:
  694. SetFocus(hwnd);
  695. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_LBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  696. return FALSE;
  697. case WM_MBUTTONDOWN:
  698. SetFocus(hwnd);
  699. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_MBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  700. return FALSE;
  701. case WM_RBUTTONDOWN:
  702. SetFocus(hwnd);
  703. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_RBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  704. return FALSE;
  706. case WM_LBUTTONDBLCLK:
  707. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_LBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
  708. return FALSE;
  709. case WM_MBUTTONDBLCLK:
  710. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_MBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
  711. return FALSE;
  712. case WM_RBUTTONDBLCLK:
  713. pHGE->_BuildEvent(INPUT_MBUTTONDOWN, HGEK_RBUTTON, 0, HGEINP_REPEAT, LOWORDINT(lparam), HIWORDINT(lparam));
  714. return FALSE;
  716. case WM_LBUTTONUP:
  717. pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_LBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  718. return FALSE;
  719. case WM_MBUTTONUP:
  720. pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_MBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  721. return FALSE;
  722. case WM_RBUTTONUP:
  723. pHGE->_BuildEvent(INPUT_MBUTTONUP, HGEK_RBUTTON, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  724. return FALSE;
  726. case WM_MOUSEMOVE:
  727. pHGE->_BuildEvent(INPUT_MOUSEMOVE, 0, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  728. return FALSE;
  729. case 0x020A: // WM_MOUSEWHEEL, GET_WHEEL_DELTA_WPARAM(wparam);
  730. pHGE->_BuildEvent(INPUT_MOUSEWHEEL, short(HIWORD(wparam))/120, 0, 0, LOWORDINT(lparam), HIWORDINT(lparam));
  731. return FALSE;
  733. case WM_SIZE:
  734. if(wparam==SIZE_RESTORED) pHGE->_Resize(LOWORD(lparam), HIWORD(lparam));
  735. //return FALSE;
  736. break;
  738. case WM_SYSCOMMAND:
  739. if(wparam==SC_CLOSE)
  740. {
  741. if(pHGE->procExitFunc)
  742. {
  743. if(pHGE->procExitFunc()) { pHGE->bActive=false; return DefWindowProc(hwnd, msg, wparam, lparam); }
  744. else return FALSE;
  745. }
  746. else { pHGE->bActive=false; return DefWindowProc(hwnd, msg, wparam, lparam); }
  747. }
  748. break;
  749. }
  751. return DefWindowProc(hwnd, msg, wparam, lparam);
  752. }