API tools faq
paste
Guest User

Untitled

a guest
May 24th, 2018
103
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.78 KB | None | 0 0
raw download clone embed print report
  1. char FontShader[] =
  2. "\
  3. Texture2D tex2D;\
  4. SamplerState linearSampler\
  5. {\
  6. Filter = MIN_MAG_MIP_POINT;\
  7. AddressU = Wrap;\
  8. AddressV = Wrap;\
  9. };\
  10. struct _FONTVS\
  11. {\
  12. float4 Pos : POSITION;\
  13. float4 Color : COLOR;\
  14. float2 Tex : TEXCOORD;\
  15. };\
  16. struct _FONTPS\
  17. {\
  18. float4 Pos : SV_POSITION;\
  19. float4 Color : COLOR;\
  20. float2 Tex : TEXCOORD;\
  21. };\
  22. _FONTPS FONT_VS( _FONTVS input )\
  23. {\
  24. _FONTPS output;\
  25. output.Pos = input.Pos;\
  26. output.Color = input.Color;\
  27. output.Tex = input.Tex;\
  28. return output;\
  29. }\
  30. float4 FONT_PS( _FONTPS input ) : SV_Target\
  31. {\
  32. float4 color = tex2D.Sample( linearSampler, input.Tex );\
  33. if (color.r == 0)\
  34. color = 0;\
  35. else\
  36. {\
  37. color = input.Color;\
  38. color.w = 1;\
  39. }\
  40. return color;\
  41. }";
  42.  
  43. char DrawShader[] =
  44. "\
  45. struct _DRAWVS\
  46. {\
  47. float4 Pos : POSITION;\
  48. float4 Color : COLOR;\
  49. };\
  50. struct _DRAWPS\
  51. {\
  52. float4 Pos : SV_POSITION;\
  53. float4 Color : COLOR;\
  54. };\
  55. _DRAWPS DRAW_VS( _DRAWVS input )\
  56. {\
  57. _DRAWPS output;\
  58. output.Pos = input.Pos;\
  59. output.Color = input.Color;\
  60. return output;\
  61. }\
  62. float4 DRAW_PS( _DRAWPS input ) : SV_Target\
  63. {\
  64. return input.Color;\
  65. }";
  66.  
  67. ------------------------------------
  68.  
  69. #pragma once
  70. //Only include this in the .cpp file that will init/draw the menus!!!
  71.  
  72. #include "MenuSystem.h"
  73. #include <d3d11.h>
  74. #include <d3dx11.h>
  75. #include <d3dx10.h>
  76.  
  77. // include the Direct3D Library file
  78. #pragma comment (lib, "d3d11.lib")
  79. #pragma comment (lib, "d3dx11.lib")
  80. #pragma comment (lib, "d3dx10.lib")
  81.  
  82. #include "fontdx11.h"
  83. #define SAFE_RELEASE(p) { if ( (p) ) { (p)->Release(); (p) = 0; } }
  84.  
  85. struct VERTEX
  86. {
  87. D3DXVECTOR3 Pos;
  88. D3DXCOLOR Color;
  89. D3DXVECTOR2 Tex;
  90. };
  91.  
  92. struct DRAWVERTEX
  93. {
  94. D3DXVECTOR3 Pos;
  95. D3DXCOLOR Color;
  96. };
  97.  
  98.  
  99. class CDX11Canvas : public CCanvas
  100. {
  101. public:
  102. int ScreenWidth;
  103. int ScreenHeight;
  104.  
  105. IDXGISwapChain* swapchain;
  106. ID3D11Device* dev;
  107. ID3D11DeviceContext* devcon;
  108.  
  109. //Saved
  110. ID3D11RasterizerState* pSavedRS;
  111. ID3D11ShaderResourceView* pSavedRV;
  112. ID3D11BlendState* pSavedBlendState;
  113. FLOAT SavedBlendFactor[4];
  114. UINT SaveSampleMask;
  115.  
  116. //Font
  117. ID3D11Buffer* pFontVBuffer;
  118. ID3D11VertexShader* pFontVS;
  119. ID3D11PixelShader* pFontPS;
  120. ID3D11InputLayout* pFontLayout;
  121. ID3D11RasterizerState* pFontRS;
  122. ID3D11ShaderResourceView* pFontRV;
  123. ID3D11BlendState* pFontBlendState;
  124.  
  125. //Drawing
  126. ID3D11Buffer* pDrawVBuffer;
  127. ID3D11VertexShader* pDrawVS;
  128. ID3D11PixelShader* pDrawPS;
  129. ID3D11InputLayout* pDrawLayout;
  130. ID3D11RasterizerState* pDrawRS;
  131. ID3D11BlendState* pDrawBlendState;
  132.  
  133.  
  134. public:
  135. CDX11Canvas()
  136. {
  137. swapchain = NULL;
  138. dev = NULL;
  139. devcon = NULL;
  140.  
  141. pFontVBuffer = NULL;
  142. pFontVS = NULL;
  143. pFontPS = NULL;
  144. pFontLayout = NULL;
  145. pFontRS = NULL;
  146. pFontRV = NULL;
  147. pFontBlendState = NULL;
  148.  
  149. pDrawVBuffer = NULL;
  150. pDrawVS = NULL;
  151. pDrawPS = NULL;
  152. pDrawLayout = NULL;
  153. pDrawRS = NULL;
  154. pDrawBlendState = NULL;
  155. }
  156.  
  157. virtual void Init(void* Pram)
  158. {
  159. HRESULT hr;
  160. swapchain = (IDXGISwapChain *)Pram;
  161. if (!swapchain) return;
  162. swapchain->GetDevice(__uuidof(ID3D11Device),(LPVOID*)&dev);
  163. dev->GetImmediateContext(&devcon);
  164.  
  165. if (!pFontVBuffer)
  166. {
  167. D3D11_BUFFER_DESC bd;
  168. ZeroMemory(&bd, sizeof(bd));
  169. bd.Usage = D3D11_USAGE_DYNAMIC; // write access access by CPU and GPU
  170. bd.ByteWidth = sizeof(VERTEX) * 256 * 6; // size is the VERTEX struct * 3
  171. bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; // use as a vertex buffer
  172. bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // allow CPU to write in buffer
  173. dev->CreateBuffer(&bd, NULL, &pFontVBuffer); // create the buffer
  174. }
  175.  
  176. if (!pFontVS)
  177. {
  178. ID3D10Blob *VS;
  179. hr = D3DX11CompileFromMemory(FontShader,sizeof(FontShader),0,0,0,"FONT_VS","vs_4_0", 0, 0, 0, &VS, 0, 0);
  180. //D3DX11CompileFromFile("D:\\dx11\\font.hlsl", 0, 0, "FONT_VS", "vs_4_0", 0, 0, 0, &VS, 0, 0);
  181. dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, &pFontVS);
  182.  
  183.  
  184. D3D11_INPUT_ELEMENT_DESC ied[] =
  185. {
  186. {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
  187. {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
  188. {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 },
  189. };
  190. dev->CreateInputLayout(ied, 3, VS->GetBufferPointer(), VS->GetBufferSize(), &pFontLayout);
  191. }
  192. if (!pFontPS)
  193. {
  194. ID3D10Blob *PS;
  195. hr = D3DX11CompileFromMemory(FontShader,sizeof(FontShader),0,0,0,"FONT_PS","ps_4_0", 0, 0, 0, &PS, 0, 0);
  196. //D3DX11CompileFromFile("D:\\dx11\\font.hlsl", 0, 0, "FONT_PS", "ps_4_0", 0, 0, 0, &PS, 0, 0);
  197. dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &pFontPS);
  198. }
  199.  
  200. if (!pFontRV)
  201. {
  202. D3DX11CreateShaderResourceViewFromMemory(dev,FontTexture,sizeof(FontTexture),0,0,&pFontRV,0);
  203. //D3DX11CreateShaderResourceViewFromFile( dev, "D:\\dx11\\font.bmp", NULL, NULL,&pFontRV, NULL );
  204. }
  205.  
  206. if (!pFontRS)
  207. {
  208. D3D11_RASTERIZER_DESC rasterizerState;
  209. rasterizerState.CullMode = D3D11_CULL_NONE;
  210. rasterizerState.FillMode = D3D11_FILL_SOLID;
  211. rasterizerState.FrontCounterClockwise = true;
  212. rasterizerState.DepthBias = false;
  213. rasterizerState.DepthBiasClamp = 0;
  214. rasterizerState.SlopeScaledDepthBias = 0;
  215. rasterizerState.DepthClipEnable = false;
  216. rasterizerState.ScissorEnable = false;
  217. rasterizerState.MultisampleEnable = false;
  218. rasterizerState.AntialiasedLineEnable = false;
  219. dev->CreateRasterizerState( &rasterizerState, &pFontRS);
  220. }
  221.  
  222. if (!pFontBlendState)
  223. {
  224. D3D11_BLEND_DESC BlendStateDescription;
  225. ZeroMemory(&BlendStateDescription, sizeof(D3D11_BLEND_DESC) );
  226. BlendStateDescription.RenderTarget[0].BlendEnable = true;
  227. BlendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
  228. BlendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
  229. BlendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
  230. BlendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_DEST_ALPHA;
  231. BlendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
  232. BlendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
  233. BlendStateDescription.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
  234. dev->CreateBlendState(&BlendStateDescription,&pFontBlendState);
  235. }
  236.  
  237. if (!pDrawVBuffer)
  238. {
  239. D3D11_BUFFER_DESC bd;
  240. ZeroMemory(&bd, sizeof(bd));
  241. bd.Usage = D3D11_USAGE_DYNAMIC; // write access access by CPU and GPU
  242. bd.ByteWidth = sizeof(DRAWVERTEX) * 256 * 2; // size is the VERTEX struct * 3
  243. bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; // use as a vertex buffer
  244. bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // allow CPU to write in buffer
  245. dev->CreateBuffer(&bd, NULL, &pDrawVBuffer); // create the buffer
  246. }
  247.  
  248. if (!pDrawVS)
  249. {
  250. ID3D10Blob *VS;
  251. hr = D3DX11CompileFromMemory(DrawShader,sizeof(DrawShader),0,0,0,"DRAW_VS","vs_4_0", 0, 0, 0, &VS, 0, 0);
  252. //hr = D3DX11CompileFromFile("D:\\dx11\\draw.hlsl", 0, 0, "DRAW_VS", "vs_4_0", 0, 0, 0, &VS, 0, 0);
  253. dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, &pDrawVS);
  254.  
  255. D3D11_INPUT_ELEMENT_DESC ied[] =
  256. {
  257. {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
  258. {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
  259. };
  260. dev->CreateInputLayout(ied, 2, VS->GetBufferPointer(), VS->GetBufferSize(), &pDrawLayout);
  261. }
  262. if (!pDrawPS)
  263. {
  264. ID3D10Blob *PS;
  265. hr = D3DX11CompileFromMemory(DrawShader,sizeof(DrawShader),0,0,0,"DRAW_PS","ps_4_0", 0, 0, 0, &PS, 0, 0);
  266. //hr = D3DX11CompileFromFile("D:\\dx11\\draw.hlsl", 0, 0, "DRAW_PS", "ps_5_0", 0, 0, 0, &PS, 0, 0);
  267. dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &pDrawPS);
  268. }
  269.  
  270. if (!pDrawRS)
  271. {
  272. D3D11_RASTERIZER_DESC rasterizerState;
  273. rasterizerState.CullMode = D3D11_CULL_NONE;
  274. rasterizerState.FillMode = D3D11_FILL_SOLID;
  275. rasterizerState.FrontCounterClockwise = true;
  276. rasterizerState.DepthBias = false;
  277. rasterizerState.DepthBiasClamp = 0;
  278. rasterizerState.SlopeScaledDepthBias = 0;
  279. rasterizerState.DepthClipEnable = false;
  280. rasterizerState.ScissorEnable = false;
  281. rasterizerState.MultisampleEnable = false;
  282. rasterizerState.AntialiasedLineEnable = false;
  283. dev->CreateRasterizerState( &rasterizerState, &pDrawRS);
  284. }
  285.  
  286. if (!pDrawBlendState)
  287. {
  288. D3D11_BLEND_DESC BlendStateDescription;
  289. ZeroMemory(&BlendStateDescription, sizeof(D3D11_BLEND_DESC) );
  290. BlendStateDescription.RenderTarget[0].BlendEnable = false;
  291. BlendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
  292. BlendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
  293. BlendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
  294. BlendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_DEST_ALPHA;
  295. BlendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
  296. BlendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
  297. BlendStateDescription.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
  298. dev->CreateBlendState(&BlendStateDescription,&pDrawBlendState);
  299. }
  300. }
  301.  
  302.  
  303. virtual void Begin()
  304. {
  305. if (!IsValid()) return;
  306.  
  307. ID3D11Texture2D *pBackBuffer;
  308. swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
  309. D3D11_TEXTURE2D_DESC desc;
  310. pBackBuffer->GetDesc(&desc);
  311. ScreenWidth = desc.Width;
  312. ScreenHeight = desc.Height;
  313. pBackBuffer->Release();
  314.  
  315. devcon->RSGetState(&pSavedRS);
  316. devcon->PSGetShaderResources(0,1,&pSavedRV);
  317. devcon->OMGetBlendState(&pSavedBlendState,SavedBlendFactor,&SaveSampleMask);
  318. }
  319. virtual bool IsValid()
  320. {
  321. if (!swapchain) return false;
  322. if (!dev) return false;
  323. if (!devcon) return false;
  324. if (!pFontVBuffer) return false;
  325. if (!pFontVS) return false;
  326. if (!pFontPS) return false;
  327. if (!pFontLayout) return false;
  328. if (!pFontRS) return false;
  329. if (!pFontRV) return false;
  330. if (!pFontBlendState) return false;
  331.  
  332. if (!pDrawVBuffer) return false;
  333. if (!pDrawVS) return false;
  334. if (!pDrawPS) return false;
  335. if (!pDrawLayout) return false;
  336. if (!pDrawRS) return false;
  337. if (!pDrawBlendState) return false;
  338.  
  339. return true;
  340. }
  341.  
  342. virtual void End()
  343. {
  344. if (pSavedRS) devcon->RSSetState(pSavedRS);
  345. if (pSavedRV) devcon->PSSetShaderResources(0,1,&pSavedRV);
  346. if (pSavedBlendState) devcon->OMSetBlendState(pSavedBlendState,SavedBlendFactor,SaveSampleMask);
  347.  
  348. SAFE_RELEASE(dev);
  349. SAFE_RELEASE(devcon);
  350. SAFE_RELEASE(pSavedRS);
  351. SAFE_RELEASE(pSavedRV);
  352. SAFE_RELEASE(pSavedBlendState);
  353. }
  354.  
  355. virtual void Reset()
  356. {
  357. SAFE_RELEASE(pFontVBuffer);
  358. SAFE_RELEASE(pFontVS);
  359. SAFE_RELEASE(pFontPS);
  360. SAFE_RELEASE(pFontLayout);
  361. SAFE_RELEASE(pFontRS);
  362. SAFE_RELEASE(pFontRV);
  363. SAFE_RELEASE(pFontBlendState);
  364. SAFE_RELEASE(pDrawVBuffer);
  365. SAFE_RELEASE(pDrawVS);
  366. SAFE_RELEASE(pDrawPS);
  367. SAFE_RELEASE(pDrawLayout);
  368. SAFE_RELEASE(pDrawRS);
  369. SAFE_RELEASE(pDrawBlendState);
  370. }
  371.  
  372. D3DXVECTOR3 ToScreen(float X,float Y)
  373. {
  374. float hx = (X/((float)ScreenWidth * .5))-1;
  375. float hy = 1- (Y/((float)ScreenHeight * .5));
  376. return D3DXVECTOR3( hx,hy,0);
  377. }
  378.  
  379. virtual void Text(char* text,int x, int y, DWORD color)
  380. {
  381. if (!IsValid()) return;
  382. color |= 0xFF000000;
  383.  
  384. VERTEX vChar[6*256];
  385.  
  386. char* c = text;
  387. int count = 0;
  388. int vidx = 0;
  389. int cx = x;
  390. int cy = y;
  391.  
  392. while(*c)
  393. {
  394. float tsx = (float)((*c)*16) / 4096;
  395. float tex = (float)((*c)*16) / 4096 + (16.0f/4096.0f);
  396.  
  397. vChar[vidx+0].Pos = ToScreen(cx,cy);
  398. vChar[vidx+0].Color = color;
  399. vChar[vidx+0].Tex = D3DXVECTOR2(tsx,0);
  400.  
  401. vChar[vidx+1].Pos = ToScreen(cx+16,cy);
  402. vChar[vidx+1].Color = color;
  403. vChar[vidx+1].Tex = D3DXVECTOR2(tex,0);
  404.  
  405. vChar[vidx+2].Pos = ToScreen(cx,cy+16);
  406. vChar[vidx+2].Color = color;
  407. vChar[vidx+2].Tex = D3DXVECTOR2(tsx,1);
  408.  
  409.  
  410. vChar[vidx+3].Pos = ToScreen(cx+16,cy);
  411. vChar[vidx+3].Color = color;
  412. vChar[vidx+3].Tex = D3DXVECTOR2(tex,0);
  413.  
  414. vChar[vidx+4].Pos = ToScreen(cx+16,cy+16);
  415. vChar[vidx+4].Color = color;
  416. vChar[vidx+4].Tex = D3DXVECTOR2(tex,1);
  417.  
  418. vChar[vidx+5].Pos = ToScreen(cx,cy+16);
  419. vChar[vidx+5].Color = color;
  420. vChar[vidx+5].Tex = D3DXVECTOR2(tsx,1);
  421.  
  422. cx += FONTCHARWIDTH[*c+17];
  423. c++;
  424. count++;
  425. vidx += 6;
  426. }
  427.  
  428. devcon->VSSetShader(pFontVS, 0, 0);
  429. devcon->PSSetShader(pFontPS, 0, 0);
  430. devcon->IASetInputLayout(pFontLayout);
  431. devcon->PSSetShaderResources( 0, 1, &pFontRV );
  432. devcon->RSSetState(pFontRS);
  433. devcon->OMSetBlendState( pFontBlendState,NULL,0xffffffff);
  434.  
  435. D3D11_MAPPED_SUBRESOURCE ms;
  436. devcon->Map(pFontVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
  437. memcpy(ms.pData, vChar, sizeof(VERTEX)*count*6);
  438. devcon->Unmap(pFontVBuffer, NULL);
  439.  
  440. UINT stride = sizeof(VERTEX);
  441. UINT offset = 0;
  442. devcon->IASetVertexBuffers(0, 1, &pFontVBuffer, &stride, &offset);
  443.  
  444. devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
  445. devcon->Draw(count*6, 0);
  446.  
  447. }
  448. virtual int TextWidth(char* text)
  449. {
  450. char* c = text;
  451. int cx = 0;
  452. while(*c)
  453. {
  454. cx += FONTCHARWIDTH[*c+17];
  455. c++;
  456. }
  457. return cx;
  458. }
  459. virtual int TextHeight(char* text)
  460. {
  461. return 16;
  462. }
  463. virtual void Line(float x1,float y1,float x2,float y2,DWORD color)
  464. {
  465. if (!IsValid()) return;
  466.  
  467. DRAWVERTEX points[2];
  468.  
  469. points[0].Pos = ToScreen(x1,y1);
  470. points[0].Color = color;
  471.  
  472. points[1].Pos = ToScreen(x2,y2);
  473. points[1].Color = color;
  474.  
  475. devcon->VSSetShader(pDrawVS, 0, 0);
  476. devcon->PSSetShader(pDrawPS, 0, 0);
  477. devcon->IASetInputLayout(pDrawLayout);
  478. devcon->RSSetState(pDrawRS);
  479. devcon->OMSetBlendState( pDrawBlendState,NULL,0xffffffff);
  480.  
  481. D3D11_MAPPED_SUBRESOURCE ms;
  482. devcon->Map(pDrawVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
  483. memcpy(ms.pData, points, sizeof(DRAWVERTEX)*2);
  484. devcon->Unmap(pDrawVBuffer, NULL);
  485.  
  486. UINT stride = sizeof(DRAWVERTEX);
  487. UINT offset = 0;
  488. devcon->IASetVertexBuffers(0, 1, &pDrawVBuffer, &stride, &offset);
  489.  
  490. devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
  491. devcon->Draw(2, 0);
  492.  
  493. }
  494. virtual void FillGradient(float x,float y,float w,float h,DWORD color1,DWORD color2,DWORD color3,DWORD color4)
  495. {
  496. if (!IsValid()) return;
  497.  
  498. DRAWVERTEX points[6];
  499.  
  500. points[0].Pos = ToScreen(x,y);
  501. points[0].Color = color1;
  502.  
  503. points[1].Pos = ToScreen(x+w,y);
  504. points[1].Color = color2;
  505.  
  506. points[2].Pos = ToScreen(x,y+h);
  507. points[2].Color = color4;
  508.  
  509. points[3].Pos = ToScreen(x+w,y);
  510. points[3].Color = color2;
  511.  
  512. points[4].Pos = ToScreen(x+w,y+h);
  513. points[4].Color = color3;
  514.  
  515. points[5].Pos = ToScreen(x,y+h);
  516. points[5].Color = color4;
  517.  
  518. devcon->VSSetShader(pDrawVS, 0, 0);
  519. devcon->PSSetShader(pDrawPS, 0, 0);
  520. devcon->IASetInputLayout(pDrawLayout);
  521. devcon->RSSetState(pDrawRS);
  522. devcon->OMSetBlendState( pDrawBlendState,NULL,0xffffffff);
  523.  
  524. D3D11_MAPPED_SUBRESOURCE ms;
  525. devcon->Map(pDrawVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
  526. memcpy(ms.pData, points, sizeof(DRAWVERTEX)*6);
  527. devcon->Unmap(pDrawVBuffer, NULL);
  528.  
  529. UINT stride = sizeof(DRAWVERTEX);
  530. UINT offset = 0;
  531. devcon->IASetVertexBuffers(0, 1, &pDrawVBuffer, &stride, &offset);
  532.  
  533. devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
  534. devcon->Draw(6, 0);
  535.  
  536. }
  537. virtual void Poly(POINT* points,int count,DWORD color)
  538. {
  539. if (!IsValid()) return;
  540. if (count<3) return;
  541.  
  542. DRAWVERTEX* pPoints = new DRAWVERTEX[count+1];
  543.  
  544. pPoints[0].Pos = ToScreen(points[0].x,points[0].y);
  545. pPoints[0].Color = color;
  546.  
  547. pPoints[1].Pos = ToScreen(points[1].x,points[1].y);
  548. pPoints[1].Color = color;
  549.  
  550. pPoints[2].Pos = ToScreen(points[count-1].x,points[count-1].y);
  551. pPoints[2].Color = color;
  552.  
  553. for (int i=3; i < count;i++)
  554. {
  555. pPoints[i].Pos = ToScreen(points[i-1].x,points[i-1].y);
  556. pPoints[i].Color = color;
  557. }
  558.  
  559. devcon->VSSetShader(pDrawVS, 0, 0);
  560. devcon->PSSetShader(pDrawPS, 0, 0);
  561. devcon->IASetInputLayout(pDrawLayout);
  562. devcon->RSSetState(pDrawRS);
  563. devcon->OMSetBlendState( pDrawBlendState,NULL,0xffffffff);
  564.  
  565. D3D11_MAPPED_SUBRESOURCE ms;
  566. devcon->Map(pDrawVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
  567. memcpy(ms.pData, pPoints, sizeof(DRAWVERTEX)*count);
  568. devcon->Unmap(pDrawVBuffer, NULL);
  569.  
  570. UINT stride = sizeof(DRAWVERTEX);
  571. UINT offset = 0;
  572. devcon->IASetVertexBuffers(0, 1, &pDrawVBuffer, &stride, &offset);
  573.  
  574. devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
  575. devcon->Draw(count, 0);
  576.  
  577. delete pPoints;
  578. }
  579.  
  580. };
  581. CCanvas* pCanvas = NULL;
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!