1. #include "StdAfx.h"
2. #include "StateManager.h"
3.  
4. //#define StateManager_Assert(a) if (!(a)) puts("assert"#a)
5. #define StateManager_Assert(a) assert(a)
6.  
7. struct SLightData
8. {
9.         enum
10.         {
11.                 LIGHT_NUM = 8,
12.         };
13.         D3DLIGHT9 m_akD3DLight[LIGHT_NUM];
14. } m_kLightData;
15.  
16.  
17.  
18. void CStateManager::SetLight(DWORD index, CONST D3DLIGHT9* pLight)
19. {
20.         assert(index<SLightData::LIGHT_NUM);
21.         m_kLightData.m_akD3DLight[index]=*pLight;
22.  
23.         m_lpD3DDev->SetLight(index, pLight);
24. }
25.  
26. void CStateManager::GetLight(DWORD index, D3DLIGHT9* pLight)
27. {
28.         assert(index<8);
29.         *pLight=m_kLightData.m_akD3DLight[index];
30. }
31.  
32. bool CStateManager::BeginScene()
33. {
34.         m_bScene=true;
35.  
36.         D3DXMATRIX m4Proj;
37.         D3DXMATRIX m4View;
38.         D3DXMATRIX m4World;
39.         GetTransform(D3DTS_WORLD, &m4World);
40.         GetTransform(D3DTS_PROJECTION, &m4Proj);
41.         GetTransform(D3DTS_VIEW, &m4View);
42.         SetTransform(D3DTS_WORLD, &m4World);
43.         SetTransform(D3DTS_PROJECTION, &m4Proj);
44.         SetTransform(D3DTS_VIEW, &m4View);
45.  
46.         if (FAILED(m_lpD3DDev->BeginScene()))
47.                 return false;
48.         return true;
49. }
50.  
51. void CStateManager::EndScene()
52. {
53.         m_lpD3DDev->EndScene();
54.         m_bScene=false;
55. }
56.  
57. CStateManager::CStateManager(LPDIRECT3DDEVICE9 lpDevice) : m_lpD3DDev(NULL)
58. {
59.         m_bScene = false;
60.         m_dwBestMinFilter = D3DTEXF_LINEAR;
61.         m_dwBestMagFilter = D3DTEXF_LINEAR;
62.         SetDevice(lpDevice);
63. }
64.  
65. CStateManager::~CStateManager()
66. {
67.         if (m_lpD3DDev)
68.         {
69.                 m_lpD3DDev->Release();
70.                 m_lpD3DDev = NULL;
71.         }
72. }
73.  
74. void CStateManager::SetDevice(LPDIRECT3DDEVICE9 lpDevice)
75. {
76.         StateManager_Assert(lpDevice);
77.         lpDevice->AddRef();
78.  
79.         if (m_lpD3DDev)
80.         {
81.                 m_lpD3DDev->Release();
82.                 m_lpD3DDev = NULL;
83.         }
84.  
85.         m_lpD3DDev = lpDevice;
86.  
87.         D3DCAPS9 d3dCaps;
88.         m_lpD3DDev->GetDeviceCaps(&d3dCaps);
89.  
90.         if (d3dCaps.TextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
91.                 m_dwBestMagFilter = D3DTEXF_ANISOTROPIC;
92.         else
93.                 m_dwBestMagFilter = D3DTEXF_LINEAR;
94.  
95.         if (d3dCaps.TextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
96.                 m_dwBestMinFilter = D3DTEXF_ANISOTROPIC;
97.         else
98.                 m_dwBestMinFilter = D3DTEXF_LINEAR;
99.  
100.         DWORD dwMax = d3dCaps.MaxAnisotropy;
101.         dwMax = dwMax < 4 ? dwMax : 4;
102.  
103.         for (int i = 0; i < 8; ++i)
104.                 m_lpD3DDev->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, dwMax);
105.  
106.         SetDefaultState();
107. }
108.  
109. void CStateManager::SetBestFiltering(DWORD dwStage)
110. {
111.         SetSamplerState(dwStage, D3DSAMP_MINFILTER,     m_dwBestMinFilter);
112.         SetSamplerState(dwStage, D3DSAMP_MAGFILTER, m_dwBestMagFilter);
113.         SetSamplerState(dwStage, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
114. }
115.  
116. void CStateManager::Restore()
117. {
118.         int i, j;
119.  
120.         m_bForce = true;
121.  
122.         for (i = 0; i < STATEMANAGER_MAX_RENDERSTATES; ++i)
123.                 SetRenderState(D3DRENDERSTATETYPE(i), m_CurrentState.m_RenderStates[i]);
124.  
125.         for (i = 0; i < STATEMANAGER_MAX_STAGES; ++i)
126.                 for (j = 0; j < STATEMANAGER_MAX_TEXTURESTATES; ++j)
127.                 {
128.                         SetTextureStageState(i, D3DTEXTURESTAGESTATETYPE(j), m_CurrentState.m_TextureStates[i][j]);
129.                         SetTextureStageState(i, D3DTEXTURESTAGESTATETYPE(j), m_CurrentState.m_SamplerStates[i][j]);
130.                 }
131.  
132.         for (i = 0; i < STATEMANAGER_MAX_STAGES; ++i)
133.                 SetTexture(i, m_CurrentState.m_Textures[i]);
134.  
135.         m_bForce = false;
136. }
137.  
138. void CStateManager::SetDefaultState()
139. {
140.         m_CurrentState.ResetState();
141.         m_CopyState.ResetState();
142.         m_ChipState.ResetState();
143.  
144.         m_bScene = false;
145.         m_bForce = true;
146.  
147.         D3DXMATRIX Identity;
148.         D3DXMatrixIdentity(&Identity);
149.  
150.         SetTransform(D3DTS_WORLD, &Identity);
151.         SetTransform(D3DTS_VIEW, &Identity);
152.         SetTransform(D3DTS_PROJECTION, &Identity);
153.  
154.         D3DMATERIAL9 DefaultMat;
155.         ZeroMemory(&DefaultMat, sizeof(D3DMATERIAL9));
156.  
157.         DefaultMat.Diffuse.r = 1.0f;
158.         DefaultMat.Diffuse.g = 1.0f;
159.         DefaultMat.Diffuse.b = 1.0f;
160.         DefaultMat.Diffuse.a = 1.0f;
161.         DefaultMat.Ambient.r = 1.0f;
162.         DefaultMat.Ambient.g = 1.0f;
163.         DefaultMat.Ambient.b = 1.0f;
164.         DefaultMat.Ambient.a = 1.0f;
165.         DefaultMat.Emissive.r = 0.0f;
166.         DefaultMat.Emissive.g = 0.0f;
167.         DefaultMat.Emissive.b = 0.0f;
168.         DefaultMat.Emissive.a = 0.0f;
169.         DefaultMat.Specular.r = 0.0f;
170.         DefaultMat.Specular.g = 0.0f;
171.         DefaultMat.Specular.b = 0.0f;
172.         DefaultMat.Specular.a = 0.0f;
173.         DefaultMat.Power = 0.0f;
174.  
175.         SetMaterial(&DefaultMat);
176.  
177.         SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
178.         SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
179.         SetRenderState(D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
180.         SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
181.  
182.         SetRenderState(D3DRS_LASTPIXEL, FALSE);
183.         SetRenderState(D3DRS_ALPHAREF, 1);
184.         SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);
185.         SetRenderState(D3DRS_FOGSTART, 0);
186.         SetRenderState(D3DRS_FOGEND, 0);
187.         SetRenderState(D3DRS_FOGDENSITY, 0);
188.         SetRenderState(D3DRS_STENCILWRITEMASK, 0xFFFFFFFF);
189.         SetRenderState(D3DRS_AMBIENT, 0x00000000);
190.         SetRenderState(D3DRS_LOCALVIEWER, FALSE);
191.         SetRenderState(D3DRS_NORMALIZENORMALS, FALSE);
192.         SetRenderState(D3DRS_VERTEXBLEND, D3DVBF_DISABLE);
193.         SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
194.         SaveVertexProcessing(FALSE);
195.         SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, FALSE);
196.         SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
197.         SetRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE);
198.         SetRenderState(D3DRS_COLORWRITEENABLE, 0xFFFFFFFF);
199.         SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
200.         SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
201.         SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
202.         SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
203.         SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
204.         SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
205.         SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
206.         SetRenderState(D3DRS_FOGENABLE, FALSE);
207.         SetRenderState(D3DRS_FOGCOLOR, 0xFF000000);
208.         SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
209.         SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
210.         SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
211.         SetRenderState(D3DRS_ZENABLE, TRUE);
212.         SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
213.         SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
214.         SetRenderState(D3DRS_DITHERENABLE, TRUE);
215.         SetRenderState(D3DRS_STENCILENABLE, FALSE);
216.         SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
217.         SetRenderState(D3DRS_CLIPPING, TRUE);
218.         SetRenderState(D3DRS_LIGHTING, FALSE);
219.         SetRenderState(D3DRS_SPECULARENABLE, FALSE);
220.         SetRenderState(D3DRS_COLORVERTEX, FALSE);
221.         SetRenderState(D3DRS_WRAP0, 0);
222.         SetRenderState(D3DRS_WRAP1, 0);
223.         SetRenderState(D3DRS_WRAP2, 0);
224.         SetRenderState(D3DRS_WRAP3, 0);
225.         SetRenderState(D3DRS_WRAP4, 0);
226.         SetRenderState(D3DRS_WRAP5, 0);
227.         SetRenderState(D3DRS_WRAP6, 0);
228.         SetRenderState(D3DRS_WRAP7, 0);
229.  
230.         SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
231.         SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
232.         SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
233.         SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
234.         SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
235.         SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
236.  
237.         SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
238.         SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
239.         SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
240.         SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
241.         SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
242.         SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
243.  
244.         SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
245.         SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_TEXTURE);
246.         SetTextureStageState(2, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
247.         SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
248.         SetTextureStageState(2, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
249.         SetTextureStageState(2, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
250.  
251.         SetTextureStageState(3, D3DTSS_COLOROP, D3DTOP_DISABLE);
252.         SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_TEXTURE);
253.         SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
254.         SetTextureStageState(3, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
255.         SetTextureStageState(3, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
256.         SetTextureStageState(3, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
257.  
258.         SetTextureStageState(4, D3DTSS_COLOROP, D3DTOP_DISABLE);
259.         SetTextureStageState(4, D3DTSS_COLORARG1, D3DTA_TEXTURE);
260.         SetTextureStageState(4, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
261.         SetTextureStageState(4, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
262.         SetTextureStageState(4, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
263.         SetTextureStageState(4, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
264.  
265.         SetTextureStageState(5, D3DTSS_COLOROP, D3DTOP_DISABLE);
266.         SetTextureStageState(5, D3DTSS_COLORARG1, D3DTA_TEXTURE);
267.         SetTextureStageState(5, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
268.         SetTextureStageState(5, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
269.         SetTextureStageState(5, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
270.         SetTextureStageState(5, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
271.  
272.         SetTextureStageState(6, D3DTSS_COLOROP, D3DTOP_DISABLE);
273.         SetTextureStageState(6, D3DTSS_COLORARG1, D3DTA_TEXTURE);
274.         SetTextureStageState(6, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
275.         SetTextureStageState(6, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
276.         SetTextureStageState(6, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
277.         SetTextureStageState(6, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
278.  
279.         SetTextureStageState(7, D3DTSS_COLOROP, D3DTOP_DISABLE);
280.         SetTextureStageState(7, D3DTSS_COLORARG1, D3DTA_TEXTURE);
281.         SetTextureStageState(7, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
282.         SetTextureStageState(7, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
283.         SetTextureStageState(7, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
284.         SetTextureStageState(7, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
285.  
286.         SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
287.         SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
288.         SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, 2);
289.         SetTextureStageState(3, D3DTSS_TEXCOORDINDEX, 3);
290.         SetTextureStageState(4, D3DTSS_TEXCOORDINDEX, 4);
291.         SetTextureStageState(5, D3DTSS_TEXCOORDINDEX, 5);
292.         SetTextureStageState(6, D3DTSS_TEXCOORDINDEX, 6);
293.         SetTextureStageState(7, D3DTSS_TEXCOORDINDEX, 7);
294.  
295.         SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
296.         SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
297.         SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
298.  
299.         SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
300.         SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
301.         SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
302.  
303.         SetSamplerState(2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
304.         SetSamplerState(2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
305.         SetSamplerState(2, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
306.  
307.         SetSamplerState(3, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
308.         SetSamplerState(3, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
309.         SetSamplerState(3, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
310.  
311.         SetSamplerState(4, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
312.         SetSamplerState(4, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
313.         SetSamplerState(4, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
314.  
315.         SetSamplerState(5, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
316.         SetSamplerState(5, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
317.         SetSamplerState(5, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
318.  
319.         SetSamplerState(6, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
320.         SetSamplerState(6, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
321.         SetSamplerState(6, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
322.  
323.         SetSamplerState(7, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
324.         SetSamplerState(7, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
325.         SetSamplerState(7, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
326.  
327.         SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
328.         SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
329.         SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
330.         SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
331.         SetSamplerState(2, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
332.         SetSamplerState(2, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
333.         SetSamplerState(3, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
334.         SetSamplerState(3, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
335.         SetSamplerState(4, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
336.         SetSamplerState(4, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
337.         SetSamplerState(5, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
338.         SetSamplerState(5, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
339.         SetSamplerState(6, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
340.         SetSamplerState(6, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
341.         SetSamplerState(7, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
342.         SetSamplerState(7, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
343.  
344.         SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
345.         SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
346.         SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
347.         SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
348.         SetTextureStageState(4, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
349.         SetTextureStageState(5, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
350.         SetTextureStageState(6, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
351.         SetTextureStageState(7, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
352.  
353.         SetTexture(0, NULL);
354.         SetTexture(1, NULL);
355.         SetTexture(2, NULL);
356.         SetTexture(3, NULL);
357.         SetTexture(4, NULL);
358.         SetTexture(5, NULL);
359.         SetTexture(6, NULL);
360.         SetTexture(7, NULL);
361.  
362.         SetPixelShader(0);
363.         SetFVF(D3DFVF_XYZ);
364.  
365.         D3DXVECTOR4 av4Null[STATEMANAGER_MAX_VCONSTANTS];
366.         memset(av4Null, 0, sizeof(av4Null));
367.         SetVertexShaderConstant(0, av4Null, STATEMANAGER_MAX_VCONSTANTS);
368.         SetPixelShaderConstant(0, av4Null, STATEMANAGER_MAX_PCONSTANTS);
369.  
370.         m_bForce = false;
371.  
372. #ifdef _DEBUG
373.         int i, j;
374.         for (i = 0; i < STATEMANAGER_MAX_RENDERSTATES; i++)
375.                 m_bRenderStateSavingFlag[i] = FALSE;
376.  
377.         for (j = 0; j < STATEMANAGER_MAX_TRANSFORMSTATES; j++)
378.                 m_bTransformSavingFlag[j] = FALSE;
379.  
380.         for (j = 0; j < STATEMANAGER_MAX_STAGES; ++j)
381.                 for (i = 0; i < STATEMANAGER_MAX_TEXTURESTATES; ++i)
382.                 {
383.                         m_bTextureStageStateSavingFlag[j][i] = FALSE;
384.                         m_bSamplerStateSavingFlag[j][i] = FALSE;
385.                 }
386. #endif _DEBUG
387. }
388.  
389. // Material
390. void CStateManager::SaveMaterial()
391. {
392.         m_CopyState.m_D3DMaterial = m_CurrentState.m_D3DMaterial;
393. }
394.  
395. void CStateManager::SaveMaterial(const D3DMATERIAL9 * pMaterial)
396. {
397.         // Check that we have set this up before, if not, the default is this.
398.         m_CopyState.m_D3DMaterial = m_CurrentState.m_D3DMaterial;
399.         SetMaterial(pMaterial);
400. }
401.  
402. void CStateManager::RestoreMaterial()
403. {
404.         SetMaterial(&m_CopyState.m_D3DMaterial);
405. }
406.  
407. void CStateManager::SetMaterial(const D3DMATERIAL9 * pMaterial)
408. {
409.         m_lpD3DDev->SetMaterial(pMaterial);
410.         m_CurrentState.m_D3DMaterial = *pMaterial;
411. }
412.  
413. void CStateManager::GetMaterial(D3DMATERIAL9 * pMaterial)
414. {
415.         // Set the renderstate and remember it.
416.         *pMaterial = m_CurrentState.m_D3DMaterial;
417. }
418.  
419. // Renderstates
420. DWORD CStateManager::GetRenderState(D3DRENDERSTATETYPE Type)
421. {
422.         return m_CurrentState.m_RenderStates[Type];
423. }
424.  
425. void CStateManager::SaveRenderState(D3DRENDERSTATETYPE Type, DWORD dwValue)
426. {
427. #ifdef _DEBUG
428.         if (m_bRenderStateSavingFlag[Type])
429.         {
430.                 Tracef(" CStateManager::SaveRenderState - This render state is already saved [%d, %d]\n", Type, dwValue);
431.                 StateManager_Assert(!" This render state is already saved!");
432.         }
433.         m_bRenderStateSavingFlag[Type] = TRUE;
434. #endif _DEBUG
435.  
436.         // Check that we have set this up before, if not, the default is this.
437.         m_CopyState.m_RenderStates[Type] = m_CurrentState.m_RenderStates[Type];
438.         SetRenderState(Type, dwValue);
439. }
440.  
441. void CStateManager::RestoreRenderState(D3DRENDERSTATETYPE Type)
442. {
443. #ifdef _DEBUG
444.         if (!m_bRenderStateSavingFlag[Type])
445.         {
446.                 Tracef(" CStateManager::SaveRenderState - This render state was not saved [%d, %d]\n", Type);
447.                 StateManager_Assert(!" This render state was not saved!");
448.         }
449.         m_bRenderStateSavingFlag[Type] = FALSE;
450. #endif _DEBUG
451.  
452.         SetRenderState(Type, m_CopyState.m_RenderStates[Type]);
453. }
454.  
455. void CStateManager::SetRenderState(D3DRENDERSTATETYPE Type, DWORD Value)
456. {
457.         if (m_CurrentState.m_RenderStates[Type] == Value)
458.                 return;
459.  
460.         m_lpD3DDev->SetRenderState(Type, Value);
461.         m_CurrentState.m_RenderStates[Type] = Value;
462. }
463.  
464. void CStateManager::GetRenderState(D3DRENDERSTATETYPE Type, DWORD * pdwValue)
465. {
466.         *pdwValue = m_CurrentState.m_RenderStates[Type];
467. }
468.  
469. // Textures
470. void CStateManager::SaveTexture(DWORD dwStage, LPDIRECT3DBASETEXTURE9 pTexture)
471. {
472.         // Check that we have set this up before, if not, the default is this.
473.         m_CopyState.m_Textures[dwStage] = m_CurrentState.m_Textures[dwStage];
474.         SetTexture(dwStage, pTexture);
475. }
476.  
477. void CStateManager::RestoreTexture(DWORD dwStage)
478. {
479.         SetTexture(dwStage, m_CopyState.m_Textures[dwStage]);
480. }
481.  
482. void CStateManager::SetTexture(DWORD dwStage, LPDIRECT3DBASETEXTURE9 pTexture)
483. {
484.         if (pTexture == m_CurrentState.m_Textures[dwStage])
485.                 return;
486.  
487.         m_lpD3DDev->SetTexture(dwStage, pTexture);
488.         m_CurrentState.m_Textures[dwStage] = pTexture;
489. }
490.  
491. void CStateManager::GetTexture(DWORD dwStage, LPDIRECT3DBASETEXTURE9 * ppTexture)
492. {
493.         *ppTexture = m_CurrentState.m_Textures[dwStage];
494. }
495.  
496. // Texture stage states
497. void CStateManager::SaveTextureStageState(DWORD dwStage,D3DTEXTURESTAGESTATETYPE Type, DWORD dwValue)
498. {
499.         // Check that we have set this up before, if not, the default is this.
500. #ifdef _DEBUG
501.         if (m_bTextureStageStateSavingFlag[dwStage][Type])
502.         {
503.                 Tracef(" CStateManager::SaveTextureStageState - This texture stage state is already saved [%d, %d]\n", dwStage, Type);
504.                 StateManager_Assert(!" This texture stage state is already saved!");
505.         }
506.         m_bTextureStageStateSavingFlag[dwStage][Type] = TRUE;
507. #endif _DEBUG
508.         m_CopyState.m_TextureStates[dwStage][Type] = m_CurrentState.m_TextureStates[dwStage][Type];
509.         SetTextureStageState(dwStage, Type, dwValue);
510. }
511.  
512. void CStateManager::RestoreTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE Type)
513. {
514. #ifdef _DEBUG
515.         if (!m_bTextureStageStateSavingFlag[dwStage][Type])
516.         {
517.                 Tracef(" CStateManager::RestoreTextureStageState - This texture stage state was not saved [%d, %d]\n", dwStage, Type);
518.                 StateManager_Assert(!" This texture stage state was not saved!");
519.         }
520.         m_bTextureStageStateSavingFlag[dwStage][Type] = FALSE;
521. #endif _DEBUG
522.         SetTextureStageState(dwStage, Type, m_CopyState.m_TextureStates[dwStage][Type]);
523. }
524.  
525. void CStateManager::SetTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE Type, DWORD dwValue)
526. {
527.         if (m_CurrentState.m_TextureStates[dwStage][Type] == dwValue)
528.                 return;
529.  
530.         m_lpD3DDev->SetTextureStageState(dwStage, Type, dwValue);
531.         m_CurrentState.m_TextureStates[dwStage][Type] = dwValue;
532. }
533.  
534. void CStateManager::GetTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE Type, DWORD * pdwValue)
535. {
536.         *pdwValue = m_CurrentState.m_TextureStates[dwStage][Type];
537. }
538.  
539. // Sampler states
540. void CStateManager::SaveSamplerState(DWORD dwStage, D3DSAMPLERSTATETYPE Type, DWORD dwValue)
541. {
542. #ifdef _DEBUG
543.         if (m_bSamplerStateSavingFlag[dwStage][Type])
544.         {
545.                 Tracef(" CStateManager::SaveTextureStageState - This texture stage state is already saved [%d, %d]\n", dwStage, Type);
546.                 StateManager_Assert(!" This texture stage state is already saved!");
547.         }
548.         m_bSamplerStateSavingFlag[dwStage][Type] = TRUE;
549. #endif _DEBUG
550.         m_CopyState.m_SamplerStates[dwStage][Type] = m_CurrentState.m_SamplerStates[dwStage][Type];
551.         SetSamplerState(dwStage, Type, dwValue);
552. }
553. void CStateManager::RestoreSamplerState(DWORD dwStage, D3DSAMPLERSTATETYPE Type)
554. {
555. #ifdef _DEBUG
556.         if (!m_bSamplerStateSavingFlag[dwStage][Type])
557.         {
558.                 Tracef(" CStateManager::RestoreTextureStageState - This texture stage state was not saved [%d, %d]\n", dwStage, Type);
559.                 StateManager_Assert(!" This texture stage state was not saved!");
560.         }
561.         m_bSamplerStateSavingFlag[dwStage][Type] = FALSE;
562. #endif _DEBUG
563.         SetSamplerState(dwStage, Type, m_CopyState.m_SamplerStates[dwStage][Type]);
564. }
565. void CStateManager::SetSamplerState(DWORD dwStage, D3DSAMPLERSTATETYPE Type, DWORD dwValue)
566. {
567.         if (m_CurrentState.m_SamplerStates[dwStage][Type] == dwValue)
568.                 return;
569.         m_lpD3DDev->SetSamplerState(dwStage, Type, dwValue);
570.         m_CurrentState.m_SamplerStates[dwStage][Type] = dwValue;
571. }
572. void CStateManager::GetSamplerState(DWORD dwStage, D3DSAMPLERSTATETYPE Type, DWORD * pdwValue)
573. {
574.         *pdwValue = m_CurrentState.m_SamplerStates[dwStage][Type];
575. }
576. // Vertex Shader
577. void CStateManager::SaveVertexShader(LPDIRECT3DVERTEXSHADER9 dwShader)
578. {
579.         m_CopyState.m_dwVertexShader = m_CurrentState.m_dwVertexShader;
580.         SetVertexShader(dwShader);
581. }
582.  
583. void CStateManager::RestoreVertexShader()
584. {
585.         SetVertexShader(m_CopyState.m_dwVertexShader);
586. }
587.  
588. void CStateManager::SetVertexShader(LPDIRECT3DVERTEXSHADER9 dwShader)
589. {
590.         //if (m_CurrentState.m_dwVertexShader == dwShader)
591.         //      return;
592.  
593.         m_lpD3DDev->SetVertexShader(dwShader);
594.         m_CurrentState.m_dwVertexShader = dwShader;
595. }
596.  
597. void CStateManager::GetVertexShader(LPDIRECT3DVERTEXSHADER9 * pdwShader)
598. {
599.         *pdwShader = m_CurrentState.m_dwVertexShader;
600. }
601.  
602. // Vertex Processing
603. void CStateManager::SaveVertexProcessing(BOOL IsON)
604. {
605.         if (m_CurrentState.m_bVertexProcessing = IsON)
606.                 return;
607.         m_CopyState.m_bVertexProcessing = m_CurrentState.m_bVertexProcessing;
608.         m_lpD3DDev->SetSoftwareVertexProcessing(IsON);
609.         m_CurrentState.m_bVertexProcessing = IsON;
610. }
611. void CStateManager::RestoreVertexProcessing()
612. {
613.         if (m_CopyState.m_bVertexProcessing = m_CurrentState.m_bVertexProcessing)
614.                 return;
615.         m_lpD3DDev->SetSoftwareVertexProcessing(m_CopyState.m_bVertexProcessing);
616. }
617. // Vertex Declaration
618. void CStateManager::SaveVertexDeclaration(LPDIRECT3DVERTEXDECLARATION9 dwShader)
619. {
620.         m_CopyState.m_dwVertexDeclaration = m_CurrentState.m_dwVertexDeclaration;
621.         SetVertexDeclaration(dwShader);
622. }
623. void CStateManager::RestoreVertexDeclaration()
624. {
625.         SetVertexDeclaration(m_CopyState.m_dwVertexDeclaration);
626. }
627. void CStateManager::SetVertexDeclaration(LPDIRECT3DVERTEXDECLARATION9 dwShader)
628. {
629.         //if (m_CurrentState.m_dwVertexDeclaration == dwShader)
630.         //      return;
631.         m_lpD3DDev->SetVertexDeclaration(dwShader);
632.         m_CurrentState.m_dwVertexDeclaration = dwShader;
633. }
634. void CStateManager::GetVertexDeclaration(LPDIRECT3DVERTEXDECLARATION9 * pdwShader)
635. {
636.         *pdwShader = m_CurrentState.m_dwVertexDeclaration;
637. }
638. // FVF
639. void CStateManager::SaveFVF(DWORD dwShader)
640. {
641.         m_CopyState.m_dwFVF = m_CurrentState.m_dwFVF;
642.         SetFVF(dwShader);
643. }
644. void CStateManager::RestoreFVF()
645. {
646.         SetFVF(m_CopyState.m_dwFVF);
647. }
648. void CStateManager::SetFVF(DWORD dwShader)
649. {
650.         //if (m_CurrentState.m_dwFVF == dwShader)
651.         //      return;
652.         m_lpD3DDev->SetFVF(dwShader);
653.         m_CurrentState.m_dwFVF = dwShader;
654. }
655. void CStateManager::GetFVF(DWORD * pdwShader)
656. {
657.         *pdwShader = m_CurrentState.m_dwFVF;
658. }
659. // Pixel Shader
660. void CStateManager::SavePixelShader(LPDIRECT3DPIXELSHADER9 dwShader)
661. {
662.         m_CopyState.m_dwPixelShader = m_CurrentState.m_dwPixelShader;
663.         SetPixelShader(dwShader);
664. }
665.  
666. void CStateManager::RestorePixelShader()
667. {
668.         SetPixelShader(m_CopyState.m_dwPixelShader);
669. }
670.  
671. void CStateManager::SetPixelShader(LPDIRECT3DPIXELSHADER9 dwShader)
672. {
673.         if (m_CurrentState.m_dwPixelShader == dwShader)
674.                 return;
675.  
676.         m_lpD3DDev->SetPixelShader(dwShader);
677.         m_CurrentState.m_dwPixelShader = dwShader;
678. }
679.  
680. void CStateManager::GetPixelShader(LPDIRECT3DPIXELSHADER9* pdwShader)
681. {
682.         *pdwShader = m_CurrentState.m_dwPixelShader;
683. }
684.  
685. // *** These states are cached, but not protected from multiple sends of the same value.
686. // Transform
687. void CStateManager::SaveTransform(D3DTRANSFORMSTATETYPE Type, const D3DMATRIX* pMatrix)
688. {
689. #ifdef _DEBUG
690.         if (m_bTransformSavingFlag[Type])
691.         {
692.                 Tracef(" CStateManager::SaveTransform - This transform is already saved [%d]\n", Type);
693.                 StateManager_Assert(!" This trasform is already saved!");
694.         }
695.         m_bTransformSavingFlag[Type] = TRUE;
696. #endif _DEBUG
697.  
698.         m_CopyState.m_Matrices[Type] = m_CurrentState.m_Matrices[Type];
699.         SetTransform(Type, (D3DXMATRIX *)pMatrix);
700. }
701.  
702. void CStateManager::RestoreTransform(D3DTRANSFORMSTATETYPE Type)
703. {
704. #ifdef _DEBUG
705.         if (!m_bTransformSavingFlag[Type])
706.         {
707.                 Tracef(" CStateManager::RestoreTransform - This transform was not saved [%d]\n", Type);
708.                 StateManager_Assert(!" This render state was not saved!");
709.         }
710.         m_bTransformSavingFlag[Type] = FALSE;
711. #endif _DEBUG
712.  
713.         SetTransform(Type, &m_CopyState.m_Matrices[Type]);
714. }
715.  
716. // Don't cache-check the transform.  To much to do
717. void CStateManager::SetTransform(D3DTRANSFORMSTATETYPE Type, const D3DMATRIX* pMatrix)
718. {
719.         if (m_bScene)
720.         {
721.                 m_lpD3DDev->SetTransform(Type, pMatrix);
722.         }
723.         else
724.         {
725.                 assert(D3DTS_VIEW==Type || D3DTS_PROJECTION==Type || D3DTS_WORLD==Type);
726.         }
727.  
728.         m_CurrentState.m_Matrices[Type] = *pMatrix;
729. }
730.  
731. void CStateManager::GetTransform(D3DTRANSFORMSTATETYPE Type, D3DMATRIX * pMatrix)
732. {
733.         *pMatrix = m_CurrentState.m_Matrices[Type];
734. }
735.  
736. // SetVertexShaderConstant
737. void CStateManager::SaveVertexShaderConstant(DWORD dwRegister,CONST void* pConstantData,DWORD dwConstantCount)
738. {
739.         DWORD i;
740.  
741.         for (i = 0; i < dwConstantCount; i++)
742.         {
743.                 StateManager_Assert((dwRegister + i) < STATEMANAGER_MAX_VCONSTANTS);
744.                 m_CopyState.m_VertexShaderConstants[dwRegister + i] = m_CurrentState.m_VertexShaderConstants[dwRegister + i];
745.         }
746.  
747.         SetVertexShaderConstant(dwRegister, pConstantData, dwConstantCount);
748. }
749.  
750. void CStateManager::RestoreVertexShaderConstant(DWORD dwRegister, DWORD dwConstantCount)
751. {
752.         SetVertexShaderConstant(dwRegister, &m_CopyState.m_VertexShaderConstants[dwRegister], dwConstantCount);
753. }
754.  
755. void CStateManager::SetVertexShaderConstant(DWORD dwRegister,CONST void* pConstantData,DWORD dwConstantCount)
756. {
757.         m_lpD3DDev->SetVertexShaderConstantF(dwRegister, (const float*)pConstantData, dwConstantCount);
758.  
759.         // Set the renderstate and remember it.
760.         for (DWORD i = 0; i < dwConstantCount; i++)
761.         {
762.                 StateManager_Assert((dwRegister + i) < STATEMANAGER_MAX_VCONSTANTS);
763.                 m_CurrentState.m_VertexShaderConstants[dwRegister + i] = *(((D3DXVECTOR4*)pConstantData) + i);
764.         }
765. }
766.  
767. // SetPixelShaderConstant
768. void CStateManager::SavePixelShaderConstant(DWORD dwRegister,CONST void* pConstantData,DWORD dwConstantCount)
769. {
770.         DWORD i;
771.  
772.         for (i = 0; i < dwConstantCount; i++)
773.         {
774.                 StateManager_Assert((dwRegister + i) < STATEMANAGER_MAX_VCONSTANTS);
775.                 m_CopyState.m_PixelShaderConstants[dwRegister + i] = *(((D3DXVECTOR4*)pConstantData) + i);
776.         }
777.  
778.         SetPixelShaderConstant(dwRegister, pConstantData, dwConstantCount);
779. }
780.  
781. void CStateManager::RestorePixelShaderConstant(DWORD dwRegister, DWORD dwConstantCount)
782. {
783.         SetPixelShaderConstant(dwRegister, &m_CopyState.m_PixelShaderConstants[dwRegister], dwConstantCount);
784. }
785.  
786. void CStateManager::SetPixelShaderConstant(DWORD dwRegister,CONST void* pConstantData,DWORD dwConstantCount)
787. {
788.         m_lpD3DDev->SetVertexShaderConstantF(dwRegister, *(D3DXVECTOR4*)pConstantData, dwConstantCount);
789.  
790.         // Set the renderstate and remember it.
791.         for (DWORD i = 0; i < dwConstantCount; i++)
792.         {
793.                 StateManager_Assert((dwRegister + i) < STATEMANAGER_MAX_VCONSTANTS);
794.                 m_CurrentState.m_PixelShaderConstants[dwRegister + i] = *(((D3DXVECTOR4*)pConstantData) + i);
795.         }
796. }
797.  
798. void CStateManager::SaveStreamSource(UINT StreamNumber, LPDIRECT3DVERTEXBUFFER9 pStreamData,UINT Stride)
799. {
800.         // Check that we have set this up before, if not, the default is this.
801.         m_CopyState.m_StreamData[StreamNumber] = m_CurrentState.m_StreamData[StreamNumber];
802.         SetStreamSource(StreamNumber, pStreamData, Stride);
803. }
804.  
805. void CStateManager::RestoreStreamSource(UINT StreamNumber)
806. {
807.         SetStreamSource(StreamNumber,
808.                                         m_CopyState.m_StreamData[StreamNumber].m_lpStreamData,
809.                                         m_CopyState.m_StreamData[StreamNumber].m_Stride);
810. }
811.  
812. void CStateManager::SetStreamSource(UINT StreamNumber, LPDIRECT3DVERTEXBUFFER9 pStreamData, UINT Stride)
813. {
814.         CStreamData kStreamData(pStreamData, Stride);
815.         if (m_CurrentState.m_StreamData[StreamNumber] == kStreamData)
816.                 return;
817.  
818.         m_lpD3DDev->SetStreamSource(StreamNumber, pStreamData, 0, Stride);
819.         m_CurrentState.m_StreamData[StreamNumber] = kStreamData;
820. }
821.  
822. void CStateManager::SaveIndices(LPDIRECT3DINDEXBUFFER9 pIndexData, UINT BaseVertexIndex)
823. {
824.         m_CopyState.m_IndexData = m_CurrentState.m_IndexData;
825.         SetIndices(pIndexData, BaseVertexIndex);
826. }
827.  
828. void CStateManager::RestoreIndices()
829. {
830.         SetIndices(m_CopyState.m_IndexData.m_lpIndexData, m_CopyState.m_IndexData.m_BaseVertexIndex);
831. }
832.  
833. void CStateManager::SetIndices(LPDIRECT3DINDEXBUFFER9 pIndexData, UINT BaseVertexIndex)
834. {
835.         CIndexData kIndexData(pIndexData, BaseVertexIndex);
836.  
837.         if (m_CurrentState.m_IndexData == kIndexData)
838.                 return;
839.        
840.         m_lpD3DDev->SetIndices(pIndexData);
841.         m_CurrentState.m_IndexData = kIndexData;
842. }
843.  
844. HRESULT CStateManager::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount)
845. {
846.         return (m_lpD3DDev->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount));
847. }
848.  
849. HRESULT CStateManager::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, const void* pVertexStreamZeroData, UINT VertexStreamZeroStride)
850. {
851.         m_CurrentState.m_StreamData[0] = NULL;
852.         return (m_lpD3DDev->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride));
853. }
854.  
855. HRESULT CStateManager::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT minIndex, UINT NumVertices, UINT startIndex, UINT primCount)
856. {
857.         return (m_lpD3DDev->DrawIndexedPrimitive(PrimitiveType, minIndex, 0, NumVertices, startIndex, primCount));
858. }
859.  
860. HRESULT CStateManager::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount, CONST void * pIndexData, D3DFORMAT IndexDataFormat, CONST void * pVertexStreamZeroData, UINT VertexStreamZeroStride)
861. {
862.         m_CurrentState.m_IndexData = NULL;
863.         m_CurrentState.m_StreamData[0] = NULL;
864.         return (m_lpD3DDev->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride));
865. }
866.