wined3d: Set the nvidia_texture_shader.c GLINFO_LOCATION to *gl_info.
[wine] / dlls / wined3d / stateblock.c
1 /*
2  * state block implementation
3  *
4  * Copyright 2002 Raphael Junqueira
5  * Copyright 2004 Jason Edmeades
6  * Copyright 2005 Oliver Stieber
7  * Copyright 2007 Stefan Dösinger for CodeWeavers
8  * Copyright 2009 Henri Verbeet for CodeWeavers
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24
25 #include "config.h"
26 #include "wined3d_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
29
30 static const DWORD pixel_states_render[] =
31 {
32     WINED3DRS_ALPHABLENDENABLE,
33     WINED3DRS_ALPHAFUNC,
34     WINED3DRS_ALPHAREF,
35     WINED3DRS_ALPHATESTENABLE,
36     WINED3DRS_ANTIALIASEDLINEENABLE,
37     WINED3DRS_BLENDFACTOR,
38     WINED3DRS_BLENDOP,
39     WINED3DRS_BLENDOPALPHA,
40     WINED3DRS_CCW_STENCILFAIL,
41     WINED3DRS_CCW_STENCILPASS,
42     WINED3DRS_CCW_STENCILZFAIL,
43     WINED3DRS_COLORWRITEENABLE,
44     WINED3DRS_COLORWRITEENABLE1,
45     WINED3DRS_COLORWRITEENABLE2,
46     WINED3DRS_COLORWRITEENABLE3,
47     WINED3DRS_DEPTHBIAS,
48     WINED3DRS_DESTBLEND,
49     WINED3DRS_DESTBLENDALPHA,
50     WINED3DRS_DITHERENABLE,
51     WINED3DRS_FILLMODE,
52     WINED3DRS_FOGDENSITY,
53     WINED3DRS_FOGEND,
54     WINED3DRS_FOGSTART,
55     WINED3DRS_LASTPIXEL,
56     WINED3DRS_SCISSORTESTENABLE,
57     WINED3DRS_SEPARATEALPHABLENDENABLE,
58     WINED3DRS_SHADEMODE,
59     WINED3DRS_SLOPESCALEDEPTHBIAS,
60     WINED3DRS_SRCBLEND,
61     WINED3DRS_SRCBLENDALPHA,
62     WINED3DRS_SRGBWRITEENABLE,
63     WINED3DRS_STENCILENABLE,
64     WINED3DRS_STENCILFAIL,
65     WINED3DRS_STENCILFUNC,
66     WINED3DRS_STENCILMASK,
67     WINED3DRS_STENCILPASS,
68     WINED3DRS_STENCILREF,
69     WINED3DRS_STENCILWRITEMASK,
70     WINED3DRS_STENCILZFAIL,
71     WINED3DRS_TEXTUREFACTOR,
72     WINED3DRS_TWOSIDEDSTENCILMODE,
73     WINED3DRS_WRAP0,
74     WINED3DRS_WRAP1,
75     WINED3DRS_WRAP10,
76     WINED3DRS_WRAP11,
77     WINED3DRS_WRAP12,
78     WINED3DRS_WRAP13,
79     WINED3DRS_WRAP14,
80     WINED3DRS_WRAP15,
81     WINED3DRS_WRAP2,
82     WINED3DRS_WRAP3,
83     WINED3DRS_WRAP4,
84     WINED3DRS_WRAP5,
85     WINED3DRS_WRAP6,
86     WINED3DRS_WRAP7,
87     WINED3DRS_WRAP8,
88     WINED3DRS_WRAP9,
89     WINED3DRS_ZENABLE,
90     WINED3DRS_ZFUNC,
91     WINED3DRS_ZWRITEENABLE,
92 };
93
94 static const DWORD pixel_states_texture[] =
95 {
96     WINED3DTSS_ALPHAARG0,
97     WINED3DTSS_ALPHAARG1,
98     WINED3DTSS_ALPHAARG2,
99     WINED3DTSS_ALPHAOP,
100     WINED3DTSS_BUMPENVLOFFSET,
101     WINED3DTSS_BUMPENVLSCALE,
102     WINED3DTSS_BUMPENVMAT00,
103     WINED3DTSS_BUMPENVMAT01,
104     WINED3DTSS_BUMPENVMAT10,
105     WINED3DTSS_BUMPENVMAT11,
106     WINED3DTSS_COLORARG0,
107     WINED3DTSS_COLORARG1,
108     WINED3DTSS_COLORARG2,
109     WINED3DTSS_COLOROP,
110     WINED3DTSS_RESULTARG,
111     WINED3DTSS_TEXCOORDINDEX,
112     WINED3DTSS_TEXTURETRANSFORMFLAGS,
113 };
114
115 static const DWORD pixel_states_sampler[] =
116 {
117     WINED3DSAMP_ADDRESSU,
118     WINED3DSAMP_ADDRESSV,
119     WINED3DSAMP_ADDRESSW,
120     WINED3DSAMP_BORDERCOLOR,
121     WINED3DSAMP_MAGFILTER,
122     WINED3DSAMP_MINFILTER,
123     WINED3DSAMP_MIPFILTER,
124     WINED3DSAMP_MIPMAPLODBIAS,
125     WINED3DSAMP_MAXMIPLEVEL,
126     WINED3DSAMP_MAXANISOTROPY,
127     WINED3DSAMP_SRGBTEXTURE,
128     WINED3DSAMP_ELEMENTINDEX,
129 };
130
131 static const DWORD vertex_states_render[] =
132 {
133     WINED3DRS_ADAPTIVETESS_W,
134     WINED3DRS_ADAPTIVETESS_X,
135     WINED3DRS_ADAPTIVETESS_Y,
136     WINED3DRS_ADAPTIVETESS_Z,
137     WINED3DRS_AMBIENT,
138     WINED3DRS_AMBIENTMATERIALSOURCE,
139     WINED3DRS_CLIPPING,
140     WINED3DRS_CLIPPLANEENABLE,
141     WINED3DRS_COLORVERTEX,
142     WINED3DRS_CULLMODE,
143     WINED3DRS_DIFFUSEMATERIALSOURCE,
144     WINED3DRS_EMISSIVEMATERIALSOURCE,
145     WINED3DRS_ENABLEADAPTIVETESSELLATION,
146     WINED3DRS_FOGCOLOR,
147     WINED3DRS_FOGDENSITY,
148     WINED3DRS_FOGENABLE,
149     WINED3DRS_FOGEND,
150     WINED3DRS_FOGSTART,
151     WINED3DRS_FOGTABLEMODE,
152     WINED3DRS_FOGVERTEXMODE,
153     WINED3DRS_INDEXEDVERTEXBLENDENABLE,
154     WINED3DRS_LIGHTING,
155     WINED3DRS_LOCALVIEWER,
156     WINED3DRS_MAXTESSELLATIONLEVEL,
157     WINED3DRS_MINTESSELLATIONLEVEL,
158     WINED3DRS_MULTISAMPLEANTIALIAS,
159     WINED3DRS_MULTISAMPLEMASK,
160     WINED3DRS_NORMALDEGREE,
161     WINED3DRS_NORMALIZENORMALS,
162     WINED3DRS_PATCHEDGESTYLE,
163     WINED3DRS_POINTSCALE_A,
164     WINED3DRS_POINTSCALE_B,
165     WINED3DRS_POINTSCALE_C,
166     WINED3DRS_POINTSCALEENABLE,
167     WINED3DRS_POINTSIZE,
168     WINED3DRS_POINTSIZE_MAX,
169     WINED3DRS_POINTSIZE_MIN,
170     WINED3DRS_POINTSPRITEENABLE,
171     WINED3DRS_POSITIONDEGREE,
172     WINED3DRS_RANGEFOGENABLE,
173     WINED3DRS_SHADEMODE,
174     WINED3DRS_SPECULARENABLE,
175     WINED3DRS_SPECULARMATERIALSOURCE,
176     WINED3DRS_TWEENFACTOR,
177     WINED3DRS_VERTEXBLEND,
178 };
179
180 static const DWORD vertex_states_texture[] =
181 {
182     WINED3DTSS_TEXCOORDINDEX,
183     WINED3DTSS_TEXTURETRANSFORMFLAGS,
184 };
185
186 static const DWORD vertex_states_sampler[] =
187 {
188     WINED3DSAMP_DMAPOFFSET,
189 };
190
191 /* Allocates the correct amount of space for pixel and vertex shader constants,
192  * along with their set/changed flags on the given stateblock object
193  */
194 static HRESULT stateblock_allocate_shader_constants(IWineD3DStateBlockImpl *object)
195 {
196     IWineD3DDeviceImpl *device = object->device;
197
198     /* Allocate space for floating point constants */
199     object->pixelShaderConstantF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
200             sizeof(float) * device->d3d_pshader_constantF * 4);
201     if (!object->pixelShaderConstantF) goto fail;
202
203     object->changed.pixelShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
204             sizeof(BOOL) * device->d3d_pshader_constantF);
205     if (!object->changed.pixelShaderConstantsF) goto fail;
206
207     object->vertexShaderConstantF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
208             sizeof(float) * device->d3d_vshader_constantF * 4);
209     if (!object->vertexShaderConstantF) goto fail;
210
211     object->changed.vertexShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
212             sizeof(BOOL) * device->d3d_vshader_constantF);
213     if (!object->changed.vertexShaderConstantsF) goto fail;
214
215     object->contained_vs_consts_f = HeapAlloc(GetProcessHeap(), 0,
216             sizeof(DWORD) * device->d3d_vshader_constantF);
217     if (!object->contained_vs_consts_f) goto fail;
218
219     object->contained_ps_consts_f = HeapAlloc(GetProcessHeap(), 0,
220             sizeof(DWORD) * device->d3d_pshader_constantF);
221     if (!object->contained_ps_consts_f) goto fail;
222
223     return WINED3D_OK;
224
225 fail:
226     ERR("Failed to allocate memory\n");
227     HeapFree(GetProcessHeap(), 0, object->pixelShaderConstantF);
228     HeapFree(GetProcessHeap(), 0, object->changed.pixelShaderConstantsF);
229     HeapFree(GetProcessHeap(), 0, object->vertexShaderConstantF);
230     HeapFree(GetProcessHeap(), 0, object->changed.vertexShaderConstantsF);
231     HeapFree(GetProcessHeap(), 0, object->contained_vs_consts_f);
232     HeapFree(GetProcessHeap(), 0, object->contained_ps_consts_f);
233     return E_OUTOFMEMORY;
234 }
235
236 static inline void stateblock_set_bits(DWORD *map, UINT map_size)
237 {
238     DWORD mask = (1 << (map_size & 0x1f)) - 1;
239     memset(map, 0xff, (map_size >> 5) * sizeof(*map));
240     if (mask) map[map_size >> 5] = mask;
241 }
242
243 /* Set all members of a stateblock savedstate to the given value */
244 static void stateblock_savedstates_set_all(SAVEDSTATES *states, DWORD vs_consts, DWORD ps_consts)
245 {
246     unsigned int i;
247
248     /* Single values */
249     states->primitive_type = 1;
250     states->indices = 1;
251     states->material = 1;
252     states->viewport = 1;
253     states->vertexDecl = 1;
254     states->pixelShader = 1;
255     states->vertexShader = 1;
256     states->scissorRect = 1;
257
258     /* Fixed size arrays */
259     states->streamSource = 0xffff;
260     states->streamFreq = 0xffff;
261     states->textures = 0xfffff;
262     stateblock_set_bits(states->transform, HIGHEST_TRANSFORMSTATE + 1);
263     stateblock_set_bits(states->renderState, WINEHIGHEST_RENDER_STATE + 1);
264     for (i = 0; i < MAX_TEXTURES; ++i) states->textureState[i] = 0x3ffff;
265     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = 0x3fff;
266     states->clipplane = 0xffffffff;
267     states->pixelShaderConstantsB = 0xffff;
268     states->pixelShaderConstantsI = 0xffff;
269     states->vertexShaderConstantsB = 0xffff;
270     states->vertexShaderConstantsI = 0xffff;
271
272     /* Dynamically sized arrays */
273     memset(states->pixelShaderConstantsF, TRUE, sizeof(BOOL) * ps_consts);
274     memset(states->vertexShaderConstantsF, TRUE, sizeof(BOOL) * vs_consts);
275 }
276
277 static void stateblock_savedstates_set_pixel(SAVEDSTATES *states, const DWORD num_constants)
278 {
279     DWORD texture_mask = 0;
280     WORD sampler_mask = 0;
281     unsigned int i;
282
283     states->pixelShader = 1;
284
285     for (i = 0; i < sizeof(pixel_states_render) / sizeof(*pixel_states_render); ++i)
286     {
287         DWORD rs = pixel_states_render[i];
288         states->renderState[rs >> 5] |= 1 << (rs & 0x1f);
289     }
290
291     for (i = 0; i < sizeof(pixel_states_texture) / sizeof(*pixel_states_texture); ++i)
292         texture_mask |= 1 << pixel_states_texture[i];
293     for (i = 0; i < MAX_TEXTURES; ++i) states->textureState[i] = texture_mask;
294     for (i = 0; i < sizeof(pixel_states_sampler) / sizeof(*pixel_states_sampler); ++i)
295         sampler_mask |= 1 << pixel_states_sampler[i];
296     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = sampler_mask;
297     states->pixelShaderConstantsB = 0xffff;
298     states->pixelShaderConstantsI = 0xffff;
299
300     memset(states->pixelShaderConstantsF, TRUE, sizeof(BOOL) * num_constants);
301 }
302
303 static void stateblock_savedstates_set_vertex(SAVEDSTATES *states, const DWORD num_constants)
304 {
305     DWORD texture_mask = 0;
306     WORD sampler_mask = 0;
307     unsigned int i;
308
309     states->vertexDecl = 1;
310     states->vertexShader = 1;
311
312     for (i = 0; i < sizeof(vertex_states_render) / sizeof(*vertex_states_render); ++i)
313     {
314         DWORD rs = vertex_states_render[i];
315         states->renderState[rs >> 5] |= 1 << (rs & 0x1f);
316     }
317
318     for (i = 0; i < sizeof(vertex_states_texture) / sizeof(*vertex_states_texture); ++i)
319         texture_mask |= 1 << vertex_states_texture[i];
320     for (i = 0; i < MAX_TEXTURES; ++i) states->textureState[i] = texture_mask;
321     for (i = 0; i < sizeof(vertex_states_sampler) / sizeof(*vertex_states_sampler); ++i)
322         sampler_mask |= 1 << vertex_states_sampler[i];
323     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = sampler_mask;
324     states->vertexShaderConstantsB = 0xffff;
325     states->vertexShaderConstantsI = 0xffff;
326
327     memset(states->vertexShaderConstantsF, TRUE, sizeof(BOOL) * num_constants);
328 }
329
330 void stateblock_init_contained_states(IWineD3DStateBlockImpl *stateblock)
331 {
332     IWineD3DDeviceImpl *device = stateblock->device;
333     unsigned int i, j;
334
335     for (i = 0; i <= WINEHIGHEST_RENDER_STATE >> 5; ++i)
336     {
337         DWORD map = stateblock->changed.renderState[i];
338         for (j = 0; map; map >>= 1, ++j)
339         {
340             if (!(map & 1)) continue;
341
342             stateblock->contained_render_states[stateblock->num_contained_render_states] = (i << 5) | j;
343             ++stateblock->num_contained_render_states;
344         }
345     }
346
347     for (i = 0; i <= HIGHEST_TRANSFORMSTATE >> 5; ++i)
348     {
349         DWORD map = stateblock->changed.transform[i];
350         for (j = 0; map; map >>= 1, ++j)
351         {
352             if (!(map & 1)) continue;
353
354             stateblock->contained_transform_states[stateblock->num_contained_transform_states] = (i << 5) | j;
355             ++stateblock->num_contained_transform_states;
356         }
357     }
358
359     for (i = 0; i < device->d3d_vshader_constantF; ++i)
360     {
361         if (stateblock->changed.vertexShaderConstantsF[i])
362         {
363             stateblock->contained_vs_consts_f[stateblock->num_contained_vs_consts_f] = i;
364             ++stateblock->num_contained_vs_consts_f;
365         }
366     }
367
368     for (i = 0; i < MAX_CONST_I; ++i)
369     {
370         if (stateblock->changed.vertexShaderConstantsI & (1 << i))
371         {
372             stateblock->contained_vs_consts_i[stateblock->num_contained_vs_consts_i] = i;
373             ++stateblock->num_contained_vs_consts_i;
374         }
375     }
376
377     for (i = 0; i < MAX_CONST_B; ++i)
378     {
379         if (stateblock->changed.vertexShaderConstantsB & (1 << i))
380         {
381             stateblock->contained_vs_consts_b[stateblock->num_contained_vs_consts_b] = i;
382             ++stateblock->num_contained_vs_consts_b;
383         }
384     }
385
386     for (i = 0; i < device->d3d_pshader_constantF; ++i)
387     {
388         if (stateblock->changed.pixelShaderConstantsF[i])
389         {
390             stateblock->contained_ps_consts_f[stateblock->num_contained_ps_consts_f] = i;
391             ++stateblock->num_contained_ps_consts_f;
392         }
393     }
394
395     for (i = 0; i < MAX_CONST_I; ++i)
396     {
397         if (stateblock->changed.pixelShaderConstantsI & (1 << i))
398         {
399             stateblock->contained_ps_consts_i[stateblock->num_contained_ps_consts_i] = i;
400             ++stateblock->num_contained_ps_consts_i;
401         }
402     }
403
404     for (i = 0; i < MAX_CONST_B; ++i)
405     {
406         if (stateblock->changed.pixelShaderConstantsB & (1 << i))
407         {
408             stateblock->contained_ps_consts_b[stateblock->num_contained_ps_consts_b] = i;
409             ++stateblock->num_contained_ps_consts_b;
410         }
411     }
412
413     for (i = 0; i < MAX_TEXTURES; ++i)
414     {
415         DWORD map = stateblock->changed.textureState[i];
416
417         for(j = 0; map; map >>= 1, ++j)
418         {
419             if (!(map & 1)) continue;
420
421             stateblock->contained_tss_states[stateblock->num_contained_tss_states].stage = i;
422             stateblock->contained_tss_states[stateblock->num_contained_tss_states].state = j;
423             ++stateblock->num_contained_tss_states;
424         }
425     }
426
427     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
428     {
429         DWORD map = stateblock->changed.samplerState[i];
430
431         for (j = 0; map; map >>= 1, ++j)
432         {
433             if (!(map & 1)) continue;
434
435             stateblock->contained_sampler_states[stateblock->num_contained_sampler_states].stage = i;
436             stateblock->contained_sampler_states[stateblock->num_contained_sampler_states].state = j;
437             ++stateblock->num_contained_sampler_states;
438         }
439     }
440 }
441
442 static void stateblock_init_lights(IWineD3DStateBlockImpl *stateblock, struct list *light_map)
443 {
444     unsigned int i;
445
446     for (i = 0; i < LIGHTMAP_SIZE; ++i)
447     {
448         const struct wined3d_light_info *src_light;
449
450         LIST_FOR_EACH_ENTRY(src_light, &light_map[i], struct wined3d_light_info, entry)
451         {
452             struct wined3d_light_info *dst_light = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_light));
453
454             *dst_light = *src_light;
455             list_add_tail(&stateblock->lightMap[i], &dst_light->entry);
456         }
457     }
458 }
459
460 /**********************************************************
461  * IWineD3DStateBlockImpl IUnknown parts follows
462  **********************************************************/
463 static HRESULT  WINAPI IWineD3DStateBlockImpl_QueryInterface(IWineD3DStateBlock *iface,REFIID riid,LPVOID *ppobj)
464 {
465     IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
466     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
467     if (IsEqualGUID(riid, &IID_IUnknown)
468             || IsEqualGUID(riid, &IID_IWineD3DStateBlock))
469     {
470         IUnknown_AddRef(iface);
471         *ppobj = This;
472         return S_OK;
473     }
474     *ppobj = NULL;
475     return E_NOINTERFACE;
476 }
477
478 static ULONG  WINAPI IWineD3DStateBlockImpl_AddRef(IWineD3DStateBlock *iface) {
479     IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
480     ULONG refCount = InterlockedIncrement(&This->ref);
481
482     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
483     return refCount;
484 }
485
486 static ULONG  WINAPI IWineD3DStateBlockImpl_Release(IWineD3DStateBlock *iface) {
487     IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
488     ULONG refCount = InterlockedDecrement(&This->ref);
489
490     TRACE("(%p) : Releasing from %d\n", This, refCount + 1);
491
492     if (!refCount) {
493         int counter;
494
495         if (This->vertexDecl) IWineD3DVertexDeclaration_Release(This->vertexDecl);
496
497         for (counter = 0; counter < MAX_COMBINED_SAMPLERS; counter++)
498         {
499             if (This->textures[counter]) IWineD3DBaseTexture_Release(This->textures[counter]);
500         }
501
502         for (counter = 0; counter < MAX_STREAMS; counter++) {
503             if(This->streamSource[counter]) {
504                 if (IWineD3DBuffer_Release(This->streamSource[counter]))
505                 {
506                     TRACE("Vertex buffer still referenced by stateblock, applications has leaked Stream %u, buffer %p\n", counter, This->streamSource[counter]);
507                 }
508             }
509         }
510         if(This->pIndexData) IWineD3DBuffer_Release(This->pIndexData);
511         if(This->vertexShader) IWineD3DVertexShader_Release(This->vertexShader);
512         if(This->pixelShader) IWineD3DPixelShader_Release(This->pixelShader);
513
514         for(counter = 0; counter < LIGHTMAP_SIZE; counter++) {
515             struct list *e1, *e2;
516             LIST_FOR_EACH_SAFE(e1, e2, &This->lightMap[counter])
517             {
518                 struct wined3d_light_info *light = LIST_ENTRY(e1, struct wined3d_light_info, entry);
519                 list_remove(&light->entry);
520                 HeapFree(GetProcessHeap(), 0, light);
521             }
522         }
523
524         HeapFree(GetProcessHeap(), 0, This->vertexShaderConstantF);
525         HeapFree(GetProcessHeap(), 0, This->changed.vertexShaderConstantsF);
526         HeapFree(GetProcessHeap(), 0, This->pixelShaderConstantF);
527         HeapFree(GetProcessHeap(), 0, This->changed.pixelShaderConstantsF);
528         HeapFree(GetProcessHeap(), 0, This->contained_vs_consts_f);
529         HeapFree(GetProcessHeap(), 0, This->contained_ps_consts_f);
530         HeapFree(GetProcessHeap(), 0, This);
531     }
532     return refCount;
533 }
534
535 /**********************************************************
536  * IWineD3DStateBlockImpl parts follows
537  **********************************************************/
538 static void record_lights(IWineD3DStateBlockImpl *This, const IWineD3DStateBlockImpl *targetStateBlock)
539 {
540     UINT i;
541
542     /* Lights... For a recorded state block, we just had a chain of actions to perform,
543      * so we need to walk that chain and update any actions which differ
544      */
545     for(i = 0; i < LIGHTMAP_SIZE; i++) {
546         struct list *e, *f;
547         LIST_FOR_EACH(e, &This->lightMap[i]) {
548             BOOL updated = FALSE;
549             struct wined3d_light_info *src = LIST_ENTRY(e, struct wined3d_light_info, entry), *realLight;
550
551             /* Look up the light in the destination */
552             LIST_FOR_EACH(f, &targetStateBlock->lightMap[i]) {
553                 realLight = LIST_ENTRY(f, struct wined3d_light_info, entry);
554                 if (realLight->OriginalIndex == src->OriginalIndex)
555                 {
556                     src->OriginalParms = realLight->OriginalParms;
557
558                     if (realLight->glIndex == -1 && src->glIndex != -1)
559                     {
560                         /* Light disabled */
561                         This->activeLights[src->glIndex] = NULL;
562                     }
563                     else if (realLight->glIndex != -1 && src->glIndex == -1)
564                     {
565                         /* Light enabled */
566                         This->activeLights[realLight->glIndex] = src;
567                     }
568                     src->glIndex = realLight->glIndex;
569                     updated = TRUE;
570                     break;
571                 }
572             }
573
574             if (!updated)
575             {
576                 /* This can happen if the light was originally created as a
577                  * default light for SetLightEnable() while recording. */
578                 WARN("Light %u in stateblock %p does not exist in device stateblock %p.\n",
579                         src->OriginalIndex, This, targetStateBlock);
580
581                 src->OriginalParms = WINED3D_default_light;
582                 if (src->glIndex != -1)
583                 {
584                     This->activeLights[src->glIndex] = NULL;
585                     src->glIndex = -1;
586                 }
587             }
588         }
589     }
590 }
591
592 static HRESULT WINAPI IWineD3DStateBlockImpl_Capture(IWineD3DStateBlock *iface)
593 {
594     IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
595     IWineD3DStateBlockImpl *targetStateBlock = This->device->stateBlock;
596     unsigned int i;
597     DWORD map;
598
599     TRACE("(%p) : Updating state block %p ------------------v\n", targetStateBlock, This);
600
601     if (This->changed.vertexShader && This->vertexShader != targetStateBlock->vertexShader)
602     {
603         TRACE("Updating vertex shader from %p to %p\n", This->vertexShader, targetStateBlock->vertexShader);
604
605         if (targetStateBlock->vertexShader) IWineD3DVertexShader_AddRef(targetStateBlock->vertexShader);
606         if (This->vertexShader) IWineD3DVertexShader_Release(This->vertexShader);
607         This->vertexShader = targetStateBlock->vertexShader;
608     }
609
610     /* Vertex Shader Float Constants */
611     for (i = 0; i < This->num_contained_vs_consts_f; ++i)
612     {
613         unsigned int idx = This->contained_vs_consts_f[i];
614
615         TRACE("Setting %p from %p %u to {%.8e, %.8e, %.8e, %.8e}.\n",
616                 This, targetStateBlock, idx,
617                 targetStateBlock->vertexShaderConstantF[idx * 4 + 0],
618                 targetStateBlock->vertexShaderConstantF[idx * 4 + 1],
619                 targetStateBlock->vertexShaderConstantF[idx * 4 + 2],
620                 targetStateBlock->vertexShaderConstantF[idx * 4 + 3]);
621
622         This->vertexShaderConstantF[idx * 4 + 0] = targetStateBlock->vertexShaderConstantF[idx * 4 + 0];
623         This->vertexShaderConstantF[idx * 4 + 1] = targetStateBlock->vertexShaderConstantF[idx * 4 + 1];
624         This->vertexShaderConstantF[idx * 4 + 2] = targetStateBlock->vertexShaderConstantF[idx * 4 + 2];
625         This->vertexShaderConstantF[idx * 4 + 3] = targetStateBlock->vertexShaderConstantF[idx * 4 + 3];
626     }
627
628     /* Vertex Shader Integer Constants */
629     for (i = 0; i < This->num_contained_vs_consts_i; ++i)
630     {
631         unsigned int idx = This->contained_vs_consts_i[i];
632
633         TRACE("Setting %p from %p %u to {%d, %d, %d, %d}.\n",
634                 This, targetStateBlock, idx,
635                 targetStateBlock->vertexShaderConstantI[idx * 4 + 0],
636                 targetStateBlock->vertexShaderConstantI[idx * 4 + 1],
637                 targetStateBlock->vertexShaderConstantI[idx * 4 + 2],
638                 targetStateBlock->vertexShaderConstantI[idx * 4 + 3]);
639
640         This->vertexShaderConstantI[idx * 4 + 0] = targetStateBlock->vertexShaderConstantI[idx * 4 + 0];
641         This->vertexShaderConstantI[idx * 4 + 1] = targetStateBlock->vertexShaderConstantI[idx * 4 + 1];
642         This->vertexShaderConstantI[idx * 4 + 2] = targetStateBlock->vertexShaderConstantI[idx * 4 + 2];
643         This->vertexShaderConstantI[idx * 4 + 3] = targetStateBlock->vertexShaderConstantI[idx * 4 + 3];
644     }
645
646     /* Vertex Shader Boolean Constants */
647     for (i = 0; i < This->num_contained_vs_consts_b; ++i)
648     {
649         unsigned int idx = This->contained_vs_consts_b[i];
650
651         TRACE("Setting %p from %p %u to %s.\n",
652                 This, targetStateBlock, idx,
653                 targetStateBlock->vertexShaderConstantB[idx] ? "TRUE" : "FALSE");
654
655         This->vertexShaderConstantB[idx] = targetStateBlock->vertexShaderConstantB[idx];
656     }
657
658     /* Pixel Shader Float Constants */
659     for (i = 0; i < This->num_contained_ps_consts_f; ++i)
660     {
661         unsigned int idx = This->contained_ps_consts_f[i];
662
663         TRACE("Setting %p from %p %u to {%.8e, %.8e, %.8e, %.8e}.\n",
664                 This, targetStateBlock, idx,
665                 targetStateBlock->pixelShaderConstantF[idx * 4 + 0],
666                 targetStateBlock->pixelShaderConstantF[idx * 4 + 1],
667                 targetStateBlock->pixelShaderConstantF[idx * 4 + 2],
668                 targetStateBlock->pixelShaderConstantF[idx * 4 + 3]);
669
670         This->pixelShaderConstantF[idx * 4 + 0] = targetStateBlock->pixelShaderConstantF[idx * 4 + 0];
671         This->pixelShaderConstantF[idx * 4 + 1] = targetStateBlock->pixelShaderConstantF[idx * 4 + 1];
672         This->pixelShaderConstantF[idx * 4 + 2] = targetStateBlock->pixelShaderConstantF[idx * 4 + 2];
673         This->pixelShaderConstantF[idx * 4 + 3] = targetStateBlock->pixelShaderConstantF[idx * 4 + 3];
674     }
675
676     /* Pixel Shader Integer Constants */
677     for (i = 0; i < This->num_contained_ps_consts_i; ++i)
678     {
679         unsigned int idx = This->contained_ps_consts_i[i];
680         TRACE("Setting %p from %p %u to {%d, %d, %d, %d}.\n",
681                 This, targetStateBlock, idx,
682                 targetStateBlock->pixelShaderConstantI[idx * 4 + 0],
683                 targetStateBlock->pixelShaderConstantI[idx * 4 + 1],
684                 targetStateBlock->pixelShaderConstantI[idx * 4 + 2],
685                 targetStateBlock->pixelShaderConstantI[idx * 4 + 3]);
686
687         This->pixelShaderConstantI[idx * 4 + 0] = targetStateBlock->pixelShaderConstantI[idx * 4 + 0];
688         This->pixelShaderConstantI[idx * 4 + 1] = targetStateBlock->pixelShaderConstantI[idx * 4 + 1];
689         This->pixelShaderConstantI[idx * 4 + 2] = targetStateBlock->pixelShaderConstantI[idx * 4 + 2];
690         This->pixelShaderConstantI[idx * 4 + 3] = targetStateBlock->pixelShaderConstantI[idx * 4 + 3];
691     }
692
693     /* Pixel Shader Boolean Constants */
694     for (i = 0; i < This->num_contained_ps_consts_b; ++i)
695     {
696         unsigned int idx = This->contained_ps_consts_b[i];
697         TRACE("Setting %p from %p %u to %s.\n", This, targetStateBlock, idx,
698                 targetStateBlock->pixelShaderConstantB[idx] ? "TRUE" : "FALSE");
699
700         This->pixelShaderConstantB[idx] = targetStateBlock->pixelShaderConstantB[idx];
701     }
702
703     /* Others + Render & Texture */
704     for (i = 0; i < This->num_contained_transform_states; ++i)
705     {
706         WINED3DTRANSFORMSTATETYPE transform = This->contained_transform_states[i];
707
708         TRACE("Updating transform %#x.\n", transform);
709
710         This->transforms[transform] = targetStateBlock->transforms[transform];
711     }
712
713     if (This->changed.primitive_type) This->gl_primitive_type = targetStateBlock->gl_primitive_type;
714
715     if (This->changed.indices
716             && ((This->pIndexData != targetStateBlock->pIndexData)
717                 || (This->baseVertexIndex != targetStateBlock->baseVertexIndex)
718                 || (This->IndexFmt != targetStateBlock->IndexFmt)))
719     {
720         TRACE("Updating pIndexData to %p, baseVertexIndex to %d.\n",
721                 targetStateBlock->pIndexData, targetStateBlock->baseVertexIndex);
722
723         if (targetStateBlock->pIndexData) IWineD3DBuffer_AddRef(targetStateBlock->pIndexData);
724         if (This->pIndexData) IWineD3DBuffer_Release(This->pIndexData);
725         This->pIndexData = targetStateBlock->pIndexData;
726         This->baseVertexIndex = targetStateBlock->baseVertexIndex;
727         This->IndexFmt = targetStateBlock->IndexFmt;
728     }
729
730     if (This->changed.vertexDecl && This->vertexDecl != targetStateBlock->vertexDecl)
731     {
732         TRACE("Updating vertex declaration from %p to %p.\n", This->vertexDecl, targetStateBlock->vertexDecl);
733
734         if (targetStateBlock->vertexDecl) IWineD3DVertexDeclaration_AddRef(targetStateBlock->vertexDecl);
735         if (This->vertexDecl) IWineD3DVertexDeclaration_Release(This->vertexDecl);
736         This->vertexDecl = targetStateBlock->vertexDecl;
737     }
738
739     if (This->changed.material
740             && memcmp(&targetStateBlock->material, &This->material, sizeof(This->material)))
741     {
742         TRACE("Updating material.\n");
743
744         This->material = targetStateBlock->material;
745     }
746
747     if (This->changed.viewport
748             && memcmp(&targetStateBlock->viewport, &This->viewport, sizeof(This->viewport)))
749     {
750         TRACE("Updating viewport.\n");
751
752         This->viewport = targetStateBlock->viewport;
753     }
754
755     if(This->changed.scissorRect
756             && memcmp(&targetStateBlock->scissorRect, &This->scissorRect, sizeof(This->scissorRect)))
757     {
758         TRACE("Updating scissor rect.\n");
759
760         This->scissorRect = targetStateBlock->scissorRect;
761     }
762
763     map = This->changed.streamSource;
764     for (i = 0; map; map >>= 1, ++i)
765     {
766         if (!(map & 1)) continue;
767
768         if (This->streamStride[i] != targetStateBlock->streamStride[i]
769                 || This->streamSource[i] != targetStateBlock->streamSource[i])
770         {
771             TRACE("Updating stream source %u to %p, stride to %u.\n",
772                     i, targetStateBlock->streamSource[i], targetStateBlock->streamStride[i]);
773
774             This->streamStride[i] = targetStateBlock->streamStride[i];
775             if (targetStateBlock->streamSource[i]) IWineD3DBuffer_AddRef(targetStateBlock->streamSource[i]);
776             if (This->streamSource[i]) IWineD3DBuffer_Release(This->streamSource[i]);
777             This->streamSource[i] = targetStateBlock->streamSource[i];
778         }
779     }
780
781     map = This->changed.streamFreq;
782     for (i = 0; map; map >>= 1, ++i)
783     {
784         if (!(map & 1)) continue;
785
786         if (This->streamFreq[i] != targetStateBlock->streamFreq[i]
787                 || This->streamFlags[i] != targetStateBlock->streamFlags[i])
788         {
789             TRACE("Updating stream frequency %u to %u flags to %#x.\n",
790                     i, targetStateBlock->streamFreq[i], targetStateBlock->streamFlags[i]);
791
792             This->streamFreq[i] = targetStateBlock->streamFreq[i];
793             This->streamFlags[i] = targetStateBlock->streamFlags[i];
794         }
795     }
796
797     map = This->changed.clipplane;
798     for (i = 0; map; map >>= 1, ++i)
799     {
800         if (!(map & 1)) continue;
801
802         if (memcmp(targetStateBlock->clipplane[i], This->clipplane[i], sizeof(*This->clipplane)))
803         {
804             TRACE("Updating clipplane %u.\n", i);
805             memcpy(This->clipplane[i], targetStateBlock->clipplane[i], sizeof(*This->clipplane));
806         }
807     }
808
809     /* Render */
810     for (i = 0; i < This->num_contained_render_states; ++i)
811     {
812         WINED3DRENDERSTATETYPE rs = This->contained_render_states[i];
813
814         TRACE("Updating renderState %#x to %u.\n", rs, targetStateBlock->renderState[rs]);
815
816         This->renderState[rs] = targetStateBlock->renderState[rs];
817     }
818
819     /* Texture states */
820     for (i = 0; i < This->num_contained_tss_states; ++i)
821     {
822         DWORD stage = This->contained_tss_states[i].stage;
823         DWORD state = This->contained_tss_states[i].state;
824
825         TRACE("Updating texturestage state %u, %u to %u (was %u).\n", stage, state,
826                 targetStateBlock->textureState[stage][state], This->textureState[stage][state]);
827
828         This->textureState[stage][state] = targetStateBlock->textureState[stage][state];
829     }
830
831     /* Samplers */
832     map = This->changed.textures;
833     for (i = 0; map; map >>= 1, ++i)
834     {
835         if (!(map & 1)) continue;
836
837         TRACE("Updating texture %u to %p (was %p).\n", i, targetStateBlock->textures[i], This->textures[i]);
838
839         if (targetStateBlock->textures[i]) IWineD3DBaseTexture_AddRef(targetStateBlock->textures[i]);
840         if (This->textures[i]) IWineD3DBaseTexture_Release(This->textures[i]);
841         This->textures[i] = targetStateBlock->textures[i];
842     }
843
844     for (i = 0; i < This->num_contained_sampler_states; ++i)
845     {
846         DWORD stage = This->contained_sampler_states[i].stage;
847         DWORD state = This->contained_sampler_states[i].state;
848
849         TRACE("Updating sampler state %u, %u to %u (was %u).\n", stage, state,
850                 targetStateBlock->samplerState[stage][state], This->samplerState[stage][state]);
851
852         This->samplerState[stage][state] = targetStateBlock->samplerState[stage][state];
853     }
854
855     if (This->changed.pixelShader && This->pixelShader != targetStateBlock->pixelShader)
856     {
857         if (targetStateBlock->pixelShader) IWineD3DPixelShader_AddRef(targetStateBlock->pixelShader);
858         if (This->pixelShader) IWineD3DPixelShader_Release(This->pixelShader);
859         This->pixelShader = targetStateBlock->pixelShader;
860     }
861
862     record_lights(This, targetStateBlock);
863
864     TRACE("(%p) : Updated state block %p ------------------^\n", targetStateBlock, This);
865
866     return WINED3D_OK;
867 }
868
869 static void apply_lights(IWineD3DDevice *device, const IWineD3DStateBlockImpl *This)
870 {
871     UINT i;
872     for(i = 0; i < LIGHTMAP_SIZE; i++) {
873         struct list *e;
874
875         LIST_FOR_EACH(e, &This->lightMap[i])
876         {
877             const struct wined3d_light_info *light = LIST_ENTRY(e, struct wined3d_light_info, entry);
878
879             IWineD3DDevice_SetLight(device, light->OriginalIndex, &light->OriginalParms);
880             IWineD3DDevice_SetLightEnable(device, light->OriginalIndex, light->glIndex != -1);
881         }
882     }
883 }
884
885 static HRESULT WINAPI IWineD3DStateBlockImpl_Apply(IWineD3DStateBlock *iface)
886 {
887     IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
888     IWineD3DDevice *device = (IWineD3DDevice *)This->device;
889     unsigned int i;
890     DWORD map;
891
892     TRACE("(%p) : Applying state block %p ------------------v\n", This, device);
893
894     TRACE("Blocktype: %d\n", This->blockType);
895
896     if (This->changed.vertexShader) IWineD3DDevice_SetVertexShader(device, This->vertexShader);
897
898     /* Vertex Shader Constants */
899     for (i = 0; i < This->num_contained_vs_consts_f; ++i)
900     {
901         IWineD3DDevice_SetVertexShaderConstantF(device, This->contained_vs_consts_f[i],
902                 This->vertexShaderConstantF + This->contained_vs_consts_f[i] * 4, 1);
903     }
904     for (i = 0; i < This->num_contained_vs_consts_i; ++i)
905     {
906         IWineD3DDevice_SetVertexShaderConstantI(device, This->contained_vs_consts_i[i],
907                 This->vertexShaderConstantI + This->contained_vs_consts_i[i] * 4, 1);
908     }
909     for (i = 0; i < This->num_contained_vs_consts_b; ++i)
910     {
911         IWineD3DDevice_SetVertexShaderConstantB(device, This->contained_vs_consts_b[i],
912                 This->vertexShaderConstantB + This->contained_vs_consts_b[i], 1);
913     }
914
915     apply_lights(device, This);
916
917     if (This->changed.pixelShader) IWineD3DDevice_SetPixelShader(device, This->pixelShader);
918
919     /* Pixel Shader Constants */
920     for (i = 0; i < This->num_contained_ps_consts_f; ++i)
921     {
922         IWineD3DDevice_SetPixelShaderConstantF(device, This->contained_ps_consts_f[i],
923                 This->pixelShaderConstantF + This->contained_ps_consts_f[i] * 4, 1);
924     }
925     for (i = 0; i < This->num_contained_ps_consts_i; ++i)
926     {
927         IWineD3DDevice_SetPixelShaderConstantI(device, This->contained_ps_consts_i[i],
928                 This->pixelShaderConstantI + This->contained_ps_consts_i[i] * 4, 1);
929     }
930     for (i = 0; i < This->num_contained_ps_consts_b; ++i)
931     {
932         IWineD3DDevice_SetPixelShaderConstantB(device, This->contained_ps_consts_b[i],
933                 This->pixelShaderConstantB + This->contained_ps_consts_b[i], 1);
934     }
935
936     /* Render */
937     for (i = 0; i < This->num_contained_render_states; ++i)
938     {
939         IWineD3DDevice_SetRenderState(device, This->contained_render_states[i],
940                 This->renderState[This->contained_render_states[i]]);
941     }
942
943     /* Texture states */
944     for (i = 0; i < This->num_contained_tss_states; ++i)
945     {
946         DWORD stage = This->contained_tss_states[i].stage;
947         DWORD state = This->contained_tss_states[i].state;
948
949         IWineD3DDevice_SetTextureStageState(device, stage, state, This->textureState[stage][state]);
950     }
951
952     /* Sampler states */
953     for (i = 0; i < This->num_contained_sampler_states; ++i)
954     {
955         DWORD stage = This->contained_sampler_states[i].stage;
956         DWORD state = This->contained_sampler_states[i].state;
957         DWORD value = This->samplerState[stage][state];
958
959         if (stage >= MAX_FRAGMENT_SAMPLERS) stage += WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS;
960         IWineD3DDevice_SetSamplerState(device, stage, state, value);
961     }
962
963     for (i = 0; i < This->num_contained_transform_states; ++i)
964     {
965         IWineD3DDevice_SetTransform(device, This->contained_transform_states[i],
966                 &This->transforms[This->contained_transform_states[i]]);
967     }
968
969     if (This->changed.primitive_type)
970     {
971         This->device->updateStateBlock->changed.primitive_type = TRUE;
972         This->device->updateStateBlock->gl_primitive_type = This->gl_primitive_type;
973     }
974
975     if (This->changed.indices)
976     {
977         IWineD3DDevice_SetIndexBuffer(device, This->pIndexData, This->IndexFmt);
978         IWineD3DDevice_SetBaseVertexIndex(device, This->baseVertexIndex);
979     }
980
981     if (This->changed.vertexDecl && This->vertexDecl)
982     {
983         IWineD3DDevice_SetVertexDeclaration(device, This->vertexDecl);
984     }
985
986     if (This->changed.material)
987     {
988         IWineD3DDevice_SetMaterial(device, &This->material);
989     }
990
991     if (This->changed.viewport)
992     {
993         IWineD3DDevice_SetViewport(device, &This->viewport);
994     }
995
996     if (This->changed.scissorRect)
997     {
998         IWineD3DDevice_SetScissorRect(device, &This->scissorRect);
999     }
1000
1001     map = This->changed.streamSource;
1002     for (i = 0; map; map >>= 1, ++i)
1003     {
1004         if (map & 1) IWineD3DDevice_SetStreamSource(device, i, This->streamSource[i], 0, This->streamStride[i]);
1005     }
1006
1007     map = This->changed.streamFreq;
1008     for (i = 0; map; map >>= 1, ++i)
1009     {
1010         if (map & 1) IWineD3DDevice_SetStreamSourceFreq(device, i, This->streamFreq[i] | This->streamFlags[i]);
1011     }
1012
1013     map = This->changed.textures;
1014     for (i = 0; map; map >>= 1, ++i)
1015     {
1016         DWORD stage;
1017
1018         if (!(map & 1)) continue;
1019
1020         stage = i < MAX_FRAGMENT_SAMPLERS ? i : WINED3DVERTEXTEXTURESAMPLER0 + i - MAX_FRAGMENT_SAMPLERS;
1021         IWineD3DDevice_SetTexture(device, stage, This->textures[i]);
1022     }
1023
1024     map = This->changed.clipplane;
1025     for (i = 0; map; map >>= 1, ++i)
1026     {
1027         float clip[4];
1028
1029         if (!(map & 1)) continue;
1030
1031         clip[0] = This->clipplane[i][0];
1032         clip[1] = This->clipplane[i][1];
1033         clip[2] = This->clipplane[i][2];
1034         clip[3] = This->clipplane[i][3];
1035         IWineD3DDevice_SetClipPlane(device, i, clip);
1036     }
1037
1038     This->device->stateBlock->lowest_disabled_stage = MAX_TEXTURES - 1;
1039     for (i = 0; i < MAX_TEXTURES - 1; ++i)
1040     {
1041         if (This->device->stateBlock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE)
1042         {
1043             This->device->stateBlock->lowest_disabled_stage = i;
1044             break;
1045         }
1046     }
1047     TRACE("(%p) : Applied state block %p ------------------^\n", This, device);
1048
1049     return WINED3D_OK;
1050 }
1051
1052 static HRESULT  WINAPI IWineD3DStateBlockImpl_InitStartupStateBlock(IWineD3DStateBlock* iface) {
1053     IWineD3DStateBlockImpl *This = (IWineD3DStateBlockImpl *)iface;
1054     IWineD3DDevice *device = (IWineD3DDevice *)This->device;
1055     IWineD3DDeviceImpl *device_impl = (IWineD3DDeviceImpl *)device;
1056     const struct wined3d_gl_info *gl_info = &device_impl->adapter->gl_info;
1057     union {
1058         WINED3DLINEPATTERN lp;
1059         DWORD d;
1060     } lp;
1061     union {
1062         float f;
1063         DWORD d;
1064     } tmpfloat;
1065     unsigned int i;
1066     IWineD3DSwapChain *swapchain;
1067     IWineD3DSurface *backbuffer;
1068     HRESULT hr;
1069
1070     /* Note this may have a large overhead but it should only be executed
1071        once, in order to initialize the complete state of the device and
1072        all opengl equivalents                                            */
1073     TRACE("(%p) -----------------------> Setting up device defaults... %p\n", This, device);
1074     /* TODO: make a special stateblock type for the primary stateblock (it never gets applied so it doesn't need a real type) */
1075     This->blockType = WINED3DSBT_INIT;
1076
1077     /* Set some of the defaults for lights, transforms etc */
1078     memcpy(&This->transforms[WINED3DTS_PROJECTION], identity, sizeof(identity));
1079     memcpy(&This->transforms[WINED3DTS_VIEW], identity, sizeof(identity));
1080     for (i = 0; i < 256; ++i) {
1081       memcpy(&This->transforms[WINED3DTS_WORLDMATRIX(i)], identity, sizeof(identity));
1082     }
1083
1084     TRACE("Render states\n");
1085     /* Render states: */
1086     if (device_impl->auto_depth_stencil)
1087        IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE,       WINED3DZB_TRUE);
1088     else
1089        IWineD3DDevice_SetRenderState(device, WINED3DRS_ZENABLE,       WINED3DZB_FALSE);
1090     IWineD3DDevice_SetRenderState(device, WINED3DRS_FILLMODE,         WINED3DFILL_SOLID);
1091     IWineD3DDevice_SetRenderState(device, WINED3DRS_SHADEMODE,        WINED3DSHADE_GOURAUD);
1092     lp.lp.wRepeatFactor = 0;
1093     lp.lp.wLinePattern  = 0;
1094     IWineD3DDevice_SetRenderState(device, WINED3DRS_LINEPATTERN,      lp.d);
1095     IWineD3DDevice_SetRenderState(device, WINED3DRS_ZWRITEENABLE,     TRUE);
1096     IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHATESTENABLE,  FALSE);
1097     IWineD3DDevice_SetRenderState(device, WINED3DRS_LASTPIXEL,        TRUE);
1098     IWineD3DDevice_SetRenderState(device, WINED3DRS_SRCBLEND,         WINED3DBLEND_ONE);
1099     IWineD3DDevice_SetRenderState(device, WINED3DRS_DESTBLEND,        WINED3DBLEND_ZERO);
1100     IWineD3DDevice_SetRenderState(device, WINED3DRS_CULLMODE,         WINED3DCULL_CCW);
1101     IWineD3DDevice_SetRenderState(device, WINED3DRS_ZFUNC,            WINED3DCMP_LESSEQUAL);
1102     IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHAFUNC,        WINED3DCMP_ALWAYS);
1103     IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHAREF,         0);
1104     IWineD3DDevice_SetRenderState(device, WINED3DRS_DITHERENABLE,     FALSE);
1105     IWineD3DDevice_SetRenderState(device, WINED3DRS_ALPHABLENDENABLE, FALSE);
1106     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGENABLE,        FALSE);
1107     IWineD3DDevice_SetRenderState(device, WINED3DRS_SPECULARENABLE,   FALSE);
1108     IWineD3DDevice_SetRenderState(device, WINED3DRS_ZVISIBLE,         0);
1109     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGCOLOR,         0);
1110     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGTABLEMODE,     WINED3DFOG_NONE);
1111     tmpfloat.f = 0.0f;
1112     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGSTART,         tmpfloat.d);
1113     tmpfloat.f = 1.0f;
1114     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGEND,           tmpfloat.d);
1115     tmpfloat.f = 1.0f;
1116     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGDENSITY,       tmpfloat.d);
1117     IWineD3DDevice_SetRenderState(device, WINED3DRS_EDGEANTIALIAS,    FALSE);
1118     IWineD3DDevice_SetRenderState(device, WINED3DRS_ZBIAS,            0);
1119     IWineD3DDevice_SetRenderState(device, WINED3DRS_RANGEFOGENABLE,   FALSE);
1120     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILENABLE,    FALSE);
1121     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILFAIL,      WINED3DSTENCILOP_KEEP);
1122     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILZFAIL,     WINED3DSTENCILOP_KEEP);
1123     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILPASS,      WINED3DSTENCILOP_KEEP);
1124     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILREF,       0);
1125     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILMASK,      0xFFFFFFFF);
1126     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILFUNC,      WINED3DCMP_ALWAYS);
1127     IWineD3DDevice_SetRenderState(device, WINED3DRS_STENCILWRITEMASK, 0xFFFFFFFF);
1128     IWineD3DDevice_SetRenderState(device, WINED3DRS_TEXTUREFACTOR,    0xFFFFFFFF);
1129     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP0, 0);
1130     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP1, 0);
1131     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP2, 0);
1132     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP3, 0);
1133     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP4, 0);
1134     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP5, 0);
1135     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP6, 0);
1136     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP7, 0);
1137     IWineD3DDevice_SetRenderState(device, WINED3DRS_CLIPPING,                 TRUE);
1138     IWineD3DDevice_SetRenderState(device, WINED3DRS_LIGHTING,                 TRUE);
1139     IWineD3DDevice_SetRenderState(device, WINED3DRS_AMBIENT,                  0);
1140     IWineD3DDevice_SetRenderState(device, WINED3DRS_FOGVERTEXMODE,            WINED3DFOG_NONE);
1141     IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORVERTEX,              TRUE);
1142     IWineD3DDevice_SetRenderState(device, WINED3DRS_LOCALVIEWER,              TRUE);
1143     IWineD3DDevice_SetRenderState(device, WINED3DRS_NORMALIZENORMALS,         FALSE);
1144     IWineD3DDevice_SetRenderState(device, WINED3DRS_DIFFUSEMATERIALSOURCE,    WINED3DMCS_COLOR1);
1145     IWineD3DDevice_SetRenderState(device, WINED3DRS_SPECULARMATERIALSOURCE,   WINED3DMCS_COLOR2);
1146     IWineD3DDevice_SetRenderState(device, WINED3DRS_AMBIENTMATERIALSOURCE,    WINED3DMCS_MATERIAL);
1147     IWineD3DDevice_SetRenderState(device, WINED3DRS_EMISSIVEMATERIALSOURCE,   WINED3DMCS_MATERIAL);
1148     IWineD3DDevice_SetRenderState(device, WINED3DRS_VERTEXBLEND,              WINED3DVBF_DISABLE);
1149     IWineD3DDevice_SetRenderState(device, WINED3DRS_CLIPPLANEENABLE,          0);
1150     IWineD3DDevice_SetRenderState(device, WINED3DRS_SOFTWAREVERTEXPROCESSING, FALSE);
1151     tmpfloat.f = 1.0f;
1152     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSIZE,                tmpfloat.d);
1153     tmpfloat.f = 1.0f;
1154     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSIZE_MIN,            tmpfloat.d);
1155     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSPRITEENABLE,        FALSE);
1156     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALEENABLE,         FALSE);
1157     tmpfloat.f = 1.0f;
1158     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALE_A,             tmpfloat.d);
1159     tmpfloat.f = 0.0f;
1160     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALE_B,             tmpfloat.d);
1161     tmpfloat.f = 0.0f;
1162     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSCALE_C,             tmpfloat.d);
1163     IWineD3DDevice_SetRenderState(device, WINED3DRS_MULTISAMPLEANTIALIAS,     TRUE);
1164     IWineD3DDevice_SetRenderState(device, WINED3DRS_MULTISAMPLEMASK,          0xFFFFFFFF);
1165     IWineD3DDevice_SetRenderState(device, WINED3DRS_PATCHEDGESTYLE,           WINED3DPATCHEDGE_DISCRETE);
1166     tmpfloat.f = 1.0f;
1167     IWineD3DDevice_SetRenderState(device, WINED3DRS_PATCHSEGMENTS,            tmpfloat.d);
1168     IWineD3DDevice_SetRenderState(device, WINED3DRS_DEBUGMONITORTOKEN,        0xbaadcafe);
1169     tmpfloat.f = gl_info->limits.pointsize_max;
1170     IWineD3DDevice_SetRenderState(device, WINED3DRS_POINTSIZE_MAX,            tmpfloat.d);
1171     IWineD3DDevice_SetRenderState(device, WINED3DRS_INDEXEDVERTEXBLENDENABLE, FALSE);
1172     IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE,         0x0000000F);
1173     tmpfloat.f = 0.0f;
1174     IWineD3DDevice_SetRenderState(device, WINED3DRS_TWEENFACTOR,              tmpfloat.d);
1175     IWineD3DDevice_SetRenderState(device, WINED3DRS_BLENDOP,                  WINED3DBLENDOP_ADD);
1176     IWineD3DDevice_SetRenderState(device, WINED3DRS_POSITIONDEGREE,           WINED3DDEGREE_CUBIC);
1177     IWineD3DDevice_SetRenderState(device, WINED3DRS_NORMALDEGREE,             WINED3DDEGREE_LINEAR);
1178     /* states new in d3d9 */
1179     IWineD3DDevice_SetRenderState(device, WINED3DRS_SCISSORTESTENABLE,        FALSE);
1180     IWineD3DDevice_SetRenderState(device, WINED3DRS_SLOPESCALEDEPTHBIAS,      0);
1181     tmpfloat.f = 1.0f;
1182     IWineD3DDevice_SetRenderState(device, WINED3DRS_MINTESSELLATIONLEVEL,     tmpfloat.d);
1183     IWineD3DDevice_SetRenderState(device, WINED3DRS_MAXTESSELLATIONLEVEL,     tmpfloat.d);
1184     IWineD3DDevice_SetRenderState(device, WINED3DRS_ANTIALIASEDLINEENABLE,    FALSE);
1185     tmpfloat.f = 0.0f;
1186     IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_X,           tmpfloat.d);
1187     IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_Y,           tmpfloat.d);
1188     tmpfloat.f = 1.0f;
1189     IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_Z,           tmpfloat.d);
1190     tmpfloat.f = 0.0f;
1191     IWineD3DDevice_SetRenderState(device, WINED3DRS_ADAPTIVETESS_W,           tmpfloat.d);
1192     IWineD3DDevice_SetRenderState(device, WINED3DRS_ENABLEADAPTIVETESSELLATION, FALSE);
1193     IWineD3DDevice_SetRenderState(device, WINED3DRS_TWOSIDEDSTENCILMODE,      FALSE);
1194     IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILFAIL,          WINED3DSTENCILOP_KEEP);
1195     IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILZFAIL,         WINED3DSTENCILOP_KEEP);
1196     IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILPASS,          WINED3DSTENCILOP_KEEP);
1197     IWineD3DDevice_SetRenderState(device, WINED3DRS_CCW_STENCILFUNC,          WINED3DCMP_ALWAYS);
1198     IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE1,        0x0000000F);
1199     IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE2,        0x0000000F);
1200     IWineD3DDevice_SetRenderState(device, WINED3DRS_COLORWRITEENABLE3,        0x0000000F);
1201     IWineD3DDevice_SetRenderState(device, WINED3DRS_BLENDFACTOR,              0xFFFFFFFF);
1202     IWineD3DDevice_SetRenderState(device, WINED3DRS_SRGBWRITEENABLE,          0);
1203     IWineD3DDevice_SetRenderState(device, WINED3DRS_DEPTHBIAS,                0);
1204     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP8,  0);
1205     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP9,  0);
1206     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP10, 0);
1207     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP11, 0);
1208     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP12, 0);
1209     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP13, 0);
1210     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP14, 0);
1211     IWineD3DDevice_SetRenderState(device, WINED3DRS_WRAP15, 0);
1212     IWineD3DDevice_SetRenderState(device, WINED3DRS_SEPARATEALPHABLENDENABLE, FALSE);
1213     IWineD3DDevice_SetRenderState(device, WINED3DRS_SRCBLENDALPHA,            WINED3DBLEND_ONE);
1214     IWineD3DDevice_SetRenderState(device, WINED3DRS_DESTBLENDALPHA,           WINED3DBLEND_ZERO);
1215     IWineD3DDevice_SetRenderState(device, WINED3DRS_BLENDOPALPHA,             WINED3DBLENDOP_ADD);
1216
1217     /* clipping status */
1218     This->clip_status.ClipUnion = 0;
1219     This->clip_status.ClipIntersection = 0xFFFFFFFF;
1220
1221     /* Texture Stage States - Put directly into state block, we will call function below */
1222     for (i = 0; i < MAX_TEXTURES; i++) {
1223         TRACE("Setting up default texture states for texture Stage %d\n", i);
1224         memcpy(&This->transforms[WINED3DTS_TEXTURE0 + i], identity, sizeof(identity));
1225         This->textureState[i][WINED3DTSS_COLOROP               ] = (i==0)? WINED3DTOP_MODULATE :  WINED3DTOP_DISABLE;
1226         This->textureState[i][WINED3DTSS_COLORARG1             ] = WINED3DTA_TEXTURE;
1227         This->textureState[i][WINED3DTSS_COLORARG2             ] = WINED3DTA_CURRENT;
1228         This->textureState[i][WINED3DTSS_ALPHAOP               ] = (i==0)? WINED3DTOP_SELECTARG1 :  WINED3DTOP_DISABLE;
1229         This->textureState[i][WINED3DTSS_ALPHAARG1             ] = WINED3DTA_TEXTURE;
1230         This->textureState[i][WINED3DTSS_ALPHAARG2             ] = WINED3DTA_CURRENT;
1231         This->textureState[i][WINED3DTSS_BUMPENVMAT00          ] = 0;
1232         This->textureState[i][WINED3DTSS_BUMPENVMAT01          ] = 0;
1233         This->textureState[i][WINED3DTSS_BUMPENVMAT10          ] = 0;
1234         This->textureState[i][WINED3DTSS_BUMPENVMAT11          ] = 0;
1235         This->textureState[i][WINED3DTSS_TEXCOORDINDEX         ] = i;
1236         This->textureState[i][WINED3DTSS_BUMPENVLSCALE         ] = 0;
1237         This->textureState[i][WINED3DTSS_BUMPENVLOFFSET        ] = 0;
1238         This->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS ] = WINED3DTTFF_DISABLE;
1239         This->textureState[i][WINED3DTSS_COLORARG0             ] = WINED3DTA_CURRENT;
1240         This->textureState[i][WINED3DTSS_ALPHAARG0             ] = WINED3DTA_CURRENT;
1241         This->textureState[i][WINED3DTSS_RESULTARG             ] = WINED3DTA_CURRENT;
1242     }
1243     This->lowest_disabled_stage = 1;
1244
1245         /* Sampler states*/
1246     for (i = 0 ; i <  MAX_COMBINED_SAMPLERS; i++) {
1247         TRACE("Setting up default samplers states for sampler %d\n", i);
1248         This->samplerState[i][WINED3DSAMP_ADDRESSU         ] = WINED3DTADDRESS_WRAP;
1249         This->samplerState[i][WINED3DSAMP_ADDRESSV         ] = WINED3DTADDRESS_WRAP;
1250         This->samplerState[i][WINED3DSAMP_ADDRESSW         ] = WINED3DTADDRESS_WRAP;
1251         This->samplerState[i][WINED3DSAMP_BORDERCOLOR      ] = 0x00;
1252         This->samplerState[i][WINED3DSAMP_MAGFILTER        ] = WINED3DTEXF_POINT;
1253         This->samplerState[i][WINED3DSAMP_MINFILTER        ] = WINED3DTEXF_POINT;
1254         This->samplerState[i][WINED3DSAMP_MIPFILTER        ] = WINED3DTEXF_NONE;
1255         This->samplerState[i][WINED3DSAMP_MIPMAPLODBIAS    ] = 0;
1256         This->samplerState[i][WINED3DSAMP_MAXMIPLEVEL      ] = 0;
1257         This->samplerState[i][WINED3DSAMP_MAXANISOTROPY    ] = 1;
1258         This->samplerState[i][WINED3DSAMP_SRGBTEXTURE      ] = 0;
1259         This->samplerState[i][WINED3DSAMP_ELEMENTINDEX     ] = 0; /* TODO: Indicates which element of a  multielement texture to use */
1260         This->samplerState[i][WINED3DSAMP_DMAPOFFSET       ] = 0; /* TODO: Vertex offset in the presampled displacement map */
1261     }
1262
1263     for (i = 0; i < gl_info->limits.textures; ++i)
1264     {
1265         /* Note: This avoids calling SetTexture, so pretend it has been called */
1266         This->changed.textures |= 1 << i;
1267         This->textures[i]         = NULL;
1268     }
1269
1270     /* check the return values, because the GetBackBuffer call isn't valid for ddraw */
1271     hr = IWineD3DDevice_GetSwapChain(device, 0, &swapchain);
1272     if( hr == WINED3D_OK && swapchain != NULL) {
1273         WINED3DVIEWPORT vp;
1274
1275         hr = IWineD3DSwapChain_GetBackBuffer(swapchain, 0, WINED3DBACKBUFFER_TYPE_MONO, &backbuffer);
1276         if (SUCCEEDED(hr) && backbuffer)
1277         {
1278             WINED3DSURFACE_DESC desc;
1279             RECT scissorrect;
1280
1281             IWineD3DSurface_GetDesc(backbuffer, &desc);
1282             IWineD3DSurface_Release(backbuffer);
1283
1284             /* Set the default scissor rect values */
1285             scissorrect.left = 0;
1286             scissorrect.right = desc.width;
1287             scissorrect.top = 0;
1288             scissorrect.bottom = desc.height;
1289             hr = IWineD3DDevice_SetScissorRect(device, &scissorrect);
1290             if (FAILED(hr)) ERR("This should never happen, expect rendering issues!\n");
1291         }
1292
1293         /* Set the default viewport */
1294         vp.X      = 0;
1295         vp.Y      = 0;
1296         vp.Width  = ((IWineD3DSwapChainImpl *)swapchain)->presentParms.BackBufferWidth;
1297         vp.Height = ((IWineD3DSwapChainImpl *)swapchain)->presentParms.BackBufferHeight;
1298         vp.MinZ   = 0.0f;
1299         vp.MaxZ   = 1.0f;
1300         IWineD3DDevice_SetViewport(device, &vp);
1301
1302         IWineD3DSwapChain_Release(swapchain);
1303     }
1304
1305     TRACE("-----------------------> Device defaults now set up...\n");
1306     return WINED3D_OK;
1307 }
1308
1309 /**********************************************************
1310  * IWineD3DStateBlock VTbl follows
1311  **********************************************************/
1312
1313 static const IWineD3DStateBlockVtbl IWineD3DStateBlock_Vtbl =
1314 {
1315     /* IUnknown */
1316     IWineD3DStateBlockImpl_QueryInterface,
1317     IWineD3DStateBlockImpl_AddRef,
1318     IWineD3DStateBlockImpl_Release,
1319     /* IWineD3DStateBlock */
1320     IWineD3DStateBlockImpl_Capture,
1321     IWineD3DStateBlockImpl_Apply,
1322     IWineD3DStateBlockImpl_InitStartupStateBlock
1323 };
1324
1325 HRESULT stateblock_init(IWineD3DStateBlockImpl *stateblock, IWineD3DDeviceImpl *device, WINED3DSTATEBLOCKTYPE type)
1326 {
1327     unsigned int i;
1328     HRESULT hr;
1329
1330     stateblock->lpVtbl = &IWineD3DStateBlock_Vtbl;
1331     stateblock->ref = 1;
1332     stateblock->device = device;
1333     stateblock->blockType = type;
1334
1335     for (i = 0; i < LIGHTMAP_SIZE; i++)
1336     {
1337         list_init(&stateblock->lightMap[i]);
1338     }
1339
1340     hr = stateblock_allocate_shader_constants(stateblock);
1341     if (FAILED(hr)) return hr;
1342
1343     /* The WINED3DSBT_INIT stateblock type is used during initialization to
1344      * produce a placeholder stateblock so other functions called can update a
1345      * state block. */
1346     if (type == WINED3DSBT_INIT || type == WINED3DSBT_RECORDED) return WINED3D_OK;
1347
1348     TRACE("Updating changed flags appropriate for type %#x.\n", type);
1349
1350     switch (type)
1351     {
1352         case WINED3DSBT_ALL:
1353             stateblock_init_lights(stateblock, device->stateBlock->lightMap);
1354             stateblock_savedstates_set_all(&stateblock->changed, device->d3d_vshader_constantF,
1355                                            device->d3d_pshader_constantF);
1356             break;
1357
1358         case WINED3DSBT_PIXELSTATE:
1359             stateblock_savedstates_set_pixel(&stateblock->changed, device->d3d_pshader_constantF);
1360             break;
1361
1362         case WINED3DSBT_VERTEXSTATE:
1363             stateblock_init_lights(stateblock, device->stateBlock->lightMap);
1364             stateblock_savedstates_set_vertex(&stateblock->changed, device->d3d_vshader_constantF);
1365             break;
1366
1367         default:
1368             FIXME("Unrecognized state block type %#x.\n", type);
1369             break;
1370     }
1371
1372     stateblock_init_contained_states(stateblock);
1373     IWineD3DStateBlockImpl_Capture((IWineD3DStateBlock *)stateblock);
1374
1375     return WINED3D_OK;
1376 }