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

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

游戏引擎

开发平台：

Visual C++

graphics.cpp：源码内容
  1. /*
  2. ** Haaf's Game Engine 1.8
  3. ** Copyright (C) 2003-2007, Relish Games
  4. ** hge.relishgames.com
  5. **
  6. ** Core functions implementation: graphics
  7. */
  10. #include "hge_impl.h"
  11. #include <d3d8.h>
  12. #include <d3dx8.h>
  15. void CALL HGE_Impl::Gfx_Clear(DWORD color)
  16. {
  17. if(pCurTarget)
  18. {
  19. if(pCurTarget->pDepth)
  20. pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 1.0f, 0 );
  21. else
  22. pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, color, 1.0f, 0 );
  23. }
  24. else
  25. {
  26. if(bZBuffer)
  27. pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 1.0f, 0 );
  28. else
  29. pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, color, 1.0f, 0 );
  30. }
  31. }
  33. void CALL HGE_Impl::Gfx_SetClipping(int x, int y, int w, int h)
  34. {
  35. D3DVIEWPORT8 vp;
  36. int scr_width, scr_height;
  38. if(!pCurTarget) {
  39. scr_width=pHGE->System_GetStateInt(HGE_SCREENWIDTH);
  40. scr_height=pHGE->System_GetStateInt(HGE_SCREENHEIGHT);
  41. }
  42. else {
  43. scr_width=Texture_GetWidth((HTEXTURE)pCurTarget->pTex);
  44. scr_height=Texture_GetHeight((HTEXTURE)pCurTarget->pTex);
  45. }
  47. if(!w) {
  48. vp.X=0;
  49. vp.Y=0;
  50. vp.Width=scr_width;
  51. vp.Height=scr_height;
  52. }
  53. else
  54. {
  55. if(x<0) { w+=x; x=0; }
  56. if(y<0) { h+=y; y=0; }
  58. if(x+w > scr_width) w=scr_width-x;
  59. if(y+h > scr_height) h=scr_height-y;
  61. vp.X=x;
  62. vp.Y=y;
  63. vp.Width=w;
  64. vp.Height=h;
  65. }
  67. vp.MinZ=0.0f;
  68. vp.MaxZ=1.0f;
  70. _render_batch();
  71. pD3DDevice->SetViewport(&vp);
  73. D3DXMATRIX tmp;
  74. D3DXMatrixScaling(&matProj, 1.0f, -1.0f, 1.0f);
  75. D3DXMatrixTranslation(&tmp, -0.5f, +0.5f, 0.0f);
  76. D3DXMatrixMultiply(&matProj, &matProj, &tmp);
  77. D3DXMatrixOrthoOffCenterLH(&tmp, (float)vp.X, (float)(vp.X+vp.Width), -((float)(vp.Y+vp.Height)), -((float)vp.Y), vp.MinZ, vp.MaxZ);
  78. D3DXMatrixMultiply(&matProj, &matProj, &tmp);
  79. pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
  80. }
  82. void CALL HGE_Impl::Gfx_SetTransform(float x, float y, float dx, float dy, float rot, float hscale, float vscale)
  83. {
  84. D3DXMATRIX tmp;
  86. if(vscale==0.0f) D3DXMatrixIdentity(&matView);
  87. else
  88. {
  89. D3DXMatrixTranslation(&matView, -x, -y, 0.0f);
  90. D3DXMatrixScaling(&tmp, hscale, vscale, 1.0f);
  91. D3DXMatrixMultiply(&matView, &matView, &tmp);
  92. D3DXMatrixRotationZ(&tmp, -rot);
  93. D3DXMatrixMultiply(&matView, &matView, &tmp);
  94. D3DXMatrixTranslation(&tmp, x+dx, y+dy, 0.0f);
  95. D3DXMatrixMultiply(&matView, &matView, &tmp);
  96. }
  98. _render_batch();
  99. pD3DDevice->SetTransform(D3DTS_VIEW, &matView);
  100. }
  102. bool CALL HGE_Impl::Gfx_BeginScene(HTARGET targ)
  103. {
  104. LPDIRECT3DSURFACE8 pSurf=0, pDepth=0;
  105. D3DDISPLAYMODE Mode;
  106. CRenderTargetList *target=(CRenderTargetList *)targ;
  108. HRESULT hr = pD3DDevice->TestCooperativeLevel();
  109. if (hr == D3DERR_DEVICELOST) return false;
  110. else if (hr == D3DERR_DEVICENOTRESET)
  111. {
  112. if(bWindowed)
  113. {
  114. if(FAILED(pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &Mode)) || Mode.Format==D3DFMT_UNKNOWN) 
  115. {
  116. _PostError("Can't determine desktop video mode");
  117. return false;
  118. }
  120. d3dppW.BackBufferFormat = Mode.Format;
  121. if(_format_id(Mode.Format) < 4) nScreenBPP=16;
  122. else nScreenBPP=32;
  123. }
  125.     if(!_GfxRestore()) return false; 
  126. }
  127.     
  128. if(VertArray)
  129. {
  130. _PostError("Gfx_BeginScene: Scene is already being rendered");
  131. return false;
  132. }
  134. if(target != pCurTarget)
  135. {
  136. if(target)
  137. {
  138. target->pTex->GetSurfaceLevel(0, &pSurf);
  139. pDepth=target->pDepth;
  140. }
  141. else
  142. {
  143. pSurf=pScreenSurf;
  144. pDepth=pScreenDepth;
  145. }
  146. if(FAILED(pD3DDevice->SetRenderTarget(pSurf, pDepth)))
  147. {
  148. if(target) pSurf->Release();
  149. _PostError("Gfx_BeginScene: Can't set render target");
  150. return false;
  151. }
  152. if(target)
  153. {
  154. pSurf->Release();
  155. if(target->pDepth) pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE ); 
  156. else pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE ); 
  157. _SetProjectionMatrix(target->width, target->height);
  158. }
  159. else
  160. {
  161. if(bZBuffer) pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE ); 
  162. else pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
  163. _SetProjectionMatrix(nScreenWidth, nScreenHeight);
  164. }
  166. pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
  167. D3DXMatrixIdentity(&matView);
  168. pD3DDevice->SetTransform(D3DTS_VIEW, &matView);
  170. pCurTarget=target;
  171. }
  173. pD3DDevice->BeginScene();
  174. pVB->Lock( 0, 0, (BYTE**)&VertArray, 0 );
  176. return true;
  177. }
  179. void CALL HGE_Impl::Gfx_EndScene()
  180. {
  181. _render_batch(true);
  182. pD3DDevice->EndScene();
  183. if(!pCurTarget) pD3DDevice->Present( NULL, NULL, NULL, NULL );
  184. }
  186. void CALL HGE_Impl::Gfx_RenderLine(float x1, float y1, float x2, float y2, DWORD color, float z)
  187. {
  188. if(VertArray)
  189. {
  190. if(CurPrimType!=HGEPRIM_LINES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_LINES || CurTexture || CurBlendMode!=BLEND_DEFAULT)
  191. {
  192. _render_batch();
  194. CurPrimType=HGEPRIM_LINES;
  195. if(CurBlendMode != BLEND_DEFAULT) _SetBlendMode(BLEND_DEFAULT);
  196. if(CurTexture) { pD3DDevice->SetTexture(0, 0); CurTexture=0; }
  197. }
  199. int i=nPrim*HGEPRIM_LINES;
  200. VertArray[i].x = x1; VertArray[i+1].x = x2;
  201. VertArray[i].y = y1; VertArray[i+1].y = y2;
  202. VertArray[i].z     = VertArray[i+1].z = z;
  203. VertArray[i].col   = VertArray[i+1].col = color;
  204. VertArray[i].tx    = VertArray[i+1].tx =
  205. VertArray[i].ty    = VertArray[i+1].ty = 0.0f;
  207. nPrim++;
  208. }
  209. }
  211. void CALL HGE_Impl::Gfx_RenderTriple(const hgeTriple *triple)
  212. {
  213. if(VertArray)
  214. {
  215. if(CurPrimType!=HGEPRIM_TRIPLES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_TRIPLES || CurTexture!=triple->tex || CurBlendMode!=triple->blend)
  216. {
  217. _render_batch();
  219. CurPrimType=HGEPRIM_TRIPLES;
  220. if(CurBlendMode != triple->blend) _SetBlendMode(triple->blend);
  221. if(triple->tex != CurTexture) {
  222. pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)triple->tex );
  223. CurTexture = triple->tex;
  224. }
  225. }
  227. memcpy(&VertArray[nPrim*HGEPRIM_TRIPLES], triple->v, sizeof(hgeVertex)*HGEPRIM_TRIPLES);
  228. nPrim++;
  229. }
  230. }
  232. void CALL HGE_Impl::Gfx_RenderQuad(const hgeQuad *quad)
  233. {
  234. if(VertArray)
  235. {
  236. if(CurPrimType!=HGEPRIM_QUADS || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_QUADS || CurTexture!=quad->tex || CurBlendMode!=quad->blend)
  237. {
  238. _render_batch();
  240. CurPrimType=HGEPRIM_QUADS;
  241. if(CurBlendMode != quad->blend) _SetBlendMode(quad->blend);
  242. if(quad->tex != CurTexture)
  243. {
  244. pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)quad->tex );
  245. CurTexture = quad->tex;
  246. }
  247. }
  249. memcpy(&VertArray[nPrim*HGEPRIM_QUADS], quad->v, sizeof(hgeVertex)*HGEPRIM_QUADS);
  250. nPrim++;
  251. }
  252. }
  254. hgeVertex* CALL HGE_Impl::Gfx_StartBatch(int prim_type, HTEXTURE tex, int blend, int *max_prim)
  255. {
  256. if(VertArray)
  257. {
  258. _render_batch();
  260. CurPrimType=prim_type;
  261. if(CurBlendMode != blend) _SetBlendMode(blend);
  262. if(tex != CurTexture)
  263. {
  264. pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)tex );
  265. CurTexture = tex;
  266. }
  268. *max_prim=VERTEX_BUFFER_SIZE / prim_type;
  269. return VertArray;
  270. }
  271. else return 0;
  272. }
  274. void CALL HGE_Impl::Gfx_FinishBatch(int nprim)
  275. {
  276. nPrim=nprim;
  277. }
  279. HTARGET CALL HGE_Impl::Target_Create(int width, int height, bool zbuffer)
  280. {
  281. CRenderTargetList *pTarget;
  282. D3DSURFACE_DESC TDesc;
  284. pTarget = new CRenderTargetList;
  285. pTarget->pTex=0;
  286. pTarget->pDepth=0;
  288. if(FAILED(D3DXCreateTexture(pD3DDevice, width, height, 1, D3DUSAGE_RENDERTARGET,
  289. d3dpp->BackBufferFormat, D3DPOOL_DEFAULT, &pTarget->pTex)))
  290. {
  291. _PostError("Can't create render target texture");
  292. delete pTarget;
  293. return 0;
  294. }
  296. pTarget->pTex->GetLevelDesc(0, &TDesc);
  297. pTarget->width=TDesc.Width;
  298. pTarget->height=TDesc.Height;
  300. if(zbuffer)
  301. {
  302. if(FAILED(pD3DDevice->CreateDepthStencilSurface(pTarget->width, pTarget->height,
  303. D3DFMT_D16, D3DMULTISAMPLE_NONE, &pTarget->pDepth)))
  304. {   
  305. pTarget->pTex->Release();
  306. _PostError("Can't create render target depth buffer");
  307. delete pTarget;
  308. return 0;
  309. }
  310. }
  312. pTarget->next=pTargets;
  313. pTargets=pTarget;
  315. return (HTARGET)pTarget;
  316. }
  318. void CALL HGE_Impl::Target_Free(HTARGET target)
  319. {
  320. CRenderTargetList *pTarget=pTargets, *pPrevTarget=NULL;
  322. while(pTarget)
  323. {
  324. if((CRenderTargetList *)target == pTarget)
  325. {
  326. if(pPrevTarget)
  327. pPrevTarget->next = pTarget->next;
  328. else
  329. pTargets = pTarget->next;
  331. if(pTarget->pTex) pTarget->pTex->Release();
  332. if(pTarget->pDepth) pTarget->pDepth->Release();
  334. delete pTarget;
  335. return;
  336. }
  338. pPrevTarget = pTarget;
  339. pTarget = pTarget->next;
  340. }
  341. }
  343. HTEXTURE CALL HGE_Impl::Target_GetTexture(HTARGET target)
  344. {
  345. CRenderTargetList *targ=(CRenderTargetList *)target;
  346. if(target) return (HTEXTURE)targ->pTex;
  347. else return 0;
  348. }
  350. HTEXTURE CALL HGE_Impl::Texture_Create(int width, int height)
  351. {
  352. LPDIRECT3DTEXTURE8 pTex;
  354. if( FAILED( D3DXCreateTexture( pD3DDevice, width, height,
  355. 1, // Mip levels
  356. 0, // Usage
  357. D3DFMT_A8R8G8B8, // Format
  358. D3DPOOL_MANAGED, // Memory pool
  359. &pTex ) ) )
  360. {
  361. _PostError("Can't create texture");
  362. return NULL;
  363. }
  365. return (HTEXTURE)pTex;
  366. }
  368. HTEXTURE CALL HGE_Impl::Texture_Load(const char *filename, DWORD size, bool bMipmap)
  369. {
  370. void *data;
  371. DWORD _size;
  372. D3DFORMAT fmt1, fmt2;
  373. LPDIRECT3DTEXTURE8 pTex;
  374. D3DXIMAGE_INFO info;
  375. CTextureList *texItem;
  377. if(size) { data=(void *)filename; _size=size; }
  378. else
  379. {
  380. data=pHGE->Resource_Load(filename, &_size);
  381. if(!data) return NULL;
  382. }
  384. if(*(DWORD*)data == 0x20534444) // Compressed DDS format magic number
  385. {
  386. fmt1=D3DFMT_UNKNOWN;
  387. fmt2=D3DFMT_A8R8G8B8;
  388. }
  389. else
  390. {
  391. fmt1=D3DFMT_A8R8G8B8;
  392. fmt2=D3DFMT_UNKNOWN;
  393. }
  395. // if( FAILED( D3DXCreateTextureFromFileInMemory( pD3DDevice, data, _size, &pTex ) ) ) pTex=NULL;
  396. if( FAILED( D3DXCreateTextureFromFileInMemoryEx( pD3DDevice, data, _size,
  397. D3DX_DEFAULT, D3DX_DEFAULT,
  398. bMipmap ? 0:1, // Mip levels
  399. 0, // Usage
  400. fmt1, // Format
  401. D3DPOOL_MANAGED, // Memory pool
  402. D3DX_FILTER_NONE, // Filter
  403. D3DX_DEFAULT, // Mip filter
  404. 0, // Color key
  405. &info, NULL,
  406. &pTex ) ) )
  408. if( FAILED( D3DXCreateTextureFromFileInMemoryEx( pD3DDevice, data, _size,
  409. D3DX_DEFAULT, D3DX_DEFAULT,
  410. bMipmap ? 0:1, // Mip levels
  411. 0, // Usage
  412. fmt2, // Format
  413. D3DPOOL_MANAGED, // Memory pool
  414. D3DX_FILTER_NONE, // Filter
  415. D3DX_DEFAULT, // Mip filter
  416. 0, // Color key
  417. &info, NULL,
  418. &pTex ) ) )
  420. {
  421. _PostError("Can't create texture");
  422. if(!size) Resource_Free(data);
  423. return NULL;
  424. }
  426. if(!size) Resource_Free(data);
  428. texItem=new CTextureList;
  429. texItem->tex=(HTEXTURE)pTex;
  430. texItem->width=info.Width;
  431. texItem->height=info.Height;
  432. texItem->next=textures;
  433. textures=texItem;
  435. return (HTEXTURE)pTex;
  436. }
  438. void CALL HGE_Impl::Texture_Free(HTEXTURE tex)
  439. {
  440. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  441. CTextureList *texItem=textures, *texPrev=0;
  443. while(texItem)
  444. {
  445. if(texItem->tex==tex)
  446. {
  447. if(texPrev) texPrev->next=texItem->next;
  448. else textures=texItem->next;
  449. delete texItem;
  450. break;
  451. }
  452. texPrev=texItem;
  453. texItem=texItem->next;
  454. }
  455. if(pTex != NULL) pTex->Release();
  456. }
  458. int CALL HGE_Impl::Texture_GetWidth(HTEXTURE tex, bool bOriginal)
  459. {
  460. D3DSURFACE_DESC TDesc;
  461. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  462. CTextureList *texItem=textures;
  464. if(bOriginal)
  465. {
  466. while(texItem)
  467. {
  468. if(texItem->tex==tex) return texItem->width;
  469. texItem=texItem->next;
  470. }
  471. return 0;
  472. }
  473. else
  474. {
  475. if(FAILED(pTex->GetLevelDesc(0, &TDesc))) return 0;
  476. else return TDesc.Width;
  477. }
  478. }
  481. int CALL HGE_Impl::Texture_GetHeight(HTEXTURE tex, bool bOriginal)
  482. {
  483. D3DSURFACE_DESC TDesc;
  484. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  485. CTextureList *texItem=textures;
  487. if(bOriginal)
  488. {
  489. while(texItem)
  490. {
  491. if(texItem->tex==tex) return texItem->height;
  492. texItem=texItem->next;
  493. }
  494. return 0;
  495. }
  496. else
  497. {
  498. if(FAILED(pTex->GetLevelDesc(0, &TDesc))) return 0;
  499. else return TDesc.Height;
  500. }
  501. }
  504. DWORD * CALL HGE_Impl::Texture_Lock(HTEXTURE tex, bool bReadOnly, int left, int top, int width, int height)
  505. {
  506. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  507. D3DSURFACE_DESC TDesc;
  508. D3DLOCKED_RECT TRect;
  509. RECT region, *prec;
  510. int flags;
  512. pTex->GetLevelDesc(0, &TDesc);
  513. if(TDesc.Format!=D3DFMT_A8R8G8B8 && TDesc.Format!=D3DFMT_X8R8G8B8) return 0;
  515. if(width && height)
  516. {
  517. region.left=left;
  518. region.top=top;
  519. region.right=left+width;
  520. region.bottom=top+height;
  521. prec=&region;
  522. }
  523. else prec=0;
  525. if(bReadOnly) flags=D3DLOCK_READONLY;
  526. else flags=0;
  528. if(FAILED(pTex->LockRect(0, &TRect, prec, flags)))
  529. {
  530. _PostError("Can't lock texture");
  531. return 0;
  532. }
  534. return (DWORD *)TRect.pBits;
  535. }
  538. void CALL HGE_Impl::Texture_Unlock(HTEXTURE tex)
  539. {
  540. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  541. pTex->UnlockRect(0);
  542. }
  544. //////// Implementation ////////
  546. void HGE_Impl::_render_batch(bool bEndScene)
  547. {
  548. if(VertArray)
  549. {
  550. pVB->Unlock();
  552. if(nPrim)
  553. {
  554. switch(CurPrimType)
  555. {
  556. case HGEPRIM_QUADS:
  557. pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, nPrim<<2, 0, nPrim<<1);
  558. break;
  560. case HGEPRIM_TRIPLES:
  561. pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, nPrim);
  562. break;
  564. case HGEPRIM_LINES:
  565. pD3DDevice->DrawPrimitive(D3DPT_LINELIST, 0, nPrim);
  566. break;
  567. }
  569. nPrim=0;
  570. }
  572. if(bEndScene) VertArray = 0;
  573. else pVB->Lock( 0, 0, (BYTE**)&VertArray, 0 );
  574. }
  575. }
  577. void HGE_Impl::_SetBlendMode(int blend)
  578. {
  579. if((blend & BLEND_ALPHABLEND) != (CurBlendMode & BLEND_ALPHABLEND))
  580. {
  581. if(blend & BLEND_ALPHABLEND) pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
  582. else pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
  583. }
  585.     if((blend & BLEND_ZWRITE) != (CurBlendMode & BLEND_ZWRITE))
  586. {
  587. if(blend & BLEND_ZWRITE) pD3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
  588. else pD3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
  589. }
  591. if((blend & BLEND_COLORADD) != (CurBlendMode & BLEND_COLORADD))
  592. {
  593. if(blend & BLEND_COLORADD) pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_ADD);
  594. else pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
  595. }
  597. CurBlendMode = blend;
  598. }
  600. void HGE_Impl::_SetProjectionMatrix(int width, int height)
  601. {
  602. D3DXMATRIX tmp;
  603. D3DXMatrixScaling(&matProj, 1.0f, -1.0f, 1.0f);
  604. D3DXMatrixTranslation(&tmp, -0.5f, height+0.5f, 0.0f);
  605. D3DXMatrixMultiply(&matProj, &matProj, &tmp);
  606. D3DXMatrixOrthoOffCenterLH(&tmp, 0, (float)width, 0, (float)height, 0.0f, 1.0f);
  607. D3DXMatrixMultiply(&matProj, &matProj, &tmp);
  608. }
  610. bool HGE_Impl::_GfxInit()
  611. {
  612. static const char *szFormats[]={"UNKNOWN", "R5G6B5", "X1R5G5B5", "A1R5G5B5", "X8R8G8B8", "A8R8G8B8"};
  613. D3DADAPTER_IDENTIFIER8 AdID;
  614. D3DDISPLAYMODE Mode;
  615. D3DFORMAT Format=D3DFMT_UNKNOWN;
  616. UINT nModes, i;
  618. // Init D3D
  620. pD3D=Direct3DCreate8(120); // D3D_SDK_VERSION
  621. if(pD3D==NULL)
  622. {
  623. _PostError("Can't create D3D interface");
  624. return false;
  625. }
  627. // Get adapter info
  629. pD3D->GetAdapterIdentifier(D3DADAPTER_DEFAULT, D3DENUM_NO_WHQL_LEVEL, &AdID);
  630. System_Log("D3D Driver: %s",AdID.Driver);
  631. System_Log("Description: %s",AdID.Description);
  632. System_Log("Version: %d.%d.%d.%d",
  633. HIWORD(AdID.DriverVersion.HighPart),
  634. LOWORD(AdID.DriverVersion.HighPart),
  635. HIWORD(AdID.DriverVersion.LowPart),
  636. LOWORD(AdID.DriverVersion.LowPart));
  638. // Set up Windowed presentation parameters
  640. if(FAILED(pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &Mode)) || Mode.Format==D3DFMT_UNKNOWN) 
  641. {
  642. _PostError("Can't determine desktop video mode");
  643. if(bWindowed) return false;
  644. }
  646. ZeroMemory(&d3dppW, sizeof(d3dppW));
  648. d3dppW.BackBufferWidth  = nScreenWidth;
  649. d3dppW.BackBufferHeight = nScreenHeight;
  650. d3dppW.BackBufferFormat = Mode.Format;
  651. d3dppW.BackBufferCount  = 1;
  652. d3dppW.MultiSampleType  = D3DMULTISAMPLE_NONE;
  653. d3dppW.hDeviceWindow    = hwnd;
  654. d3dppW.Windowed         = TRUE;
  656. if(nHGEFPS==HGEFPS_VSYNC) d3dppW.SwapEffect = D3DSWAPEFFECT_COPY_VSYNC;
  657. else   d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
  659. if(bZBuffer)
  660. {
  661. d3dppW.EnableAutoDepthStencil = TRUE;
  662. d3dppW.AutoDepthStencilFormat = D3DFMT_D16;
  663. }
  665. // Set up Full Screen presentation parameters
  667. nModes=pD3D->GetAdapterModeCount(D3DADAPTER_DEFAULT);
  669. for(i=0; i<nModes; i++)
  670. {
  671. pD3D->EnumAdapterModes(D3DADAPTER_DEFAULT, i, &Mode);
  672. if(Mode.Width != (UINT)nScreenWidth || Mode.Height != (UINT)nScreenHeight) continue;
  673. if(nScreenBPP==16 && (_format_id(Mode.Format) > _format_id(D3DFMT_A1R5G5B5))) continue;
  674. if(_format_id(Mode.Format) > _format_id(Format)) Format=Mode.Format;
  675. }
  677. if(Format == D3DFMT_UNKNOWN)
  678. {
  679. _PostError("Can't find appropriate full screen video mode");
  680. if(!bWindowed) return false;
  681. }
  683. ZeroMemory(&d3dppFS, sizeof(d3dppFS));
  685. d3dppFS.BackBufferWidth  = nScreenWidth;
  686. d3dppFS.BackBufferHeight = nScreenHeight;
  687. d3dppFS.BackBufferFormat = Format;
  688. d3dppFS.BackBufferCount  = 1;
  689. d3dppFS.MultiSampleType  = D3DMULTISAMPLE_NONE;
  690. d3dppFS.hDeviceWindow    = hwnd;
  691. d3dppFS.Windowed         = FALSE;
  693. d3dppFS.SwapEffect       = D3DSWAPEFFECT_FLIP;
  694. d3dppFS.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
  696. if(nHGEFPS==HGEFPS_VSYNC) d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
  697. else   d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
  699. if(bZBuffer)
  700. {
  701. d3dppFS.EnableAutoDepthStencil = TRUE;
  702. d3dppFS.AutoDepthStencilFormat = D3DFMT_D16;
  703. }
  705. d3dpp = bWindowed ? &d3dppW : &d3dppFS;
  707. if(_format_id(d3dpp->BackBufferFormat) < 4) nScreenBPP=16;
  708. else nScreenBPP=32;
  710. // Create D3D Device
  712. if( FAILED( pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
  713.                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING,
  714.                                   d3dpp, &pD3DDevice ) ) )
  715. {
  716. _PostError("Can't create D3D device");
  717. return false;
  718. }
  720. _AdjustWindow();
  722. System_Log("Mode: %d x %d x %sn",nScreenWidth,nScreenHeight,szFormats[_format_id(Format)]);
  724. // Create vertex batch buffer
  726. VertArray=0;
  727. textures=0;
  729. // Init all stuff that can be lost
  731. _SetProjectionMatrix(nScreenWidth, nScreenHeight);
  732. D3DXMatrixIdentity(&matView);
  734. if(!_init_lost()) return false;
  736. Gfx_Clear(0);
  738. return true;
  739. }
  741. int HGE_Impl::_format_id(D3DFORMAT fmt)
  742. {
  743. switch(fmt) {
  744. case D3DFMT_R5G6B5: return 1;
  745. case D3DFMT_X1R5G5B5: return 2;
  746. case D3DFMT_A1R5G5B5: return 3;
  747. case D3DFMT_X8R8G8B8: return 4;
  748. case D3DFMT_A8R8G8B8: return 5;
  749. default: return 0;
  750. }
  751. }
  753. void HGE_Impl::_AdjustWindow()
  754. {
  755. RECT *rc;
  756. LONG style;
  758. if(bWindowed) {rc=&rectW; style=styleW; }
  759. else  {rc=&rectFS; style=styleFS; }
  760. SetWindowLong(hwnd, GWL_STYLE, style);
  762. style=GetWindowLong(hwnd, GWL_EXSTYLE);
  763. if(bWindowed)
  764. {
  765. SetWindowLong(hwnd, GWL_EXSTYLE, style & (~WS_EX_TOPMOST));
  766.     SetWindowPos(hwnd, HWND_NOTOPMOST, rc->left, rc->top, rc->right-rc->left, rc->bottom-rc->top, SWP_FRAMECHANGED);
  767. }
  768. else
  769. {
  770. SetWindowLong(hwnd, GWL_EXSTYLE, style | WS_EX_TOPMOST);
  771.     SetWindowPos(hwnd, HWND_TOPMOST, rc->left, rc->top, rc->right-rc->left, rc->bottom-rc->top, SWP_FRAMECHANGED);
  772. }
  773. }
  775. void HGE_Impl::_Resize(int width, int height)
  776. {
  777. if(hwndParent)
  778. {
  779. //if(procFocusLostFunc) procFocusLostFunc();
  781. d3dppW.BackBufferWidth=width;
  782. d3dppW.BackBufferHeight=height;
  783. nScreenWidth=width;
  784. nScreenHeight=height;
  786. _SetProjectionMatrix(nScreenWidth, nScreenHeight);
  787. _GfxRestore();
  789. //if(procFocusGainFunc) procFocusGainFunc();
  790. }
  791. }
  793. void HGE_Impl::_GfxDone()
  794. {
  795. CRenderTargetList *target=pTargets, *next_target;
  797. while(textures) Texture_Free(textures->tex);
  799. if(pScreenSurf) { pScreenSurf->Release(); pScreenSurf=0; }
  800. if(pScreenDepth) { pScreenDepth->Release(); pScreenDepth=0; }
  802. while(target)
  803. {
  804. if(target->pTex) target->pTex->Release();
  805. if(target->pDepth) target->pDepth->Release();
  806. next_target=target->next;
  807. delete target;
  808. target=next_target;
  809. }
  810. pTargets=0;
  812. if(pIB)
  813. {
  814. pD3DDevice->SetIndices(NULL,0);
  815. pIB->Release();
  816. pIB=0;
  817. }
  818. if(pVB)
  819. {
  820. if(VertArray) { pVB->Unlock(); VertArray=0; }
  821. pD3DDevice->SetStreamSource( 0, NULL, sizeof(hgeVertex) );
  822. pVB->Release();
  823. pVB=0;
  824. }
  825. if(pD3DDevice) { pD3DDevice->Release(); pD3DDevice=0; }
  826. if(pD3D) { pD3D->Release(); pD3D=0; }
  827. }
  830. bool HGE_Impl::_GfxRestore()
  831. {
  832. CRenderTargetList *target=pTargets;
  834. //if(!pD3DDevice) return false;
  835. //if(pD3DDevice->TestCooperativeLevel() == D3DERR_DEVICELOST) return;
  837. if(pScreenSurf) pScreenSurf->Release();
  838. if(pScreenDepth) pScreenDepth->Release();
  840. while(target)
  841. {
  842. if(target->pTex) target->pTex->Release();
  843. if(target->pDepth) target->pDepth->Release();
  844. target=target->next;
  845. }
  847. if(pIB)
  848. {
  849. pD3DDevice->SetIndices(NULL,0);
  850. pIB->Release();
  851. }
  852. if(pVB)
  853. {
  854. pD3DDevice->SetStreamSource( 0, NULL, sizeof(hgeVertex) );
  855. pVB->Release();
  856. }
  858. pD3DDevice->Reset(d3dpp);
  860. if(!_init_lost()) return false;
  862. if(procGfxRestoreFunc) return procGfxRestoreFunc();
  864. return true;
  865. }
  868. bool HGE_Impl::_init_lost()
  869. {
  870. CRenderTargetList *target=pTargets;
  872. // Store render target
  874. pScreenSurf=0;
  875. pScreenDepth=0;
  877. pD3DDevice->GetRenderTarget(&pScreenSurf);
  878. pD3DDevice->GetDepthStencilSurface(&pScreenDepth);
  880. while(target)
  881. {
  882. if(target->pTex)
  883. D3DXCreateTexture(pD3DDevice, target->width, target->height, 1, D3DUSAGE_RENDERTARGET,
  884.   d3dpp->BackBufferFormat, D3DPOOL_DEFAULT, &target->pTex);
  885. if(target->pDepth)
  886. pD3DDevice->CreateDepthStencilSurface(target->width, target->height,
  887.   D3DFMT_D16, D3DMULTISAMPLE_NONE, &target->pDepth);
  888. target=target->next;
  889. }
  891. // Create Vertex buffer
  893. if( FAILED (pD3DDevice->CreateVertexBuffer(VERTEX_BUFFER_SIZE*sizeof(hgeVertex),
  894.                                               D3DUSAGE_WRITEONLY,
  895.   D3DFVF_HGEVERTEX,
  896.                                               D3DPOOL_DEFAULT, &pVB )))
  897. {
  898. _PostError("Can't create D3D vertex buffer");
  899. return false;
  900. }
  902. pD3DDevice->SetVertexShader( D3DFVF_HGEVERTEX );
  903. pD3DDevice->SetStreamSource( 0, pVB, sizeof(hgeVertex) );
  905. // Create and setup Index buffer
  907. if( FAILED( pD3DDevice->CreateIndexBuffer(VERTEX_BUFFER_SIZE*6/4*sizeof(WORD),
  908.                                               D3DUSAGE_WRITEONLY,
  909.   D3DFMT_INDEX16,
  910.                                               D3DPOOL_DEFAULT, &pIB ) ) )
  911. {
  912. _PostError("Can't create D3D index buffer");
  913. return false;
  914. }
  916. WORD *pIndices, n=0;
  917. if( FAILED( pIB->Lock( 0, 0, (BYTE**)&pIndices, 0 ) ) )
  918. {
  919. _PostError("Can't lock D3D index buffer");
  920. return false;
  921. }
  923. for(int i=0; i<VERTEX_BUFFER_SIZE/4; i++) {
  924. *pIndices++=n;
  925. *pIndices++=n+1;
  926. *pIndices++=n+2;
  927. *pIndices++=n+2;
  928. *pIndices++=n+3;
  929. *pIndices++=n;
  930. n+=4;
  931. }
  933. pIB->Unlock();
  934. pD3DDevice->SetIndices(pIB,0);
  936. // Set common render states
  938. //pD3DDevice->SetRenderState( D3DRS_LASTPIXEL, FALSE );
  939. pD3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
  940. pD3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
  942. pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE,   TRUE );
  943. pD3DDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
  944. pD3DDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
  946. pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
  947. pD3DDevice->SetRenderState( D3DRS_ALPHAREF,        0x01 );
  948. pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
  950. pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
  951. pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
  952. pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
  954. pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
  955. pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
  956. pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
  958. pD3DDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_POINT);
  960. if(bTextureFilter)
  961. {
  962. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
  963. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
  964. }
  965. else
  966. {
  967. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_POINT);
  968. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_POINT);
  969. }
  971. nPrim=0;
  972. CurPrimType=HGEPRIM_QUADS;
  973. CurBlendMode = BLEND_DEFAULT;
  974. CurTexture = NULL;
  976. pD3DDevice->SetTransform(D3DTS_VIEW, &matView);
  977. pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
  979. return true;
  980. }