• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //    http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include "Direct3DStateBlock8.hpp"
16 
17 #include "Direct3DDevice8.hpp"
18 #include "Direct3DBaseTexture8.hpp"
19 #include "Direct3DVertexBuffer8.hpp"
20 #include "Direct3DIndexBuffer8.hpp"
21 #include "Debug.hpp"
22 
23 #include <assert.h>
24 
25 namespace D3D8
26 {
Direct3DStateBlock8(Direct3DDevice8 * device,D3DSTATEBLOCKTYPE type)27 	Direct3DStateBlock8::Direct3DStateBlock8(Direct3DDevice8 *device, D3DSTATEBLOCKTYPE type) : device(device), type(type)
28 	{
29 		vertexShaderHandle = 0;
30 		pixelShaderHandle = 0;
31 		indexBuffer = 0;
32 
33 		for(int stream = 0; stream < 16; stream++)
34 		{
35 			streamSource[stream].vertexBuffer = 0;
36 		}
37 
38 		for(int stage = 0; stage < 8; stage++)
39 		{
40 			texture[stage] = 0;
41 		}
42 
43 		clear();
44 
45 		if(type == D3DSBT_PIXELSTATE || type == D3DSBT_ALL)
46 		{
47 			capturePixelRenderStates();
48 			capturePixelTextureStates();
49 			capturePixelShaderStates();
50 		}
51 
52 		if(type == D3DSBT_VERTEXSTATE || type == D3DSBT_ALL)
53 		{
54 			captureVertexRenderStates();
55 			captureVertexTextureStates();
56 			captureLightStates();
57 			captureVertexShaderStates();
58 		}
59 
60 		if(type == D3DSBT_ALL)   // Capture remaining states
61 		{
62 			captureTextures();
63 			captureVertexTextures();
64 			captureDisplacementTextures();
65 			captureTexturePalette();
66 			captureVertexStreams();
67 			captureIndexBuffer();
68 			captureViewport();
69 			captureTransforms();
70 			captureTextureTransforms();
71 			captureClippingPlanes();
72 			captureMaterial();
73 		}
74 	}
75 
~Direct3DStateBlock8()76 	Direct3DStateBlock8::~Direct3DStateBlock8()
77 	{
78 		clear();
79 	}
80 
QueryInterface(const IID & iid,void ** object)81 	long Direct3DStateBlock8::QueryInterface(const IID &iid, void **object)
82 	{
83 		TRACE("");
84 
85 		ASSERT(false);   // Internal object
86 
87 		return NOINTERFACE(iid);
88 	}
89 
AddRef()90 	unsigned long Direct3DStateBlock8::AddRef()
91 	{
92 		TRACE("");
93 
94 		return Unknown::AddRef();
95 	}
96 
Release()97 	unsigned long Direct3DStateBlock8::Release()
98 	{
99 		TRACE("");
100 
101 		return Unknown::Release();
102 	}
103 
Apply()104 	long Direct3DStateBlock8::Apply()
105 	{
106 		TRACE("");
107 
108 		if(vertexShaderCaptured)
109 		{
110 			device->SetVertexShader(vertexShaderHandle);
111 		}
112 
113 		if(pixelShaderCaptured)
114 		{
115 			device->SetPixelShader(pixelShaderHandle);
116 		}
117 
118 		if(indexBufferCaptured)
119 		{
120 			device->SetIndices(indexBuffer, baseVertexIndex);
121 		}
122 
123 		for(int state = 0; state < D3DRS_NORMALORDER + 1; state++)
124 		{
125 			if(renderStateCaptured[state])
126 			{
127 				device->SetRenderState((D3DRENDERSTATETYPE)state, renderState[state]);
128 			}
129 		}
130 
131 		for(int stage = 0; stage < 8; stage++)
132 		{
133 			for(int state = 0; state < D3DTSS_RESULTARG + 1; state++)
134 			{
135 				if(textureStageStateCaptured[stage][state])
136 				{
137 					device->SetTextureStageState(stage, (D3DTEXTURESTAGESTATETYPE)state, textureStageState[stage][state]);
138 				}
139 			}
140 		}
141 
142 		for(int stream = 0; stream < 16; stream++)
143 		{
144 			if(streamSourceCaptured[stream])
145 			{
146 				device->SetStreamSource(stream, streamSource[stream].vertexBuffer, streamSource[stream].stride);
147 			}
148 		}
149 
150 		for(int stage = 0; stage < 8; stage++)
151 		{
152 			if(textureCaptured[stage])
153 			{
154 				device->SetTexture(stage, texture[stage]);
155 			}
156 		}
157 
158 		for(int state = 0; state < 512; state++)
159 		{
160 			if(transformCaptured[state])
161 			{
162 				device->SetTransform((D3DTRANSFORMSTATETYPE)state, &transform[state]);
163 			}
164 		}
165 
166 		if(viewportCaptured)
167 		{
168 			device->SetViewport(&viewport);
169 		}
170 
171 		for(int index = 0; index < 6; index++)
172 		{
173 			if(clipPlaneCaptured[index])
174 			{
175 				device->SetClipPlane(index, clipPlane[index]);
176 			}
177 		}
178 
179 		return D3D_OK;
180 	}
181 
Capture()182 	long Direct3DStateBlock8::Capture()
183 	{
184 		TRACE("");
185 
186 		if(vertexShaderCaptured)
187 		{
188 			device->GetVertexShader(&vertexShaderHandle);
189 		}
190 
191 		if(pixelShaderCaptured)
192 		{
193 			device->GetPixelShader(&pixelShaderHandle);
194 		}
195 
196 		if(indexBufferCaptured)
197 		{
198 			if(indexBuffer)
199 			{
200 				indexBuffer->Release();
201 			}
202 
203 			device->GetIndices(reinterpret_cast<IDirect3DIndexBuffer8**>(&indexBuffer), &baseVertexIndex);
204 		}
205 
206 		for(int state = 0; state < D3DRS_NORMALORDER + 1; state++)
207 		{
208 			if(renderStateCaptured[state])
209 			{
210 				device->GetRenderState((D3DRENDERSTATETYPE)state, &renderState[state]);
211 			}
212 		}
213 
214 		for(int stage = 0; stage < 8; stage++)
215 		{
216 			for(int state = 0; state < D3DTSS_RESULTARG + 1; state++)
217 			{
218 				if(textureStageStateCaptured[stage][state])
219 				{
220 					device->GetTextureStageState(stage, (D3DTEXTURESTAGESTATETYPE)state, &textureStageState[stage][state]);
221 				}
222 			}
223 		}
224 
225 		for(int stream = 0; stream < 16; stream++)
226 		{
227 			if(streamSourceCaptured[stream])
228 			{
229 				if(streamSource[stream].vertexBuffer)
230 				{
231 					streamSource[stream].vertexBuffer->Release();
232 				}
233 
234 				device->GetStreamSource(stream, reinterpret_cast<IDirect3DVertexBuffer8**>(&streamSource[stream].vertexBuffer), &streamSource[stream].stride);
235 			}
236 		}
237 
238 		for(int stage = 0; stage < 8; stage++)
239 		{
240 			if(textureCaptured[stage])
241 			{
242 				if(texture[stage])
243 				{
244 					texture[stage]->Release();
245 				}
246 
247 				device->GetTexture(stage, reinterpret_cast<IDirect3DBaseTexture8**>(&texture[stage]));
248 			}
249 		}
250 
251 		for(int state = 0; state < 512; state++)
252 		{
253 			if(transformCaptured[state])
254 			{
255 				device->GetTransform((D3DTRANSFORMSTATETYPE)state, &transform[state]);
256 			}
257 		}
258 
259 		if(viewportCaptured)
260 		{
261 			device->GetViewport(&viewport);
262 		}
263 
264 		for(int index = 0; index < 6; index++)
265 		{
266 			if(clipPlaneCaptured[index])
267 			{
268 				device->GetClipPlane(index, clipPlane[index]);
269 			}
270 		}
271 
272 		return D3D_OK;
273 	}
274 
GetDevice(IDirect3DDevice8 ** device)275 	long Direct3DStateBlock8::GetDevice(IDirect3DDevice8 **device)
276 	{
277 		TRACE("");
278 
279 		if(!device)
280 		{
281 			return INVALIDCALL();
282 		}
283 
284 		this->device->AddRef();
285 		*device = this->device;
286 
287 		return D3D_OK;
288 	}
289 
lightEnable(unsigned long index,int enable)290 	void Direct3DStateBlock8::lightEnable(unsigned long index, int enable)
291 	{
292 		UNIMPLEMENTED();
293 	}
294 
setClipPlane(unsigned long index,const float * plane)295 	void Direct3DStateBlock8::setClipPlane(unsigned long index, const float *plane)
296 	{
297 		clipPlaneCaptured[index] = true;
298 		clipPlane[index][0] = plane[0];
299 		clipPlane[index][1] = plane[1];
300 		clipPlane[index][2] = plane[2];
301 		clipPlane[index][3] = plane[3];
302 	}
303 
setCurrentTexturePalette(unsigned int paletteNumber)304 	void Direct3DStateBlock8::setCurrentTexturePalette(unsigned int paletteNumber)
305 	{
306 		UNIMPLEMENTED();
307 	}
308 
setFVF(unsigned long FVF)309 	void Direct3DStateBlock8::setFVF(unsigned long FVF)
310 	{
311 		UNIMPLEMENTED();
312 	}
313 
setIndices(Direct3DIndexBuffer8 * indexData,unsigned int baseVertexIndex)314 	void Direct3DStateBlock8::setIndices(Direct3DIndexBuffer8 *indexData, unsigned int baseVertexIndex)
315 	{
316 		if(indexData) indexData->AddRef();
317 
318 		indexBufferCaptured = true;
319 		indexBuffer = indexData;
320 		this->baseVertexIndex = baseVertexIndex;
321 	}
322 
setLight(unsigned long index,const D3DLIGHT8 * light)323 	void Direct3DStateBlock8::setLight(unsigned long index, const D3DLIGHT8 *light)
324 	{
325 		UNIMPLEMENTED();
326 	}
327 
setMaterial(const D3DMATERIAL8 * material)328 	void Direct3DStateBlock8::setMaterial(const D3DMATERIAL8 *material)
329 	{
330 		UNIMPLEMENTED();
331 	}
332 
setPixelShader(unsigned long shaderHandle)333 	void Direct3DStateBlock8::setPixelShader(unsigned long shaderHandle)
334 	{
335 		pixelShaderCaptured = true;
336 		pixelShaderHandle = shaderHandle;
337 	}
338 
setPixelShaderConstant(unsigned int startRegister,const void * constantData,unsigned int count)339 	void Direct3DStateBlock8::setPixelShaderConstant(unsigned int startRegister, const void *constantData, unsigned int count)
340 	{
341 		UNIMPLEMENTED();
342 	}
343 
setRenderState(D3DRENDERSTATETYPE state,unsigned long value)344 	void Direct3DStateBlock8::setRenderState(D3DRENDERSTATETYPE state, unsigned long value)
345 	{
346 		renderStateCaptured[state] = true;
347 		renderState[state] = value;
348 	}
349 
setScissorRect(const RECT * rect)350 	void Direct3DStateBlock8::setScissorRect(const RECT *rect)
351 	{
352 		UNIMPLEMENTED();
353 	}
354 
setStreamSource(unsigned int stream,Direct3DVertexBuffer8 * data,unsigned int stride)355 	void Direct3DStateBlock8::setStreamSource(unsigned int stream, Direct3DVertexBuffer8 *data, unsigned int stride)
356 	{
357 		if(data) data->AddRef();
358 
359 		streamSourceCaptured[stream] = true;
360 		streamSource[stream].vertexBuffer = data;
361 		streamSource[stream].stride = stride;
362 	}
363 
setTexture(unsigned long stage,Direct3DBaseTexture8 * texture)364 	void Direct3DStateBlock8::setTexture(unsigned long stage, Direct3DBaseTexture8 *texture)
365 	{
366 		if(texture) texture->AddRef();
367 
368 		textureCaptured[stage] = true;
369 		this->texture[stage] = texture;
370 	}
371 
setTextureStageState(unsigned long stage,D3DTEXTURESTAGESTATETYPE type,unsigned long value)372 	void Direct3DStateBlock8::setTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long value)
373 	{
374 		textureStageStateCaptured[stage][type] = true;
375 		textureStageState[stage][type] = value;
376 	}
377 
setTransform(D3DTRANSFORMSTATETYPE state,const D3DMATRIX * matrix)378 	void Direct3DStateBlock8::setTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
379 	{
380 		transformCaptured[state] = true;
381 		transform[state] = *matrix;
382 	}
383 
setViewport(const D3DVIEWPORT8 * viewport)384 	void Direct3DStateBlock8::setViewport(const D3DVIEWPORT8 *viewport)
385 	{
386 		viewportCaptured = true;
387 		this->viewport = *viewport;
388 	}
389 
setVertexShader(unsigned long shaderHandle)390 	void Direct3DStateBlock8::setVertexShader(unsigned long shaderHandle)
391 	{
392 		vertexShaderCaptured = true;
393 		vertexShaderHandle = shaderHandle;
394 	}
395 
setVertexShaderConstant(unsigned int startRegister,const void * constantData,unsigned int count)396 	void Direct3DStateBlock8::setVertexShaderConstant(unsigned int startRegister, const void *constantData, unsigned int count)
397 	{
398 		UNIMPLEMENTED();
399 	}
400 
clear()401 	void Direct3DStateBlock8::clear()
402 	{
403 		// Erase capture flags
404 		vertexShaderCaptured = false;
405 		pixelShaderCaptured = false;
406 		indexBufferCaptured = false;
407 
408 		for(int state = 0; state < D3DRS_NORMALORDER + 1; state++)
409 		{
410 			renderStateCaptured[state] = false;
411 		}
412 
413 		for(int stage = 0; stage < 8; stage++)
414 		{
415 			for(int state = 0; state < D3DTSS_RESULTARG + 1; state++)
416 			{
417 				textureStageStateCaptured[stage][state] = false;
418 			}
419 		}
420 
421 		for(int stream = 0; stream < 16; stream++)
422 		{
423 			streamSourceCaptured[stream] = false;
424 		}
425 
426 		for(int stage = 0; stage < 8; stage++)
427 		{
428 			textureCaptured[stage] = false;
429 		}
430 
431 		for(int state = 0; state < 512; state++)
432 		{
433 			transformCaptured[state] = false;
434 		}
435 
436 		viewportCaptured = false;
437 
438 		for(int index = 0; index < 6; index++)
439 		{
440 			clipPlaneCaptured[index] = false;
441 		}
442 
443 		// Release resources
444 		vertexShaderHandle = 0;
445 		pixelShaderHandle = 0;
446 
447 		if(indexBuffer)
448 		{
449 			indexBuffer->Release();
450 			indexBuffer = 0;
451 		}
452 
453 		for(int stream = 0; stream < 16; stream++)
454 		{
455 			if(streamSource[stream].vertexBuffer)
456 			{
457 				streamSource[stream].vertexBuffer->Release();
458 				streamSource[stream].vertexBuffer = 0;
459 			}
460 		}
461 
462 		for(int stage = 0; stage < 8; stage++)
463 		{
464 			if(texture[stage])
465 			{
466 				texture[stage]->Release();
467 				texture[stage] = 0;
468 			}
469 		}
470 	}
471 
captureRenderState(D3DRENDERSTATETYPE state)472 	void Direct3DStateBlock8::captureRenderState(D3DRENDERSTATETYPE state)
473 	{
474 		device->GetRenderState(state, &renderState[state]);
475 		renderStateCaptured[state] = true;
476 	}
477 
captureTextureStageState(unsigned long stage,D3DTEXTURESTAGESTATETYPE type)478 	void Direct3DStateBlock8::captureTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type)
479 	{
480 		device->GetTextureStageState(stage, type, &textureStageState[stage][type]);
481 		textureStageStateCaptured[stage][type] = true;
482 	}
483 
captureTransform(D3DTRANSFORMSTATETYPE state)484 	void Direct3DStateBlock8::captureTransform(D3DTRANSFORMSTATETYPE state)
485 	{
486 		device->GetTransform(state, &transform[state]);
487 		transformCaptured[state] = true;
488 	}
489 
capturePixelRenderStates()490 	void Direct3DStateBlock8::capturePixelRenderStates()
491 	{
492 		captureRenderState(D3DRS_ZENABLE);
493 		captureRenderState(D3DRS_FILLMODE);
494 		captureRenderState(D3DRS_SHADEMODE);
495 		captureRenderState(D3DRS_ZWRITEENABLE);
496 		captureRenderState(D3DRS_ALPHATESTENABLE);
497 		captureRenderState(D3DRS_LASTPIXEL);
498 		captureRenderState(D3DRS_SRCBLEND);
499 		captureRenderState(D3DRS_DESTBLEND);
500 		captureRenderState(D3DRS_ZFUNC);
501 		captureRenderState(D3DRS_ALPHAREF);
502 		captureRenderState(D3DRS_ALPHAFUNC);
503 		captureRenderState(D3DRS_DITHERENABLE);
504 		captureRenderState(D3DRS_FOGSTART);
505 		captureRenderState(D3DRS_FOGEND);
506 		captureRenderState(D3DRS_FOGDENSITY);
507 		captureRenderState(D3DRS_ALPHABLENDENABLE);
508 		captureRenderState(D3DRS_ZBIAS);
509 		captureRenderState(D3DRS_STENCILENABLE);
510 		captureRenderState(D3DRS_STENCILFAIL);
511 		captureRenderState(D3DRS_STENCILZFAIL);
512 		captureRenderState(D3DRS_STENCILPASS);
513 		captureRenderState(D3DRS_STENCILFUNC);
514 		captureRenderState(D3DRS_STENCILREF);
515 		captureRenderState(D3DRS_STENCILMASK);
516 		captureRenderState(D3DRS_STENCILWRITEMASK);
517 		captureRenderState(D3DRS_TEXTUREFACTOR);
518 		captureRenderState(D3DRS_WRAP0);
519 		captureRenderState(D3DRS_WRAP1);
520 		captureRenderState(D3DRS_WRAP2);
521 		captureRenderState(D3DRS_WRAP3);
522 		captureRenderState(D3DRS_WRAP4);
523 		captureRenderState(D3DRS_WRAP5);
524 		captureRenderState(D3DRS_WRAP6);
525 		captureRenderState(D3DRS_WRAP7);
526 		captureRenderState(D3DRS_COLORWRITEENABLE);
527 		captureRenderState(D3DRS_BLENDOP);
528 	}
529 
capturePixelTextureStates()530 	void Direct3DStateBlock8::capturePixelTextureStates()
531 	{
532 		for(int stage = 0; stage < 8; stage++)
533 		{
534 			captureTextureStageState(stage, D3DTSS_COLOROP);
535 			captureTextureStageState(stage, D3DTSS_COLORARG1);
536 			captureTextureStageState(stage, D3DTSS_COLORARG2);
537 			captureTextureStageState(stage, D3DTSS_ALPHAOP);
538 			captureTextureStageState(stage, D3DTSS_ALPHAARG1);
539 			captureTextureStageState(stage, D3DTSS_ALPHAARG2);
540 			captureTextureStageState(stage, D3DTSS_BUMPENVMAT00);
541 			captureTextureStageState(stage, D3DTSS_BUMPENVMAT01);
542 			captureTextureStageState(stage, D3DTSS_BUMPENVMAT10);
543 			captureTextureStageState(stage, D3DTSS_BUMPENVMAT11);
544 			captureTextureStageState(stage, D3DTSS_TEXCOORDINDEX);
545 			captureTextureStageState(stage, D3DTSS_BUMPENVLSCALE);
546 			captureTextureStageState(stage, D3DTSS_BUMPENVLOFFSET);
547 			captureTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS);
548 			captureTextureStageState(stage, D3DTSS_COLORARG0);
549 			captureTextureStageState(stage, D3DTSS_ALPHAARG0);
550 			captureTextureStageState(stage, D3DTSS_RESULTARG);
551 
552 			captureTextureStageState(stage, D3DTSS_ADDRESSU);
553 			captureTextureStageState(stage, D3DTSS_ADDRESSV);
554 			captureTextureStageState(stage, D3DTSS_ADDRESSW);
555 			captureTextureStageState(stage, D3DTSS_BORDERCOLOR);
556 			captureTextureStageState(stage, D3DTSS_MAGFILTER);
557 			captureTextureStageState(stage, D3DTSS_MINFILTER);
558 			captureTextureStageState(stage, D3DTSS_MIPFILTER);
559 			captureTextureStageState(stage, D3DTSS_MIPMAPLODBIAS);
560 			captureTextureStageState(stage, D3DTSS_MAXMIPLEVEL);
561 			captureTextureStageState(stage, D3DTSS_MAXANISOTROPY);
562 		}
563 	}
564 
capturePixelShaderStates()565 	void Direct3DStateBlock8::capturePixelShaderStates()
566 	{
567 		pixelShaderCaptured = true;
568 		device->GetPixelShader(&pixelShaderHandle);
569 
570 		device->GetPixelShaderConstant(0, pixelShaderConstant, 8);
571 	}
572 
captureVertexRenderStates()573 	void Direct3DStateBlock8::captureVertexRenderStates()
574 	{
575 		captureRenderState(D3DRS_CULLMODE);
576 		captureRenderState(D3DRS_FOGENABLE);
577 		captureRenderState(D3DRS_FOGCOLOR);
578 		captureRenderState(D3DRS_FOGTABLEMODE);
579 		captureRenderState(D3DRS_FOGSTART);
580 		captureRenderState(D3DRS_FOGEND);
581 		captureRenderState(D3DRS_FOGDENSITY);
582 		captureRenderState(D3DRS_RANGEFOGENABLE);
583 		captureRenderState(D3DRS_AMBIENT);
584 		captureRenderState(D3DRS_COLORVERTEX);
585 		captureRenderState(D3DRS_FOGVERTEXMODE);
586 		captureRenderState(D3DRS_CLIPPING);
587 		captureRenderState(D3DRS_LIGHTING);
588 		captureRenderState(D3DRS_LOCALVIEWER);
589 		captureRenderState(D3DRS_EMISSIVEMATERIALSOURCE);
590 		captureRenderState(D3DRS_AMBIENTMATERIALSOURCE);
591 		captureRenderState(D3DRS_DIFFUSEMATERIALSOURCE);
592 		captureRenderState(D3DRS_SPECULARMATERIALSOURCE);
593 		captureRenderState(D3DRS_VERTEXBLEND);
594 		captureRenderState(D3DRS_CLIPPLANEENABLE);
595 		captureRenderState(D3DRS_POINTSIZE);
596 		captureRenderState(D3DRS_POINTSIZE_MIN);
597 		captureRenderState(D3DRS_POINTSPRITEENABLE);
598 		captureRenderState(D3DRS_POINTSCALEENABLE);
599 		captureRenderState(D3DRS_POINTSCALE_A);
600 		captureRenderState(D3DRS_POINTSCALE_B);
601 		captureRenderState(D3DRS_POINTSCALE_C);
602 		captureRenderState(D3DRS_MULTISAMPLEANTIALIAS);
603 		captureRenderState(D3DRS_MULTISAMPLEMASK);
604 		captureRenderState(D3DRS_PATCHEDGESTYLE);
605 		captureRenderState(D3DRS_POINTSIZE_MAX);
606 		captureRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE);
607 		captureRenderState(D3DRS_TWEENFACTOR);
608 		captureRenderState(D3DRS_NORMALIZENORMALS);
609 		captureRenderState(D3DRS_SPECULARENABLE);
610 		captureRenderState(D3DRS_SHADEMODE);
611 	}
612 
captureVertexTextureStates()613 	void Direct3DStateBlock8::captureVertexTextureStates()
614 	{
615 		for(int stage = 0; stage < 8; stage++)
616 		{
617 			captureTextureStageState(stage, D3DTSS_TEXCOORDINDEX);
618 			captureTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS);
619 		}
620 	}
621 
captureLightStates()622 	void Direct3DStateBlock8::captureLightStates()
623 	{
624 		for(int index = 0; index < 8; index++)   // FIXME: Support unlimited index
625 		{
626 			device->GetLight(index, &light[index]);
627 			lightCaptured[index] = true;
628 		}
629 
630 		for(int index = 0; index < 8; index++)   // FIXME: Support unlimited index
631 		{
632 			lightEnableState[index] = false;
633 			device->GetLightEnable(index, &lightEnableState[index]);
634 			lightEnableCaptured[index] = true;
635 		}
636 	}
637 
captureVertexShaderStates()638 	void Direct3DStateBlock8::captureVertexShaderStates()
639 	{
640 		vertexShaderCaptured = true;
641 		device->GetVertexShader(&vertexShaderHandle);
642 
643 		device->GetVertexShaderConstant(0, vertexShaderConstant[0], 256);
644 	}
645 
captureTextures()646 	void Direct3DStateBlock8::captureTextures()
647 	{
648 		for(int sampler = 0; sampler < 8; sampler++)
649 		{
650 			textureCaptured[sampler] = true;
651 			device->GetTexture(sampler, reinterpret_cast<IDirect3DBaseTexture8**>(&texture[sampler]));
652 
653 			if(texture[sampler])
654 			{
655 				texture[sampler]->bind();
656 				texture[sampler]->Release();
657 			}
658 		}
659 	}
660 
captureVertexTextures()661 	void Direct3DStateBlock8::captureVertexTextures()
662 	{
663 		// FIXME
664 	}
665 
captureDisplacementTextures()666 	void Direct3DStateBlock8::captureDisplacementTextures()
667 	{
668 		// FIXME
669 	}
670 
captureTexturePalette()671 	void Direct3DStateBlock8::captureTexturePalette()
672 	{
673 		paletteNumberCaptured = true;
674 		device->GetCurrentTexturePalette(&paletteNumber);
675 	}
676 
captureVertexStreams()677 	void Direct3DStateBlock8::captureVertexStreams()
678 	{
679 		for(int stream = 0; stream < 16; stream++)
680 		{
681 			streamSourceCaptured[stream] = true;
682 			device->GetStreamSource(stream, reinterpret_cast<IDirect3DVertexBuffer8**>(&streamSource[stream].vertexBuffer),  &streamSource[stream].stride);
683 
684 			if(streamSource[stream].vertexBuffer)
685 			{
686 				streamSource[stream].vertexBuffer->bind();
687 				streamSource[stream].vertexBuffer->Release();
688 			}
689 		}
690 	}
691 
captureIndexBuffer()692 	void Direct3DStateBlock8::captureIndexBuffer()
693 	{
694 		indexBufferCaptured = true;
695 		device->GetIndices(reinterpret_cast<IDirect3DIndexBuffer8**>(&indexBuffer), &baseVertexIndex);
696 
697 		if(indexBuffer)
698 		{
699 			indexBuffer->bind();
700 			indexBuffer->Release();
701 		}
702 	}
703 
captureViewport()704 	void Direct3DStateBlock8::captureViewport()
705 	{
706 		device->GetViewport(&viewport);
707 		viewportCaptured = true;
708 	}
709 
captureTransforms()710 	void Direct3DStateBlock8::captureTransforms()
711 	{
712 		captureTransform(D3DTS_VIEW);
713 		captureTransform(D3DTS_PROJECTION);
714 		captureTransform(D3DTS_WORLD);
715 	}
716 
captureTextureTransforms()717 	void Direct3DStateBlock8::captureTextureTransforms()
718 	{
719 		captureTransform(D3DTS_TEXTURE0);
720 		captureTransform(D3DTS_TEXTURE1);
721 		captureTransform(D3DTS_TEXTURE2);
722 		captureTransform(D3DTS_TEXTURE3);
723 		captureTransform(D3DTS_TEXTURE4);
724 		captureTransform(D3DTS_TEXTURE5);
725 		captureTransform(D3DTS_TEXTURE6);
726 		captureTransform(D3DTS_TEXTURE7);
727 	}
728 
captureClippingPlanes()729 	void Direct3DStateBlock8::captureClippingPlanes()
730 	{
731 		for(int index = 0; index < 6; index++)
732 		{
733 			device->GetClipPlane(index, (float*)&clipPlane[index]);
734 			clipPlaneCaptured[index] = true;
735 		}
736 	}
737 
captureMaterial()738 	void Direct3DStateBlock8::captureMaterial()
739 	{
740 		device->GetMaterial(&material);
741 		materialCaptured = true;
742 	}
743 }