?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oleaut32: Convert CustData to use standard linked lists.
[wine.git] / dlls / wined3d / stateblock.c
blob30f5d370b12a7aaec6cfe125e774a5da25c3c1aa
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(struct wined3d_stateblock *object)
195 {
196 IWineD3DDeviceImpl *device = object->device;
197
198 /* Allocate space for floating point constants */
199 object->state.ps_consts_f = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
200 sizeof(float) * device->d3d_pshader_constantF * 4);
201 if (!object->state.ps_consts_f) 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->state.vs_consts_f = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
208 sizeof(float) * device->d3d_vshader_constantF * 4);
209 if (!object->state.vs_consts_f) 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->state.ps_consts_f);
228 HeapFree(GetProcessHeap(), 0, object->changed.pixelShaderConstantsF);
229 HeapFree(GetProcessHeap(), 0, object->state.vs_consts_f);
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] = 0x3ffe;
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(struct wined3d_stateblock *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(struct wined3d_stateblock *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->state.light_map[i], &dst_light->entry);
456 }
457 }
458 }
459
460 ULONG CDECL wined3d_stateblock_incref(struct wined3d_stateblock *stateblock)
461 {
462 ULONG refcount = InterlockedIncrement(&stateblock->ref);
463
464 TRACE("%p increasing refcount to %u.\n", stateblock, refcount);
465
466 return refcount;
467 }
468
469 ULONG CDECL wined3d_stateblock_decref(struct wined3d_stateblock *stateblock)
470 {
471 ULONG refcount = InterlockedDecrement(&stateblock->ref);
472
473 TRACE("%p decreasing refcount to %u\n", stateblock, refcount);
474
475 if (!refcount)
476 {
477 int counter;
478
479 if (stateblock->state.vertex_declaration)
480 wined3d_vertex_declaration_incref(stateblock->state.vertex_declaration);
481
482 for (counter = 0; counter < MAX_COMBINED_SAMPLERS; counter++)
483 {
484 if (stateblock->state.textures[counter])
485 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *)stateblock->state.textures[counter]);
486 }
487
488 for (counter = 0; counter < MAX_STREAMS; ++counter)
489 {
490 struct wined3d_buffer *buffer = stateblock->state.streams[counter].buffer;
491 if (buffer)
492 {
493 if (wined3d_buffer_decref(buffer))
494 {
495 WARN("Buffer %p still referenced by stateblock, stream %u.\n", buffer, counter);
496 }
497 }
498 }
499 if (stateblock->state.index_buffer)
500 wined3d_buffer_decref(stateblock->state.index_buffer);
501 if (stateblock->state.vertex_shader)
502 IWineD3DVertexShader_Release((IWineD3DVertexShader *)stateblock->state.vertex_shader);
503 if (stateblock->state.pixel_shader)
504 IWineD3DPixelShader_Release((IWineD3DPixelShader *)stateblock->state.pixel_shader);
505
506 for (counter = 0; counter < LIGHTMAP_SIZE; ++counter)
507 {
508 struct list *e1, *e2;
509 LIST_FOR_EACH_SAFE(e1, e2, &stateblock->state.light_map[counter])
510 {
511 struct wined3d_light_info *light = LIST_ENTRY(e1, struct wined3d_light_info, entry);
512 list_remove(&light->entry);
513 HeapFree(GetProcessHeap(), 0, light);
514 }
515 }
516
517 HeapFree(GetProcessHeap(), 0, stateblock->state.vs_consts_f);
518 HeapFree(GetProcessHeap(), 0, stateblock->changed.vertexShaderConstantsF);
519 HeapFree(GetProcessHeap(), 0, stateblock->state.ps_consts_f);
520 HeapFree(GetProcessHeap(), 0, stateblock->changed.pixelShaderConstantsF);
521 HeapFree(GetProcessHeap(), 0, stateblock->contained_vs_consts_f);
522 HeapFree(GetProcessHeap(), 0, stateblock->contained_ps_consts_f);
523 HeapFree(GetProcessHeap(), 0, stateblock);
524 }
525
526 return refcount;
527 }
528
529 static void wined3d_state_record_lights(struct wined3d_state *dst_state, const struct wined3d_state *src_state)
530 {
531 UINT i;
532
533 /* Lights... For a recorded state block, we just had a chain of actions
534 * to perform, so we need to walk that chain and update any actions which
535 * differ. */
536 for (i = 0; i < LIGHTMAP_SIZE; ++i)
537 {
538 struct list *e, *f;
539 LIST_FOR_EACH(e, &dst_state->light_map[i])
540 {
541 BOOL updated = FALSE;
542 struct wined3d_light_info *src = LIST_ENTRY(e, struct wined3d_light_info, entry), *realLight;
543
544 /* Look up the light in the destination */
545 LIST_FOR_EACH(f, &src_state->light_map[i])
546 {
547 realLight = LIST_ENTRY(f, struct wined3d_light_info, entry);
548 if (realLight->OriginalIndex == src->OriginalIndex)
549 {
550 src->OriginalParms = realLight->OriginalParms;
551
552 if (realLight->glIndex == -1 && src->glIndex != -1)
553 {
554 /* Light disabled */
555 dst_state->lights[src->glIndex] = NULL;
556 }
557 else if (realLight->glIndex != -1 && src->glIndex == -1)
558 {
559 /* Light enabled */
560 dst_state->lights[realLight->glIndex] = src;
561 }
562 src->glIndex = realLight->glIndex;
563 updated = TRUE;
564 break;
565 }
566 }
567
568 if (!updated)
569 {
570 /* This can happen if the light was originally created as a
571 * default light for SetLightEnable() while recording. */
572 WARN("Light %u in dst_state %p does not exist in src_state %p.\n",
573 src->OriginalIndex, dst_state, src_state);
574
575 src->OriginalParms = WINED3D_default_light;
576 if (src->glIndex != -1)
577 {
578 dst_state->lights[src->glIndex] = NULL;
579 src->glIndex = -1;
580 }
581 }
582 }
583 }
584 }
585
586 HRESULT CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock)
587 {
588 const struct wined3d_state *src_state = &stateblock->device->stateBlock->state;
589 unsigned int i;
590 DWORD map;
591
592 TRACE("stateblock %p.\n", stateblock);
593
594 TRACE("Capturing state %p.\n", src_state);
595
596 if (stateblock->changed.vertexShader && stateblock->state.vertex_shader != src_state->vertex_shader)
597 {
598 TRACE("Updating vertex shader from %p to %p\n",
599 stateblock->state.vertex_shader, src_state->vertex_shader);
600
601 if (src_state->vertex_shader)
602 IWineD3DVertexShader_AddRef((IWineD3DVertexShader *)src_state->vertex_shader);
603 if (stateblock->state.vertex_shader)
604 IWineD3DVertexShader_Release((IWineD3DVertexShader *)stateblock->state.vertex_shader);
605 stateblock->state.vertex_shader = src_state->vertex_shader;
606 }
607
608 /* Vertex shader float constants. */
609 for (i = 0; i < stateblock->num_contained_vs_consts_f; ++i)
610 {
611 unsigned int idx = stateblock->contained_vs_consts_f[i];
612
613 TRACE("Setting vs_consts_f[%u] to {%.8e, %.8e, %.8e, %.8e}.\n", idx,
614 src_state->vs_consts_f[idx * 4 + 0],
615 src_state->vs_consts_f[idx * 4 + 1],
616 src_state->vs_consts_f[idx * 4 + 2],
617 src_state->vs_consts_f[idx * 4 + 3]);
618
619 stateblock->state.vs_consts_f[idx * 4 + 0] = src_state->vs_consts_f[idx * 4 + 0];
620 stateblock->state.vs_consts_f[idx * 4 + 1] = src_state->vs_consts_f[idx * 4 + 1];
621 stateblock->state.vs_consts_f[idx * 4 + 2] = src_state->vs_consts_f[idx * 4 + 2];
622 stateblock->state.vs_consts_f[idx * 4 + 3] = src_state->vs_consts_f[idx * 4 + 3];
623 }
624
625 /* Vertex shader integer constants. */
626 for (i = 0; i < stateblock->num_contained_vs_consts_i; ++i)
627 {
628 unsigned int idx = stateblock->contained_vs_consts_i[i];
629
630 TRACE("Setting vs_consts[%u] to {%d, %d, %d, %d}.\n", idx,
631 src_state->vs_consts_i[idx * 4 + 0],
632 src_state->vs_consts_i[idx * 4 + 1],
633 src_state->vs_consts_i[idx * 4 + 2],
634 src_state->vs_consts_i[idx * 4 + 3]);
635
636 stateblock->state.vs_consts_i[idx * 4 + 0] = src_state->vs_consts_i[idx * 4 + 0];
637 stateblock->state.vs_consts_i[idx * 4 + 1] = src_state->vs_consts_i[idx * 4 + 1];
638 stateblock->state.vs_consts_i[idx * 4 + 2] = src_state->vs_consts_i[idx * 4 + 2];
639 stateblock->state.vs_consts_i[idx * 4 + 3] = src_state->vs_consts_i[idx * 4 + 3];
640 }
641
642 /* Vertex shader boolean constants. */
643 for (i = 0; i < stateblock->num_contained_vs_consts_b; ++i)
644 {
645 unsigned int idx = stateblock->contained_vs_consts_b[i];
646
647 TRACE("Setting vs_consts_b[%u] to %s.\n",
648 idx, src_state->vs_consts_b[idx] ? "TRUE" : "FALSE");
649
650 stateblock->state.vs_consts_b[idx] = src_state->vs_consts_b[idx];
651 }
652
653 /* Pixel shader float constants. */
654 for (i = 0; i < stateblock->num_contained_ps_consts_f; ++i)
655 {
656 unsigned int idx = stateblock->contained_ps_consts_f[i];
657
658 TRACE("Setting ps_consts_f[%u] to {%.8e, %.8e, %.8e, %.8e}.\n", idx,
659 src_state->ps_consts_f[idx * 4 + 0],
660 src_state->ps_consts_f[idx * 4 + 1],
661 src_state->ps_consts_f[idx * 4 + 2],
662 src_state->ps_consts_f[idx * 4 + 3]);
663
664 stateblock->state.ps_consts_f[idx * 4 + 0] = src_state->ps_consts_f[idx * 4 + 0];
665 stateblock->state.ps_consts_f[idx * 4 + 1] = src_state->ps_consts_f[idx * 4 + 1];
666 stateblock->state.ps_consts_f[idx * 4 + 2] = src_state->ps_consts_f[idx * 4 + 2];
667 stateblock->state.ps_consts_f[idx * 4 + 3] = src_state->ps_consts_f[idx * 4 + 3];
668 }
669
670 /* Pixel shader integer constants. */
671 for (i = 0; i < stateblock->num_contained_ps_consts_i; ++i)
672 {
673 unsigned int idx = stateblock->contained_ps_consts_i[i];
674 TRACE("Setting ps_consts_i[%u] to {%d, %d, %d, %d}.\n", idx,
675 src_state->ps_consts_i[idx * 4 + 0],
676 src_state->ps_consts_i[idx * 4 + 1],
677 src_state->ps_consts_i[idx * 4 + 2],
678 src_state->ps_consts_i[idx * 4 + 3]);
679
680 stateblock->state.ps_consts_i[idx * 4 + 0] = src_state->ps_consts_i[idx * 4 + 0];
681 stateblock->state.ps_consts_i[idx * 4 + 1] = src_state->ps_consts_i[idx * 4 + 1];
682 stateblock->state.ps_consts_i[idx * 4 + 2] = src_state->ps_consts_i[idx * 4 + 2];
683 stateblock->state.ps_consts_i[idx * 4 + 3] = src_state->ps_consts_i[idx * 4 + 3];
684 }
685
686 /* Pixel shader boolean constants. */
687 for (i = 0; i < stateblock->num_contained_ps_consts_b; ++i)
688 {
689 unsigned int idx = stateblock->contained_ps_consts_b[i];
690 TRACE("Setting ps_consts_b[%u] to %s.\n",
691 idx, src_state->ps_consts_b[idx] ? "TRUE" : "FALSE");
692
693 stateblock->state.ps_consts_b[idx] = src_state->ps_consts_b[idx];
694 }
695
696 /* Others + Render & Texture */
697 for (i = 0; i < stateblock->num_contained_transform_states; ++i)
698 {
699 WINED3DTRANSFORMSTATETYPE transform = stateblock->contained_transform_states[i];
700
701 TRACE("Updating transform %#x.\n", transform);
702
703 stateblock->state.transforms[transform] = src_state->transforms[transform];
704 }
705
706 if (stateblock->changed.primitive_type)
707 stateblock->state.gl_primitive_type = src_state->gl_primitive_type;
708
709 if (stateblock->changed.indices
710 && ((stateblock->state.index_buffer != src_state->index_buffer)
711 || (stateblock->state.base_vertex_index != src_state->base_vertex_index)
712 || (stateblock->state.index_format != src_state->index_format)))
713 {
714 TRACE("Updating index buffer to %p, base vertex index to %d.\n",
715 src_state->index_buffer, src_state->base_vertex_index);
716
717 if (src_state->index_buffer)
718 wined3d_buffer_incref(src_state->index_buffer);
719 if (stateblock->state.index_buffer)
720 wined3d_buffer_decref(stateblock->state.index_buffer);
721 stateblock->state.index_buffer = src_state->index_buffer;
722 stateblock->state.base_vertex_index = src_state->base_vertex_index;
723 stateblock->state.index_format = src_state->index_format;
724 }
725
726 if (stateblock->changed.vertexDecl && stateblock->state.vertex_declaration != src_state->vertex_declaration)
727 {
728 TRACE("Updating vertex declaration from %p to %p.\n",
729 stateblock->state.vertex_declaration, src_state->vertex_declaration);
730
731 if (src_state->vertex_declaration)
732 wined3d_vertex_declaration_incref(src_state->vertex_declaration);
733 if (stateblock->state.vertex_declaration)
734 wined3d_vertex_declaration_decref(stateblock->state.vertex_declaration);
735 stateblock->state.vertex_declaration = src_state->vertex_declaration;
736 }
737
738 if (stateblock->changed.material
739 && memcmp(&src_state->material, &stateblock->state.material, sizeof(stateblock->state.material)))
740 {
741 TRACE("Updating material.\n");
742
743 stateblock->state.material = src_state->material;
744 }
745
746 if (stateblock->changed.viewport
747 && memcmp(&src_state->viewport, &stateblock->state.viewport, sizeof(stateblock->state.viewport)))
748 {
749 TRACE("Updating viewport.\n");
750
751 stateblock->state.viewport = src_state->viewport;
752 }
753
754 if (stateblock->changed.scissorRect && memcmp(&src_state->scissor_rect,
755 &stateblock->state.scissor_rect, sizeof(stateblock->state.scissor_rect)))
756 {
757 TRACE("Updating scissor rect.\n");
758
759 stateblock->state.scissor_rect = src_state->scissor_rect;
760 }
761
762 map = stateblock->changed.streamSource;
763 for (i = 0; map; map >>= 1, ++i)
764 {
765 if (!(map & 1)) continue;
766
767 if (stateblock->state.streams[i].stride != src_state->streams[i].stride
768 || stateblock->state.streams[i].buffer != src_state->streams[i].buffer)
769 {
770 TRACE("Updating stream source %u to %p, stride to %u.\n",
771 i, src_state->streams[i].buffer,
772 src_state->streams[i].stride);
773
774 stateblock->state.streams[i].stride = src_state->streams[i].stride;
775 if (src_state->streams[i].buffer)
776 wined3d_buffer_incref(src_state->streams[i].buffer);
777 if (stateblock->state.streams[i].buffer)
778 wined3d_buffer_decref(stateblock->state.streams[i].buffer);
779 stateblock->state.streams[i].buffer = src_state->streams[i].buffer;
780 }
781 }
782
783 map = stateblock->changed.streamFreq;
784 for (i = 0; map; map >>= 1, ++i)
785 {
786 if (!(map & 1)) continue;
787
788 if (stateblock->state.streams[i].frequency != src_state->streams[i].frequency
789 || stateblock->state.streams[i].flags != src_state->streams[i].flags)
790 {
791 TRACE("Updating stream frequency %u to %u flags to %#x.\n",
792 i, src_state->streams[i].frequency, src_state->streams[i].flags);
793
794 stateblock->state.streams[i].frequency = src_state->streams[i].frequency;
795 stateblock->state.streams[i].flags = src_state->streams[i].flags;
796 }
797 }
798
799 map = stateblock->changed.clipplane;
800 for (i = 0; map; map >>= 1, ++i)
801 {
802 if (!(map & 1)) continue;
803
804 if (memcmp(src_state->clip_planes[i], stateblock->state.clip_planes[i], sizeof(*stateblock->state.clip_planes)))
805 {
806 TRACE("Updating clipplane %u.\n", i);
807 memcpy(stateblock->state.clip_planes[i], src_state->clip_planes[i], sizeof(*stateblock->state.clip_planes));
808 }
809 }
810
811 /* Render */
812 for (i = 0; i < stateblock->num_contained_render_states; ++i)
813 {
814 WINED3DRENDERSTATETYPE rs = stateblock->contained_render_states[i];
815
816 TRACE("Updating render state %#x to %u.\n", rs, src_state->render_states[rs]);
817
818 stateblock->state.render_states[rs] = src_state->render_states[rs];
819 }
820
821 /* Texture states */
822 for (i = 0; i < stateblock->num_contained_tss_states; ++i)
823 {
824 DWORD stage = stateblock->contained_tss_states[i].stage;
825 DWORD state = stateblock->contained_tss_states[i].state;
826
827 TRACE("Updating texturestage state %u, %u to %#x (was %#x).\n", stage, state,
828 src_state->texture_states[stage][state], stateblock->state.texture_states[stage][state]);
829
830 stateblock->state.texture_states[stage][state] = src_state->texture_states[stage][state];
831 }
832
833 /* Samplers */
834 map = stateblock->changed.textures;
835 for (i = 0; map; map >>= 1, ++i)
836 {
837 if (!(map & 1)) continue;
838
839 TRACE("Updating texture %u to %p (was %p).\n",
840 i, src_state->textures[i], stateblock->state.textures[i]);
841
842 if (src_state->textures[i])
843 IWineD3DBaseTexture_AddRef((IWineD3DBaseTexture *)src_state->textures[i]);
844 if (stateblock->state.textures[i])
845 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *)stateblock->state.textures[i]);
846 stateblock->state.textures[i] = src_state->textures[i];
847 }
848
849 for (i = 0; i < stateblock->num_contained_sampler_states; ++i)
850 {
851 DWORD stage = stateblock->contained_sampler_states[i].stage;
852 DWORD state = stateblock->contained_sampler_states[i].state;
853
854 TRACE("Updating sampler state %u, %u to %#x (was %#x).\n", stage, state,
855 src_state->sampler_states[stage][state], stateblock->state.sampler_states[stage][state]);
856
857 stateblock->state.sampler_states[stage][state] = src_state->sampler_states[stage][state];
858 }
859
860 if (stateblock->changed.pixelShader && stateblock->state.pixel_shader != src_state->pixel_shader)
861 {
862 if (src_state->pixel_shader)
863 IWineD3DPixelShader_AddRef((IWineD3DPixelShader *)src_state->pixel_shader);
864 if (stateblock->state.pixel_shader)
865 IWineD3DPixelShader_Release((IWineD3DPixelShader *)stateblock->state.pixel_shader);
866 stateblock->state.pixel_shader = src_state->pixel_shader;
867 }
868
869 wined3d_state_record_lights(&stateblock->state, src_state);
870
871 TRACE("Captue done.\n");
872
873 return WINED3D_OK;
874 }
875
876 static void apply_lights(IWineD3DDevice *device, const struct wined3d_state *state)
877 {
878 UINT i;
879
880 for (i = 0; i < LIGHTMAP_SIZE; ++i)
881 {
882 struct list *e;
883
884 LIST_FOR_EACH(e, &state->light_map[i])
885 {
886 const struct wined3d_light_info *light = LIST_ENTRY(e, struct wined3d_light_info, entry);
887
888 IWineD3DDevice_SetLight(device, light->OriginalIndex, &light->OriginalParms);
889 IWineD3DDevice_SetLightEnable(device, light->OriginalIndex, light->glIndex != -1);
890 }
891 }
892 }
893
894 HRESULT CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock)
895 {
896 IWineD3DDevice *device = (IWineD3DDevice *)stateblock->device;
897 unsigned int i;
898 DWORD map;
899
900 TRACE("Applying stateblock %p to device %p.\n", stateblock, device);
901 TRACE("Blocktype: %#x.\n", stateblock->blockType);
902
903 if (stateblock->changed.vertexShader)
904 IWineD3DDevice_SetVertexShader(device, (IWineD3DVertexShader *)stateblock->state.vertex_shader);
905
906 /* Vertex Shader Constants. */
907 for (i = 0; i < stateblock->num_contained_vs_consts_f; ++i)
908 {
909 IWineD3DDevice_SetVertexShaderConstantF(device, stateblock->contained_vs_consts_f[i],
910 stateblock->state.vs_consts_f + stateblock->contained_vs_consts_f[i] * 4, 1);
911 }
912 for (i = 0; i < stateblock->num_contained_vs_consts_i; ++i)
913 {
914 IWineD3DDevice_SetVertexShaderConstantI(device, stateblock->contained_vs_consts_i[i],
915 stateblock->state.vs_consts_i + stateblock->contained_vs_consts_i[i] * 4, 1);
916 }
917 for (i = 0; i < stateblock->num_contained_vs_consts_b; ++i)
918 {
919 IWineD3DDevice_SetVertexShaderConstantB(device, stateblock->contained_vs_consts_b[i],
920 stateblock->state.vs_consts_b + stateblock->contained_vs_consts_b[i], 1);
921 }
922
923 apply_lights(device, &stateblock->state);
924
925 if (stateblock->changed.pixelShader)
926 IWineD3DDevice_SetPixelShader(device, (IWineD3DPixelShader *)stateblock->state.pixel_shader);
927
928 /* Pixel Shader Constants. */
929 for (i = 0; i < stateblock->num_contained_ps_consts_f; ++i)
930 {
931 IWineD3DDevice_SetPixelShaderConstantF(device, stateblock->contained_ps_consts_f[i],
932 stateblock->state.ps_consts_f + stateblock->contained_ps_consts_f[i] * 4, 1);
933 }
934 for (i = 0; i < stateblock->num_contained_ps_consts_i; ++i)
935 {
936 IWineD3DDevice_SetPixelShaderConstantI(device, stateblock->contained_ps_consts_i[i],
937 stateblock->state.ps_consts_i + stateblock->contained_ps_consts_i[i] * 4, 1);
938 }
939 for (i = 0; i < stateblock->num_contained_ps_consts_b; ++i)
940 {
941 IWineD3DDevice_SetPixelShaderConstantB(device, stateblock->contained_ps_consts_b[i],
942 stateblock->state.ps_consts_b + stateblock->contained_ps_consts_b[i], 1);
943 }
944
945 /* Render states. */
946 for (i = 0; i < stateblock->num_contained_render_states; ++i)
947 {
948 IWineD3DDevice_SetRenderState(device, stateblock->contained_render_states[i],
949 stateblock->state.render_states[stateblock->contained_render_states[i]]);
950 }
951
952 /* Texture states. */
953 for (i = 0; i < stateblock->num_contained_tss_states; ++i)
954 {
955 DWORD stage = stateblock->contained_tss_states[i].stage;
956 DWORD state = stateblock->contained_tss_states[i].state;
957
958 IWineD3DDevice_SetTextureStageState(device, stage, state, stateblock->state.texture_states[stage][state]);
959 }
960
961 /* Sampler states. */
962 for (i = 0; i < stateblock->num_contained_sampler_states; ++i)
963 {
964 DWORD stage = stateblock->contained_sampler_states[i].stage;
965 DWORD state = stateblock->contained_sampler_states[i].state;
966 DWORD value = stateblock->state.sampler_states[stage][state];
967
968 if (stage >= MAX_FRAGMENT_SAMPLERS) stage += WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS;
969 IWineD3DDevice_SetSamplerState(device, stage, state, value);
970 }
971
972 /* Transform states. */
973 for (i = 0; i < stateblock->num_contained_transform_states; ++i)
974 {
975 IWineD3DDevice_SetTransform(device, stateblock->contained_transform_states[i],
976 &stateblock->state.transforms[stateblock->contained_transform_states[i]]);
977 }
978
979 if (stateblock->changed.primitive_type)
980 {
981 stateblock->device->updateStateBlock->changed.primitive_type = TRUE;
982 stateblock->device->updateStateBlock->state.gl_primitive_type = stateblock->state.gl_primitive_type;
983 }
984
985 if (stateblock->changed.indices)
986 {
987 IWineD3DDevice_SetIndexBuffer(device, stateblock->state.index_buffer, stateblock->state.index_format);
988 IWineD3DDevice_SetBaseVertexIndex(device, stateblock->state.base_vertex_index);
989 }
990
991 if (stateblock->changed.vertexDecl && stateblock->state.vertex_declaration)
992 {
993 IWineD3DDevice_SetVertexDeclaration(device, stateblock->state.vertex_declaration);
994 }
995
996 if (stateblock->changed.material)
997 {
998 IWineD3DDevice_SetMaterial(device, &stateblock->state.material);
999 }
1000
1001 if (stateblock->changed.viewport)
1002 {
1003 IWineD3DDevice_SetViewport(device, &stateblock->state.viewport);
1004 }
1005
1006 if (stateblock->changed.scissorRect)
1007 {
1008 IWineD3DDevice_SetScissorRect(device, &stateblock->state.scissor_rect);
1009 }
1010
1011 map = stateblock->changed.streamSource;
1012 for (i = 0; map; map >>= 1, ++i)
1013 {
1014 if (map & 1)
1015 IWineD3DDevice_SetStreamSource(device, i,
1016 stateblock->state.streams[i].buffer,
1017 0, stateblock->state.streams[i].stride);
1018 }
1019
1020 map = stateblock->changed.streamFreq;
1021 for (i = 0; map; map >>= 1, ++i)
1022 {
1023 if (map & 1)
1024 IWineD3DDevice_SetStreamSourceFreq(device, i,
1025 stateblock->state.streams[i].frequency | stateblock->state.streams[i].flags);
1026 }
1027
1028 map = stateblock->changed.textures;
1029 for (i = 0; map; map >>= 1, ++i)
1030 {
1031 DWORD stage;
1032
1033 if (!(map & 1)) continue;
1034
1035 stage = i < MAX_FRAGMENT_SAMPLERS ? i : WINED3DVERTEXTEXTURESAMPLER0 + i - MAX_FRAGMENT_SAMPLERS;
1036 IWineD3DDevice_SetTexture(device, stage, (IWineD3DBaseTexture *)stateblock->state.textures[i]);
1037 }
1038
1039 map = stateblock->changed.clipplane;
1040 for (i = 0; map; map >>= 1, ++i)
1041 {
1042 float clip[4];
1043
1044 if (!(map & 1)) continue;
1045
1046 clip[0] = stateblock->state.clip_planes[i][0];
1047 clip[1] = stateblock->state.clip_planes[i][1];
1048 clip[2] = stateblock->state.clip_planes[i][2];
1049 clip[3] = stateblock->state.clip_planes[i][3];
1050 IWineD3DDevice_SetClipPlane(device, i, clip);
1051 }
1052
1053 stateblock->device->stateBlock->state.lowest_disabled_stage = MAX_TEXTURES - 1;
1054 for (i = 0; i < MAX_TEXTURES - 1; ++i)
1055 {
1056 if (stateblock->device->stateBlock->state.texture_states[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE)
1057 {
1058 stateblock->device->stateBlock->state.lowest_disabled_stage = i;
1059 break;
1060 }
1061 }
1062
1063 TRACE("Applied stateblock %p.\n", stateblock);
1064
1065 return WINED3D_OK;
1066 }
1067
1068 void stateblock_init_default_state(struct wined3d_stateblock *stateblock)
1069 {
1070 IWineD3DDeviceImpl *device = stateblock->device;
1071 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1072 struct wined3d_state *state = &stateblock->state;
1073 union {
1074 WINED3DLINEPATTERN lp;
1075 DWORD d;
1076 } lp;
1077 union {
1078 float f;
1079 DWORD d;
1080 } tmpfloat;
1081 unsigned int i;
1082 IWineD3DSwapChain *swapchain;
1083 IWineD3DSurface *backbuffer;
1084 HRESULT hr;
1085
1086 TRACE("stateblock %p.\n", stateblock);
1087
1088 stateblock->blockType = WINED3DSBT_INIT;
1089
1090 /* Set some of the defaults for lights, transforms etc */
1091 memcpy(&state->transforms[WINED3DTS_PROJECTION], identity, sizeof(identity));
1092 memcpy(&state->transforms[WINED3DTS_VIEW], identity, sizeof(identity));
1093 for (i = 0; i < 256; ++i)
1094 {
1095 memcpy(&state->transforms[WINED3DTS_WORLDMATRIX(i)], identity, sizeof(identity));
1096 }
1097
1098 TRACE("Render states\n");
1099 /* Render states: */
1100 if (device->auto_depth_stencil)
1101 state->render_states[WINED3DRS_ZENABLE] = WINED3DZB_TRUE;
1102 else
1103 state->render_states[WINED3DRS_ZENABLE] = WINED3DZB_FALSE;
1104 state->render_states[WINED3DRS_FILLMODE] = WINED3DFILL_SOLID;
1105 state->render_states[WINED3DRS_SHADEMODE] = WINED3DSHADE_GOURAUD;
1106 lp.lp.wRepeatFactor = 0;
1107 lp.lp.wLinePattern = 0;
1108 state->render_states[WINED3DRS_LINEPATTERN] = lp.d;
1109 state->render_states[WINED3DRS_ZWRITEENABLE] = TRUE;
1110 state->render_states[WINED3DRS_ALPHATESTENABLE] = FALSE;
1111 state->render_states[WINED3DRS_LASTPIXEL] = TRUE;
1112 state->render_states[WINED3DRS_SRCBLEND] = WINED3DBLEND_ONE;
1113 state->render_states[WINED3DRS_DESTBLEND] = WINED3DBLEND_ZERO;
1114 state->render_states[WINED3DRS_CULLMODE] = WINED3DCULL_CCW;
1115 state->render_states[WINED3DRS_ZFUNC] = WINED3DCMP_LESSEQUAL;
1116 state->render_states[WINED3DRS_ALPHAFUNC] = WINED3DCMP_ALWAYS;
1117 state->render_states[WINED3DRS_ALPHAREF] = 0;
1118 state->render_states[WINED3DRS_DITHERENABLE] = FALSE;
1119 state->render_states[WINED3DRS_ALPHABLENDENABLE] = FALSE;
1120 state->render_states[WINED3DRS_FOGENABLE] = FALSE;
1121 state->render_states[WINED3DRS_SPECULARENABLE] = FALSE;
1122 state->render_states[WINED3DRS_ZVISIBLE] = 0;
1123 state->render_states[WINED3DRS_FOGCOLOR] = 0;
1124 state->render_states[WINED3DRS_FOGTABLEMODE] = WINED3DFOG_NONE;
1125 tmpfloat.f = 0.0f;
1126 state->render_states[WINED3DRS_FOGSTART] = tmpfloat.d;
1127 tmpfloat.f = 1.0f;
1128 state->render_states[WINED3DRS_FOGEND] = tmpfloat.d;
1129 tmpfloat.f = 1.0f;
1130 state->render_states[WINED3DRS_FOGDENSITY] = tmpfloat.d;
1131 state->render_states[WINED3DRS_EDGEANTIALIAS] = FALSE;
1132 state->render_states[WINED3DRS_ZBIAS] = 0;
1133 state->render_states[WINED3DRS_RANGEFOGENABLE] = FALSE;
1134 state->render_states[WINED3DRS_STENCILENABLE] = FALSE;
1135 state->render_states[WINED3DRS_STENCILFAIL] = WINED3DSTENCILOP_KEEP;
1136 state->render_states[WINED3DRS_STENCILZFAIL] = WINED3DSTENCILOP_KEEP;
1137 state->render_states[WINED3DRS_STENCILPASS] = WINED3DSTENCILOP_KEEP;
1138 state->render_states[WINED3DRS_STENCILREF] = 0;
1139 state->render_states[WINED3DRS_STENCILMASK] = 0xffffffff;
1140 state->render_states[WINED3DRS_STENCILFUNC] = WINED3DCMP_ALWAYS;
1141 state->render_states[WINED3DRS_STENCILWRITEMASK] = 0xffffffff;
1142 state->render_states[WINED3DRS_TEXTUREFACTOR] = 0xffffffff;
1143 state->render_states[WINED3DRS_WRAP0] = 0;
1144 state->render_states[WINED3DRS_WRAP1] = 0;
1145 state->render_states[WINED3DRS_WRAP2] = 0;
1146 state->render_states[WINED3DRS_WRAP3] = 0;
1147 state->render_states[WINED3DRS_WRAP4] = 0;
1148 state->render_states[WINED3DRS_WRAP5] = 0;
1149 state->render_states[WINED3DRS_WRAP6] = 0;
1150 state->render_states[WINED3DRS_WRAP7] = 0;
1151 state->render_states[WINED3DRS_CLIPPING] = TRUE;
1152 state->render_states[WINED3DRS_LIGHTING] = TRUE;
1153 state->render_states[WINED3DRS_AMBIENT] = 0;
1154 state->render_states[WINED3DRS_FOGVERTEXMODE] = WINED3DFOG_NONE;
1155 state->render_states[WINED3DRS_COLORVERTEX] = TRUE;
1156 state->render_states[WINED3DRS_LOCALVIEWER] = TRUE;
1157 state->render_states[WINED3DRS_NORMALIZENORMALS] = FALSE;
1158 state->render_states[WINED3DRS_DIFFUSEMATERIALSOURCE] = WINED3DMCS_COLOR1;
1159 state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] = WINED3DMCS_COLOR2;
1160 state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE] = WINED3DMCS_MATERIAL;
1161 state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] = WINED3DMCS_MATERIAL;
1162 state->render_states[WINED3DRS_VERTEXBLEND] = WINED3DVBF_DISABLE;
1163 state->render_states[WINED3DRS_CLIPPLANEENABLE] = 0;
1164 state->render_states[WINED3DRS_SOFTWAREVERTEXPROCESSING] = FALSE;
1165 tmpfloat.f = 1.0f;
1166 state->render_states[WINED3DRS_POINTSIZE] = tmpfloat.d;
1167 tmpfloat.f = 1.0f;
1168 state->render_states[WINED3DRS_POINTSIZE_MIN] = tmpfloat.d;
1169 state->render_states[WINED3DRS_POINTSPRITEENABLE] = FALSE;
1170 state->render_states[WINED3DRS_POINTSCALEENABLE] = FALSE;
1171 tmpfloat.f = 1.0f;
1172 state->render_states[WINED3DRS_POINTSCALE_A] = tmpfloat.d;
1173 tmpfloat.f = 0.0f;
1174 state->render_states[WINED3DRS_POINTSCALE_B] = tmpfloat.d;
1175 tmpfloat.f = 0.0f;
1176 state->render_states[WINED3DRS_POINTSCALE_C] = tmpfloat.d;
1177 state->render_states[WINED3DRS_MULTISAMPLEANTIALIAS] = TRUE;
1178 state->render_states[WINED3DRS_MULTISAMPLEMASK] = 0xffffffff;
1179 state->render_states[WINED3DRS_PATCHEDGESTYLE] = WINED3DPATCHEDGE_DISCRETE;
1180 tmpfloat.f = 1.0f;
1181 state->render_states[WINED3DRS_PATCHSEGMENTS] = tmpfloat.d;
1182 state->render_states[WINED3DRS_DEBUGMONITORTOKEN] = 0xbaadcafe;
1183 tmpfloat.f = gl_info->limits.pointsize_max;
1184 state->render_states[WINED3DRS_POINTSIZE_MAX] = tmpfloat.d;
1185 state->render_states[WINED3DRS_INDEXEDVERTEXBLENDENABLE] = FALSE;
1186 state->render_states[WINED3DRS_COLORWRITEENABLE] = 0x0000000f;
1187 tmpfloat.f = 0.0f;
1188 state->render_states[WINED3DRS_TWEENFACTOR] = tmpfloat.d;
1189 state->render_states[WINED3DRS_BLENDOP] = WINED3DBLENDOP_ADD;
1190 state->render_states[WINED3DRS_POSITIONDEGREE] = WINED3DDEGREE_CUBIC;
1191 state->render_states[WINED3DRS_NORMALDEGREE] = WINED3DDEGREE_LINEAR;
1192 /* states new in d3d9 */
1193 state->render_states[WINED3DRS_SCISSORTESTENABLE] = FALSE;
1194 state->render_states[WINED3DRS_SLOPESCALEDEPTHBIAS] = 0;
1195 tmpfloat.f = 1.0f;
1196 state->render_states[WINED3DRS_MINTESSELLATIONLEVEL] = tmpfloat.d;
1197 state->render_states[WINED3DRS_MAXTESSELLATIONLEVEL] = tmpfloat.d;
1198 state->render_states[WINED3DRS_ANTIALIASEDLINEENABLE] = FALSE;
1199 tmpfloat.f = 0.0f;
1200 state->render_states[WINED3DRS_ADAPTIVETESS_X] = tmpfloat.d;
1201 state->render_states[WINED3DRS_ADAPTIVETESS_Y] = tmpfloat.d;
1202 tmpfloat.f = 1.0f;
1203 state->render_states[WINED3DRS_ADAPTIVETESS_Z] = tmpfloat.d;
1204 tmpfloat.f = 0.0f;
1205 state->render_states[WINED3DRS_ADAPTIVETESS_W] = tmpfloat.d;
1206 state->render_states[WINED3DRS_ENABLEADAPTIVETESSELLATION] = FALSE;
1207 state->render_states[WINED3DRS_TWOSIDEDSTENCILMODE] = FALSE;
1208 state->render_states[WINED3DRS_CCW_STENCILFAIL] = WINED3DSTENCILOP_KEEP;
1209 state->render_states[WINED3DRS_CCW_STENCILZFAIL] = WINED3DSTENCILOP_KEEP;
1210 state->render_states[WINED3DRS_CCW_STENCILPASS] = WINED3DSTENCILOP_KEEP;
1211 state->render_states[WINED3DRS_CCW_STENCILFUNC] = WINED3DCMP_ALWAYS;
1212 state->render_states[WINED3DRS_COLORWRITEENABLE1] = 0x0000000f;
1213 state->render_states[WINED3DRS_COLORWRITEENABLE2] = 0x0000000f;
1214 state->render_states[WINED3DRS_COLORWRITEENABLE3] = 0x0000000f;
1215 state->render_states[WINED3DRS_BLENDFACTOR] = 0xFFFFFFFF;
1216 state->render_states[WINED3DRS_SRGBWRITEENABLE] = 0;
1217 state->render_states[WINED3DRS_DEPTHBIAS] = 0;
1218 state->render_states[WINED3DRS_WRAP8] = 0;
1219 state->render_states[WINED3DRS_WRAP9] = 0;
1220 state->render_states[WINED3DRS_WRAP10] = 0;
1221 state->render_states[WINED3DRS_WRAP11] = 0;
1222 state->render_states[WINED3DRS_WRAP12] = 0;
1223 state->render_states[WINED3DRS_WRAP13] = 0;
1224 state->render_states[WINED3DRS_WRAP14] = 0;
1225 state->render_states[WINED3DRS_WRAP15] = 0;
1226 state->render_states[WINED3DRS_SEPARATEALPHABLENDENABLE] = FALSE;
1227 state->render_states[WINED3DRS_SRCBLENDALPHA] = WINED3DBLEND_ONE;
1228 state->render_states[WINED3DRS_DESTBLENDALPHA] = WINED3DBLEND_ZERO;
1229 state->render_states[WINED3DRS_BLENDOPALPHA] = WINED3DBLENDOP_ADD;
1230
1231 /* clipping status */
1232 state->clip_status.ClipUnion = 0;
1233 state->clip_status.ClipIntersection = 0xFFFFFFFF;
1234
1235 /* Texture Stage States - Put directly into state block, we will call function below */
1236 for (i = 0; i < MAX_TEXTURES; ++i)
1237 {
1238 TRACE("Setting up default texture states for texture Stage %u.\n", i);
1239 memcpy(&state->transforms[WINED3DTS_TEXTURE0 + i], identity, sizeof(identity));
1240 state->texture_states[i][WINED3DTSS_COLOROP] = i ? WINED3DTOP_DISABLE : WINED3DTOP_MODULATE;
1241 state->texture_states[i][WINED3DTSS_COLORARG1] = WINED3DTA_TEXTURE;
1242 state->texture_states[i][WINED3DTSS_COLORARG2] = WINED3DTA_CURRENT;
1243 state->texture_states[i][WINED3DTSS_ALPHAOP] = i ? WINED3DTOP_DISABLE : WINED3DTOP_SELECTARG1;
1244 state->texture_states[i][WINED3DTSS_ALPHAARG1] = WINED3DTA_TEXTURE;
1245 state->texture_states[i][WINED3DTSS_ALPHAARG2] = WINED3DTA_CURRENT;
1246 state->texture_states[i][WINED3DTSS_BUMPENVMAT00] = 0;
1247 state->texture_states[i][WINED3DTSS_BUMPENVMAT01] = 0;
1248 state->texture_states[i][WINED3DTSS_BUMPENVMAT10] = 0;
1249 state->texture_states[i][WINED3DTSS_BUMPENVMAT11] = 0;
1250 state->texture_states[i][WINED3DTSS_TEXCOORDINDEX] = i;
1251 state->texture_states[i][WINED3DTSS_BUMPENVLSCALE] = 0;
1252 state->texture_states[i][WINED3DTSS_BUMPENVLOFFSET] = 0;
1253 state->texture_states[i][WINED3DTSS_TEXTURETRANSFORMFLAGS] = WINED3DTTFF_DISABLE;
1254 state->texture_states[i][WINED3DTSS_COLORARG0] = WINED3DTA_CURRENT;
1255 state->texture_states[i][WINED3DTSS_ALPHAARG0] = WINED3DTA_CURRENT;
1256 state->texture_states[i][WINED3DTSS_RESULTARG] = WINED3DTA_CURRENT;
1257 }
1258 state->lowest_disabled_stage = 1;
1259
1260 /* Sampler states*/
1261 for (i = 0 ; i < MAX_COMBINED_SAMPLERS; ++i)
1262 {
1263 TRACE("Setting up default samplers states for sampler %u.\n", i);
1264 state->sampler_states[i][WINED3DSAMP_ADDRESSU] = WINED3DTADDRESS_WRAP;
1265 state->sampler_states[i][WINED3DSAMP_ADDRESSV] = WINED3DTADDRESS_WRAP;
1266 state->sampler_states[i][WINED3DSAMP_ADDRESSW] = WINED3DTADDRESS_WRAP;
1267 state->sampler_states[i][WINED3DSAMP_BORDERCOLOR] = 0;
1268 state->sampler_states[i][WINED3DSAMP_MAGFILTER] = WINED3DTEXF_POINT;
1269 state->sampler_states[i][WINED3DSAMP_MINFILTER] = WINED3DTEXF_POINT;
1270 state->sampler_states[i][WINED3DSAMP_MIPFILTER] = WINED3DTEXF_NONE;
1271 state->sampler_states[i][WINED3DSAMP_MIPMAPLODBIAS] = 0;
1272 state->sampler_states[i][WINED3DSAMP_MAXMIPLEVEL] = 0;
1273 state->sampler_states[i][WINED3DSAMP_MAXANISOTROPY] = 1;
1274 state->sampler_states[i][WINED3DSAMP_SRGBTEXTURE] = 0;
1275 /* TODO: Indicates which element of a multielement texture to use. */
1276 state->sampler_states[i][WINED3DSAMP_ELEMENTINDEX] = 0;
1277 /* TODO: Vertex offset in the presampled displacement map. */
1278 state->sampler_states[i][WINED3DSAMP_DMAPOFFSET] = 0;
1279 }
1280
1281 for (i = 0; i < gl_info->limits.textures; ++i)
1282 {
1283 state->textures[i] = NULL;
1284 }
1285
1286 /* check the return values, because the GetBackBuffer call isn't valid for ddraw */
1287 hr = IWineD3DDevice_GetSwapChain((IWineD3DDevice *)device, 0, &swapchain);
1288 if (SUCCEEDED(hr) && swapchain)
1289 {
1290 hr = IWineD3DSwapChain_GetBackBuffer(swapchain, 0, WINED3DBACKBUFFER_TYPE_MONO, &backbuffer);
1291 if (SUCCEEDED(hr) && backbuffer)
1292 {
1293 struct wined3d_resource_desc desc;
1294
1295 wined3d_resource_get_desc(&((IWineD3DSurfaceImpl *)backbuffer)->resource, &desc);
1296 IWineD3DSurface_Release(backbuffer);
1297
1298 /* Set the default scissor rect values */
1299 state->scissor_rect.left = 0;
1300 state->scissor_rect.right = desc.width;
1301 state->scissor_rect.top = 0;
1302 state->scissor_rect.bottom = desc.height;
1303 }
1304
1305 /* Set the default viewport */
1306 state->viewport.X = 0;
1307 state->viewport.Y = 0;
1308 state->viewport.Width = ((IWineD3DSwapChainImpl *)swapchain)->presentParms.BackBufferWidth;
1309 state->viewport.Height = ((IWineD3DSwapChainImpl *)swapchain)->presentParms.BackBufferHeight;
1310 state->viewport.MinZ = 0.0f;
1311 state->viewport.MaxZ = 1.0f;
1312
1313 IWineD3DSwapChain_Release(swapchain);
1314 }
1315
1316 TRACE("Done.\n");
1317 }
1318
1319 HRESULT stateblock_init(struct wined3d_stateblock *stateblock, IWineD3DDeviceImpl *device, WINED3DSTATEBLOCKTYPE type)
1320 {
1321 unsigned int i;
1322 HRESULT hr;
1323
1324 stateblock->ref = 1;
1325 stateblock->device = device;
1326 stateblock->blockType = type;
1327
1328 for (i = 0; i < LIGHTMAP_SIZE; i++)
1329 {
1330 list_init(&stateblock->state.light_map[i]);
1331 }
1332
1333 hr = stateblock_allocate_shader_constants(stateblock);
1334 if (FAILED(hr)) return hr;
1335
1336 /* The WINED3DSBT_INIT stateblock type is used during initialization to
1337 * produce a placeholder stateblock so other functions called can update a
1338 * state block. */
1339 if (type == WINED3DSBT_INIT || type == WINED3DSBT_RECORDED) return WINED3D_OK;
1340
1341 TRACE("Updating changed flags appropriate for type %#x.\n", type);
1342
1343 switch (type)
1344 {
1345 case WINED3DSBT_ALL:
1346 stateblock_init_lights(stateblock, device->stateBlock->state.light_map);
1347 stateblock_savedstates_set_all(&stateblock->changed, device->d3d_vshader_constantF,
1348 device->d3d_pshader_constantF);
1349 break;
1350
1351 case WINED3DSBT_PIXELSTATE:
1352 stateblock_savedstates_set_pixel(&stateblock->changed, device->d3d_pshader_constantF);
1353 break;
1354
1355 case WINED3DSBT_VERTEXSTATE:
1356 stateblock_init_lights(stateblock, device->stateBlock->state.light_map);
1357 stateblock_savedstates_set_vertex(&stateblock->changed, device->d3d_vshader_constantF);
1358 break;
1359
1360 default:
1361 FIXME("Unrecognized state block type %#x.\n", type);
1362 break;
1363 }
1364
1365 stateblock_init_contained_states(stateblock);
1366 wined3d_stateblock_capture(stateblock);
1367
1368 return WINED3D_OK;
1369 }
Windows API implementation