2 * state block implementation
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
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.
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.
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
26 #include "wine/port.h"
27 #include "wined3d_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
31 static const DWORD pixel_states_render
[] =
33 WINED3D_RS_ALPHABLENDENABLE
,
36 WINED3D_RS_ALPHATESTENABLE
,
37 WINED3D_RS_ANTIALIASEDLINEENABLE
,
38 WINED3D_RS_BLENDFACTOR
,
40 WINED3D_RS_BLENDOPALPHA
,
41 WINED3D_RS_CCW_STENCILFAIL
,
42 WINED3D_RS_CCW_STENCILPASS
,
43 WINED3D_RS_CCW_STENCILZFAIL
,
44 WINED3D_RS_COLORWRITEENABLE
,
45 WINED3D_RS_COLORWRITEENABLE1
,
46 WINED3D_RS_COLORWRITEENABLE2
,
47 WINED3D_RS_COLORWRITEENABLE3
,
50 WINED3D_RS_DESTBLENDALPHA
,
51 WINED3D_RS_DITHERENABLE
,
53 WINED3D_RS_FOGDENSITY
,
57 WINED3D_RS_SCISSORTESTENABLE
,
58 WINED3D_RS_SEPARATEALPHABLENDENABLE
,
60 WINED3D_RS_SLOPESCALEDEPTHBIAS
,
62 WINED3D_RS_SRCBLENDALPHA
,
63 WINED3D_RS_SRGBWRITEENABLE
,
64 WINED3D_RS_STENCILENABLE
,
65 WINED3D_RS_STENCILFAIL
,
66 WINED3D_RS_STENCILFUNC
,
67 WINED3D_RS_STENCILMASK
,
68 WINED3D_RS_STENCILPASS
,
69 WINED3D_RS_STENCILREF
,
70 WINED3D_RS_STENCILWRITEMASK
,
71 WINED3D_RS_STENCILZFAIL
,
72 WINED3D_RS_TEXTUREFACTOR
,
73 WINED3D_RS_TWOSIDEDSTENCILMODE
,
92 WINED3D_RS_ZWRITEENABLE
,
95 static const DWORD pixel_states_texture
[] =
97 WINED3D_TSS_ALPHA_ARG0
,
98 WINED3D_TSS_ALPHA_ARG1
,
99 WINED3D_TSS_ALPHA_ARG2
,
100 WINED3D_TSS_ALPHA_OP
,
101 WINED3D_TSS_BUMPENV_LOFFSET
,
102 WINED3D_TSS_BUMPENV_LSCALE
,
103 WINED3D_TSS_BUMPENV_MAT00
,
104 WINED3D_TSS_BUMPENV_MAT01
,
105 WINED3D_TSS_BUMPENV_MAT10
,
106 WINED3D_TSS_BUMPENV_MAT11
,
107 WINED3D_TSS_COLOR_ARG0
,
108 WINED3D_TSS_COLOR_ARG1
,
109 WINED3D_TSS_COLOR_ARG2
,
110 WINED3D_TSS_COLOR_OP
,
111 WINED3D_TSS_RESULT_ARG
,
112 WINED3D_TSS_TEXCOORD_INDEX
,
113 WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
,
116 static const DWORD pixel_states_sampler
[] =
118 WINED3D_SAMP_ADDRESS_U
,
119 WINED3D_SAMP_ADDRESS_V
,
120 WINED3D_SAMP_ADDRESS_W
,
121 WINED3D_SAMP_BORDER_COLOR
,
122 WINED3D_SAMP_MAG_FILTER
,
123 WINED3D_SAMP_MIN_FILTER
,
124 WINED3D_SAMP_MIP_FILTER
,
125 WINED3D_SAMP_MIPMAP_LOD_BIAS
,
126 WINED3D_SAMP_MAX_MIP_LEVEL
,
127 WINED3D_SAMP_MAX_ANISOTROPY
,
128 WINED3D_SAMP_SRGB_TEXTURE
,
129 WINED3D_SAMP_ELEMENT_INDEX
,
132 static const DWORD vertex_states_render
[] =
134 WINED3D_RS_ADAPTIVETESS_W
,
135 WINED3D_RS_ADAPTIVETESS_X
,
136 WINED3D_RS_ADAPTIVETESS_Y
,
137 WINED3D_RS_ADAPTIVETESS_Z
,
139 WINED3D_RS_AMBIENTMATERIALSOURCE
,
141 WINED3D_RS_CLIPPLANEENABLE
,
142 WINED3D_RS_COLORVERTEX
,
144 WINED3D_RS_DIFFUSEMATERIALSOURCE
,
145 WINED3D_RS_EMISSIVEMATERIALSOURCE
,
146 WINED3D_RS_ENABLEADAPTIVETESSELLATION
,
148 WINED3D_RS_FOGDENSITY
,
149 WINED3D_RS_FOGENABLE
,
152 WINED3D_RS_FOGTABLEMODE
,
153 WINED3D_RS_FOGVERTEXMODE
,
154 WINED3D_RS_INDEXEDVERTEXBLENDENABLE
,
156 WINED3D_RS_LOCALVIEWER
,
157 WINED3D_RS_MAXTESSELLATIONLEVEL
,
158 WINED3D_RS_MINTESSELLATIONLEVEL
,
159 WINED3D_RS_MULTISAMPLEANTIALIAS
,
160 WINED3D_RS_MULTISAMPLEMASK
,
161 WINED3D_RS_NORMALDEGREE
,
162 WINED3D_RS_NORMALIZENORMALS
,
163 WINED3D_RS_PATCHEDGESTYLE
,
164 WINED3D_RS_POINTSCALE_A
,
165 WINED3D_RS_POINTSCALE_B
,
166 WINED3D_RS_POINTSCALE_C
,
167 WINED3D_RS_POINTSCALEENABLE
,
168 WINED3D_RS_POINTSIZE
,
169 WINED3D_RS_POINTSIZE_MAX
,
170 WINED3D_RS_POINTSIZE_MIN
,
171 WINED3D_RS_POINTSPRITEENABLE
,
172 WINED3D_RS_POSITIONDEGREE
,
173 WINED3D_RS_RANGEFOGENABLE
,
174 WINED3D_RS_SHADEMODE
,
175 WINED3D_RS_SPECULARENABLE
,
176 WINED3D_RS_SPECULARMATERIALSOURCE
,
177 WINED3D_RS_TWEENFACTOR
,
178 WINED3D_RS_VERTEXBLEND
,
181 static const DWORD vertex_states_texture
[] =
183 WINED3D_TSS_TEXCOORD_INDEX
,
184 WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
,
187 static const DWORD vertex_states_sampler
[] =
189 WINED3D_SAMP_DMAP_OFFSET
,
192 /* Allocates the correct amount of space for pixel and vertex shader constants,
193 * along with their set/changed flags on the given stateblock object
195 static HRESULT
stateblock_allocate_shader_constants(struct wined3d_stateblock
*object
)
197 struct wined3d_device
*device
= object
->device
;
199 /* Allocate space for floating point constants */
200 object
->state
.ps_consts_f
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
201 sizeof(float) * device
->d3d_pshader_constantF
* 4);
202 if (!object
->state
.ps_consts_f
) goto fail
;
204 object
->changed
.pixelShaderConstantsF
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
205 sizeof(BOOL
) * device
->d3d_pshader_constantF
);
206 if (!object
->changed
.pixelShaderConstantsF
) goto fail
;
208 object
->state
.vs_consts_f
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
209 sizeof(float) * device
->d3d_vshader_constantF
* 4);
210 if (!object
->state
.vs_consts_f
) goto fail
;
212 object
->changed
.vertexShaderConstantsF
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
213 sizeof(BOOL
) * device
->d3d_vshader_constantF
);
214 if (!object
->changed
.vertexShaderConstantsF
) goto fail
;
216 object
->contained_vs_consts_f
= HeapAlloc(GetProcessHeap(), 0,
217 sizeof(DWORD
) * device
->d3d_vshader_constantF
);
218 if (!object
->contained_vs_consts_f
) goto fail
;
220 object
->contained_ps_consts_f
= HeapAlloc(GetProcessHeap(), 0,
221 sizeof(DWORD
) * device
->d3d_pshader_constantF
);
222 if (!object
->contained_ps_consts_f
) goto fail
;
227 ERR("Failed to allocate memory\n");
228 HeapFree(GetProcessHeap(), 0, object
->state
.ps_consts_f
);
229 HeapFree(GetProcessHeap(), 0, object
->changed
.pixelShaderConstantsF
);
230 HeapFree(GetProcessHeap(), 0, object
->state
.vs_consts_f
);
231 HeapFree(GetProcessHeap(), 0, object
->changed
.vertexShaderConstantsF
);
232 HeapFree(GetProcessHeap(), 0, object
->contained_vs_consts_f
);
233 HeapFree(GetProcessHeap(), 0, object
->contained_ps_consts_f
);
234 return E_OUTOFMEMORY
;
237 static inline void stateblock_set_bits(DWORD
*map
, UINT map_size
)
239 DWORD mask
= (1 << (map_size
& 0x1f)) - 1;
240 memset(map
, 0xff, (map_size
>> 5) * sizeof(*map
));
241 if (mask
) map
[map_size
>> 5] = mask
;
244 /* Set all members of a stateblock savedstate to the given value */
245 static void stateblock_savedstates_set_all(struct wined3d_saved_states
*states
, DWORD vs_consts
, DWORD ps_consts
)
250 states
->primitive_type
= 1;
252 states
->material
= 1;
253 states
->viewport
= 1;
254 states
->vertexDecl
= 1;
255 states
->pixelShader
= 1;
256 states
->vertexShader
= 1;
257 states
->scissorRect
= 1;
259 /* Fixed size arrays */
260 states
->streamSource
= 0xffff;
261 states
->streamFreq
= 0xffff;
262 states
->textures
= 0xfffff;
263 stateblock_set_bits(states
->transform
, HIGHEST_TRANSFORMSTATE
+ 1);
264 stateblock_set_bits(states
->renderState
, WINEHIGHEST_RENDER_STATE
+ 1);
265 for (i
= 0; i
< MAX_TEXTURES
; ++i
) states
->textureState
[i
] = 0x3ffff;
266 for (i
= 0; i
< MAX_COMBINED_SAMPLERS
; ++i
) states
->samplerState
[i
] = 0x3ffe;
267 states
->clipplane
= 0xffffffff;
268 states
->pixelShaderConstantsB
= 0xffff;
269 states
->pixelShaderConstantsI
= 0xffff;
270 states
->vertexShaderConstantsB
= 0xffff;
271 states
->vertexShaderConstantsI
= 0xffff;
273 /* Dynamically sized arrays */
274 memset(states
->pixelShaderConstantsF
, TRUE
, sizeof(BOOL
) * ps_consts
);
275 memset(states
->vertexShaderConstantsF
, TRUE
, sizeof(BOOL
) * vs_consts
);
278 static void stateblock_savedstates_set_pixel(struct wined3d_saved_states
*states
, const DWORD num_constants
)
280 DWORD texture_mask
= 0;
281 WORD sampler_mask
= 0;
284 states
->pixelShader
= 1;
286 for (i
= 0; i
< sizeof(pixel_states_render
) / sizeof(*pixel_states_render
); ++i
)
288 DWORD rs
= pixel_states_render
[i
];
289 states
->renderState
[rs
>> 5] |= 1 << (rs
& 0x1f);
292 for (i
= 0; i
< sizeof(pixel_states_texture
) / sizeof(*pixel_states_texture
); ++i
)
293 texture_mask
|= 1 << pixel_states_texture
[i
];
294 for (i
= 0; i
< MAX_TEXTURES
; ++i
) states
->textureState
[i
] = texture_mask
;
295 for (i
= 0; i
< sizeof(pixel_states_sampler
) / sizeof(*pixel_states_sampler
); ++i
)
296 sampler_mask
|= 1 << pixel_states_sampler
[i
];
297 for (i
= 0; i
< MAX_COMBINED_SAMPLERS
; ++i
) states
->samplerState
[i
] = sampler_mask
;
298 states
->pixelShaderConstantsB
= 0xffff;
299 states
->pixelShaderConstantsI
= 0xffff;
301 memset(states
->pixelShaderConstantsF
, TRUE
, sizeof(BOOL
) * num_constants
);
304 static void stateblock_savedstates_set_vertex(struct wined3d_saved_states
*states
, const DWORD num_constants
)
306 DWORD texture_mask
= 0;
307 WORD sampler_mask
= 0;
310 states
->vertexDecl
= 1;
311 states
->vertexShader
= 1;
313 for (i
= 0; i
< sizeof(vertex_states_render
) / sizeof(*vertex_states_render
); ++i
)
315 DWORD rs
= vertex_states_render
[i
];
316 states
->renderState
[rs
>> 5] |= 1 << (rs
& 0x1f);
319 for (i
= 0; i
< sizeof(vertex_states_texture
) / sizeof(*vertex_states_texture
); ++i
)
320 texture_mask
|= 1 << vertex_states_texture
[i
];
321 for (i
= 0; i
< MAX_TEXTURES
; ++i
) states
->textureState
[i
] = texture_mask
;
322 for (i
= 0; i
< sizeof(vertex_states_sampler
) / sizeof(*vertex_states_sampler
); ++i
)
323 sampler_mask
|= 1 << vertex_states_sampler
[i
];
324 for (i
= 0; i
< MAX_COMBINED_SAMPLERS
; ++i
) states
->samplerState
[i
] = sampler_mask
;
325 states
->vertexShaderConstantsB
= 0xffff;
326 states
->vertexShaderConstantsI
= 0xffff;
328 memset(states
->vertexShaderConstantsF
, TRUE
, sizeof(BOOL
) * num_constants
);
331 void stateblock_init_contained_states(struct wined3d_stateblock
*stateblock
)
333 struct wined3d_device
*device
= stateblock
->device
;
336 for (i
= 0; i
<= WINEHIGHEST_RENDER_STATE
>> 5; ++i
)
338 DWORD map
= stateblock
->changed
.renderState
[i
];
339 for (j
= 0; map
; map
>>= 1, ++j
)
341 if (!(map
& 1)) continue;
343 stateblock
->contained_render_states
[stateblock
->num_contained_render_states
] = (i
<< 5) | j
;
344 ++stateblock
->num_contained_render_states
;
348 for (i
= 0; i
<= HIGHEST_TRANSFORMSTATE
>> 5; ++i
)
350 DWORD map
= stateblock
->changed
.transform
[i
];
351 for (j
= 0; map
; map
>>= 1, ++j
)
353 if (!(map
& 1)) continue;
355 stateblock
->contained_transform_states
[stateblock
->num_contained_transform_states
] = (i
<< 5) | j
;
356 ++stateblock
->num_contained_transform_states
;
360 for (i
= 0; i
< device
->d3d_vshader_constantF
; ++i
)
362 if (stateblock
->changed
.vertexShaderConstantsF
[i
])
364 stateblock
->contained_vs_consts_f
[stateblock
->num_contained_vs_consts_f
] = i
;
365 ++stateblock
->num_contained_vs_consts_f
;
369 for (i
= 0; i
< MAX_CONST_I
; ++i
)
371 if (stateblock
->changed
.vertexShaderConstantsI
& (1 << i
))
373 stateblock
->contained_vs_consts_i
[stateblock
->num_contained_vs_consts_i
] = i
;
374 ++stateblock
->num_contained_vs_consts_i
;
378 for (i
= 0; i
< MAX_CONST_B
; ++i
)
380 if (stateblock
->changed
.vertexShaderConstantsB
& (1 << i
))
382 stateblock
->contained_vs_consts_b
[stateblock
->num_contained_vs_consts_b
] = i
;
383 ++stateblock
->num_contained_vs_consts_b
;
387 for (i
= 0; i
< device
->d3d_pshader_constantF
; ++i
)
389 if (stateblock
->changed
.pixelShaderConstantsF
[i
])
391 stateblock
->contained_ps_consts_f
[stateblock
->num_contained_ps_consts_f
] = i
;
392 ++stateblock
->num_contained_ps_consts_f
;
396 for (i
= 0; i
< MAX_CONST_I
; ++i
)
398 if (stateblock
->changed
.pixelShaderConstantsI
& (1 << i
))
400 stateblock
->contained_ps_consts_i
[stateblock
->num_contained_ps_consts_i
] = i
;
401 ++stateblock
->num_contained_ps_consts_i
;
405 for (i
= 0; i
< MAX_CONST_B
; ++i
)
407 if (stateblock
->changed
.pixelShaderConstantsB
& (1 << i
))
409 stateblock
->contained_ps_consts_b
[stateblock
->num_contained_ps_consts_b
] = i
;
410 ++stateblock
->num_contained_ps_consts_b
;
414 for (i
= 0; i
< MAX_TEXTURES
; ++i
)
416 DWORD map
= stateblock
->changed
.textureState
[i
];
418 for(j
= 0; map
; map
>>= 1, ++j
)
420 if (!(map
& 1)) continue;
422 stateblock
->contained_tss_states
[stateblock
->num_contained_tss_states
].stage
= i
;
423 stateblock
->contained_tss_states
[stateblock
->num_contained_tss_states
].state
= j
;
424 ++stateblock
->num_contained_tss_states
;
428 for (i
= 0; i
< MAX_COMBINED_SAMPLERS
; ++i
)
430 DWORD map
= stateblock
->changed
.samplerState
[i
];
432 for (j
= 0; map
; map
>>= 1, ++j
)
434 if (!(map
& 1)) continue;
436 stateblock
->contained_sampler_states
[stateblock
->num_contained_sampler_states
].stage
= i
;
437 stateblock
->contained_sampler_states
[stateblock
->num_contained_sampler_states
].state
= j
;
438 ++stateblock
->num_contained_sampler_states
;
443 static void stateblock_init_lights(struct wined3d_stateblock
*stateblock
, struct list
*light_map
)
447 for (i
= 0; i
< LIGHTMAP_SIZE
; ++i
)
449 const struct wined3d_light_info
*src_light
;
451 LIST_FOR_EACH_ENTRY(src_light
, &light_map
[i
], struct wined3d_light_info
, entry
)
453 struct wined3d_light_info
*dst_light
= HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_light
));
455 *dst_light
= *src_light
;
456 list_add_tail(&stateblock
->state
.light_map
[i
], &dst_light
->entry
);
461 ULONG CDECL
wined3d_stateblock_incref(struct wined3d_stateblock
*stateblock
)
463 ULONG refcount
= InterlockedIncrement(&stateblock
->ref
);
465 TRACE("%p increasing refcount to %u.\n", stateblock
, refcount
);
470 void stateblock_unbind_resources(struct wined3d_stateblock
*stateblock
)
472 struct wined3d_state
*state
= &stateblock
->state
;
473 struct wined3d_vertex_declaration
*decl
;
474 struct wined3d_texture
*texture
;
475 struct wined3d_buffer
*buffer
;
476 struct wined3d_shader
*shader
;
479 if ((decl
= state
->vertex_declaration
))
481 state
->vertex_declaration
= NULL
;
482 wined3d_vertex_declaration_decref(decl
);
485 for (i
= 0; i
< MAX_COMBINED_SAMPLERS
; ++i
)
487 if ((texture
= state
->textures
[i
]))
489 state
->textures
[i
] = NULL
;
490 wined3d_texture_decref(texture
);
494 for (i
= 0; i
< MAX_STREAMS
; ++i
)
496 if ((buffer
= state
->streams
[i
].buffer
))
498 state
->streams
[i
].buffer
= NULL
;
499 wined3d_buffer_decref(buffer
);
503 if ((buffer
= state
->index_buffer
))
505 state
->index_buffer
= NULL
;
506 wined3d_buffer_decref(buffer
);
509 if ((shader
= state
->vertex_shader
))
511 state
->vertex_shader
= NULL
;
512 wined3d_shader_decref(shader
);
515 if ((shader
= state
->pixel_shader
))
517 state
->pixel_shader
= NULL
;
518 wined3d_shader_decref(shader
);
522 ULONG CDECL
wined3d_stateblock_decref(struct wined3d_stateblock
*stateblock
)
524 ULONG refcount
= InterlockedDecrement(&stateblock
->ref
);
526 TRACE("%p decreasing refcount to %u\n", stateblock
, refcount
);
532 stateblock_unbind_resources(stateblock
);
534 for (counter
= 0; counter
< LIGHTMAP_SIZE
; ++counter
)
536 struct list
*e1
, *e2
;
537 LIST_FOR_EACH_SAFE(e1
, e2
, &stateblock
->state
.light_map
[counter
])
539 struct wined3d_light_info
*light
= LIST_ENTRY(e1
, struct wined3d_light_info
, entry
);
540 list_remove(&light
->entry
);
541 HeapFree(GetProcessHeap(), 0, light
);
545 HeapFree(GetProcessHeap(), 0, stateblock
->state
.vs_consts_f
);
546 HeapFree(GetProcessHeap(), 0, stateblock
->changed
.vertexShaderConstantsF
);
547 HeapFree(GetProcessHeap(), 0, stateblock
->state
.ps_consts_f
);
548 HeapFree(GetProcessHeap(), 0, stateblock
->changed
.pixelShaderConstantsF
);
549 HeapFree(GetProcessHeap(), 0, stateblock
->contained_vs_consts_f
);
550 HeapFree(GetProcessHeap(), 0, stateblock
->contained_ps_consts_f
);
551 HeapFree(GetProcessHeap(), 0, stateblock
);
557 static void wined3d_state_record_lights(struct wined3d_state
*dst_state
, const struct wined3d_state
*src_state
)
561 /* Lights... For a recorded state block, we just had a chain of actions
562 * to perform, so we need to walk that chain and update any actions which
564 for (i
= 0; i
< LIGHTMAP_SIZE
; ++i
)
567 LIST_FOR_EACH(e
, &dst_state
->light_map
[i
])
569 BOOL updated
= FALSE
;
570 struct wined3d_light_info
*src
= LIST_ENTRY(e
, struct wined3d_light_info
, entry
), *realLight
;
572 /* Look up the light in the destination */
573 LIST_FOR_EACH(f
, &src_state
->light_map
[i
])
575 realLight
= LIST_ENTRY(f
, struct wined3d_light_info
, entry
);
576 if (realLight
->OriginalIndex
== src
->OriginalIndex
)
578 src
->OriginalParms
= realLight
->OriginalParms
;
580 if (realLight
->glIndex
== -1 && src
->glIndex
!= -1)
583 dst_state
->lights
[src
->glIndex
] = NULL
;
585 else if (realLight
->glIndex
!= -1 && src
->glIndex
== -1)
588 dst_state
->lights
[realLight
->glIndex
] = src
;
590 src
->glIndex
= realLight
->glIndex
;
598 /* This can happen if the light was originally created as a
599 * default light for SetLightEnable() while recording. */
600 WARN("Light %u in dst_state %p does not exist in src_state %p.\n",
601 src
->OriginalIndex
, dst_state
, src_state
);
603 src
->OriginalParms
= WINED3D_default_light
;
604 if (src
->glIndex
!= -1)
606 dst_state
->lights
[src
->glIndex
] = NULL
;
614 void CDECL
wined3d_stateblock_capture(struct wined3d_stateblock
*stateblock
)
616 const struct wined3d_state
*src_state
= &stateblock
->device
->stateBlock
->state
;
620 TRACE("stateblock %p.\n", stateblock
);
622 TRACE("Capturing state %p.\n", src_state
);
624 if (stateblock
->changed
.vertexShader
&& stateblock
->state
.vertex_shader
!= src_state
->vertex_shader
)
626 TRACE("Updating vertex shader from %p to %p\n",
627 stateblock
->state
.vertex_shader
, src_state
->vertex_shader
);
629 if (src_state
->vertex_shader
)
630 wined3d_shader_incref(src_state
->vertex_shader
);
631 if (stateblock
->state
.vertex_shader
)
632 wined3d_shader_decref(stateblock
->state
.vertex_shader
);
633 stateblock
->state
.vertex_shader
= src_state
->vertex_shader
;
636 /* Vertex shader float constants. */
637 for (i
= 0; i
< stateblock
->num_contained_vs_consts_f
; ++i
)
639 unsigned int idx
= stateblock
->contained_vs_consts_f
[i
];
641 TRACE("Setting vs_consts_f[%u] to {%.8e, %.8e, %.8e, %.8e}.\n", idx
,
642 src_state
->vs_consts_f
[idx
* 4 + 0],
643 src_state
->vs_consts_f
[idx
* 4 + 1],
644 src_state
->vs_consts_f
[idx
* 4 + 2],
645 src_state
->vs_consts_f
[idx
* 4 + 3]);
647 stateblock
->state
.vs_consts_f
[idx
* 4 + 0] = src_state
->vs_consts_f
[idx
* 4 + 0];
648 stateblock
->state
.vs_consts_f
[idx
* 4 + 1] = src_state
->vs_consts_f
[idx
* 4 + 1];
649 stateblock
->state
.vs_consts_f
[idx
* 4 + 2] = src_state
->vs_consts_f
[idx
* 4 + 2];
650 stateblock
->state
.vs_consts_f
[idx
* 4 + 3] = src_state
->vs_consts_f
[idx
* 4 + 3];
653 /* Vertex shader integer constants. */
654 for (i
= 0; i
< stateblock
->num_contained_vs_consts_i
; ++i
)
656 unsigned int idx
= stateblock
->contained_vs_consts_i
[i
];
658 TRACE("Setting vs_consts[%u] to {%d, %d, %d, %d}.\n", idx
,
659 src_state
->vs_consts_i
[idx
* 4 + 0],
660 src_state
->vs_consts_i
[idx
* 4 + 1],
661 src_state
->vs_consts_i
[idx
* 4 + 2],
662 src_state
->vs_consts_i
[idx
* 4 + 3]);
664 stateblock
->state
.vs_consts_i
[idx
* 4 + 0] = src_state
->vs_consts_i
[idx
* 4 + 0];
665 stateblock
->state
.vs_consts_i
[idx
* 4 + 1] = src_state
->vs_consts_i
[idx
* 4 + 1];
666 stateblock
->state
.vs_consts_i
[idx
* 4 + 2] = src_state
->vs_consts_i
[idx
* 4 + 2];
667 stateblock
->state
.vs_consts_i
[idx
* 4 + 3] = src_state
->vs_consts_i
[idx
* 4 + 3];
670 /* Vertex shader boolean constants. */
671 for (i
= 0; i
< stateblock
->num_contained_vs_consts_b
; ++i
)
673 unsigned int idx
= stateblock
->contained_vs_consts_b
[i
];
675 TRACE("Setting vs_consts_b[%u] to %s.\n",
676 idx
, src_state
->vs_consts_b
[idx
] ? "TRUE" : "FALSE");
678 stateblock
->state
.vs_consts_b
[idx
] = src_state
->vs_consts_b
[idx
];
681 /* Pixel shader float constants. */
682 for (i
= 0; i
< stateblock
->num_contained_ps_consts_f
; ++i
)
684 unsigned int idx
= stateblock
->contained_ps_consts_f
[i
];
686 TRACE("Setting ps_consts_f[%u] to {%.8e, %.8e, %.8e, %.8e}.\n", idx
,
687 src_state
->ps_consts_f
[idx
* 4 + 0],
688 src_state
->ps_consts_f
[idx
* 4 + 1],
689 src_state
->ps_consts_f
[idx
* 4 + 2],
690 src_state
->ps_consts_f
[idx
* 4 + 3]);
692 stateblock
->state
.ps_consts_f
[idx
* 4 + 0] = src_state
->ps_consts_f
[idx
* 4 + 0];
693 stateblock
->state
.ps_consts_f
[idx
* 4 + 1] = src_state
->ps_consts_f
[idx
* 4 + 1];
694 stateblock
->state
.ps_consts_f
[idx
* 4 + 2] = src_state
->ps_consts_f
[idx
* 4 + 2];
695 stateblock
->state
.ps_consts_f
[idx
* 4 + 3] = src_state
->ps_consts_f
[idx
* 4 + 3];
698 /* Pixel shader integer constants. */
699 for (i
= 0; i
< stateblock
->num_contained_ps_consts_i
; ++i
)
701 unsigned int idx
= stateblock
->contained_ps_consts_i
[i
];
702 TRACE("Setting ps_consts_i[%u] to {%d, %d, %d, %d}.\n", idx
,
703 src_state
->ps_consts_i
[idx
* 4 + 0],
704 src_state
->ps_consts_i
[idx
* 4 + 1],
705 src_state
->ps_consts_i
[idx
* 4 + 2],
706 src_state
->ps_consts_i
[idx
* 4 + 3]);
708 stateblock
->state
.ps_consts_i
[idx
* 4 + 0] = src_state
->ps_consts_i
[idx
* 4 + 0];
709 stateblock
->state
.ps_consts_i
[idx
* 4 + 1] = src_state
->ps_consts_i
[idx
* 4 + 1];
710 stateblock
->state
.ps_consts_i
[idx
* 4 + 2] = src_state
->ps_consts_i
[idx
* 4 + 2];
711 stateblock
->state
.ps_consts_i
[idx
* 4 + 3] = src_state
->ps_consts_i
[idx
* 4 + 3];
714 /* Pixel shader boolean constants. */
715 for (i
= 0; i
< stateblock
->num_contained_ps_consts_b
; ++i
)
717 unsigned int idx
= stateblock
->contained_ps_consts_b
[i
];
718 TRACE("Setting ps_consts_b[%u] to %s.\n",
719 idx
, src_state
->ps_consts_b
[idx
] ? "TRUE" : "FALSE");
721 stateblock
->state
.ps_consts_b
[idx
] = src_state
->ps_consts_b
[idx
];
724 /* Others + Render & Texture */
725 for (i
= 0; i
< stateblock
->num_contained_transform_states
; ++i
)
727 enum wined3d_transform_state transform
= stateblock
->contained_transform_states
[i
];
729 TRACE("Updating transform %#x.\n", transform
);
731 stateblock
->state
.transforms
[transform
] = src_state
->transforms
[transform
];
734 if (stateblock
->changed
.primitive_type
)
735 stateblock
->state
.gl_primitive_type
= src_state
->gl_primitive_type
;
737 if (stateblock
->changed
.indices
738 && ((stateblock
->state
.index_buffer
!= src_state
->index_buffer
)
739 || (stateblock
->state
.base_vertex_index
!= src_state
->base_vertex_index
)
740 || (stateblock
->state
.index_format
!= src_state
->index_format
)))
742 TRACE("Updating index buffer to %p, base vertex index to %d.\n",
743 src_state
->index_buffer
, src_state
->base_vertex_index
);
745 if (src_state
->index_buffer
)
746 wined3d_buffer_incref(src_state
->index_buffer
);
747 if (stateblock
->state
.index_buffer
)
748 wined3d_buffer_decref(stateblock
->state
.index_buffer
);
749 stateblock
->state
.index_buffer
= src_state
->index_buffer
;
750 stateblock
->state
.base_vertex_index
= src_state
->base_vertex_index
;
751 stateblock
->state
.index_format
= src_state
->index_format
;
754 if (stateblock
->changed
.vertexDecl
&& stateblock
->state
.vertex_declaration
!= src_state
->vertex_declaration
)
756 TRACE("Updating vertex declaration from %p to %p.\n",
757 stateblock
->state
.vertex_declaration
, src_state
->vertex_declaration
);
759 if (src_state
->vertex_declaration
)
760 wined3d_vertex_declaration_incref(src_state
->vertex_declaration
);
761 if (stateblock
->state
.vertex_declaration
)
762 wined3d_vertex_declaration_decref(stateblock
->state
.vertex_declaration
);
763 stateblock
->state
.vertex_declaration
= src_state
->vertex_declaration
;
766 if (stateblock
->changed
.material
767 && memcmp(&src_state
->material
, &stateblock
->state
.material
, sizeof(stateblock
->state
.material
)))
769 TRACE("Updating material.\n");
771 stateblock
->state
.material
= src_state
->material
;
774 if (stateblock
->changed
.viewport
775 && memcmp(&src_state
->viewport
, &stateblock
->state
.viewport
, sizeof(stateblock
->state
.viewport
)))
777 TRACE("Updating viewport.\n");
779 stateblock
->state
.viewport
= src_state
->viewport
;
782 if (stateblock
->changed
.scissorRect
&& memcmp(&src_state
->scissor_rect
,
783 &stateblock
->state
.scissor_rect
, sizeof(stateblock
->state
.scissor_rect
)))
785 TRACE("Updating scissor rect.\n");
787 stateblock
->state
.scissor_rect
= src_state
->scissor_rect
;
790 map
= stateblock
->changed
.streamSource
;
791 for (i
= 0; map
; map
>>= 1, ++i
)
793 if (!(map
& 1)) continue;
795 if (stateblock
->state
.streams
[i
].stride
!= src_state
->streams
[i
].stride
796 || stateblock
->state
.streams
[i
].buffer
!= src_state
->streams
[i
].buffer
)
798 TRACE("Updating stream source %u to %p, stride to %u.\n",
799 i
, src_state
->streams
[i
].buffer
,
800 src_state
->streams
[i
].stride
);
802 stateblock
->state
.streams
[i
].stride
= src_state
->streams
[i
].stride
;
803 if (src_state
->streams
[i
].buffer
)
804 wined3d_buffer_incref(src_state
->streams
[i
].buffer
);
805 if (stateblock
->state
.streams
[i
].buffer
)
806 wined3d_buffer_decref(stateblock
->state
.streams
[i
].buffer
);
807 stateblock
->state
.streams
[i
].buffer
= src_state
->streams
[i
].buffer
;
811 map
= stateblock
->changed
.streamFreq
;
812 for (i
= 0; map
; map
>>= 1, ++i
)
814 if (!(map
& 1)) continue;
816 if (stateblock
->state
.streams
[i
].frequency
!= src_state
->streams
[i
].frequency
817 || stateblock
->state
.streams
[i
].flags
!= src_state
->streams
[i
].flags
)
819 TRACE("Updating stream frequency %u to %u flags to %#x.\n",
820 i
, src_state
->streams
[i
].frequency
, src_state
->streams
[i
].flags
);
822 stateblock
->state
.streams
[i
].frequency
= src_state
->streams
[i
].frequency
;
823 stateblock
->state
.streams
[i
].flags
= src_state
->streams
[i
].flags
;
827 map
= stateblock
->changed
.clipplane
;
828 for (i
= 0; map
; map
>>= 1, ++i
)
830 if (!(map
& 1)) continue;
832 if (memcmp(&stateblock
->state
.clip_planes
[i
], &src_state
->clip_planes
[i
], sizeof(src_state
->clip_planes
[i
])))
834 TRACE("Updating clipplane %u.\n", i
);
835 stateblock
->state
.clip_planes
[i
] = src_state
->clip_planes
[i
];
840 for (i
= 0; i
< stateblock
->num_contained_render_states
; ++i
)
842 enum wined3d_render_state rs
= stateblock
->contained_render_states
[i
];
844 TRACE("Updating render state %#x to %u.\n", rs
, src_state
->render_states
[rs
]);
846 stateblock
->state
.render_states
[rs
] = src_state
->render_states
[rs
];
850 for (i
= 0; i
< stateblock
->num_contained_tss_states
; ++i
)
852 DWORD stage
= stateblock
->contained_tss_states
[i
].stage
;
853 DWORD state
= stateblock
->contained_tss_states
[i
].state
;
855 TRACE("Updating texturestage state %u, %u to %#x (was %#x).\n", stage
, state
,
856 src_state
->texture_states
[stage
][state
], stateblock
->state
.texture_states
[stage
][state
]);
858 stateblock
->state
.texture_states
[stage
][state
] = src_state
->texture_states
[stage
][state
];
862 map
= stateblock
->changed
.textures
;
863 for (i
= 0; map
; map
>>= 1, ++i
)
865 if (!(map
& 1)) continue;
867 TRACE("Updating texture %u to %p (was %p).\n",
868 i
, src_state
->textures
[i
], stateblock
->state
.textures
[i
]);
870 if (src_state
->textures
[i
])
871 wined3d_texture_incref(src_state
->textures
[i
]);
872 if (stateblock
->state
.textures
[i
])
873 wined3d_texture_decref(stateblock
->state
.textures
[i
]);
874 stateblock
->state
.textures
[i
] = src_state
->textures
[i
];
877 for (i
= 0; i
< stateblock
->num_contained_sampler_states
; ++i
)
879 DWORD stage
= stateblock
->contained_sampler_states
[i
].stage
;
880 DWORD state
= stateblock
->contained_sampler_states
[i
].state
;
882 TRACE("Updating sampler state %u, %u to %#x (was %#x).\n", stage
, state
,
883 src_state
->sampler_states
[stage
][state
], stateblock
->state
.sampler_states
[stage
][state
]);
885 stateblock
->state
.sampler_states
[stage
][state
] = src_state
->sampler_states
[stage
][state
];
888 if (stateblock
->changed
.pixelShader
&& stateblock
->state
.pixel_shader
!= src_state
->pixel_shader
)
890 if (src_state
->pixel_shader
)
891 wined3d_shader_incref(src_state
->pixel_shader
);
892 if (stateblock
->state
.pixel_shader
)
893 wined3d_shader_decref(stateblock
->state
.pixel_shader
);
894 stateblock
->state
.pixel_shader
= src_state
->pixel_shader
;
897 wined3d_state_record_lights(&stateblock
->state
, src_state
);
899 TRACE("Capture done.\n");
902 static void apply_lights(struct wined3d_device
*device
, const struct wined3d_state
*state
)
906 for (i
= 0; i
< LIGHTMAP_SIZE
; ++i
)
910 LIST_FOR_EACH(e
, &state
->light_map
[i
])
912 const struct wined3d_light_info
*light
= LIST_ENTRY(e
, struct wined3d_light_info
, entry
);
914 wined3d_device_set_light(device
, light
->OriginalIndex
, &light
->OriginalParms
);
915 wined3d_device_set_light_enable(device
, light
->OriginalIndex
, light
->glIndex
!= -1);
920 void CDECL
wined3d_stateblock_apply(const struct wined3d_stateblock
*stateblock
)
922 struct wined3d_device
*device
= stateblock
->device
;
926 TRACE("Applying stateblock %p to device %p.\n", stateblock
, device
);
928 if (stateblock
->changed
.vertexShader
)
929 wined3d_device_set_vertex_shader(device
, stateblock
->state
.vertex_shader
);
931 /* Vertex Shader Constants. */
932 for (i
= 0; i
< stateblock
->num_contained_vs_consts_f
; ++i
)
934 wined3d_device_set_vs_consts_f(device
, stateblock
->contained_vs_consts_f
[i
],
935 stateblock
->state
.vs_consts_f
+ stateblock
->contained_vs_consts_f
[i
] * 4, 1);
937 for (i
= 0; i
< stateblock
->num_contained_vs_consts_i
; ++i
)
939 wined3d_device_set_vs_consts_i(device
, stateblock
->contained_vs_consts_i
[i
],
940 stateblock
->state
.vs_consts_i
+ stateblock
->contained_vs_consts_i
[i
] * 4, 1);
942 for (i
= 0; i
< stateblock
->num_contained_vs_consts_b
; ++i
)
944 wined3d_device_set_vs_consts_b(device
, stateblock
->contained_vs_consts_b
[i
],
945 stateblock
->state
.vs_consts_b
+ stateblock
->contained_vs_consts_b
[i
], 1);
948 apply_lights(device
, &stateblock
->state
);
950 if (stateblock
->changed
.pixelShader
)
951 wined3d_device_set_pixel_shader(device
, stateblock
->state
.pixel_shader
);
953 /* Pixel Shader Constants. */
954 for (i
= 0; i
< stateblock
->num_contained_ps_consts_f
; ++i
)
956 wined3d_device_set_ps_consts_f(device
, stateblock
->contained_ps_consts_f
[i
],
957 stateblock
->state
.ps_consts_f
+ stateblock
->contained_ps_consts_f
[i
] * 4, 1);
959 for (i
= 0; i
< stateblock
->num_contained_ps_consts_i
; ++i
)
961 wined3d_device_set_ps_consts_i(device
, stateblock
->contained_ps_consts_i
[i
],
962 stateblock
->state
.ps_consts_i
+ stateblock
->contained_ps_consts_i
[i
] * 4, 1);
964 for (i
= 0; i
< stateblock
->num_contained_ps_consts_b
; ++i
)
966 wined3d_device_set_ps_consts_b(device
, stateblock
->contained_ps_consts_b
[i
],
967 stateblock
->state
.ps_consts_b
+ stateblock
->contained_ps_consts_b
[i
], 1);
971 for (i
= 0; i
< stateblock
->num_contained_render_states
; ++i
)
973 wined3d_device_set_render_state(device
, stateblock
->contained_render_states
[i
],
974 stateblock
->state
.render_states
[stateblock
->contained_render_states
[i
]]);
977 /* Texture states. */
978 for (i
= 0; i
< stateblock
->num_contained_tss_states
; ++i
)
980 DWORD stage
= stateblock
->contained_tss_states
[i
].stage
;
981 DWORD state
= stateblock
->contained_tss_states
[i
].state
;
983 wined3d_device_set_texture_stage_state(device
, stage
, state
, stateblock
->state
.texture_states
[stage
][state
]);
986 /* Sampler states. */
987 for (i
= 0; i
< stateblock
->num_contained_sampler_states
; ++i
)
989 DWORD stage
= stateblock
->contained_sampler_states
[i
].stage
;
990 DWORD state
= stateblock
->contained_sampler_states
[i
].state
;
991 DWORD value
= stateblock
->state
.sampler_states
[stage
][state
];
993 if (stage
>= MAX_FRAGMENT_SAMPLERS
) stage
+= WINED3DVERTEXTEXTURESAMPLER0
- MAX_FRAGMENT_SAMPLERS
;
994 wined3d_device_set_sampler_state(device
, stage
, state
, value
);
997 /* Transform states. */
998 for (i
= 0; i
< stateblock
->num_contained_transform_states
; ++i
)
1000 wined3d_device_set_transform(device
, stateblock
->contained_transform_states
[i
],
1001 &stateblock
->state
.transforms
[stateblock
->contained_transform_states
[i
]]);
1004 if (stateblock
->changed
.primitive_type
)
1006 stateblock
->device
->updateStateBlock
->changed
.primitive_type
= TRUE
;
1007 stateblock
->device
->updateStateBlock
->state
.gl_primitive_type
= stateblock
->state
.gl_primitive_type
;
1010 if (stateblock
->changed
.indices
)
1012 wined3d_device_set_index_buffer(device
, stateblock
->state
.index_buffer
, stateblock
->state
.index_format
);
1013 wined3d_device_set_base_vertex_index(device
, stateblock
->state
.base_vertex_index
);
1016 if (stateblock
->changed
.vertexDecl
&& stateblock
->state
.vertex_declaration
)
1017 wined3d_device_set_vertex_declaration(device
, stateblock
->state
.vertex_declaration
);
1019 if (stateblock
->changed
.material
)
1020 wined3d_device_set_material(device
, &stateblock
->state
.material
);
1022 if (stateblock
->changed
.viewport
)
1023 wined3d_device_set_viewport(device
, &stateblock
->state
.viewport
);
1025 if (stateblock
->changed
.scissorRect
)
1026 wined3d_device_set_scissor_rect(device
, &stateblock
->state
.scissor_rect
);
1028 map
= stateblock
->changed
.streamSource
;
1029 for (i
= 0; map
; map
>>= 1, ++i
)
1032 wined3d_device_set_stream_source(device
, i
,
1033 stateblock
->state
.streams
[i
].buffer
,
1034 0, stateblock
->state
.streams
[i
].stride
);
1037 map
= stateblock
->changed
.streamFreq
;
1038 for (i
= 0; map
; map
>>= 1, ++i
)
1041 wined3d_device_set_stream_source_freq(device
, i
,
1042 stateblock
->state
.streams
[i
].frequency
| stateblock
->state
.streams
[i
].flags
);
1045 map
= stateblock
->changed
.textures
;
1046 for (i
= 0; map
; map
>>= 1, ++i
)
1050 if (!(map
& 1)) continue;
1052 stage
= i
< MAX_FRAGMENT_SAMPLERS
? i
: WINED3DVERTEXTEXTURESAMPLER0
+ i
- MAX_FRAGMENT_SAMPLERS
;
1053 wined3d_device_set_texture(device
, stage
, stateblock
->state
.textures
[i
]);
1056 map
= stateblock
->changed
.clipplane
;
1057 for (i
= 0; map
; map
>>= 1, ++i
)
1059 if (!(map
& 1)) continue;
1061 wined3d_device_set_clip_plane(device
, i
, &stateblock
->state
.clip_planes
[i
]);
1064 stateblock
->device
->stateBlock
->state
.lowest_disabled_stage
= MAX_TEXTURES
- 1;
1065 for (i
= 0; i
< MAX_TEXTURES
- 1; ++i
)
1067 if (stateblock
->device
->stateBlock
->state
.texture_states
[i
][WINED3D_TSS_COLOR_OP
] == WINED3D_TOP_DISABLE
)
1069 stateblock
->device
->stateBlock
->state
.lowest_disabled_stage
= i
;
1074 TRACE("Applied stateblock %p.\n", stateblock
);
1077 void stateblock_init_default_state(struct wined3d_stateblock
*stateblock
)
1079 struct wined3d_device
*device
= stateblock
->device
;
1080 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
1081 struct wined3d_state
*state
= &stateblock
->state
;
1084 struct wined3d_line_pattern lp
;
1092 struct wined3d_swapchain
*swapchain
;
1093 struct wined3d_surface
*backbuffer
;
1095 TRACE("stateblock %p.\n", stateblock
);
1097 memset(stateblock
->changed
.pixelShaderConstantsF
, 0, device
->d3d_pshader_constantF
* sizeof(BOOL
));
1098 memset(stateblock
->changed
.vertexShaderConstantsF
, 0, device
->d3d_vshader_constantF
* sizeof(BOOL
));
1100 /* Set some of the defaults for lights, transforms etc */
1101 memcpy(&state
->transforms
[WINED3D_TS_PROJECTION
], &identity
, sizeof(identity
));
1102 memcpy(&state
->transforms
[WINED3D_TS_VIEW
], &identity
, sizeof(identity
));
1103 for (i
= 0; i
< 256; ++i
)
1105 memcpy(&state
->transforms
[WINED3D_TS_WORLD_MATRIX(i
)], &identity
, sizeof(identity
));
1108 state
->fb
= &device
->fb
;
1110 TRACE("Render states\n");
1111 /* Render states: */
1112 if (device
->auto_depth_stencil
)
1113 state
->render_states
[WINED3D_RS_ZENABLE
] = WINED3D_ZB_TRUE
;
1115 state
->render_states
[WINED3D_RS_ZENABLE
] = WINED3D_ZB_FALSE
;
1116 state
->render_states
[WINED3D_RS_FILLMODE
] = WINED3D_FILL_SOLID
;
1117 state
->render_states
[WINED3D_RS_SHADEMODE
] = WINED3D_SHADE_GOURAUD
;
1118 lp
.lp
.repeat_factor
= 0;
1119 lp
.lp
.line_pattern
= 0;
1120 state
->render_states
[WINED3D_RS_LINEPATTERN
] = lp
.d
;
1121 state
->render_states
[WINED3D_RS_ZWRITEENABLE
] = TRUE
;
1122 state
->render_states
[WINED3D_RS_ALPHATESTENABLE
] = FALSE
;
1123 state
->render_states
[WINED3D_RS_LASTPIXEL
] = TRUE
;
1124 state
->render_states
[WINED3D_RS_SRCBLEND
] = WINED3D_BLEND_ONE
;
1125 state
->render_states
[WINED3D_RS_DESTBLEND
] = WINED3D_BLEND_ZERO
;
1126 state
->render_states
[WINED3D_RS_CULLMODE
] = WINED3D_CULL_CCW
;
1127 state
->render_states
[WINED3D_RS_ZFUNC
] = WINED3D_CMP_LESSEQUAL
;
1128 state
->render_states
[WINED3D_RS_ALPHAFUNC
] = WINED3D_CMP_ALWAYS
;
1129 state
->render_states
[WINED3D_RS_ALPHAREF
] = 0;
1130 state
->render_states
[WINED3D_RS_DITHERENABLE
] = FALSE
;
1131 state
->render_states
[WINED3D_RS_ALPHABLENDENABLE
] = FALSE
;
1132 state
->render_states
[WINED3D_RS_FOGENABLE
] = FALSE
;
1133 state
->render_states
[WINED3D_RS_SPECULARENABLE
] = FALSE
;
1134 state
->render_states
[WINED3D_RS_ZVISIBLE
] = 0;
1135 state
->render_states
[WINED3D_RS_FOGCOLOR
] = 0;
1136 state
->render_states
[WINED3D_RS_FOGTABLEMODE
] = WINED3D_FOG_NONE
;
1138 state
->render_states
[WINED3D_RS_FOGSTART
] = tmpfloat
.d
;
1140 state
->render_states
[WINED3D_RS_FOGEND
] = tmpfloat
.d
;
1142 state
->render_states
[WINED3D_RS_FOGDENSITY
] = tmpfloat
.d
;
1143 state
->render_states
[WINED3D_RS_EDGEANTIALIAS
] = FALSE
;
1144 state
->render_states
[WINED3D_RS_RANGEFOGENABLE
] = FALSE
;
1145 state
->render_states
[WINED3D_RS_STENCILENABLE
] = FALSE
;
1146 state
->render_states
[WINED3D_RS_STENCILFAIL
] = WINED3D_STENCIL_OP_KEEP
;
1147 state
->render_states
[WINED3D_RS_STENCILZFAIL
] = WINED3D_STENCIL_OP_KEEP
;
1148 state
->render_states
[WINED3D_RS_STENCILPASS
] = WINED3D_STENCIL_OP_KEEP
;
1149 state
->render_states
[WINED3D_RS_STENCILREF
] = 0;
1150 state
->render_states
[WINED3D_RS_STENCILMASK
] = 0xffffffff;
1151 state
->render_states
[WINED3D_RS_STENCILFUNC
] = WINED3D_CMP_ALWAYS
;
1152 state
->render_states
[WINED3D_RS_STENCILWRITEMASK
] = 0xffffffff;
1153 state
->render_states
[WINED3D_RS_TEXTUREFACTOR
] = 0xffffffff;
1154 state
->render_states
[WINED3D_RS_WRAP0
] = 0;
1155 state
->render_states
[WINED3D_RS_WRAP1
] = 0;
1156 state
->render_states
[WINED3D_RS_WRAP2
] = 0;
1157 state
->render_states
[WINED3D_RS_WRAP3
] = 0;
1158 state
->render_states
[WINED3D_RS_WRAP4
] = 0;
1159 state
->render_states
[WINED3D_RS_WRAP5
] = 0;
1160 state
->render_states
[WINED3D_RS_WRAP6
] = 0;
1161 state
->render_states
[WINED3D_RS_WRAP7
] = 0;
1162 state
->render_states
[WINED3D_RS_CLIPPING
] = TRUE
;
1163 state
->render_states
[WINED3D_RS_LIGHTING
] = TRUE
;
1164 state
->render_states
[WINED3D_RS_AMBIENT
] = 0;
1165 state
->render_states
[WINED3D_RS_FOGVERTEXMODE
] = WINED3D_FOG_NONE
;
1166 state
->render_states
[WINED3D_RS_COLORVERTEX
] = TRUE
;
1167 state
->render_states
[WINED3D_RS_LOCALVIEWER
] = TRUE
;
1168 state
->render_states
[WINED3D_RS_NORMALIZENORMALS
] = FALSE
;
1169 state
->render_states
[WINED3D_RS_DIFFUSEMATERIALSOURCE
] = WINED3D_MCS_COLOR1
;
1170 state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] = WINED3D_MCS_COLOR2
;
1171 state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
] = WINED3D_MCS_MATERIAL
;
1172 state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] = WINED3D_MCS_MATERIAL
;
1173 state
->render_states
[WINED3D_RS_VERTEXBLEND
] = WINED3D_VBF_DISABLE
;
1174 state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
] = 0;
1175 state
->render_states
[WINED3D_RS_SOFTWAREVERTEXPROCESSING
] = FALSE
;
1177 state
->render_states
[WINED3D_RS_POINTSIZE
] = tmpfloat
.d
;
1179 state
->render_states
[WINED3D_RS_POINTSIZE_MIN
] = tmpfloat
.d
;
1180 state
->render_states
[WINED3D_RS_POINTSPRITEENABLE
] = FALSE
;
1181 state
->render_states
[WINED3D_RS_POINTSCALEENABLE
] = FALSE
;
1183 state
->render_states
[WINED3D_RS_POINTSCALE_A
] = tmpfloat
.d
;
1185 state
->render_states
[WINED3D_RS_POINTSCALE_B
] = tmpfloat
.d
;
1187 state
->render_states
[WINED3D_RS_POINTSCALE_C
] = tmpfloat
.d
;
1188 state
->render_states
[WINED3D_RS_MULTISAMPLEANTIALIAS
] = TRUE
;
1189 state
->render_states
[WINED3D_RS_MULTISAMPLEMASK
] = 0xffffffff;
1190 state
->render_states
[WINED3D_RS_PATCHEDGESTYLE
] = WINED3D_PATCH_EDGE_DISCRETE
;
1192 state
->render_states
[WINED3D_RS_PATCHSEGMENTS
] = tmpfloat
.d
;
1193 state
->render_states
[WINED3D_RS_DEBUGMONITORTOKEN
] = 0xbaadcafe;
1194 tmpfloat
.f
= gl_info
->limits
.pointsize_max
;
1195 state
->render_states
[WINED3D_RS_POINTSIZE_MAX
] = tmpfloat
.d
;
1196 state
->render_states
[WINED3D_RS_INDEXEDVERTEXBLENDENABLE
] = FALSE
;
1197 state
->render_states
[WINED3D_RS_COLORWRITEENABLE
] = 0x0000000f;
1199 state
->render_states
[WINED3D_RS_TWEENFACTOR
] = tmpfloat
.d
;
1200 state
->render_states
[WINED3D_RS_BLENDOP
] = WINED3D_BLEND_OP_ADD
;
1201 state
->render_states
[WINED3D_RS_POSITIONDEGREE
] = WINED3D_DEGREE_CUBIC
;
1202 state
->render_states
[WINED3D_RS_NORMALDEGREE
] = WINED3D_DEGREE_LINEAR
;
1203 /* states new in d3d9 */
1204 state
->render_states
[WINED3D_RS_SCISSORTESTENABLE
] = FALSE
;
1205 state
->render_states
[WINED3D_RS_SLOPESCALEDEPTHBIAS
] = 0;
1207 state
->render_states
[WINED3D_RS_MINTESSELLATIONLEVEL
] = tmpfloat
.d
;
1208 state
->render_states
[WINED3D_RS_MAXTESSELLATIONLEVEL
] = tmpfloat
.d
;
1209 state
->render_states
[WINED3D_RS_ANTIALIASEDLINEENABLE
] = FALSE
;
1211 state
->render_states
[WINED3D_RS_ADAPTIVETESS_X
] = tmpfloat
.d
;
1212 state
->render_states
[WINED3D_RS_ADAPTIVETESS_Y
] = tmpfloat
.d
;
1214 state
->render_states
[WINED3D_RS_ADAPTIVETESS_Z
] = tmpfloat
.d
;
1216 state
->render_states
[WINED3D_RS_ADAPTIVETESS_W
] = tmpfloat
.d
;
1217 state
->render_states
[WINED3D_RS_ENABLEADAPTIVETESSELLATION
] = FALSE
;
1218 state
->render_states
[WINED3D_RS_TWOSIDEDSTENCILMODE
] = FALSE
;
1219 state
->render_states
[WINED3D_RS_CCW_STENCILFAIL
] = WINED3D_STENCIL_OP_KEEP
;
1220 state
->render_states
[WINED3D_RS_CCW_STENCILZFAIL
] = WINED3D_STENCIL_OP_KEEP
;
1221 state
->render_states
[WINED3D_RS_CCW_STENCILPASS
] = WINED3D_STENCIL_OP_KEEP
;
1222 state
->render_states
[WINED3D_RS_CCW_STENCILFUNC
] = WINED3D_CMP_ALWAYS
;
1223 state
->render_states
[WINED3D_RS_COLORWRITEENABLE1
] = 0x0000000f;
1224 state
->render_states
[WINED3D_RS_COLORWRITEENABLE2
] = 0x0000000f;
1225 state
->render_states
[WINED3D_RS_COLORWRITEENABLE3
] = 0x0000000f;
1226 state
->render_states
[WINED3D_RS_BLENDFACTOR
] = 0xffffffff;
1227 state
->render_states
[WINED3D_RS_SRGBWRITEENABLE
] = 0;
1228 state
->render_states
[WINED3D_RS_DEPTHBIAS
] = 0;
1229 state
->render_states
[WINED3D_RS_WRAP8
] = 0;
1230 state
->render_states
[WINED3D_RS_WRAP9
] = 0;
1231 state
->render_states
[WINED3D_RS_WRAP10
] = 0;
1232 state
->render_states
[WINED3D_RS_WRAP11
] = 0;
1233 state
->render_states
[WINED3D_RS_WRAP12
] = 0;
1234 state
->render_states
[WINED3D_RS_WRAP13
] = 0;
1235 state
->render_states
[WINED3D_RS_WRAP14
] = 0;
1236 state
->render_states
[WINED3D_RS_WRAP15
] = 0;
1237 state
->render_states
[WINED3D_RS_SEPARATEALPHABLENDENABLE
] = FALSE
;
1238 state
->render_states
[WINED3D_RS_SRCBLENDALPHA
] = WINED3D_BLEND_ONE
;
1239 state
->render_states
[WINED3D_RS_DESTBLENDALPHA
] = WINED3D_BLEND_ZERO
;
1240 state
->render_states
[WINED3D_RS_BLENDOPALPHA
] = WINED3D_BLEND_OP_ADD
;
1242 /* Texture Stage States - Put directly into state block, we will call function below */
1243 for (i
= 0; i
< MAX_TEXTURES
; ++i
)
1245 TRACE("Setting up default texture states for texture Stage %u.\n", i
);
1246 memcpy(&state
->transforms
[WINED3D_TS_TEXTURE0
+ i
], &identity
, sizeof(identity
));
1247 state
->texture_states
[i
][WINED3D_TSS_COLOR_OP
] = i
? WINED3D_TOP_DISABLE
: WINED3D_TOP_MODULATE
;
1248 state
->texture_states
[i
][WINED3D_TSS_COLOR_ARG1
] = WINED3DTA_TEXTURE
;
1249 state
->texture_states
[i
][WINED3D_TSS_COLOR_ARG2
] = WINED3DTA_CURRENT
;
1250 state
->texture_states
[i
][WINED3D_TSS_ALPHA_OP
] = i
? WINED3D_TOP_DISABLE
: WINED3D_TOP_SELECT_ARG1
;
1251 state
->texture_states
[i
][WINED3D_TSS_ALPHA_ARG1
] = WINED3DTA_TEXTURE
;
1252 state
->texture_states
[i
][WINED3D_TSS_ALPHA_ARG2
] = WINED3DTA_CURRENT
;
1253 state
->texture_states
[i
][WINED3D_TSS_BUMPENV_MAT00
] = 0;
1254 state
->texture_states
[i
][WINED3D_TSS_BUMPENV_MAT01
] = 0;
1255 state
->texture_states
[i
][WINED3D_TSS_BUMPENV_MAT10
] = 0;
1256 state
->texture_states
[i
][WINED3D_TSS_BUMPENV_MAT11
] = 0;
1257 state
->texture_states
[i
][WINED3D_TSS_TEXCOORD_INDEX
] = i
;
1258 state
->texture_states
[i
][WINED3D_TSS_BUMPENV_LSCALE
] = 0;
1259 state
->texture_states
[i
][WINED3D_TSS_BUMPENV_LOFFSET
] = 0;
1260 state
->texture_states
[i
][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
] = WINED3D_TTFF_DISABLE
;
1261 state
->texture_states
[i
][WINED3D_TSS_COLOR_ARG0
] = WINED3DTA_CURRENT
;
1262 state
->texture_states
[i
][WINED3D_TSS_ALPHA_ARG0
] = WINED3DTA_CURRENT
;
1263 state
->texture_states
[i
][WINED3D_TSS_RESULT_ARG
] = WINED3DTA_CURRENT
;
1265 state
->lowest_disabled_stage
= 1;
1268 for (i
= 0 ; i
< MAX_COMBINED_SAMPLERS
; ++i
)
1270 TRACE("Setting up default samplers states for sampler %u.\n", i
);
1271 state
->sampler_states
[i
][WINED3D_SAMP_ADDRESS_U
] = WINED3D_TADDRESS_WRAP
;
1272 state
->sampler_states
[i
][WINED3D_SAMP_ADDRESS_V
] = WINED3D_TADDRESS_WRAP
;
1273 state
->sampler_states
[i
][WINED3D_SAMP_ADDRESS_W
] = WINED3D_TADDRESS_WRAP
;
1274 state
->sampler_states
[i
][WINED3D_SAMP_BORDER_COLOR
] = 0;
1275 state
->sampler_states
[i
][WINED3D_SAMP_MAG_FILTER
] = WINED3D_TEXF_POINT
;
1276 state
->sampler_states
[i
][WINED3D_SAMP_MIN_FILTER
] = WINED3D_TEXF_POINT
;
1277 state
->sampler_states
[i
][WINED3D_SAMP_MIP_FILTER
] = WINED3D_TEXF_NONE
;
1278 state
->sampler_states
[i
][WINED3D_SAMP_MIPMAP_LOD_BIAS
] = 0;
1279 state
->sampler_states
[i
][WINED3D_SAMP_MAX_MIP_LEVEL
] = 0;
1280 state
->sampler_states
[i
][WINED3D_SAMP_MAX_ANISOTROPY
] = 1;
1281 state
->sampler_states
[i
][WINED3D_SAMP_SRGB_TEXTURE
] = 0;
1282 /* TODO: Indicates which element of a multielement texture to use. */
1283 state
->sampler_states
[i
][WINED3D_SAMP_ELEMENT_INDEX
] = 0;
1284 /* TODO: Vertex offset in the presampled displacement map. */
1285 state
->sampler_states
[i
][WINED3D_SAMP_DMAP_OFFSET
] = 0;
1288 for (i
= 0; i
< gl_info
->limits
.textures
; ++i
)
1290 state
->textures
[i
] = NULL
;
1293 /* check the return values, because the GetBackBuffer call isn't valid for ddraw */
1294 if ((swapchain
= wined3d_device_get_swapchain(device
, 0)))
1296 if ((backbuffer
= wined3d_swapchain_get_back_buffer(swapchain
, 0, WINED3D_BACKBUFFER_TYPE_MONO
)))
1298 struct wined3d_resource_desc desc
;
1300 wined3d_resource_get_desc(&backbuffer
->resource
, &desc
);
1302 /* Set the default scissor rect values */
1303 state
->scissor_rect
.left
= 0;
1304 state
->scissor_rect
.right
= desc
.width
;
1305 state
->scissor_rect
.top
= 0;
1306 state
->scissor_rect
.bottom
= desc
.height
;
1309 /* Set the default viewport */
1310 state
->viewport
.x
= 0;
1311 state
->viewport
.y
= 0;
1312 state
->viewport
.width
= swapchain
->desc
.backbuffer_width
;
1313 state
->viewport
.height
= swapchain
->desc
.backbuffer_height
;
1314 state
->viewport
.min_z
= 0.0f
;
1315 state
->viewport
.max_z
= 1.0f
;
1321 static HRESULT
stateblock_init(struct wined3d_stateblock
*stateblock
,
1322 struct wined3d_device
*device
, enum wined3d_stateblock_type type
)
1327 stateblock
->ref
= 1;
1328 stateblock
->device
= device
;
1330 for (i
= 0; i
< LIGHTMAP_SIZE
; i
++)
1332 list_init(&stateblock
->state
.light_map
[i
]);
1335 hr
= stateblock_allocate_shader_constants(stateblock
);
1336 if (FAILED(hr
)) return hr
;
1338 /* The WINED3D_SBT_INIT stateblock type is used during initialization to
1339 * produce a placeholder stateblock so other functions called can update a
1341 if (type
== WINED3D_SBT_INIT
|| type
== WINED3D_SBT_RECORDED
) return WINED3D_OK
;
1343 TRACE("Updating changed flags appropriate for type %#x.\n", type
);
1347 case WINED3D_SBT_ALL
:
1348 stateblock_init_lights(stateblock
, device
->stateBlock
->state
.light_map
);
1349 stateblock_savedstates_set_all(&stateblock
->changed
, device
->d3d_vshader_constantF
,
1350 device
->d3d_pshader_constantF
);
1353 case WINED3D_SBT_PIXEL_STATE
:
1354 stateblock_savedstates_set_pixel(&stateblock
->changed
, device
->d3d_pshader_constantF
);
1357 case WINED3D_SBT_VERTEX_STATE
:
1358 stateblock_init_lights(stateblock
, device
->stateBlock
->state
.light_map
);
1359 stateblock_savedstates_set_vertex(&stateblock
->changed
, device
->d3d_vshader_constantF
);
1363 FIXME("Unrecognized state block type %#x.\n", type
);
1367 stateblock_init_contained_states(stateblock
);
1368 wined3d_stateblock_capture(stateblock
);
1373 HRESULT CDECL
wined3d_stateblock_create(struct wined3d_device
*device
,
1374 enum wined3d_stateblock_type type
, struct wined3d_stateblock
**stateblock
)
1376 struct wined3d_stateblock
*object
;
1379 TRACE("device %p, type %#x, stateblock %p.\n",
1380 device
, type
, stateblock
);
1382 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
1385 ERR("Failed to allocate stateblock memory.\n");
1386 return E_OUTOFMEMORY
;
1389 hr
= stateblock_init(object
, device
, type
);
1392 WARN("Failed to initialize stateblock, hr %#x.\n", hr
);
1393 HeapFree(GetProcessHeap(), 0, object
);
1397 TRACE("Created stateblock %p.\n", object
);
1398 *stateblock
= object
;