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

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

游戏引擎

开发平台：

Visual C++

graphics.cpp：源码内容
  1. /*
  2. ** Haaf's Game Engine 1.5
  3. ** Copyright (C) 2003-2004, 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. CRenderTargetList *target=(CRenderTargetList *)targ;
  107. if(VertArray)
  108. {
  109. _PostError("Gfx_BeginScene: Scene is already being rendered");
  110. return false;
  111. }
  112.      
  113. if(target != pCurTarget)
  114. {
  115. if(target)
  116. {
  117. target->pTex->GetSurfaceLevel(0, &pSurf);
  118. pDepth=target->pDepth;
  119. }
  120. else
  121. {
  122. pSurf=pScreenSurf;
  123. pDepth=pScreenDepth;
  124. }
  125. if(FAILED(pD3DDevice->SetRenderTarget(pSurf, pDepth)))
  126. {
  127. if(target) pSurf->Release();
  128. _PostError("Gfx_BeginScene: Can't set render target");
  129. return false;
  130. }
  131. if(target)
  132. {
  133. pSurf->Release();
  134. if(target->pDepth) pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE ); 
  135. else pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE ); 
  136. _SetProjectionMatrix(target->width, target->height);
  137. }
  138. else
  139. {
  140. if(bZBuffer) pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE ); 
  141. else pD3DDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
  142. _SetProjectionMatrix(nScreenWidth, nScreenHeight);
  143. }
  145. pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
  146. D3DXMatrixIdentity(&matView);
  147. pD3DDevice->SetTransform(D3DTS_VIEW, &matView);
  149. pCurTarget=target;
  150. }
  151. pD3DDevice->BeginScene();
  152. pVB->Lock( 0, 0, (BYTE**)&VertArray, 0 );
  154. return true;
  155. }
  157. void CALL HGE_Impl::Gfx_EndScene()
  158. {
  159. if(!VertArray) return;
  160. _render_batch(true);
  161. pD3DDevice->EndScene();
  162. if(!pCurTarget) pD3DDevice->Present( NULL, NULL, NULL, NULL );
  163. VertArray=0;
  164. }
  166. void CALL HGE_Impl::Gfx_RenderLine(float x1, float y1, float x2, float y2, DWORD color, float z)
  167. {
  168. if(CurPrimType!=HGEPRIM_LINES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_LINES || CurTexture || CurBlendMode!=BLEND_DEFAULT)
  169. {
  170. _render_batch();
  172. CurPrimType=HGEPRIM_LINES;
  173. if(CurBlendMode != BLEND_DEFAULT) _SetBlendMode(BLEND_DEFAULT);
  174. if(CurTexture) { pD3DDevice->SetTexture(0, 0); CurTexture=0; }
  175. }
  177. int i=nPrim*HGEPRIM_LINES;
  178. VertArray[i].x = x1; VertArray[i+1].x = x2;
  179. VertArray[i].y = y1; VertArray[i+1].y = y2;
  180. VertArray[i].z     = VertArray[i+1].z = z;
  181. VertArray[i].col   = VertArray[i+1].col = color;
  182. VertArray[i].tx    = VertArray[i+1].tx =
  183. VertArray[i].ty    = VertArray[i+1].ty = 0.0f;
  185. nPrim++;
  186. }
  188. void CALL HGE_Impl::Gfx_RenderTriple(const hgeTriple *triple)
  189. {
  190. if(CurPrimType!=HGEPRIM_TRIPLES || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_TRIPLES || CurTexture!=triple->tex || CurBlendMode!=triple->blend)
  191. {
  192. _render_batch();
  194. CurPrimType=HGEPRIM_TRIPLES;
  195. if(CurBlendMode != triple->blend) _SetBlendMode(triple->blend);
  196. if(triple->tex != CurTexture) {
  197. pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)triple->tex );
  198. CurTexture = triple->tex;
  199. }
  200. }
  202. memcpy(&VertArray[nPrim*HGEPRIM_TRIPLES], triple->v, sizeof(hgeVertex)*HGEPRIM_TRIPLES);
  203. nPrim++;
  204. }
  206. void CALL HGE_Impl::Gfx_RenderQuad(const hgeQuad *quad)
  207. {
  208. if(CurPrimType!=HGEPRIM_QUADS || nPrim>=VERTEX_BUFFER_SIZE/HGEPRIM_QUADS || CurTexture!=quad->tex || CurBlendMode!=quad->blend)
  209. {
  210. _render_batch();
  212. CurPrimType=HGEPRIM_QUADS;
  213. if(CurBlendMode != quad->blend) _SetBlendMode(quad->blend);
  214. if(quad->tex != CurTexture) {
  215. pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)quad->tex );
  216. CurTexture = quad->tex;
  217. }
  218. }
  220. memcpy(&VertArray[nPrim*HGEPRIM_QUADS], quad->v, sizeof(hgeVertex)*HGEPRIM_QUADS);
  221. nPrim++;
  222. }
  224. hgeVertex* CALL HGE_Impl::Gfx_StartBatch(int prim_type, HTEXTURE tex, int blend, int *max_prim)
  225. {
  226. _render_batch();
  228. CurPrimType=prim_type;
  229. if(CurBlendMode != blend) _SetBlendMode(blend);
  230. if(tex != CurTexture)
  231. {
  232. pD3DDevice->SetTexture( 0, (LPDIRECT3DTEXTURE8)tex );
  233. CurTexture = tex;
  234. }
  236. *max_prim=VERTEX_BUFFER_SIZE / prim_type;
  237. return VertArray;
  238. }
  240. void CALL HGE_Impl::Gfx_FinishBatch(int nprim)
  241. {
  242. nPrim=nprim;
  243. }
  245. HTARGET CALL HGE_Impl::Target_Create(int width, int height, bool zbuffer)
  246. {
  247. CRenderTargetList *pTarget;
  248. D3DSURFACE_DESC TDesc;
  250. pTarget = new CRenderTargetList;
  251. pTarget->pTex=0;
  252. pTarget->pDepth=0;
  254. if(FAILED(D3DXCreateTexture(pD3DDevice, width, height, 1, D3DUSAGE_RENDERTARGET,
  255. d3dpp->BackBufferFormat, D3DPOOL_DEFAULT, &pTarget->pTex)))
  256. {
  257. _PostError("Can't create render target texture");
  258. delete pTarget;
  259. return 0;
  260. }
  262. pTarget->pTex->GetLevelDesc(0, &TDesc);
  263. pTarget->width=TDesc.Width;
  264. pTarget->height=TDesc.Height;
  266. if(zbuffer)
  267. {
  268. if(FAILED(pD3DDevice->CreateDepthStencilSurface(width, height,
  269. D3DFMT_D16, D3DMULTISAMPLE_NONE, &pTarget->pDepth)))
  270. {   
  271. pTarget->pTex->Release();
  272. _PostError("Can't create render target depth buffer");
  273. delete pTarget;
  274. return 0;
  275. }
  276. }
  278. pTarget->next=pTargets;
  279. pTargets=pTarget;
  281. return (HTARGET)pTarget;
  282. }
  284. void CALL HGE_Impl::Target_Free(HTARGET target)
  285. {
  286. CRenderTargetList *pTarget=pTargets, *pPrevTarget=NULL;
  288. while(pTarget)
  289. {
  290. if((CRenderTargetList *)target == pTarget)
  291. {
  292. if(pPrevTarget) pPrevTarget->next = pTarget->next;
  293. else pTargets = pTarget->next;
  294. if(pTarget->pTex) pTarget->pTex->Release();
  295. if(pTarget->pDepth) pTarget->pDepth->Release();
  296. delete pTarget;
  297. return;
  298. }
  299. pPrevTarget=pTarget;
  300. pTarget=pTarget->next;
  301. }
  302. }
  304. HTEXTURE CALL HGE_Impl::Target_GetTexture(HTARGET target)
  305. {
  306. CRenderTargetList *targ=(CRenderTargetList *)target;
  307. if(target) return (HTEXTURE)targ->pTex;
  308. else return 0;
  309. }
  311. HTEXTURE CALL HGE_Impl::Texture_Create(int width, int height)
  312. {
  313. LPDIRECT3DTEXTURE8 pTex;
  315. if( FAILED( D3DXCreateTexture( pD3DDevice, width, height,
  316. 1, // Mip levels
  317. 0, // Usage
  318. D3DFMT_A8R8G8B8, // Format
  319. D3DPOOL_MANAGED, // Memory pool
  320. &pTex ) ) )
  321. {
  322. _PostError("Can't create texture");
  323. return NULL;
  324. }
  326. return (HTEXTURE)pTex;
  327. }
  329. HTEXTURE CALL HGE_Impl::Texture_Load(const char *filename, DWORD size, bool bMipmap)
  330. {
  331. void *data;
  332. DWORD _size;
  333. D3DFORMAT fmt1, fmt2;
  334. LPDIRECT3DTEXTURE8 pTex;
  335. D3DXIMAGE_INFO info;
  336. CTextureList *texItem;
  338. if(size) { data=(void *)filename; _size=size; }
  339. else
  340. {
  341. data=pHGE->Resource_Load(filename, &_size);
  342. if(!data) return NULL;
  343. }
  345. if(*(DWORD*)data == 0x20534444) // Compressed DDS format magic number
  346. {
  347. fmt1=D3DFMT_UNKNOWN;
  348. fmt2=D3DFMT_A8R8G8B8;
  349. }
  350. else
  351. {
  352. fmt1=D3DFMT_A8R8G8B8;
  353. fmt2=D3DFMT_UNKNOWN;
  354. }
  356. // if( FAILED( D3DXCreateTextureFromFileInMemory( pD3DDevice, data, _size, &pTex ) ) ) pTex=NULL;
  357. if( FAILED( D3DXCreateTextureFromFileInMemoryEx( pD3DDevice, data, _size,
  358. D3DX_DEFAULT, D3DX_DEFAULT,
  359. bMipmap ? 0:1, // Mip levels
  360. 0, // Usage
  361. fmt1, // Format
  362. D3DPOOL_MANAGED, // Memory pool
  363. D3DX_FILTER_NONE, // Filter
  364. D3DX_DEFAULT, // Mip filter
  365. 0, // Color key
  366. &info, NULL,
  367. &pTex ) ) )
  369. if( FAILED( D3DXCreateTextureFromFileInMemoryEx( pD3DDevice, data, _size,
  370. D3DX_DEFAULT, D3DX_DEFAULT,
  371. bMipmap ? 0:1, // Mip levels
  372. 0, // Usage
  373. fmt2, // Format
  374. D3DPOOL_MANAGED, // Memory pool
  375. D3DX_FILTER_NONE, // Filter
  376. D3DX_DEFAULT, // Mip filter
  377. 0, // Color key
  378. &info, NULL,
  379. &pTex ) ) )
  381. {
  382. _PostError("Can't create texture");
  383. if(!size) delete data;
  384. return NULL;
  385. }
  387. if(!size) delete data;
  389. texItem=new CTextureList;
  390. texItem->tex=(HTEXTURE)pTex;
  391. texItem->width=info.Width;
  392. texItem->height=info.Height;
  393. texItem->next=textures;
  394. textures=texItem;
  396. return (HTEXTURE)pTex;
  397. }
  399. void CALL HGE_Impl::Texture_Free(HTEXTURE tex)
  400. {
  401. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  402. CTextureList *texItem=textures, *texPrev=0;
  404. while(texItem)
  405. {
  406. if(texItem->tex==tex)
  407. {
  408. if(texPrev) texPrev->next=texItem->next;
  409. else textures=texItem->next;
  410. delete texItem;
  411. break;
  412. }
  413. texPrev=texItem;
  414. texItem=texItem->next;
  415. }
  416. if(pTex != NULL) pTex->Release();
  417. }
  419. int CALL HGE_Impl::Texture_GetWidth(HTEXTURE tex, bool bOriginal)
  420. {
  421. D3DSURFACE_DESC TDesc;
  422. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  423. CTextureList *texItem=textures;
  425. if(bOriginal)
  426. {
  427. while(texItem)
  428. {
  429. if(texItem->tex==tex) return texItem->width;
  430. texItem=texItem->next;
  431. }
  432. return 0;
  433. }
  434. else
  435. {
  436. if(FAILED(pTex->GetLevelDesc(0, &TDesc))) return 0;
  437. else return TDesc.Width;
  438. }
  439. }
  442. int CALL HGE_Impl::Texture_GetHeight(HTEXTURE tex, bool bOriginal)
  443. {
  444. D3DSURFACE_DESC TDesc;
  445. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  446. CTextureList *texItem=textures;
  448. if(bOriginal)
  449. {
  450. while(texItem)
  451. {
  452. if(texItem->tex==tex) return texItem->height;
  453. texItem=texItem->next;
  454. }
  455. return 0;
  456. }
  457. else
  458. {
  459. if(FAILED(pTex->GetLevelDesc(0, &TDesc))) return 0;
  460. else return TDesc.Height;
  461. }
  462. }
  465. DWORD * CALL HGE_Impl::Texture_Lock(HTEXTURE tex, bool bReadOnly, int left, int top, int width, int height)
  466. {
  467. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  468. D3DSURFACE_DESC TDesc;
  469. D3DLOCKED_RECT TRect;
  470. RECT region, *prec;
  471. int flags;
  473. pTex->GetLevelDesc(0, &TDesc);
  474. if(TDesc.Format!=D3DFMT_A8R8G8B8 && TDesc.Format!=D3DFMT_X8R8G8B8) return 0;
  476. if(width && height)
  477. {
  478. region.left=left;
  479. region.top=top;
  480. region.right=left+width;
  481. region.bottom=top+height;
  482. prec=&region;
  483. }
  484. else prec=0;
  486. if(bReadOnly) flags=D3DLOCK_READONLY;
  487. else flags=0;
  489. if(FAILED(pTex->LockRect(0, &TRect, prec, flags)))
  490. {
  491. _PostError("Can't lock texture");
  492. return 0;
  493. }
  495. return (DWORD *)TRect.pBits;
  496. }
  499. void CALL HGE_Impl::Texture_Unlock(HTEXTURE tex)
  500. {
  501. LPDIRECT3DTEXTURE8 pTex=(LPDIRECT3DTEXTURE8)tex;
  502. pTex->UnlockRect(0);
  503. }
  505. //////// Implementation ////////
  507. void HGE_Impl::_render_batch(bool bEndScene)
  508. {
  509. if(!nPrim) return;
  510. pVB->Unlock();
  512. switch(CurPrimType)
  513. {
  514. case HGEPRIM_QUADS:
  515. pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, nPrim<<2, 0, nPrim<<1);
  516. break;
  518. case HGEPRIM_TRIPLES:
  519. pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, nPrim);
  520. break;
  522. case HGEPRIM_LINES:
  523. pD3DDevice->DrawPrimitive(D3DPT_LINELIST, 0, nPrim);
  524. break;
  525. }
  527. nPrim=0;
  528. if(!bEndScene) pVB->Lock( 0, 0, (BYTE**)&VertArray, 0 );
  529. }
  531. void HGE_Impl::_SetBlendMode(int blend)
  532. {
  533. if((blend & BLEND_ALPHABLEND) != (CurBlendMode & BLEND_ALPHABLEND))
  534. {
  535. if(blend & BLEND_ALPHABLEND) pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
  536. else pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
  537. }
  539.     if((blend & BLEND_ZWRITE) != (CurBlendMode & BLEND_ZWRITE))
  540. {
  541. if(blend & BLEND_ZWRITE) pD3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
  542. else pD3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
  543. }
  545. if((blend & BLEND_COLORADD) != (CurBlendMode & BLEND_COLORADD))
  546. {
  547. if(blend & BLEND_COLORADD) pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_ADD);
  548. else pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
  549. }
  551. CurBlendMode = blend;
  552. }
  554. void HGE_Impl::_SetProjectionMatrix(int width, int height)
  555. {
  556. D3DXMATRIX tmp;
  557. D3DXMatrixScaling(&matProj, 1.0f, -1.0f, 1.0f);
  558. D3DXMatrixTranslation(&tmp, -0.5f, height+0.5f, 0.0f);
  559. D3DXMatrixMultiply(&matProj, &matProj, &tmp);
  560. D3DXMatrixOrthoOffCenterLH(&tmp, 0, (float)width, 0, (float)height, 0.0f, 1.0f);
  561. D3DXMatrixMultiply(&matProj, &matProj, &tmp);
  562. }
  564. bool HGE_Impl::_GfxInit()
  565. {
  566. static const char *szFormats[]={"UNKNOWN", "R5G6B5", "X1R5G5B5", "A1R5G5B5", "X8R8G8B8", "A8R8G8B8"};
  567. D3DADAPTER_IDENTIFIER8 AdID;
  568. D3DDISPLAYMODE Mode;
  569. D3DFORMAT Format=D3DFMT_UNKNOWN;
  570. UINT nModes, i;
  572. // Init D3D
  574. pD3D=Direct3DCreate8(120); // D3D_SDK_VERSION
  575. if(pD3D==NULL)
  576. {
  577. _PostError("Can't create D3D interface");
  578. return false;
  579. }
  581. // Get adapter info
  583. pD3D->GetAdapterIdentifier(D3DADAPTER_DEFAULT, D3DENUM_NO_WHQL_LEVEL, &AdID);
  584. System_Log("D3D Driver: %s",AdID.Driver);
  585. System_Log("Description: %s",AdID.Description);
  586. System_Log("Version: %d.%d.%d.%d",
  587. HIWORD(AdID.DriverVersion.HighPart),
  588. LOWORD(AdID.DriverVersion.HighPart),
  589. HIWORD(AdID.DriverVersion.LowPart),
  590. LOWORD(AdID.DriverVersion.LowPart));
  592. // Set up Windowed presentation parameters
  594. if(FAILED(pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &Mode)) || Mode.Format==D3DFMT_UNKNOWN) 
  595. {
  596. _PostError("Can't determine desktop video mode");
  597. if(bWindowed) return false;
  598. }
  600. ZeroMemory(&d3dppW, sizeof(d3dppW));
  602. d3dppW.BackBufferWidth  = nScreenWidth;
  603. d3dppW.BackBufferHeight = nScreenHeight;
  604. d3dppW.BackBufferFormat = Mode.Format;
  605. d3dppW.BackBufferCount  = 1;
  606. d3dppW.MultiSampleType  = D3DMULTISAMPLE_NONE;
  607. d3dppW.hDeviceWindow    = hwnd;
  608. d3dppW.Windowed         = TRUE;
  610. if(nHGEFPS==HGEFPS_VSYNC) d3dppW.SwapEffect = D3DSWAPEFFECT_COPY_VSYNC;
  611. else   d3dppW.SwapEffect = D3DSWAPEFFECT_COPY;
  613. if(bZBuffer)
  614. {
  615. d3dppW.EnableAutoDepthStencil = TRUE;
  616. d3dppW.AutoDepthStencilFormat = D3DFMT_D16;
  617. }
  619. // Set up Full Screen presentation parameters
  621. nModes=pD3D->GetAdapterModeCount(D3DADAPTER_DEFAULT);
  622. for(i=0; i<nModes; i++) {
  623. pD3D->EnumAdapterModes(D3DADAPTER_DEFAULT, i, &Mode);
  624. if(Mode.Width != (UINT)nScreenWidth || Mode.Height != (UINT)nScreenHeight) continue;
  625. if(nScreenBPP==16 && (_format_id(Mode.Format) > _format_id(D3DFMT_A1R5G5B5))) continue;
  626. if(_format_id(Mode.Format) > _format_id(Format)) Format=Mode.Format;
  627. }
  628. if(Format == D3DFMT_UNKNOWN)
  629. {
  630. _PostError("Can't find appropriate full screen video mode");
  631. if(!bWindowed) return false;
  632. }
  634. ZeroMemory(&d3dppFS, sizeof(d3dppFS));
  636. d3dppFS.BackBufferWidth  = nScreenWidth;
  637. d3dppFS.BackBufferHeight = nScreenHeight;
  638. d3dppFS.BackBufferFormat = Format;
  639. d3dppFS.BackBufferCount  = 1;
  640. d3dppFS.MultiSampleType  = D3DMULTISAMPLE_NONE;
  641. d3dppFS.hDeviceWindow    = hwnd;
  642. d3dppFS.Windowed         = FALSE;
  644. d3dppFS.SwapEffect       = D3DSWAPEFFECT_FLIP;
  645. d3dppFS.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
  646. if(nHGEFPS==HGEFPS_VSYNC) d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
  647. else   d3dppFS.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
  649. if(bZBuffer)
  650. {
  651. d3dppFS.EnableAutoDepthStencil = TRUE;
  652. d3dppFS.AutoDepthStencilFormat = D3DFMT_D16;
  653. }
  655. if(bWindowed) d3dpp=&d3dppW;
  656. else d3dpp=&d3dppFS;
  658. if(_format_id(d3dpp->BackBufferFormat) < 4) nScreenBPP=16;
  659. else nScreenBPP=32;
  661. // Create D3D Device
  663. if( FAILED( pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
  664.                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING,
  665.                                   d3dpp, &pD3DDevice ) ) ) {
  666. _PostError("Can't create D3D device");
  667. return false;
  668. }
  670. _AdjustWindow();
  671. System_Log("Mode: %d x %d x %sn",nScreenWidth,nScreenHeight,szFormats[_format_id(Format)]);
  673. // Create vertex batch buffer
  675. VertArray=0;
  676. textures=0;
  678. // Init all stuff that can be lost
  680. _SetProjectionMatrix(nScreenWidth, nScreenHeight);
  681. D3DXMatrixIdentity(&matView);
  683. if(!_init_lost()) return false;
  685. Gfx_Clear(0);
  687. return true;
  688. }
  690. int HGE_Impl::_format_id(D3DFORMAT fmt)
  691. {
  692. switch(fmt) {
  693. case D3DFMT_R5G6B5: return 1;
  694. case D3DFMT_X1R5G5B5: return 2;
  695. case D3DFMT_A1R5G5B5: return 3;
  696. case D3DFMT_X8R8G8B8: return 4;
  697. case D3DFMT_A8R8G8B8: return 5;
  698. default: return 0;
  699. }
  700. }
  702. void HGE_Impl::_AdjustWindow()
  703. {
  704. RECT *rc;
  705. LONG style;
  707. if(bWindowed) {rc=&rectW; style=styleW; }
  708. else  {rc=&rectFS; style=styleFS; }
  709. SetWindowLong(hwnd, GWL_STYLE, style);
  711. style=GetWindowLong(hwnd, GWL_EXSTYLE);
  712. if(bWindowed)
  713. {
  714. SetWindowLong(hwnd, GWL_EXSTYLE, style & (~WS_EX_TOPMOST));
  715.     SetWindowPos(hwnd, HWND_NOTOPMOST, rc->left, rc->top, rc->right-rc->left, rc->bottom-rc->top, SWP_FRAMECHANGED);
  716. }
  717. else
  718. {
  719. SetWindowLong(hwnd, GWL_EXSTYLE, style | WS_EX_TOPMOST);
  720.     SetWindowPos(hwnd, HWND_TOPMOST, rc->left, rc->top, rc->right-rc->left, rc->bottom-rc->top, SWP_FRAMECHANGED);
  721. }
  722. }
  724. void HGE_Impl::_Resize(int width, int height)
  725. {
  726. if(hwndParent)
  727. {
  728. if(procFocusLostFunc) procFocusLostFunc();
  730. d3dppW.BackBufferWidth=width;
  731. d3dppW.BackBufferHeight=height;
  732. nScreenWidth=width;
  733. nScreenHeight=height;
  735. _SetProjectionMatrix(nScreenWidth, nScreenHeight);
  736. _GfxRestore();
  738. if(procFocusGainFunc) procFocusGainFunc();
  739. }
  740. }
  742. void HGE_Impl::_GfxDone()
  743. {
  744. CRenderTargetList *target=pTargets, *next_target;
  746. while(textures) Texture_Free(textures->tex);
  748. if(pScreenSurf) { pScreenSurf->Release(); pScreenSurf=0; }
  749. if(pScreenDepth) { pScreenDepth->Release(); pScreenDepth=0; }
  751. while(target)
  752. {
  753. if(target->pTex) target->pTex->Release();
  754. if(target->pDepth) target->pDepth->Release();
  755. next_target=target->next;
  756. delete target;
  757. target=next_target;
  758. }
  759. pTargets=0;
  761. if(pIB)
  762. {
  763. pD3DDevice->SetIndices(NULL,0);
  764. pIB->Release();
  765. pIB=0;
  766. }
  767. if(pVB)
  768. {
  769. if(VertArray) { pVB->Unlock(); VertArray=0; }
  770. pD3DDevice->SetStreamSource( 0, NULL, sizeof(hgeVertex) );
  771. pVB->Release();
  772. pVB=0;
  773. }
  774. if(pD3DDevice) { pD3DDevice->Release(); pD3DDevice=0; }
  775. if(pD3D) { pD3D->Release(); pD3D=0; }
  776. }
  779. void HGE_Impl::_GfxRestore()
  780. {
  781. CRenderTargetList *target=pTargets;
  783. if(!pD3DDevice) return;
  784. if(pD3DDevice->TestCooperativeLevel() != D3DERR_DEVICENOTRESET) return;
  786. if(pScreenSurf) pScreenSurf->Release();
  787. if(pScreenDepth) pScreenDepth->Release();
  789. while(target)
  790. {
  791. if(target->pTex) target->pTex->Release();
  792. if(target->pDepth) target->pDepth->Release();
  793. target=target->next;
  794. }
  796. if(pIB)
  797. {
  798. pD3DDevice->SetIndices(NULL,0);
  799. pIB->Release();
  800. }
  801. if(pVB)
  802. {
  803. pD3DDevice->SetStreamSource( 0, NULL, sizeof(hgeVertex) );
  804. pVB->Release();
  805. }
  807. pD3DDevice->Reset(d3dpp);
  808. _init_lost();
  809. }
  812. bool HGE_Impl::_init_lost()
  813. {
  814. CRenderTargetList *target=pTargets;
  816. // Store render target
  818. pScreenSurf=0;
  819. pScreenDepth=0;
  821. pD3DDevice->GetRenderTarget(&pScreenSurf);
  822. pD3DDevice->GetDepthStencilSurface(&pScreenDepth);
  824. while(target)
  825. {
  826. if(target->pTex) D3DXCreateTexture(pD3DDevice, target->width, target->height, 1, D3DUSAGE_RENDERTARGET,
  827.  d3dpp->BackBufferFormat, D3DPOOL_DEFAULT, &target->pTex);
  828. if(target->pDepth) pD3DDevice->CreateDepthStencilSurface(target->width, target->height,
  829.    D3DFMT_D16, D3DMULTISAMPLE_NONE, &target->pDepth);
  830. target=target->next;
  831. }
  833. // Create Vertex buffer
  835. if( FAILED (pD3DDevice->CreateVertexBuffer(VERTEX_BUFFER_SIZE*sizeof(hgeVertex),
  836.                                               D3DUSAGE_WRITEONLY,
  837.   D3DFVF_HGEVERTEX,
  838.                                               D3DPOOL_DEFAULT, &pVB )))
  839. {
  840. _PostError("Can't create D3D vertex buffer");
  841. return false;
  842. }
  844. pD3DDevice->SetVertexShader( D3DFVF_HGEVERTEX );
  845. pD3DDevice->SetStreamSource( 0, pVB, sizeof(hgeVertex) );
  847. // Create and setup Index buffer
  849. if( FAILED( pD3DDevice->CreateIndexBuffer(VERTEX_BUFFER_SIZE*6/4*sizeof(WORD),
  850.                                               D3DUSAGE_WRITEONLY,
  851.   D3DFMT_INDEX16,
  852.                                               D3DPOOL_DEFAULT, &pIB ) ) )
  853. {
  854. _PostError("Can't create D3D index buffer");
  855. return false;
  856. }
  858. WORD *pIndices, n=0;
  859. if( FAILED( pIB->Lock( 0, 0, (BYTE**)&pIndices, 0 ) ) )
  860. {
  861. _PostError("Can't lock D3D index buffer");
  862. return false;
  863. }
  865. for(int i=0; i<VERTEX_BUFFER_SIZE/4; i++) {
  866. *pIndices++=n;
  867. *pIndices++=n+1;
  868. *pIndices++=n+2;
  869. *pIndices++=n+2;
  870. *pIndices++=n+3;
  871. *pIndices++=n;
  872. n+=4;
  873. }
  875. pIB->Unlock();
  876. pD3DDevice->SetIndices(pIB,0);
  878. // Set common render states
  880. //pD3DDevice->SetRenderState( D3DRS_LASTPIXEL, FALSE );
  881. pD3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
  882. pD3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
  884. pD3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE,   TRUE );
  885. pD3DDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
  886. pD3DDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
  888. pD3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
  889. pD3DDevice->SetRenderState( D3DRS_ALPHAREF,        0x01 );
  890. pD3DDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
  892. pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
  893. pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
  894. pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
  896. pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
  897. pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
  898. pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
  900. pD3DDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_POINT);
  902. if(bTextureFilter)
  903. {
  904. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
  905. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
  906. }
  907. else
  908. {
  909. pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_POINT);
  910. pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_POINT);
  911. }
  913. nPrim=0;
  914. CurPrimType=HGEPRIM_QUADS;
  915. CurBlendMode = BLEND_DEFAULT;
  916. CurTexture = NULL;
  918. pD3DDevice->SetTransform(D3DTS_VIEW, &matView);
  919. pD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);
  921. return true;
  922. }