2 * state block implementation
4 * Copyright 2002 Raphael Junqueira
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include "wine/debug.h"
31 #include "d3d8_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
35 /* Used for CreateStateBlock */
36 #define NUM_SAVEDPIXELSTATES_R 38
37 #define NUM_SAVEDPIXELSTATES_T 27
38 #define NUM_SAVEDVERTEXSTATES_R 33
39 #define NUM_SAVEDVERTEXSTATES_T 2
44 extern DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R];
45 extern DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T];
46 extern DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R];
47 extern DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T];
48 static const float idmatrix[16] = {
55 HRESULT WINAPI IDirect3DDeviceImpl_InitStartupStateBlock(IDirect3DDevice8Impl* This) {
58 LPDIRECT3DDEVICE8 iface = (LPDIRECT3DDEVICE8) This;
60 /* Note this may have a large overhead but it should only be executed
61 once, in order to initialize the complete state of the device and
62 all opengl equivalents */
63 TRACE("-----------------------> Setting up device defaults...\n");
64 This->StateBlock->blockType = D3DSBT_ALL;
66 /* FIXME: Set some of the defaults for lights, transforms etc */
67 memcpy(&This->StateBlock->transforms[D3DTS_PROJECTION], &idmatrix, sizeof(idmatrix));
68 memcpy(&This->StateBlock->transforms[D3DTS_VIEW], &idmatrix, sizeof(idmatrix));
69 for (i = 0; i < 256; ++i) {
70 memcpy(&This->StateBlock->transforms[D3DTS_WORLDMATRIX(i)], &idmatrix, sizeof(idmatrix));
74 if (This->PresentParms.EnableAutoDepthStencil) {
75 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZENABLE, D3DZB_TRUE);
77 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZENABLE, D3DZB_FALSE);
79 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FILLMODE, D3DFILL_SOLID);
80 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
81 lp.wRepeatFactor = 0; lp.wLinePattern = 0; IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LINEPATTERN, (DWORD) &lp);
82 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZWRITEENABLE, TRUE);
83 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHATESTENABLE, FALSE);
84 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LASTPIXEL, TRUE);
85 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SRCBLEND, D3DBLEND_ONE);
86 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DESTBLEND, D3DBLEND_ZERO);
87 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_CULLMODE, D3DCULL_CCW);
88 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
89 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHAFUNC, D3DCMP_ALWAYS);
90 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHAREF, 0xff); /*??*/
91 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DITHERENABLE, FALSE);
92 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHABLENDENABLE, FALSE);
93 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGENABLE, FALSE);
94 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SPECULARENABLE, FALSE);
95 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZVISIBLE, 0);
96 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGCOLOR, 0);
97 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
98 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGSTART, 0.0f);
99 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGEND, 1.0f);
100 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGDENSITY, 1.0f);
101 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_EDGEANTIALIAS, FALSE);
102 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZBIAS, 0);
103 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_RANGEFOGENABLE, FALSE);
104 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILENABLE, FALSE);
105 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
106 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
107 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
108 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
109 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILREF, 0);
110 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILMASK, 0xFFFFFFFF);
111 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILWRITEMASK, 0xFFFFFFFF);
112 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_TEXTUREFACTOR, 0xFFFFFFFF);
113 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP0, 0);
114 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP1, 0);
115 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP2, 0);
116 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP3, 0);
117 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP4, 0);
118 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP5, 0);
119 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP6, 0);
120 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP7, 0);
121 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_CLIPPING, TRUE);
122 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LIGHTING, TRUE);
123 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_AMBIENT, 0);
124 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
125 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_COLORVERTEX, TRUE);
126 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LOCALVIEWER, TRUE);
127 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_NORMALIZENORMALS, FALSE);
128 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
129 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2);
130 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_COLOR2);
131 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
132 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_VERTEXBLEND, D3DVBF_DISABLE);
133 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_CLIPPLANEENABLE, 0);
134 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SOFTWAREVERTEXPROCESSING, FALSE);
135 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSIZE, 1.0f);
136 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSIZE_MIN, 0.0f);
137 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSPRITEENABLE, FALSE);
138 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALEENABLE, FALSE);
139 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALE_A, TRUE);
140 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALE_B, TRUE);
141 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALE_C, TRUE);
142 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_MULTISAMPLEANTIALIAS, TRUE);
143 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
144 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_DISCRETE);
145 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_PATCHSEGMENTS, 1.0f);
146 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DEBUGMONITORTOKEN, D3DDMT_DISABLE);
147 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSIZE_MAX, (DWORD) 64.0f);
148 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE);
149 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_COLORWRITEENABLE, 0x0000000F);
150 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_TWEENFACTOR, (DWORD) 0.0f);
151 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_BLENDOP, D3DBLENDOP_ADD);
152 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POSITIONORDER, D3DORDER_CUBIC);
153 IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_NORMALORDER, D3DORDER_LINEAR);
155 /* Texture Stage States - Put directly into state block, we will call function below */
156 for (i=0; i<This->TextureUnits;i++) {
157 memcpy(&This->StateBlock->transforms[D3DTS_TEXTURE0+i], &idmatrix, sizeof(idmatrix));
158 This->StateBlock->texture_state[i][D3DTSS_COLOROP ] = (i==0)? D3DTOP_MODULATE : D3DTOP_DISABLE;
159 This->StateBlock->texture_state[i][D3DTSS_COLORARG1 ] = D3DTA_TEXTURE;
160 This->StateBlock->texture_state[i][D3DTSS_COLORARG2 ] = D3DTA_CURRENT;
161 This->StateBlock->texture_state[i][D3DTSS_ALPHAOP ] = (i==0)? D3DTOP_SELECTARG1 : D3DTOP_DISABLE;
162 This->StateBlock->texture_state[i][D3DTSS_ALPHAARG1 ] = D3DTA_TEXTURE;
163 This->StateBlock->texture_state[i][D3DTSS_ALPHAARG2 ] = D3DTA_CURRENT;
164 This->StateBlock->texture_state[i][D3DTSS_BUMPENVMAT00 ] = (DWORD) 0.0;
165 This->StateBlock->texture_state[i][D3DTSS_BUMPENVMAT01 ] = (DWORD) 0.0;
166 This->StateBlock->texture_state[i][D3DTSS_BUMPENVMAT10 ] = (DWORD) 0.0;
167 This->StateBlock->texture_state[i][D3DTSS_BUMPENVMAT11 ] = (DWORD) 0.0;
168 This->StateBlock->texture_state[i][D3DTSS_TEXCOORDINDEX ] = i;
169 This->StateBlock->texture_state[i][D3DTSS_ADDRESSU ] = D3DTADDRESS_WRAP;
170 This->StateBlock->texture_state[i][D3DTSS_ADDRESSV ] = D3DTADDRESS_WRAP;
171 This->StateBlock->texture_state[i][D3DTSS_BORDERCOLOR ] = 0x00;
172 This->StateBlock->texture_state[i][D3DTSS_MAGFILTER ] = D3DTEXF_POINT;
173 This->StateBlock->texture_state[i][D3DTSS_MINFILTER ] = D3DTEXF_POINT;
174 This->StateBlock->texture_state[i][D3DTSS_MIPFILTER ] = D3DTEXF_NONE;
175 This->StateBlock->texture_state[i][D3DTSS_MIPMAPLODBIAS ] = 0;
176 This->StateBlock->texture_state[i][D3DTSS_MAXMIPLEVEL ] = 0;
177 This->StateBlock->texture_state[i][D3DTSS_MAXANISOTROPY ] = 1;
178 This->StateBlock->texture_state[i][D3DTSS_BUMPENVLSCALE ] = (DWORD) 0.0;
179 This->StateBlock->texture_state[i][D3DTSS_BUMPENVLOFFSET ] = (DWORD) 0.0;
180 This->StateBlock->texture_state[i][D3DTSS_TEXTURETRANSFORMFLAGS ] = D3DTTFF_DISABLE;
181 This->StateBlock->texture_state[i][D3DTSS_ADDRESSW ] = D3DTADDRESS_WRAP;
182 This->StateBlock->texture_state[i][D3DTSS_COLORARG0 ] = D3DTA_CURRENT;
183 This->StateBlock->texture_state[i][D3DTSS_ALPHAARG0 ] = D3DTA_CURRENT;
184 This->StateBlock->texture_state[i][D3DTSS_RESULTARG ] = D3DTA_CURRENT;
187 /* Under DirectX you can have texture stage operations even if no texture is
188 bound, whereas opengl will only do texture operations when a valid texture is
189 bound. We emulate this by creating dummy textures and binding them to each
190 texture stage, but disable all stages by default. Hence if a stage is enabled
191 then the default texture will kick in until replaced by a SetTexture call */
193 for (i = 0; i < This->TextureUnits; i++) {
196 /* Note this avoids calling settexture, so pretend it has been called */
197 This->StateBlock->Set.textures[i] = TRUE;
198 This->StateBlock->Changed.textures[i] = TRUE;
199 This->StateBlock->textures[i] = NULL;
201 /* Make appropriate texture active */
202 if (This->isMultiTexture) {
203 #if defined(GL_VERSION_1_3)
204 glActiveTexture(GL_TEXTURE0 + i);
206 glActiveTextureARB(GL_TEXTURE0_ARB + i);
208 checkGLcall("glActiveTextureARB");
210 FIXME("Program using multiple concurrent textures which this opengl implementation doesnt support\n");
213 /* Generate an opengl texture name */
214 glGenTextures(1, &This->dummyTextureName[i]);
215 checkGLcall("glGenTextures");
216 TRACE("Dummy Texture %d given name %d\n", i, This->dummyTextureName[i]);
218 /* Generate a dummy 1d texture */
219 This->StateBlock->textureDimensions[i] = GL_TEXTURE_1D;
220 glBindTexture(GL_TEXTURE_1D, This->dummyTextureName[i]);
221 checkGLcall("glBindTexture");
223 glTexImage1D(GL_TEXTURE_1D, 0, GL_LUMINANCE, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &white);
224 checkGLcall("glTexImage1D");
226 /* Reapply all the texture state information to this texture */
227 setupTextureStates(iface, i);
230 TRACE("-----------------------> Device defaults now set up...\n");
237 HRESULT WINAPI IDirect3DDeviceImpl_CreateStateBlock(IDirect3DDevice8Impl* This, D3DSTATEBLOCKTYPE Type, IDirect3DStateBlockImpl** ppStateBlock) {
238 IDirect3DStateBlockImpl* object;
241 TRACE("(%p) : Type(%d)\n", This, Type);
243 /* Allocate Storage */
244 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DStateBlockImpl));
246 if (NULL == This->StateBlock) { /** if it the main stateblock only do init and returns */
247 /*object->lpVtbl = &Direct3DStateBlock9_Vtbl;*/
248 object->device = This;
250 object->blockType = Type;
251 This->StateBlock = object;
252 /* don't forget to init it calling InitStartupStateBlock */
255 memcpy(object, This->StateBlock, sizeof(IDirect3DStateBlockImpl));
257 *ppStateBlock = (IDirect3DStateBlockImpl*) 0xFFFFFFFF;
258 return E_OUTOFMEMORY;
260 /*object->lpVtbl = &Direct3DStateBlock9_Vtbl;*/
261 object->device = This;
263 object->blockType = Type;
265 TRACE("Updating changed flags appropriate for type %d\n", Type);
267 if (Type == D3DSBT_ALL) {
268 TRACE("ALL => Pretend everything has changed\n");
269 memset(&object->Changed, TRUE, sizeof(This->StateBlock->Changed));
271 } else if (Type == D3DSBT_PIXELSTATE) {
273 memset(&object->Changed, FALSE, sizeof(This->StateBlock->Changed));
275 /* TODO: Pixel Shader Constants */
276 object->Changed.pixelShader = TRUE;
277 for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
278 object->Changed.renderstate[SavedPixelStates_R[i]] = TRUE;
280 for (j = 0; j < This->TextureUnits; i++) {
281 for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) {
282 object->Changed.texture_state[j][SavedPixelStates_T[i]] = TRUE;
286 } else if (Type == D3DSBT_VERTEXSTATE) {
288 memset(&object->Changed, FALSE, sizeof(This->StateBlock->Changed));
290 /* TODO: Vertex Shader Constants */
291 object->Changed.vertexShader = TRUE;
292 for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
293 object->Changed.renderstate[SavedVertexStates_R[i]] = TRUE;
295 for (j = 0; j < This->TextureUnits; i++) {
296 for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) {
297 object->Changed.texture_state[j][SavedVertexStates_T[i]] = TRUE;
300 for (i = 0; i < This->maxLights; i++) {
301 object->Changed.lightEnable[i] = TRUE;
302 object->Changed.lights[i] = TRUE;
306 FIXME("Unrecognized state block type %d\n", Type);
308 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object);
310 *ppStateBlock = object;
314 /** yakkk temporary waiting for Release */
315 HRESULT WINAPI IDirect3DDeviceImpl_DeleteStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl* pSB) {
316 TRACE("(%p) : freeing StateBlock %p\n", This, pSB);
317 HeapFree(GetProcessHeap(), 0, (void *)pSB);
321 HRESULT WINAPI IDirect3DDeviceImpl_BeginStateBlock(IDirect3DDevice8Impl* This) {
322 IDirect3DStateBlockImpl* object;
324 TRACE("(%p)\n", This);
326 if (This->isRecordingState) {
327 TRACE("(%p) already recording! returning error\n", This);
328 return D3DERR_INVALIDCALL;
331 /* Allocate Storage */
332 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DStateBlockImpl));
335 return E_OUTOFMEMORY;
337 /*object->lpVtbl = &Direct3DVextexShaderDeclaration8_Vtbl;*/
338 object->device = This;
341 This->isRecordingState = TRUE;
342 This->UpdateStateBlock = object;
347 HRESULT WINAPI IDirect3DDeviceImpl_EndStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl** ppStateBlock) {
348 TRACE("(%p)\n", This);
350 if (!This->isRecordingState) {
351 TRACE("(%p) not recording! returning error\n", This);
352 *ppStateBlock = NULL;
353 return D3DERR_INVALIDCALL;
356 This->UpdateStateBlock->blockType = D3DSBT_RECORDED;
357 *ppStateBlock = This->UpdateStateBlock; /* FIXME: AddRef() */
358 This->isRecordingState = FALSE;
359 This->UpdateStateBlock = This->StateBlock;
361 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, *ppStateBlock);
365 HRESULT WINAPI IDirect3DDeviceImpl_ApplyStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl* pSB) {
368 LPDIRECT3DDEVICE8 iface = (LPDIRECT3DDEVICE8) This;
370 TRACE("(%p) : Applying state block %p ------------------v\n", This, pSB);
372 /* FIXME: Only apply applicable states not all states */
374 if (pSB->blockType == D3DSBT_RECORDED || pSB->blockType == D3DSBT_ALL || pSB->blockType == D3DSBT_VERTEXSTATE) {
376 for (i = 0; i < This->maxLights; i++) {
378 if (pSB->Set.lightEnable[i] && pSB->Changed.lightEnable[i])
379 IDirect3DDevice8Impl_LightEnable(iface, i, pSB->lightEnable[i]);
380 if (pSB->Set.lights[i] && pSB->Changed.lights[i])
381 IDirect3DDevice8Impl_SetLight(iface, i, &pSB->lights[i]);
384 if (pSB->Set.vertexShader && pSB->Changed.vertexShader)
385 IDirect3DDevice8Impl_SetVertexShader(iface, pSB->VertexShader);
387 /* TODO: Vertex Shader Constants */
390 if (pSB->blockType == D3DSBT_RECORDED || pSB->blockType == D3DSBT_ALL || pSB->blockType == D3DSBT_PIXELSTATE) {
392 if (pSB->Set.pixelShader && pSB->Changed.pixelShader)
393 IDirect3DDevice8Impl_SetPixelShader(iface, pSB->PixelShader);
395 /* TODO: Pixel Shader Constants */
398 /* Others + Render & Texture */
399 if (pSB->blockType == D3DSBT_RECORDED || pSB->blockType == D3DSBT_ALL) {
400 for (i = 0; i < HIGHEST_TRANSFORMSTATE; i++) {
401 if (pSB->Set.transform[i] && pSB->Changed.transform[i])
402 IDirect3DDevice8Impl_SetTransform(iface, i, &pSB->transforms[i]);
405 if (pSB->Set.Indices && pSB->Changed.Indices)
406 IDirect3DDevice8Impl_SetIndices(iface, pSB->pIndexData, pSB->baseVertexIndex);
408 if (pSB->Set.material && pSB->Changed.material)
409 IDirect3DDevice8Impl_SetMaterial(iface, &pSB->material);
411 if (pSB->Set.viewport && pSB->Changed.viewport)
412 IDirect3DDevice8Impl_SetViewport(iface, &pSB->viewport);
414 for (i=0; i<MAX_STREAMS; i++) {
415 if (pSB->Set.stream_source[i] && pSB->Changed.stream_source[i])
416 IDirect3DDevice8Impl_SetStreamSource(iface, i, pSB->stream_source[i], pSB->stream_stride[i]);
419 for (i = 0; i < This->clipPlanes; i++) {
420 if (pSB->Set.clipplane[i] && pSB->Changed.clipplane[i]) {
423 clip[0] = pSB->clipplane[i][0];
424 clip[1] = pSB->clipplane[i][1];
425 clip[2] = pSB->clipplane[i][2];
426 clip[3] = pSB->clipplane[i][3];
427 IDirect3DDevice8Impl_SetClipPlane(iface, i, clip);
432 for (i = 0; i < HIGHEST_RENDER_STATE; i++) {
433 if (pSB->Set.renderstate[i] && pSB->Changed.renderstate[i])
434 IDirect3DDevice8Impl_SetRenderState(iface, i, pSB->renderstate[i]);
438 for (j = 0; j < This->TextureUnits; j++) {
439 for (i = 0; i < HIGHEST_TEXTURE_STATE; i++) {
440 if (pSB->Set.texture_state[j][i] && pSB->Changed.texture_state[j][i]) {
441 IDirect3DDevice8Impl_SetTextureStageState(iface, j, i, pSB->texture_state[j][i]);
444 if (pSB->Set.textures[j] && pSB->Changed.textures[j]) {
445 IDirect3DDevice8Impl_SetTexture(iface, j, pSB->textures[j]);
450 } else if (pSB->blockType == D3DSBT_PIXELSTATE) {
452 for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
453 if (pSB->Set.renderstate[SavedPixelStates_R[i]] && pSB->Changed.renderstate[SavedPixelStates_R[i]])
454 IDirect3DDevice8Impl_SetRenderState(iface, SavedPixelStates_R[i], pSB->renderstate[SavedPixelStates_R[i]]);
458 for (j = 0; j < This->TextureUnits; i++) {
459 for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) {
460 if (pSB->Set.texture_state[j][SavedPixelStates_T[i]] &&
461 pSB->Changed.texture_state[j][SavedPixelStates_T[i]])
462 IDirect3DDevice8Impl_SetTextureStageState(iface, j, SavedPixelStates_T[i], pSB->texture_state[j][SavedPixelStates_T[i]]);
466 } else if (pSB->blockType == D3DSBT_VERTEXSTATE) {
468 for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
469 if (pSB->Set.renderstate[SavedVertexStates_R[i]] && pSB->Changed.renderstate[SavedVertexStates_R[i]])
470 IDirect3DDevice8Impl_SetRenderState(iface, SavedVertexStates_R[i], pSB->renderstate[SavedVertexStates_R[i]]);
473 for (j = 0; j < This->TextureUnits; i++) {
474 for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) {
475 if (pSB->Set.texture_state[j][SavedVertexStates_T[i]] &&
476 pSB->Changed.texture_state[j][SavedVertexStates_T[i]])
477 IDirect3DDevice8Impl_SetTextureStageState(iface, j, SavedVertexStates_T[i], pSB->texture_state[j][SavedVertexStates_T[i]]);
483 FIXME("Unrecognized state block type %d\n", pSB->blockType);
485 memcpy(&This->StateBlock->Changed, &pSB->Changed, sizeof(This->StateBlock->Changed));
486 TRACE("(%p) : Applied state block %p ------------------^\n", This, pSB);
491 HRESULT WINAPI IDirect3DDeviceImpl_CaptureStateBlock(IDirect3DDevice8Impl* This, IDirect3DStateBlockImpl* updateBlock) {
492 LPDIRECT3DDEVICE8 iface = (LPDIRECT3DDEVICE8) This;
494 TRACE("(%p) : Updating state block %p ------------------v \n", This, updateBlock);
496 /* If not recorded, then update can just recapture */
497 if (updateBlock->blockType != D3DSBT_RECORDED) {
498 IDirect3DStateBlockImpl* tmpBlock;
499 IDirect3DDeviceImpl_CreateStateBlock(This, updateBlock->blockType, &tmpBlock);
500 memcpy(updateBlock, tmpBlock, sizeof(IDirect3DStateBlockImpl));
501 IDirect3DDeviceImpl_DeleteStateBlock(This, tmpBlock);
503 /* FIXME: This will record states of new lights! May need to have and save set_lights
504 across this action */
509 /* Recorded => Only update 'changed' values */
510 if (updateBlock->Set.vertexShader && updateBlock->VertexShader != This->StateBlock->VertexShader) {
511 updateBlock->VertexShader = This->StateBlock->VertexShader;
512 TRACE("Updating vertex shader to %ld\n", This->StateBlock->VertexShader);
515 /* TODO: Vertex Shader Constants */
517 for (i = 0; i < This->maxLights; i++) {
518 if (updateBlock->Set.lightEnable[i] && This->StateBlock->lightEnable[i] != updateBlock->lightEnable[i]) {
519 TRACE("Updating light enable for light %d to %d\n", i, This->StateBlock->lightEnable[i]);
520 updateBlock->lightEnable[i] = This->StateBlock->lightEnable[i];
523 if (updateBlock->Set.lights[i] && memcmp(&This->StateBlock->lights[i],
524 &updateBlock->lights[i],
525 sizeof(D3DLIGHT8)) != 0) {
526 TRACE("Updating lights for light %d\n", i);
527 memcpy(&updateBlock->lights[i], &This->StateBlock->lights[i], sizeof(D3DLIGHT8));
531 if (updateBlock->Set.pixelShader && updateBlock->PixelShader != This->StateBlock->PixelShader) {
532 TRACE("Updating pixel shader to %ld\n", This->StateBlock->PixelShader);
533 updateBlock->lights[i] = This->StateBlock->lights[i];
534 IDirect3DDevice8Impl_SetVertexShader(iface, updateBlock->PixelShader);
537 /* TODO: Pixel Shader Constants */
539 /* Others + Render & Texture */
540 for (i = 0; i < HIGHEST_TRANSFORMSTATE; i++) {
541 if (updateBlock->Set.transform[i] && memcmp(&This->StateBlock->transforms[i],
542 &updateBlock->transforms[i],
543 sizeof(D3DMATRIX)) != 0) {
544 TRACE("Updating transform %d\n", i);
545 memcpy(&updateBlock->transforms[i], &This->StateBlock->transforms[i], sizeof(D3DMATRIX));
549 if (updateBlock->Set.Indices && ((updateBlock->pIndexData != This->StateBlock->pIndexData)
550 || (updateBlock->baseVertexIndex != This->StateBlock->baseVertexIndex))) {
551 TRACE("Updating pindexData to %p, baseVertexIndex to %d\n",
552 This->StateBlock->pIndexData, This->StateBlock->baseVertexIndex);
553 updateBlock->pIndexData = This->StateBlock->pIndexData;
554 updateBlock->baseVertexIndex = This->StateBlock->baseVertexIndex;
557 if (updateBlock->Set.material && memcmp(&This->StateBlock->material,
558 &updateBlock->material,
559 sizeof(D3DMATERIAL8)) != 0) {
560 TRACE("Updating material\n");
561 memcpy(&updateBlock->material, &This->StateBlock->material, sizeof(D3DMATERIAL8));
564 if (updateBlock->Set.viewport && memcmp(&This->StateBlock->viewport,
565 &updateBlock->viewport,
566 sizeof(D3DVIEWPORT8)) != 0) {
567 TRACE("Updating viewport\n");
568 memcpy(&updateBlock->viewport, &This->StateBlock->viewport, sizeof(D3DVIEWPORT8));
571 for (i = 0; i < MAX_STREAMS; i++) {
572 if (updateBlock->Set.stream_source[i] &&
573 ((updateBlock->stream_stride[i] != This->StateBlock->stream_stride[i]) ||
574 (updateBlock->stream_source[i] != This->StateBlock->stream_source[i]))) {
575 TRACE("Updating stream source %d to %p, stride to %d\n", i, This->StateBlock->stream_source[i],
576 This->StateBlock->stream_stride[i]);
577 updateBlock->stream_stride[i] = This->StateBlock->stream_stride[i];
578 updateBlock->stream_source[i] = This->StateBlock->stream_source[i];
582 for (i = 0; i < This->clipPlanes; i++) {
583 if (updateBlock->Set.clipplane[i] && memcmp(&This->StateBlock->clipplane[i],
584 &updateBlock->clipplane[i],
585 sizeof(updateBlock->clipplane)) != 0) {
587 TRACE("Updating clipplane %d\n", i);
588 memcpy(&updateBlock->clipplane[i], &This->StateBlock->clipplane[i],
589 sizeof(updateBlock->clipplane));
594 for (i = 0; i < HIGHEST_RENDER_STATE; i++) {
596 if (updateBlock->Set.renderstate[i] && (updateBlock->renderstate[i] !=
597 This->StateBlock->renderstate[i])) {
598 TRACE("Updating renderstate %d to %ld\n", i, This->StateBlock->renderstate[i]);
599 updateBlock->renderstate[i] = This->StateBlock->renderstate[i];
604 for (j = 0; j < This->TextureUnits; j++) {
605 for (i = 0; i < HIGHEST_TEXTURE_STATE; i++) {
607 if (updateBlock->Set.texture_state[j][i] && (updateBlock->texture_state[j][i] !=
608 This->StateBlock->texture_state[j][i])) {
609 TRACE("Updating texturestagestate %d,%d to %ld (was %ld)\n", j,i, This->StateBlock->texture_state[j][i],
610 updateBlock->texture_state[j][i]);
611 updateBlock->texture_state[j][i] = This->StateBlock->texture_state[j][i];
614 if (updateBlock->Set.textures[j] && (updateBlock->textures[j] != This->StateBlock->textures[j])) {
615 TRACE("Updating texture %d to %p (was %p)\n", j, This->StateBlock->textures[j], updateBlock->textures[j]);
616 updateBlock->textures[j] = This->StateBlock->textures[j];
623 TRACE("(%p) : Updated state block %p ------------------^\n", This, updateBlock);
628 DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R] = {
629 D3DRS_ALPHABLENDENABLE ,
632 D3DRS_ALPHATESTENABLE ,
634 D3DRS_COLORWRITEENABLE ,
637 D3DRS_EDGEANTIALIAS ,
646 D3DRS_STENCILENABLE ,
652 D3DRS_STENCILWRITEMASK ,
654 D3DRS_TEXTUREFACTOR ,
669 DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T] = {
678 D3DTSS_BUMPENVLOFFSET ,
679 D3DTSS_BUMPENVLSCALE ,
680 D3DTSS_BUMPENVMAT00 ,
681 D3DTSS_BUMPENVMAT01 ,
682 D3DTSS_BUMPENVMAT10 ,
683 D3DTSS_BUMPENVMAT11 ,
689 D3DTSS_MAXANISOTROPY ,
693 D3DTSS_MIPMAPLODBIAS ,
695 D3DTSS_TEXCOORDINDEX ,
696 D3DTSS_TEXTURETRANSFORMFLAGS
699 DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R] = {
701 D3DRS_AMBIENTMATERIALSOURCE ,
703 D3DRS_CLIPPLANEENABLE ,
705 D3DRS_DIFFUSEMATERIALSOURCE ,
706 D3DRS_EMISSIVEMATERIALSOURCE ,
711 D3DRS_FOGVERTEXMODE ,
712 D3DRS_INDEXEDVERTEXBLENDENABLE ,
715 D3DRS_MULTISAMPLEANTIALIAS ,
716 D3DRS_MULTISAMPLEMASK ,
717 D3DRS_NORMALIZENORMALS ,
718 D3DRS_PATCHEDGESTYLE ,
719 D3DRS_PATCHSEGMENTS ,
723 D3DRS_POINTSCALEENABLE ,
725 D3DRS_POINTSIZE_MAX ,
726 D3DRS_POINTSIZE_MIN ,
727 D3DRS_POINTSPRITEENABLE ,
728 D3DRS_RANGEFOGENABLE ,
729 D3DRS_SOFTWAREVERTEXPROCESSING ,
730 D3DRS_SPECULARMATERIALSOURCE ,
735 DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T] = {
736 D3DTSS_TEXCOORDINDEX ,
737 D3DTSS_TEXTURETRANSFORMFLAGS