?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Convert a WARN to a FIXME to make it visible to a user, replace an ERR
[wine/multimedia.git] / dlls / wined3d / stateblock.c
blobc591f68a14e6f04d05432c10562f8966911f632d
1 /*
2 * state block implementation
3 *
4 * Copyright 2002 Raphael Junqueira
5 * Copyright 2004 Jason Edmeades
6 * Copyright 2005 Oliver Stieber
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include "config.h"
24 #include "wined3d_private.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
27 #define GLINFO_LOCATION ((IWineD3DImpl *)(((IWineD3DDeviceImpl *)This->wineD3DDevice)->wineD3D))->gl_info
28
29 /**********************************************************
30 * IWineD3DStateBlockImpl IUnknown parts follows
31 **********************************************************/
32 HRESULT WINAPI IWineD3DStateBlockImpl_QueryInterface(IWineD3DStateBlock *iface,REFIID riid,LPVOID *ppobj)
33 {
34 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
35 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
36 if (IsEqualGUID(riid, &IID_IUnknown)
37 || IsEqualGUID(riid, &IID_IWineD3DStateBlock)){
38 IUnknown_AddRef(iface);
39 *ppobj = This;
40 return D3D_OK;
41 }
42 return E_NOINTERFACE;
43 }
44
45 ULONG WINAPI IWineD3DStateBlockImpl_AddRef(IWineD3DStateBlock *iface) {
46 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
47 ULONG refCount = InterlockedIncrement(&This->ref);
48
49 TRACE("(%p) : AddRef increasing from %ld\n", This, refCount - 1);
50 return refCount;
51 }
52
53 ULONG WINAPI IWineD3DStateBlockImpl_Release(IWineD3DStateBlock *iface) {
54 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
55 ULONG refCount = InterlockedDecrement(&This->ref);
56
57 TRACE("(%p) : Releasing from %ld\n", This, refCount + 1);
58
59 if (!refCount) {
60 /* type 0 represents the primary stateblock, so free all the resources */
61 if (This->blockType == WINED3DSBT_INIT) {
62 int counter;
63 FIXME("Releasing primary stateblock\n");
64 /* Free any streams still bound */
65 for (counter = 0 ; counter < MAX_STREAMS ; counter++) {
66 if (This->streamSource[counter] != NULL) {
67 IUnknown *vertexBufferParent;
68 IWineD3DVertexBuffer_GetParent(This->streamSource[counter], &vertexBufferParent);
69 /* Set to NULL here so that Device_ResourceReleased can give a warning if This->streamSource[counter] == ResourceReleased */
70 This->streamSource[counter] = NULL;
71 IUnknown_Release(vertexBufferParent);
72 IUnknown_Release(vertexBufferParent);
73 }
74 }
75
76 /* free any index data */
77 if (This->pIndexData) {
78 IUnknown *indexBufferParent;
79 IWineD3DIndexBuffer_GetParent(This->pIndexData, &indexBufferParent);
80 This->pIndexData = NULL;
81 TRACE("Releasing index buffer %p p(%p)", This->pIndexData, indexBufferParent);
82 IUnknown_Release(indexBufferParent);
83 IUnknown_Release(indexBufferParent);
84 }
85
86 /* NOTE: according to MSDN: The applicaion is responsible for making sure the texture references are cleared down */
87 for (counter = 0; counter < GL_LIMITS(textures); counter++) {
88 if (This->textures[counter]) {
89 IUnknown *textureParent;
90 IWineD3DBaseTexture_GetParent(This->textures[counter], &textureParent);
91 /* FIXME: Were not using internal counting properly, so were making up for it here by releasing the object anyway */
92
93 IUnknown_Release(textureParent);
94 /* release our 'internal' hold on the texture */
95 if(0 != IUnknown_Release(textureParent)) {
96 TRACE("Texture still referenced by stateblock, applications has leaked Stage = %u Texture = %p Parent = %p\n", counter, This->textures[counter], textureParent);
97 }
98 }
99 }
100
101 }
102 HeapFree(GetProcessHeap(), 0, This);
103 }
104 return refCount;
105 }
106
107 /**********************************************************
108 * IWineD3DStateBlockImpl parts follows
109 **********************************************************/
110 HRESULT WINAPI IWineD3DStateBlockImpl_GetParent(IWineD3DStateBlock *iface, IUnknown **pParent) {
111 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
112 IUnknown_AddRef(This->parent);
113 *pParent = This->parent;
114 return D3D_OK;
115 }
116
117 HRESULT WINAPI IWineD3DStateBlockImpl_GetDevice(IWineD3DStateBlock *iface, IWineD3DDevice** ppDevice){
118
119 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
120
121 *ppDevice = (IWineD3DDevice*)This->wineD3DDevice;
122 IWineD3DDevice_AddRef(*ppDevice);
123 return D3D_OK;
124
125 }
126
127 HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface){
128
129 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
130 IWineD3DStateBlockImpl *targetStateBlock = This->wineD3DDevice->stateBlock;
131
132 TRACE("(%p) : Updating state block %p ------------------v \n", targetStateBlock, This);
133
134 /* If not recorded, then update can just recapture */
135 if (/*TODO: 'magic' statetype, replace with BOOL This->blockType == D3DSBT_RECORDED */ 0) {
136 IWineD3DStateBlockImpl* tmpBlock;
137 PLIGHTINFOEL *tmp = This->lights;
138
139 IWineD3DDevice_CreateStateBlock((IWineD3DDevice *)This->wineD3DDevice, This->blockType, (IWineD3DStateBlock**) &tmpBlock, NULL/*parent*/);
140
141 /* Note just swap the light chains over so when deleting, the old one goes */
142 memcpy(This, tmpBlock, sizeof(IWineD3DStateBlockImpl));
143 tmpBlock->lights = tmp;
144
145 /* Delete the temporary one (which points to the old light chain though */
146 IWineD3DStateBlock_Release((IWineD3DStateBlock *)tmpBlock);
147 /*IDirect3DDevice_DeleteStateBlock(pDevice, tmpBlock);*/
148
149 } else {
150 unsigned int i, j;
151
152 PLIGHTINFOEL *src;
153
154 /* Recorded => Only update 'changed' values */
155 if (This->vertexShader != targetStateBlock->vertexShader) {
156 This->vertexShader = targetStateBlock->vertexShader;
157 TRACE("Updating vertex shader to %p\n", targetStateBlock->vertexShader);
158 }
159
160 /* Vertex Shader Constants */
161 for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
162 if (This->set.vertexShaderConstants[i]) {
163 TRACE("Setting %p from %p %d to %f\n", This, targetStateBlock, i, targetStateBlock->vertexShaderConstantF[i * 4 + 1]);
164 This->vertexShaderConstantB[i] = targetStateBlock->vertexShaderConstantB[i];
165 This->vertexShaderConstantF[i * 4] = targetStateBlock->vertexShaderConstantF[i * 4];
166 This->vertexShaderConstantF[i * 4 + 1] = targetStateBlock->vertexShaderConstantF[i * 4 + 1];
167 This->vertexShaderConstantF[i * 4 + 2] = targetStateBlock->vertexShaderConstantF[i * 4 + 2];
168 This->vertexShaderConstantF[i * 4 + 3] = targetStateBlock->vertexShaderConstantF[i * 4 + 3];
169 This->vertexShaderConstantI[i * 4] = targetStateBlock->vertexShaderConstantI[i * 4];
170 This->vertexShaderConstantI[i * 4 + 1] = targetStateBlock->vertexShaderConstantI[i * 4 + 1];
171 This->vertexShaderConstantI[i * 4 + 2] = targetStateBlock->vertexShaderConstantI[i * 4 + 2];
172 This->vertexShaderConstantI[i * 4 + 3] = targetStateBlock->vertexShaderConstantI[i * 4 + 3];
173 This->vertexShaderConstantT[i] = targetStateBlock->vertexShaderConstantT[i];
174 }
175 }
176
177 /* Lights... For a recorded state block, we just had a chain of actions to perform,
178 so we need to walk that chain and update any actions which differ */
179 src = This->lights;
180 while (src != NULL) {
181 PLIGHTINFOEL *realLight = NULL;
182
183 /* Locate the light in the live lights */
184 realLight = targetStateBlock->lights;
185 while (realLight != NULL && realLight->OriginalIndex != src->OriginalIndex) realLight = realLight->next;
186
187 if (realLight == NULL) {
188 FIXME("A captured light no longer exists...?\n");
189 } else {
190
191 /* If 'changed' then its a SetLight command. Rather than comparing to see
192 if the OriginalParms have changed and then copy them (twice through
193 memory) just do the copy */
194 if (src->changed) {
195 TRACE("Updating lights for light %ld\n", src->OriginalIndex);
196 memcpy(&src->OriginalParms, &realLight->OriginalParms, sizeof(PLIGHTINFOEL));
197 }
198
199 /* If 'enabledchanged' then its a LightEnable command */
200 if (src->enabledChanged) {
201 TRACE("Updating lightEnabled for light %ld\n", src->OriginalIndex);
202 src->lightEnabled = realLight->lightEnabled;
203 }
204
205 }
206
207 src = src->next;
208 }
209
210 /* Recorded => Only update 'changed' values */
211 if (This->pixelShader != targetStateBlock->pixelShader) {
212 This->pixelShader = targetStateBlock->pixelShader;
213 TRACE("Updating pixrl shader to %p\n", targetStateBlock->pixelShader);
214 }
215
216 /* Pixel Shader Constants */
217 for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
218 if (This->set.pixelShaderConstants[i]) {
219 TRACE("Setting %p from %p %d to %f\n", This, targetStateBlock, i, targetStateBlock->pixelShaderConstantF[i * 4 + 1]);
220 This->pixelShaderConstantB[i] = targetStateBlock->pixelShaderConstantB[i];
221 This->pixelShaderConstantF[i * 4] = targetStateBlock->pixelShaderConstantF[i * 4];
222 This->pixelShaderConstantF[i * 4 + 1] = targetStateBlock->pixelShaderConstantF[i * 4 + 1];
223 This->pixelShaderConstantF[i * 4 + 2] = targetStateBlock->pixelShaderConstantF[i * 4 + 2];
224 This->pixelShaderConstantF[i * 4 + 3] = targetStateBlock->pixelShaderConstantF[i * 4 + 3];
225 This->pixelShaderConstantI[i * 4] = targetStateBlock->pixelShaderConstantI[i * 4];
226 This->pixelShaderConstantI[i * 4 + 1] = targetStateBlock->pixelShaderConstantI[i * 4 + 1];
227 This->pixelShaderConstantI[i * 4 + 2] = targetStateBlock->pixelShaderConstantI[i * 4 + 2];
228 This->pixelShaderConstantI[i * 4 + 3] = targetStateBlock->pixelShaderConstantI[i * 4 + 3];
229 This->pixelShaderConstantT[i] = targetStateBlock->pixelShaderConstantT[i];
230 }
231 }
232
233 /* Others + Render & Texture */
234 for (i = 1; i <= HIGHEST_TRANSFORMSTATE; i++) {
235 if (This->set.transform[i] && memcmp(&targetStateBlock->transforms[i],
236 &This->transforms[i],
237 sizeof(D3DMATRIX)) != 0) {
238 TRACE("Updating transform %d\n", i);
239 memcpy(&This->transforms[i], &targetStateBlock->transforms[i], sizeof(D3DMATRIX));
240 }
241 }
242
243 if (This->set.indices && ((This->pIndexData != targetStateBlock->pIndexData)
244 || (This->baseVertexIndex != targetStateBlock->baseVertexIndex))) {
245 TRACE("Updating pindexData to %p, baseVertexIndex to %d\n",
246 targetStateBlock->pIndexData, targetStateBlock->baseVertexIndex);
247 This->pIndexData = targetStateBlock->pIndexData;
248 This->baseVertexIndex = targetStateBlock->baseVertexIndex;
249 }
250
251 if(This->set.vertexDecl && This->vertexDecl != targetStateBlock->vertexDecl){
252 This->vertexDecl = targetStateBlock->vertexDecl;
253 }
254
255 if(This->set.fvf && This->fvf != targetStateBlock->fvf){
256 This->fvf = targetStateBlock->fvf;
257 }
258
259 if (This->set.material && memcmp(&targetStateBlock->material,
260 &This->material,
261 sizeof(D3DMATERIAL9)) != 0) {
262 TRACE("Updating material\n");
263 memcpy(&This->material, &targetStateBlock->material, sizeof(D3DMATERIAL9));
264 }
265
266 if (This->set.viewport && memcmp(&targetStateBlock->viewport,
267 &This->viewport,
268 sizeof(D3DVIEWPORT9)) != 0) {
269 TRACE("Updating viewport\n");
270 memcpy(&This->viewport, &targetStateBlock->viewport, sizeof(D3DVIEWPORT9));
271 }
272
273 for (i = 0; i < MAX_STREAMS; i++) {
274 if (This->set.streamSource[i] &&
275 ((This->streamStride[i] != targetStateBlock->streamStride[i]) ||
276 (This->streamSource[i] != targetStateBlock->streamSource[i]))) {
277 TRACE("Updating stream source %d to %p, stride to %d\n", i, targetStateBlock->streamSource[i],
278 targetStateBlock->streamStride[i]);
279 This->streamStride[i] = targetStateBlock->streamStride[i];
280 This->streamSource[i] = targetStateBlock->streamSource[i];
281 }
282
283 if (This->set.streamFreq[i] &&
284 (This->streamFreq[i] != targetStateBlock->streamFreq[i]
285 || This->streamFlags[i] != targetStateBlock->streamFlags[i])){
286 TRACE("Updating stream frequency %d to %d flags to %d\n", i , targetStateBlock->streamFreq[i] ,
287 targetStateBlock->streamFlags[i]);
288 This->streamFreq[i] = targetStateBlock->streamFreq[i];
289 This->streamFlags[i] = targetStateBlock->streamFlags[i];
290 }
291 }
292
293 for (i = 0; i < GL_LIMITS(clipplanes); i++) {
294 if (This->set.clipplane[i] && memcmp(&targetStateBlock->clipplane[i],
295 &This->clipplane[i],
296 sizeof(This->clipplane)) != 0) {
297
298 TRACE("Updating clipplane %d\n", i);
299 memcpy(&This->clipplane[i], &targetStateBlock->clipplane[i],
300 sizeof(This->clipplane));
301 }
302 }
303
304 /* Render */
305 for (i = 1; i <= WINEHIGHEST_RENDER_STATE; i++) {
306
307 if (This->set.renderState[i] && (This->renderState[i] != targetStateBlock->renderState[i])) {
308 TRACE("Updating renderState %d to %ld\n", i, targetStateBlock->renderState[i]);
309 This->renderState[i] = targetStateBlock->renderState[i];
310 }
311 }
312
313 /* FIXME: textures are upto MAX_SAMPLERS for d3d9? */
314 /* Texture */
315 for (j = 0; j < GL_LIMITS(textures); j++) {
316 /* TODO: move over to using memcpy */
317 for (i = 1; i <= WINED3D_HIGHEST_TEXTURE_STATE ; i++) {
318 if (This->set.textureState[j][i]) {
319 TRACE("Updating texturestagestate %d,%d to %ld (was %ld)\n", j,i, targetStateBlock->textureState[j][i],
320 This->textureState[j][i]);
321 This->textureState[j][i] = targetStateBlock->textureState[j][i];
322 }
323 }
324
325 if (This->set.textures[j]) {
326 TRACE("Updating texture %d to %p (was %p)\n", j, targetStateBlock->textures[j], This->textures[j]);
327 This->textures[j] = targetStateBlock->textures[j];
328 }
329
330 }
331
332 /* Samplers */
333 /* TODO: move over to using memcpy */
334 for (j = 0 ; j < GL_LIMITS(samplers); j++){
335 for (i = 1; i <= WINED3D_HIGHEST_SAMPLER_STATE ; i++){ /* States are 1 based */
336 if (This->set.samplerState[j][i]) {
337 TRACE("Updating sampler state %d,%d to %ld (was %ld)\n",
338 j, i, targetStateBlock->samplerState[j][i],
339 This->samplerState[j][i]);
340 This->samplerState[j][i] = targetStateBlock->samplerState[j][i];
341 }
342 }
343 }
344 }
345
346 TRACE("(%p) : Updated state block %p ------------------^\n", targetStateBlock, This);
347
348 return D3D_OK;
349 }
350
351 HRESULT WINAPI IWineD3DStateBlockImpl_Apply(IWineD3DStateBlock *iface){
352 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
353 IWineD3DDevice* pDevice = (IWineD3DDevice*)This->wineD3DDevice;
354
355 /*Copy thing over to updateBlock is isRecording otherwise StateBlock,
356 should really perform a delta so that only the changes get updated*/
357
358
359 UINT i;
360 UINT j;
361
362 TRACE("(%p) : Applying state block %p ------------------v\n", This, pDevice);
363
364 /* FIXME: Only apply applicable states not all states */
365
366 if (/*TODO: 'magic' statetype, replace with BOOL This->blockType == D3DSBT_RECORDED || */This->blockType == WINED3DSBT_INIT || This->blockType == WINED3DSBT_ALL || This->blockType == WINED3DSBT_VERTEXSTATE) {
367
368
369 PLIGHTINFOEL *toDo = This->lights;
370 while (toDo != NULL) {
371 if (toDo->changed)
372 IWineD3DDevice_SetLight(pDevice, toDo->OriginalIndex, &toDo->OriginalParms);
373 if (toDo->enabledChanged)
374 IWineD3DDevice_SetLightEnable(pDevice, toDo->OriginalIndex, toDo->lightEnabled);
375 toDo = toDo->next;
376 }
377
378 /* Vertex Shader */
379 if (This->set.vertexShader && This->changed.vertexShader) {
380 IWineD3DDevice_SetVertexShader(pDevice, This->vertexShader);
381 }
382
383 /* Vertex Shader Constants */
384 for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
385 if (This->set.vertexShaderConstants[i] && This->changed.vertexShaderConstants[i]) {
386 switch (This->vertexShaderConstantT[i]) {
387 case WINESHADERCNST_FLOAT:
388 IWineD3DDevice_SetVertexShaderConstantF(pDevice, i, This->vertexShaderConstantF + i * 4, 1);
389 break;
390 case WINESHADERCNST_BOOL:
391 IWineD3DDevice_SetVertexShaderConstantB(pDevice, i, This->vertexShaderConstantB + i, 1);
392 break;
393 case WINESHADERCNST_INTEGER:
394 IWineD3DDevice_SetVertexShaderConstantI(pDevice, i, This->vertexShaderConstantI + i * 4, 1);
395 break;
396 }
397 }
398 }
399
400 }
401
402 if (/*TODO: 'magic' statetype, replace with BOOL This->blockType == D3DSBT_RECORDED || */ This->blockType == D3DSBT_ALL || This->blockType == D3DSBT_PIXELSTATE) {
403
404 /* Pixel Shader */
405 if (This->set.pixelShader && This->changed.pixelShader) {
406 IWineD3DDevice_SetPixelShader(pDevice, This->pixelShader);
407 }
408
409 /* Pixel Shader Constants */
410 for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
411 if (This->set.pixelShaderConstants[i] && This->changed.pixelShaderConstants[i]) {
412 switch (This->pixelShaderConstantT[i]) {
413 case WINESHADERCNST_FLOAT:
414 IWineD3DDevice_SetPixelShaderConstantF(pDevice, i, This->pixelShaderConstantF + i * 4, 1);
415 break;
416 case WINESHADERCNST_BOOL:
417 IWineD3DDevice_SetPixelShaderConstantB(pDevice, i, This->pixelShaderConstantB + i, 1);
418 break;
419 case WINESHADERCNST_INTEGER:
420 IWineD3DDevice_SetPixelShaderConstantI(pDevice, i, This->pixelShaderConstantI + i * 4, 1);
421 break;
422 }
423 }
424 }
425 }
426
427 if (This->set.fvf && This->changed.fvf) {
428 IWineD3DDevice_SetFVF(pDevice, This->fvf);
429 }
430
431 if (This->set.vertexDecl && This->changed.vertexDecl) {
432 IWineD3DDevice_SetVertexDeclaration(pDevice, This->vertexDecl);
433 }
434
435 IWineD3DDevice_SetSoftwareVertexProcessing(pDevice, This->softwareVertexProcessing);
436
437 /* Others + Render & Texture */
438 if (/*TODO: 'magic' statetype, replace with BOOL This->blockType == D3DSBT_RECORDED || */ This->blockType == WINED3DSBT_ALL || This->blockType == WINED3DSBT_INIT) {
439 for (i = 1; i <= HIGHEST_TRANSFORMSTATE; i++) {
440 if (This->set.transform[i] && This->changed.transform[i])
441 IWineD3DDevice_SetTransform(pDevice, i, &This->transforms[i]);
442 }
443
444 if (This->set.indices && This->changed.indices)
445 IWineD3DDevice_SetIndices(pDevice, This->pIndexData, This->baseVertexIndex);
446
447 if (This->set.material && This->changed.material )
448 IWineD3DDevice_SetMaterial(pDevice, &This->material);
449
450 if (This->set.viewport && This->changed.viewport)
451 IWineD3DDevice_SetViewport(pDevice, &This->viewport);
452
453 /* TODO: Proper implementation using SetStreamSource offset (set to 0 for the moment)\n") */
454 for (i=0; i<MAX_STREAMS; i++) {
455 if (This->set.streamSource[i] && This->changed.streamSource[i])
456 IWineD3DDevice_SetStreamSource(pDevice, i, This->streamSource[i], 0, This->streamStride[i]);
457
458 if (This->set.streamFreq[i] && This->changed.streamFreq[i])
459 IWineD3DDevice_SetStreamSourceFreq(pDevice, i, This->streamFreq[i] | This->streamFlags[i]);
460 }
461
462 for (i = 0; i < GL_LIMITS(clipplanes); i++) {
463 if (This->set.clipplane[i] && This->changed.clipplane[i]) {
464 float clip[4];
465
466 clip[0] = This->clipplane[i][0];
467 clip[1] = This->clipplane[i][1];
468 clip[2] = This->clipplane[i][2];
469 clip[3] = This->clipplane[i][3];
470 IWineD3DDevice_SetClipPlane(pDevice, i, clip);
471 }
472 }
473
474 /* Render */
475 for (i = 1; i <= WINEHIGHEST_RENDER_STATE; i++) {
476 if (This->set.renderState[i] && This->changed.renderState[i])
477 IWineD3DDevice_SetRenderState(pDevice, i, This->renderState[i]);
478 }
479
480 /* FIXME: Texture are set against samplers... not just TextureStages */
481 /* Texture */
482 for (j = 0; j < GL_LIMITS(textures); j++) { /* Set The texture first, just in case it resets the states? */
483 if (This->set.textures[j] && This->changed.textures[j]) {
484 IWineD3DDevice_SetTexture(pDevice, j, This->textures[j]);
485 }
486 /* TODO: move over to memcpy */
487 for (i = 1; i <= WINED3D_HIGHEST_TEXTURE_STATE; i++) {
488 if (This->set.textureState[j][i] && This->changed.textureState[j][i]) { /* tb_dx9_10 failes without this test */
489 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->textureState[j][i] = This->textureState[j][i];
490 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->set.textureState[j][i] = TRUE;
491 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->changed.textureState[j][i] = TRUE;
492 }
493 }
494 }
495
496 /* Samplers */
497 /* TODO: move over to memcpy */
498 for (j = 0 ; j < GL_LIMITS(samplers); j++){
499 for (i = 1; i <= WINED3D_HIGHEST_SAMPLER_STATE; i++){
500 if (This->set.samplerState[j][i] && This->changed.samplerState[j][i]) {
501 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->samplerState[j][i] = This->samplerState[j][i];
502 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->set.samplerState[j][i] = TRUE;
503 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->changed.samplerState[j][i] = TRUE;
504 }
505 }
506
507 }
508
509 } else if (This->blockType == WINED3DSBT_PIXELSTATE) {
510
511 for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
512 if (This->set.renderState[SavedPixelStates_R[i]] && This->changed.renderState[SavedPixelStates_R[i]])
513 IWineD3DDevice_SetRenderState(pDevice, SavedPixelStates_R[i], This->renderState[SavedPixelStates_R[i]]);
514
515 }
516
517 for (j = 0; j < GL_LIMITS(textures); j++) {
518 for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) {
519 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->textureState[j][SavedPixelStates_T[i]] = This->textureState[j][SavedPixelStates_T[i]];
520 }
521 }
522
523 for (j = 0; j < GL_LIMITS(samplers); j++) {
524 for (i = 0; i < NUM_SAVEDPIXELSTATES_S; i++) {
525 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->samplerState[j][SavedPixelStates_S[i]] = This->samplerState[j][SavedPixelStates_S[i]];
526 }
527 }
528
529 } else if (This->blockType == WINED3DSBT_VERTEXSTATE) {
530
531 for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
532 if ( This->set.renderState[SavedVertexStates_R[i]] && This->changed.renderState[SavedVertexStates_R[i]])
533 IWineD3DDevice_SetRenderState(pDevice, SavedVertexStates_R[i], This->renderState[SavedVertexStates_R[i]]);
534 }
535
536 for (j = 0; j < GL_LIMITS(textures); j++) {
537 for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) {
538 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->textureState[j][SavedVertexStates_T[i]] = This->textureState[j][SavedVertexStates_T[i]];
539 }
540 }
541
542 for (j = 0; j < GL_LIMITS(textures); j++) {
543 for (i = 0; i < NUM_SAVEDVERTEXSTATES_S; i++) {
544 ((IWineD3DDeviceImpl *)pDevice)->stateBlock->samplerState[j][SavedVertexStates_S[i]] = This->samplerState[j][SavedVertexStates_S[i]];
545 }
546 }
547
548
549 } else {
550 FIXME("Unrecognized state block type %d\n", This->blockType);
551 }
552 memcpy(&((IWineD3DDeviceImpl*)pDevice)->stateBlock->changed, &This->changed, sizeof(((IWineD3DDeviceImpl*)pDevice)->stateBlock->changed));
553 TRACE("(%p) : Applied state block %p ------------------^\n", This, pDevice);
554
555 return D3D_OK;
556 }
557
558 HRESULT WINAPI IWineD3DStateBlockImpl_InitStartupStateBlock(IWineD3DStateBlock* iface) {
559 IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
560 IWineD3DDevice *device = (IWineD3DDevice *)This->wineD3DDevice;
561 IWineD3DDeviceImpl *ThisDevice = (IWineD3DDeviceImpl *)device;
562 union {
563 D3DLINEPATTERN lp;
564 DWORD d;
565 } lp;
566 union {
567 float f;
568 DWORD d;
569 } tmpfloat;
570 unsigned int i;
571
572 /* Note this may have a large overhead but it should only be executed
573 once, in order to initialize the complete state of the device and
574 all opengl equivalents */
575 TRACE("(%p) -----------------------> Setting up device defaults... %p \n", This, This->wineD3DDevice);
576 /* TODO: make a special stateblock type for the primary stateblock (it never gets applied so it doesn't need a real type) */
577 This->blockType = WINED3DSBT_INIT;
578
579 /* Set some of the defaults for lights, transforms etc */
580 memcpy(&This->transforms[D3DTS_PROJECTION], &identity, sizeof(identity));
581 memcpy(&This->transforms[D3DTS_VIEW], &identity, sizeof(identity));
582 for (i = 0; i < 256; ++i) {
583 memcpy(&This->transforms[D3DTS_WORLDMATRIX(i)], &identity, sizeof(identity));
584 }
585
586 TRACE("Render states\n");
587 /* Render states: */
588 if (ThisDevice->depthStencilBuffer != NULL) {
589 IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE, D3DZB_TRUE);
590 } else {
591 IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE, D3DZB_FALSE);
592 }
593 IWineD3DDevice_SetRenderState(device, WINED3DRS_FILLMODE, D3DFILL_SOLID);
594 IWineD3DDevice_SetRenderState(device, WINED3DRS_SHADEMODE, D3DSHADE_GOURAUD);
595 lp.lp.wRepeatFactor = 0;
596 lp.lp.wLinePattern = 0;
597 IWineD3DDevice_SetRenderState(device, WINED3DRS_LINEPATTERN, lp.d);
598 IWineD3DDevice_SetRenderState(device, WINED3DRS_ZWRITEENABLE, TRUE);
599 IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHATESTENABLE, FALSE);
600 IWineD3DDevice_SetRenderState(device, WINED3DRS_LASTPIXEL, TRUE);
601 IWineD3DDevice_SetRenderState(device, WINED3DRS_SRCBLEND, D3DBLEND_ONE);
602 IWineD3DDevice_SetRenderState(device, WINED3DRS_DESTBLEND, D3DBLEND_ZERO);
603 IWineD3DDevice_SetRenderState(device, WINED3DRS_CULLMODE, D3DCULL_CCW);
604 IWineD3DDevice_SetRenderState(device, WINED3DRS_ZFUNC, D3DCMP_LESSEQUAL);
605 IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHAFUNC, D3DCMP_ALWAYS);
606 IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHAREF, 0xff); /*??*/
607 IWineD3DDevice_SetRenderState(device, WINED3DRS_DITHERENABLE, FALSE);
608 IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHABLENDENABLE, FALSE);
609 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGENABLE, FALSE);
610 IWineD3DDevice_SetRenderState(device, WINED3DRS_SPECULARENABLE, FALSE);
611 IWineD3DDevice_SetRenderState(device, WINED3DRS_ZVISIBLE, 0);
612 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGCOLOR, 0);
613 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGTABLEMODE, D3DFOG_NONE);
614 tmpfloat.f = 0.0f;
615 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGSTART, tmpfloat.d);
616 tmpfloat.f = 1.0f;
617 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGEND, tmpfloat.d);
618 tmpfloat.f = 1.0f;
619 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGDENSITY, tmpfloat.d);
620 IWineD3DDevice_SetRenderState(device, WINED3DRS_EDGEANTIALIAS, FALSE);
621 IWineD3DDevice_SetRenderState(device, WINED3DRS_ZBIAS, 0);
622 IWineD3DDevice_SetRenderState(device, WINED3DRS_RANGEFOGENABLE, FALSE);
623 IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILENABLE, FALSE);
624 IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
625 IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
626 IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
627
628 /* Setting stencil func also uses values for stencil ref/mask, so manually set defaults
629 * so only a single call performed (and ensure defaults initialized before making that call)
630 *
631 * IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILREF, 0);
632 * IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILMASK, 0xFFFFFFFF);
633 */
634 This->renderState[WINED3DRS_STENCILREF] = 0;
635 This->renderState[WINED3DRS_STENCILMASK] = 0xFFFFFFFF;
636 IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILFUNC, D3DCMP_ALWAYS);
637 IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILWRITEMASK, 0xFFFFFFFF);
638 IWineD3DDevice_SetRenderState(device, WINED3DRS_TEXTUREFACTOR, 0xFFFFFFFF);
639 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP0, 0);
640 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP1, 0);
641 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP2, 0);
642 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP3, 0);
643 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP4, 0);
644 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP5, 0);
645 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP6, 0);
646 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP7, 0);
647 IWineD3DDevice_SetRenderState(device, WINED3DRS_CLIPPING, TRUE);
648 IWineD3DDevice_SetRenderState(device, WINED3DRS_LIGHTING, TRUE);
649 IWineD3DDevice_SetRenderState(device, WINED3DRS_AMBIENT, 0);
650 IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGVERTEXMODE, D3DFOG_NONE);
651 IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORVERTEX, TRUE);
652 IWineD3DDevice_SetRenderState(device, WINED3DRS_LOCALVIEWER, TRUE);
653 IWineD3DDevice_SetRenderState(device, WINED3DRS_NORMALIZENORMALS, FALSE);
654 IWineD3DDevice_SetRenderState(device, WINED3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
655 IWineD3DDevice_SetRenderState(device, WINED3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2);
656 IWineD3DDevice_SetRenderState(device, WINED3DRS_AMBIENTMATERIALSOURCE, D3DMCS_COLOR2);
657 IWineD3DDevice_SetRenderState(device, WINED3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
658 IWineD3DDevice_SetRenderState(device, WINED3DRS_VERTEXBLEND, D3DVBF_DISABLE);
659 IWineD3DDevice_SetRenderState(device, WINED3DRS_CLIPPLANEENABLE, 0);
660 IWineD3DDevice_SetRenderState(device, WINED3DRS_SOFTWAREVERTEXPROCESSING, FALSE);
661 tmpfloat.f = 1.0f;
662 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSIZE, tmpfloat.d);
663 tmpfloat.f = 0.0f;
664 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSIZE_MIN, tmpfloat.d);
665 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSPRITEENABLE, FALSE);
666 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALEENABLE, FALSE);
667 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALE_A, TRUE);
668 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALE_B, TRUE);
669 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALE_C, TRUE);
670 IWineD3DDevice_SetRenderState(device, WINED3DRS_MULTISAMPLEANTIALIAS, TRUE);
671 IWineD3DDevice_SetRenderState(device, WINED3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
672 IWineD3DDevice_SetRenderState(device, WINED3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_DISCRETE);
673 tmpfloat.f = 1.0f;
674 IWineD3DDevice_SetRenderState(device, WINED3DRS_PATCHSEGMENTS, tmpfloat.d);
675 IWineD3DDevice_SetRenderState(device, WINED3DRS_DEBUGMONITORTOKEN, D3DDMT_DISABLE);
676 tmpfloat.f = 64.0f;
677 IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSIZE_MAX, tmpfloat.d);
678 IWineD3DDevice_SetRenderState(device, WINED3DRS_INDEXEDVERTEXBLENDENABLE, FALSE);
679 IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE, 0x0000000F);
680 tmpfloat.f = 0.0f;
681 IWineD3DDevice_SetRenderState(device, WINED3DRS_TWEENFACTOR, tmpfloat.d);
682 IWineD3DDevice_SetRenderState(device, WINED3DRS_BLENDOP, D3DBLENDOP_ADD);
683 IWineD3DDevice_SetRenderState(device, WINED3DRS_POSITIONDEGREE, WINED3DDEGREE_CUBIC);
684 IWineD3DDevice_SetRenderState(device, WINED3DRS_NORMALDEGREE, WINED3DDEGREE_LINEAR);
685 /* states new in d3d9 */
686 IWineD3DDevice_SetRenderState(device, WINED3DRS_SCISSORTESTENABLE, FALSE);
687 IWineD3DDevice_SetRenderState(device, WINED3DRS_SLOPESCALEDEPTHBIAS, 0);
688 tmpfloat.f = 1.0f;
689 IWineD3DDevice_SetRenderState(device, WINED3DRS_MINTESSELLATIONLEVEL, tmpfloat.d);
690 IWineD3DDevice_SetRenderState(device, WINED3DRS_MAXTESSELLATIONLEVEL, tmpfloat.d);
691 IWineD3DDevice_SetRenderState(device, WINED3DRS_ANTIALIASEDLINEENABLE, FALSE);
692 tmpfloat.f = 0.0f;
693 IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_X, tmpfloat.d);
694 IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_Y, tmpfloat.d);
695 tmpfloat.f = 1.0f;
696 IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_Z, tmpfloat.d);
697 tmpfloat.f = 0.0f;
698 IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_W, tmpfloat.d);
699 IWineD3DDevice_SetRenderState(device, WINED3DRS_ENABLEADAPTIVETESSELLATION, FALSE);
700 IWineD3DDevice_SetRenderState(device, WINED3DRS_TWOSIDEDSTENCILMODE, FALSE);
701 IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILFAIL, D3DSTENCILOP_KEEP);
702 IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_KEEP);
703 IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILPASS, D3DSTENCILOP_KEEP);
704 IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILFUNC, D3DCMP_ALWAYS);
705 IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE1, 0x0000000F);
706 IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE2, 0x0000000F);
707 IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE3, 0x0000000F);
708 IWineD3DDevice_SetRenderState(device, WINED3DRS_BLENDFACTOR, 0xFFFFFFFF);
709 IWineD3DDevice_SetRenderState(device, WINED3DRS_SRGBWRITEENABLE, 0);
710 IWineD3DDevice_SetRenderState(device, WINED3DRS_DEPTHBIAS, 0);
711 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP8, 0);
712 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP9, 0);
713 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP10, 0);
714 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP11, 0);
715 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP12, 0);
716 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP13, 0);
717 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP14, 0);
718 IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP15, 0);
719 IWineD3DDevice_SetRenderState(device, WINED3DRS_SEPARATEALPHABLENDENABLE, FALSE);
720 IWineD3DDevice_SetRenderState(device, WINED3DRS_SRCBLENDALPHA, D3DBLEND_ONE);
721 IWineD3DDevice_SetRenderState(device, WINED3DRS_DESTBLENDALPHA, D3DBLEND_ZERO);
722 IWineD3DDevice_SetRenderState(device, WINED3DRS_BLENDOPALPHA, D3DBLENDOP_ADD);
723
724 /* clipping status */
725 This->clip_status.ClipUnion = 0;
726 This->clip_status.ClipIntersection = 0xFFFFFFFF;
727
728 /* Texture Stage States - Put directly into state block, we will call function below */
729 for (i = 0; i < GL_LIMITS(textures); i++) {
730 TRACE("Setting up default texture states for texture Stage %d\n", i);
731 memcpy(&This->transforms[D3DTS_TEXTURE0 + i], &identity, sizeof(identity));
732 This->textureState[i][D3DTSS_COLOROP ] = (i==0)? D3DTOP_MODULATE : D3DTOP_DISABLE;
733 This->textureState[i][D3DTSS_COLORARG1 ] = D3DTA_TEXTURE;
734 This->textureState[i][D3DTSS_COLORARG2 ] = D3DTA_CURRENT;
735 This->textureState[i][D3DTSS_ALPHAOP ] = (i==0)? D3DTOP_SELECTARG1 : D3DTOP_DISABLE;
736 This->textureState[i][D3DTSS_ALPHAARG1 ] = D3DTA_TEXTURE;
737 This->textureState[i][D3DTSS_ALPHAARG2 ] = D3DTA_CURRENT;
738 This->textureState[i][D3DTSS_BUMPENVMAT00 ] = (DWORD) 0.0;
739 This->textureState[i][D3DTSS_BUMPENVMAT01 ] = (DWORD) 0.0;
740 This->textureState[i][D3DTSS_BUMPENVMAT10 ] = (DWORD) 0.0;
741 This->textureState[i][D3DTSS_BUMPENVMAT11 ] = (DWORD) 0.0;
742 This->textureState[i][D3DTSS_TEXCOORDINDEX ] = i;
743 This->textureState[i][D3DTSS_BUMPENVLSCALE ] = (DWORD) 0.0;
744 This->textureState[i][D3DTSS_BUMPENVLOFFSET ] = (DWORD) 0.0;
745 This->textureState[i][D3DTSS_TEXTURETRANSFORMFLAGS ] = D3DTTFF_DISABLE;
746 This->textureState[i][D3DTSS_ADDRESSW ] = D3DTADDRESS_WRAP;
747 This->textureState[i][D3DTSS_COLORARG0 ] = D3DTA_CURRENT;
748 This->textureState[i][D3DTSS_ALPHAARG0 ] = D3DTA_CURRENT;
749 This->textureState[i][D3DTSS_RESULTARG ] = D3DTA_CURRENT;
750 }
751
752 /* Sampler states*/
753 for (i = 0 ; i < GL_LIMITS(samplers); i++) {
754 TRACE("Setting up default samplers states for sampler %d\n", i);
755 This->samplerState[i][WINED3DSAMP_ADDRESSU ] = D3DTADDRESS_WRAP;
756 This->samplerState[i][WINED3DSAMP_ADDRESSV ] = D3DTADDRESS_WRAP;
757 This->samplerState[i][WINED3DSAMP_ADDRESSW ] = D3DTADDRESS_WRAP;
758 This->samplerState[i][WINED3DSAMP_BORDERCOLOR ] = 0x00;
759 This->samplerState[i][WINED3DSAMP_MAGFILTER ] = D3DTEXF_POINT;
760 This->samplerState[i][WINED3DSAMP_MINFILTER ] = D3DTEXF_POINT;
761 This->samplerState[i][WINED3DSAMP_MIPFILTER ] = D3DTEXF_NONE;
762 This->samplerState[i][WINED3DSAMP_MIPMAPLODBIAS ] = 0;
763 This->samplerState[i][WINED3DSAMP_MAXMIPLEVEL ] = 0;
764 This->samplerState[i][WINED3DSAMP_MAXANISOTROPY ] = 1;
765 This->samplerState[i][WINED3DSAMP_SRGBTEXTURE ] = 0; /* TODO: Gamma correction value*/
766 This->samplerState[i][WINED3DSAMP_ELEMENTINDEX ] = 0; /* TODO: Indicates which element of a multielement texture to use */
767 This->samplerState[i][WINED3DSAMP_DMAPOFFSET ] = 256; /* TODO: Vertex offset in the presampled displacement map */
768 }
769
770 /* Under DirectX you can have texture stage operations even if no texture is
771 bound, whereas opengl will only do texture operations when a valid texture is
772 bound. We emulate this by creating dummy textures and binding them to each
773 texture stage, but disable all stages by default. Hence if a stage is enabled
774 then the default texture will kick in until replaced by a SetTexture call */
775
776 ENTER_GL();
777
778 for (i = 0; i < GL_LIMITS(textures); i++) {
779 GLubyte white = 255;
780
781 /* Note this avoids calling settexture, so pretend it has been called */
782 This->set.textures[i] = TRUE;
783 This->changed.textures[i] = TRUE;
784 This->textures[i] = NULL;
785
786 /* Make appropriate texture active */
787 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
788 GLACTIVETEXTURE(i);
789 } else if (i > 0) {
790 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
791 }
792
793 /* Generate an opengl texture name */
794 glGenTextures(1, &ThisDevice->dummyTextureName[i]);
795 checkGLcall("glGenTextures");
796 TRACE("Dummy Texture %d given name %d\n", i, ThisDevice->dummyTextureName[i]);
797
798 /* Generate a dummy 1d texture */
799 This->textureDimensions[i] = GL_TEXTURE_1D;
800 glBindTexture(GL_TEXTURE_1D, ThisDevice->dummyTextureName[i]);
801 checkGLcall("glBindTexture");
802
803 glTexImage1D(GL_TEXTURE_1D, 0, GL_LUMINANCE, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &white);
804 checkGLcall("glTexImage1D");
805 #if 1 /* TODO: move the setting texture states off to basetexture */
806 /* Reapply all the texture state information to this texture */
807 IWineD3DDevice_SetupTextureStates(device, i, REAPPLY_ALL);
808 #endif
809 }
810
811 LEAVE_GL();
812
813 /* Defaulting palettes - Note these are device wide but reinitialized here for convenience*/
814 for (i = 0; i < MAX_PALETTES; ++i) {
815 int j;
816 for (j = 0; j < 256; ++j) {
817 This->wineD3DDevice->palettes[i][j].peRed = 0xFF;
818 This->wineD3DDevice->palettes[i][j].peGreen = 0xFF;
819 This->wineD3DDevice->palettes[i][j].peBlue = 0xFF;
820 This->wineD3DDevice->palettes[i][j].peFlags = 0xFF;
821 }
822 }
823 This->wineD3DDevice->currentPalette = 0;
824
825 TRACE("-----------------------> Device defaults now set up...\n");
826 return D3D_OK;
827 }
828
829 /**********************************************************
830 * IWineD3DStateBlock VTbl follows
831 **********************************************************/
832
833 const IWineD3DStateBlockVtbl IWineD3DStateBlock_Vtbl =
834 {
835 /* IUnknown */
836 IWineD3DStateBlockImpl_QueryInterface,
837 IWineD3DStateBlockImpl_AddRef,
838 IWineD3DStateBlockImpl_Release,
839 /* IWineD3DStateBlock */
840 IWineD3DStateBlockImpl_GetParent,
841 IWineD3DStateBlockImpl_GetDevice,
842 IWineD3DStateBlockImpl_Capture,
843 IWineD3DStateBlockImpl_Apply,
844 IWineD3DStateBlockImpl_InitStartupStateBlock
845 };
Maarten's multimedia branch