dlls/wined3d/stateblock.c

   1 /*
   2  * state block implementation
   3  *
   4  * Copyright 2002 Raphael Junqueira
   5  * Copyright 2004 Jason Edmeades
   6  * Copyright 2005 Oliver Stieber
   7  * Copyright 2007 Stefan Dösinger for CodeWeavers
   8  * Copyright 2009 Henri Verbeet for CodeWeavers
   9  * Copyright 2019,2020,2022 Zebediah Figura for CodeWeavers
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "wined3d_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  29 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  30
  31 static const DWORD pixel_states_render[] =
  32 {
  33     WINED3D_RS_ALPHABLENDENABLE,
  34     WINED3D_RS_ALPHAFUNC,
  35     WINED3D_RS_ALPHAREF,
  36     WINED3D_RS_ALPHATESTENABLE,
  37     WINED3D_RS_ANTIALIASEDLINEENABLE,
  38     WINED3D_RS_BLENDFACTOR,
  39     WINED3D_RS_BLENDOP,
  40     WINED3D_RS_BLENDOPALPHA,
  41     WINED3D_RS_BACK_STENCILFAIL,
  42     WINED3D_RS_BACK_STENCILPASS,
  43     WINED3D_RS_BACK_STENCILZFAIL,
  44     WINED3D_RS_COLORWRITEENABLE,
  45     WINED3D_RS_COLORWRITEENABLE1,
  46     WINED3D_RS_COLORWRITEENABLE2,
  47     WINED3D_RS_COLORWRITEENABLE3,
  48     WINED3D_RS_DEPTHBIAS,
  49     WINED3D_RS_DESTBLEND,
  50     WINED3D_RS_DESTBLENDALPHA,
  51     WINED3D_RS_DITHERENABLE,
  52     WINED3D_RS_FILLMODE,
  53     WINED3D_RS_FOGDENSITY,
  54     WINED3D_RS_FOGEND,
  55     WINED3D_RS_FOGSTART,
  56     WINED3D_RS_LASTPIXEL,
  57     WINED3D_RS_SCISSORTESTENABLE,
  58     WINED3D_RS_SEPARATEALPHABLENDENABLE,
  59     WINED3D_RS_SHADEMODE,
  60     WINED3D_RS_SLOPESCALEDEPTHBIAS,
  61     WINED3D_RS_SRCBLEND,
  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,
  74     WINED3D_RS_WRAP0,
  75     WINED3D_RS_WRAP1,
  76     WINED3D_RS_WRAP10,
  77     WINED3D_RS_WRAP11,
  78     WINED3D_RS_WRAP12,
  79     WINED3D_RS_WRAP13,
  80     WINED3D_RS_WRAP14,
  81     WINED3D_RS_WRAP15,
  82     WINED3D_RS_WRAP2,
  83     WINED3D_RS_WRAP3,
  84     WINED3D_RS_WRAP4,
  85     WINED3D_RS_WRAP5,
  86     WINED3D_RS_WRAP6,
  87     WINED3D_RS_WRAP7,
  88     WINED3D_RS_WRAP8,
  89     WINED3D_RS_WRAP9,
  90     WINED3D_RS_ZENABLE,
  91     WINED3D_RS_ZFUNC,
  92     WINED3D_RS_ZWRITEENABLE,
  93 };
  94
  95 static const DWORD pixel_states_texture[] =
  96 {
  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,
 114 };
 115
 116 static const DWORD pixel_states_sampler[] =
 117 {
 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,
 130 };
 131
 132 static const DWORD vertex_states_render[] =
 133 {
 134     WINED3D_RS_ADAPTIVETESS_W,
 135     WINED3D_RS_ADAPTIVETESS_X,
 136     WINED3D_RS_ADAPTIVETESS_Y,
 137     WINED3D_RS_ADAPTIVETESS_Z,
 138     WINED3D_RS_AMBIENT,
 139     WINED3D_RS_AMBIENTMATERIALSOURCE,
 140     WINED3D_RS_CLIPPING,
 141     WINED3D_RS_CLIPPLANEENABLE,
 142     WINED3D_RS_COLORVERTEX,
 143     WINED3D_RS_CULLMODE,
 144     WINED3D_RS_DIFFUSEMATERIALSOURCE,
 145     WINED3D_RS_EMISSIVEMATERIALSOURCE,
 146     WINED3D_RS_ENABLEADAPTIVETESSELLATION,
 147     WINED3D_RS_FOGCOLOR,
 148     WINED3D_RS_FOGDENSITY,
 149     WINED3D_RS_FOGENABLE,
 150     WINED3D_RS_FOGEND,
 151     WINED3D_RS_FOGSTART,
 152     WINED3D_RS_FOGTABLEMODE,
 153     WINED3D_RS_FOGVERTEXMODE,
 154     WINED3D_RS_INDEXEDVERTEXBLENDENABLE,
 155     WINED3D_RS_LIGHTING,
 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,
 179 };
 180
 181 static const DWORD vertex_states_texture[] =
 182 {
 183     WINED3D_TSS_TEXCOORD_INDEX,
 184     WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS,
 185 };
 186
 187 static const DWORD vertex_states_sampler[] =
 188 {
 189     WINED3D_SAMP_DMAP_OFFSET,
 190 };
 191
 192 static inline void stateblock_set_all_bits(uint32_t *map, UINT map_size)
 193 {
 194     DWORD mask = (1u << (map_size & 0x1f)) - 1;
 195     memset(map, 0xff, (map_size >> 5) * sizeof(*map));
 196     if (mask) map[map_size >> 5] = mask;
 197 }
 198
 199 /* Set all members of a stateblock savedstate to the given value */
 200 static void stateblock_savedstates_set_all(struct wined3d_saved_states *states, DWORD vs_consts, DWORD ps_consts)
 201 {
 202     unsigned int i;
 203
 204     states->indices = 1;
 205     states->material = 1;
 206     states->viewport = 1;
 207     states->vertexDecl = 1;
 208     states->pixelShader = 1;
 209     states->vertexShader = 1;
 210     states->scissorRect = 1;
 211     states->alpha_to_coverage = 1;
 212     states->lights = 1;
 213     states->transforms = 1;
 214
 215     states->streamSource = 0xffff;
 216     states->streamFreq = 0xffff;
 217     states->textures = 0xfffff;
 218     stateblock_set_all_bits(states->transform, WINED3D_HIGHEST_TRANSFORM_STATE + 1);
 219     stateblock_set_all_bits(states->renderState, WINEHIGHEST_RENDER_STATE + 1);
 220     for (i = 0; i < WINED3D_MAX_TEXTURES; ++i) states->textureState[i] = 0x3ffff;
 221     for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = 0x3ffe;
 222     states->clipplane = wined3d_mask_from_size(WINED3D_MAX_CLIP_DISTANCES);
 223     states->pixelShaderConstantsB = 0xffff;
 224     states->pixelShaderConstantsI = 0xffff;
 225     states->vertexShaderConstantsB = 0xffff;
 226     states->vertexShaderConstantsI = 0xffff;
 227
 228     memset(states->ps_consts_f, 0xffu, sizeof(states->ps_consts_f));
 229     memset(states->vs_consts_f, 0xffu, sizeof(states->vs_consts_f));
 230 }
 231
 232 static void stateblock_savedstates_set_pixel(struct wined3d_saved_states *states, const DWORD num_constants)
 233 {
 234     DWORD texture_mask = 0;
 235     WORD sampler_mask = 0;
 236     unsigned int i;
 237
 238     states->pixelShader = 1;
 239
 240     for (i = 0; i < ARRAY_SIZE(pixel_states_render); ++i)
 241     {
 242         DWORD rs = pixel_states_render[i];
 243         states->renderState[rs >> 5] |= 1u << (rs & 0x1f);
 244     }
 245
 246     for (i = 0; i < ARRAY_SIZE(pixel_states_texture); ++i)
 247         texture_mask |= 1u << pixel_states_texture[i];
 248     for (i = 0; i < WINED3D_MAX_TEXTURES; ++i) states->textureState[i] = texture_mask;
 249     for (i = 0; i < ARRAY_SIZE(pixel_states_sampler); ++i)
 250         sampler_mask |= 1u << pixel_states_sampler[i];
 251     for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = sampler_mask;
 252     states->pixelShaderConstantsB = 0xffff;
 253     states->pixelShaderConstantsI = 0xffff;
 254
 255     memset(states->ps_consts_f, 0xffu, sizeof(states->ps_consts_f));
 256 }
 257
 258 static void stateblock_savedstates_set_vertex(struct wined3d_saved_states *states, const DWORD num_constants)
 259 {
 260     DWORD texture_mask = 0;
 261     WORD sampler_mask = 0;
 262     unsigned int i;
 263
 264     states->vertexDecl = 1;
 265     states->vertexShader = 1;
 266     states->alpha_to_coverage = 1;
 267     states->lights = 1;
 268
 269     for (i = 0; i < ARRAY_SIZE(vertex_states_render); ++i)
 270     {
 271         DWORD rs = vertex_states_render[i];
 272         states->renderState[rs >> 5] |= 1u << (rs & 0x1f);
 273     }
 274
 275     for (i = 0; i < ARRAY_SIZE(vertex_states_texture); ++i)
 276         texture_mask |= 1u << vertex_states_texture[i];
 277     for (i = 0; i < WINED3D_MAX_TEXTURES; ++i) states->textureState[i] = texture_mask;
 278     for (i = 0; i < ARRAY_SIZE(vertex_states_sampler); ++i)
 279         sampler_mask |= 1u << vertex_states_sampler[i];
 280     for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = sampler_mask;
 281     states->vertexShaderConstantsB = 0xffff;
 282     states->vertexShaderConstantsI = 0xffff;
 283
 284     memset(states->vs_consts_f, 0xffu, sizeof(states->vs_consts_f));
 285 }
 286
 287 void CDECL wined3d_stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
 288 {
 289     unsigned int i, j;
 290
 291     for (i = 0; i <= WINEHIGHEST_RENDER_STATE >> 5; ++i)
 292     {
 293         DWORD map = stateblock->changed.renderState[i];
 294         for (j = 0; map; map >>= 1, ++j)
 295         {
 296             if (!(map & 1)) continue;
 297
 298             stateblock->contained_render_states[stateblock->num_contained_render_states] = (i << 5) | j;
 299             ++stateblock->num_contained_render_states;
 300         }
 301     }
 302
 303     for (i = 0; i <= WINED3D_HIGHEST_TRANSFORM_STATE >> 5; ++i)
 304     {
 305         DWORD map = stateblock->changed.transform[i];
 306         for (j = 0; map; map >>= 1, ++j)
 307         {
 308             if (!(map & 1)) continue;
 309
 310             stateblock->contained_transform_states[stateblock->num_contained_transform_states] = (i << 5) | j;
 311             ++stateblock->num_contained_transform_states;
 312         }
 313     }
 314
 315     for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
 316     {
 317         DWORD map = stateblock->changed.textureState[i];
 318
 319         for(j = 0; map; map >>= 1, ++j)
 320         {
 321             if (!(map & 1)) continue;
 322
 323             stateblock->contained_tss_states[stateblock->num_contained_tss_states].stage = i;
 324             stateblock->contained_tss_states[stateblock->num_contained_tss_states].state = j;
 325             ++stateblock->num_contained_tss_states;
 326         }
 327     }
 328
 329     for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
 330     {
 331         DWORD map = stateblock->changed.samplerState[i];
 332
 333         for (j = 0; map; map >>= 1, ++j)
 334         {
 335             if (!(map & 1)) continue;
 336
 337             stateblock->contained_sampler_states[stateblock->num_contained_sampler_states].stage = i;
 338             stateblock->contained_sampler_states[stateblock->num_contained_sampler_states].state = j;
 339             ++stateblock->num_contained_sampler_states;
 340         }
 341     }
 342 }
 343
 344 static void stateblock_init_lights(struct wined3d_stateblock *stateblock, const struct rb_tree *src_tree)
 345 {
 346     struct rb_tree *dst_tree = &stateblock->stateblock_state.light_state->lights_tree;
 347     struct wined3d_light_info *src_light;
 348
 349     RB_FOR_EACH_ENTRY(src_light, src_tree, struct wined3d_light_info, entry)
 350     {
 351         struct wined3d_light_info *dst_light = heap_alloc(sizeof(*dst_light));
 352
 353         *dst_light = *src_light;
 354         rb_put(dst_tree, (void *)(ULONG_PTR)dst_light->OriginalIndex, &dst_light->entry);
 355         dst_light->changed = true;
 356         list_add_tail(&stateblock->changed.changed_lights, &dst_light->changed_entry);
 357     }
 358 }
 359
 360 ULONG CDECL wined3d_stateblock_incref(struct wined3d_stateblock *stateblock)
 361 {
 362     unsigned int refcount = InterlockedIncrement(&stateblock->ref);
 363
 364     TRACE("%p increasing refcount to %u.\n", stateblock, refcount);
 365
 366     return refcount;
 367 }
 368
 369 void state_unbind_resources(struct wined3d_state *state)
 370 {
 371     struct wined3d_unordered_access_view *uav;
 372     struct wined3d_shader_resource_view *srv;
 373     struct wined3d_vertex_declaration *decl;
 374     struct wined3d_blend_state *blend_state;
 375     struct wined3d_rendertarget_view *rtv;
 376     struct wined3d_sampler *sampler;
 377     struct wined3d_texture *texture;
 378     struct wined3d_buffer *buffer;
 379     struct wined3d_shader *shader;
 380     unsigned int i, j;
 381
 382     if ((decl = state->vertex_declaration))
 383     {
 384         state->vertex_declaration = NULL;
 385         wined3d_vertex_declaration_decref(decl);
 386     }
 387
 388     for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
 389     {
 390         if ((texture = state->textures[i]))
 391         {
 392             state->textures[i] = NULL;
 393             wined3d_texture_decref(texture);
 394         }
 395     }
 396
 397     for (i = 0; i < WINED3D_MAX_STREAM_OUTPUT_BUFFERS; ++i)
 398     {
 399         if ((buffer = state->stream_output[i].buffer))
 400         {
 401             state->stream_output[i].buffer = NULL;
 402             wined3d_buffer_decref(buffer);
 403         }
 404     }
 405
 406     for (i = 0; i < WINED3D_MAX_STREAMS; ++i)
 407     {
 408         if ((buffer = state->streams[i].buffer))
 409         {
 410             state->streams[i].buffer = NULL;
 411             wined3d_buffer_decref(buffer);
 412         }
 413     }
 414
 415     if ((buffer = state->index_buffer))
 416     {
 417         state->index_buffer = NULL;
 418         wined3d_buffer_decref(buffer);
 419     }
 420
 421     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 422     {
 423         if ((shader = state->shader[i]))
 424         {
 425             state->shader[i] = NULL;
 426             wined3d_shader_decref(shader);
 427         }
 428
 429         for (j = 0; j < MAX_CONSTANT_BUFFERS; ++j)
 430         {
 431             if ((buffer = state->cb[i][j].buffer))
 432             {
 433                 state->cb[i][j].buffer = NULL;
 434                 wined3d_buffer_decref(buffer);
 435             }
 436         }
 437
 438         for (j = 0; j < MAX_SAMPLER_OBJECTS; ++j)
 439         {
 440             if ((sampler = state->sampler[i][j]))
 441             {
 442                 state->sampler[i][j] = NULL;
 443                 wined3d_sampler_decref(sampler);
 444             }
 445         }
 446
 447         for (j = 0; j < MAX_SHADER_RESOURCE_VIEWS; ++j)
 448         {
 449             if ((srv = state->shader_resource_view[i][j]))
 450             {
 451                 state->shader_resource_view[i][j] = NULL;
 452                 wined3d_srv_bind_count_dec(srv);
 453                 wined3d_shader_resource_view_decref(srv);
 454             }
 455         }
 456     }
 457
 458     for (i = 0; i < WINED3D_PIPELINE_COUNT; ++i)
 459     {
 460         for (j = 0; j < MAX_UNORDERED_ACCESS_VIEWS; ++j)
 461         {
 462             if ((uav = state->unordered_access_view[i][j]))
 463             {
 464                 state->unordered_access_view[i][j] = NULL;
 465                 wined3d_unordered_access_view_decref(uav);
 466             }
 467         }
 468     }
 469
 470     if ((blend_state = state->blend_state))
 471     {
 472         state->blend_state = NULL;
 473         wined3d_blend_state_decref(blend_state);
 474     }
 475
 476     for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i)
 477     {
 478         if ((rtv = state->fb.render_targets[i]))
 479         {
 480             state->fb.render_targets[i] = NULL;
 481             wined3d_rendertarget_view_decref(rtv);
 482         }
 483     }
 484
 485     if ((rtv = state->fb.depth_stencil))
 486     {
 487         state->fb.depth_stencil = NULL;
 488         wined3d_rendertarget_view_decref(rtv);
 489     }
 490 }
 491
 492 void wined3d_stateblock_state_cleanup(struct wined3d_stateblock_state *state)
 493 {
 494     struct wined3d_light_info *light, *cursor;
 495     struct wined3d_vertex_declaration *decl;
 496     struct wined3d_texture *texture;
 497     struct wined3d_buffer *buffer;
 498     struct wined3d_shader *shader;
 499     unsigned int i;
 500
 501     if ((decl = state->vertex_declaration))
 502     {
 503         state->vertex_declaration = NULL;
 504         wined3d_vertex_declaration_decref(decl);
 505     }
 506
 507     for (i = 0; i < WINED3D_MAX_STREAMS; ++i)
 508     {
 509         if ((buffer = state->streams[i].buffer))
 510         {
 511             state->streams[i].buffer = NULL;
 512             wined3d_buffer_decref(buffer);
 513         }
 514     }
 515
 516     if ((buffer = state->index_buffer))
 517     {
 518         state->index_buffer = NULL;
 519         wined3d_buffer_decref(buffer);
 520     }
 521
 522     if ((shader = state->vs))
 523     {
 524         state->vs = NULL;
 525         wined3d_shader_decref(shader);
 526     }
 527
 528     if ((shader = state->ps))
 529     {
 530         state->ps = NULL;
 531         wined3d_shader_decref(shader);
 532     }
 533
 534     for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
 535     {
 536         if ((texture = state->textures[i]))
 537         {
 538             state->textures[i] = NULL;
 539             wined3d_texture_decref(texture);
 540         }
 541     }
 542
 543     RB_FOR_EACH_ENTRY_DESTRUCTOR(light, cursor, &state->light_state->lights_tree, struct wined3d_light_info, entry)
 544     {
 545         if (light->changed)
 546             list_remove(&light->changed_entry);
 547         rb_remove(&state->light_state->lights_tree, &light->entry);
 548         heap_free(light);
 549     }
 550 }
 551
 552 void state_cleanup(struct wined3d_state *state)
 553 {
 554     struct wined3d_light_info *light, *cursor;
 555     unsigned int i;
 556
 557     if (!(state->flags & WINED3D_STATE_NO_REF))
 558         state_unbind_resources(state);
 559
 560     for (i = 0; i < WINED3D_MAX_ACTIVE_LIGHTS; ++i)
 561     {
 562         state->light_state.lights[i] = NULL;
 563     }
 564
 565     RB_FOR_EACH_ENTRY_DESTRUCTOR(light, cursor, &state->light_state.lights_tree, struct wined3d_light_info, entry)
 566     {
 567         if (light->changed)
 568             list_remove(&light->changed_entry);
 569         rb_remove(&state->light_state.lights_tree, &light->entry);
 570         heap_free(light);
 571     }
 572 }
 573
 574 ULONG CDECL wined3d_stateblock_decref(struct wined3d_stateblock *stateblock)
 575 {
 576     unsigned int refcount = InterlockedDecrement(&stateblock->ref);
 577
 578     TRACE("%p decreasing refcount to %u\n", stateblock, refcount);
 579
 580     if (!refcount)
 581     {
 582         wined3d_mutex_lock();
 583         wined3d_stateblock_state_cleanup(&stateblock->stateblock_state);
 584         heap_free(stateblock);
 585         wined3d_mutex_unlock();
 586     }
 587
 588     return refcount;
 589 }
 590
 591 struct wined3d_light_info *wined3d_light_state_get_light(const struct wined3d_light_state *state, unsigned int idx)
 592 {
 593     struct rb_entry *entry;
 594
 595     if (!(entry = rb_get(&state->lights_tree, (void *)(ULONG_PTR)idx)))
 596         return NULL;
 597
 598     return RB_ENTRY_VALUE(entry, struct wined3d_light_info, entry);
 599 }
 600
 601 static void set_light_changed(struct wined3d_stateblock *stateblock, struct wined3d_light_info *light_info)
 602 {
 603     if (!light_info->changed)
 604     {
 605         list_add_tail(&stateblock->changed.changed_lights, &light_info->changed_entry);
 606         light_info->changed = true;
 607     }
 608     stateblock->changed.lights = 1;
 609 }
 610
 611 HRESULT wined3d_light_state_set_light(struct wined3d_light_state *state, DWORD light_idx,
 612         const struct wined3d_light *params, struct wined3d_light_info **light_info)
 613 {
 614     struct wined3d_light_info *object;
 615
 616     if (!(object = wined3d_light_state_get_light(state, light_idx)))
 617     {
 618         TRACE("Adding new light.\n");
 619         if (!(object = heap_alloc_zero(sizeof(*object))))
 620         {
 621             ERR("Failed to allocate light info.\n");
 622             return E_OUTOFMEMORY;
 623         }
 624
 625         object->glIndex = -1;
 626         object->OriginalIndex = light_idx;
 627         rb_put(&state->lights_tree, (void *)(ULONG_PTR)light_idx, &object->entry);
 628     }
 629
 630     object->OriginalParms = *params;
 631
 632     *light_info = object;
 633     return WINED3D_OK;
 634 }
 635
 636 bool wined3d_light_state_enable_light(struct wined3d_light_state *state, const struct wined3d_d3d_info *d3d_info,
 637         struct wined3d_light_info *light_info, BOOL enable)
 638 {
 639     unsigned int light_count, i;
 640
 641     if (!(light_info->enabled = enable))
 642     {
 643         if (light_info->glIndex == -1)
 644         {
 645             TRACE("Light already disabled, nothing to do.\n");
 646             return false;
 647         }
 648
 649         state->lights[light_info->glIndex] = NULL;
 650         light_info->glIndex = -1;
 651         return true;
 652     }
 653
 654     if (light_info->glIndex != -1)
 655     {
 656         TRACE("Light already enabled, nothing to do.\n");
 657         return false;
 658     }
 659
 660     /* Find a free light. */
 661     light_count = d3d_info->limits.active_light_count;
 662     for (i = 0; i < light_count; ++i)
 663     {
 664         if (state->lights[i])
 665             continue;
 666
 667         state->lights[i] = light_info;
 668         light_info->glIndex = i;
 669         return true;
 670     }
 671
 672     /* Our tests show that Windows returns D3D_OK in this situation, even with
 673      * D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE devices.
 674      * This is consistent among ddraw, d3d8 and d3d9. GetLightEnable returns
 675      * TRUE * as well for those lights.
 676      *
 677      * TODO: Test how this affects rendering. */
 678     WARN("Too many concurrently active lights.\n");
 679     return false;
 680 }
 681
 682 static void wined3d_state_record_lights(struct wined3d_light_state *dst_state,
 683         const struct wined3d_light_state *src_state)
 684 {
 685     const struct wined3d_light_info *src;
 686     struct wined3d_light_info *dst;
 687
 688     /* Lights... For a recorded state block, we just had a chain of actions
 689      * to perform, so we need to walk that chain and update any actions which
 690      * differ. */
 691     RB_FOR_EACH_ENTRY(dst, &dst_state->lights_tree, struct wined3d_light_info, entry)
 692     {
 693         if ((src = wined3d_light_state_get_light(src_state, dst->OriginalIndex)))
 694         {
 695             dst->OriginalParms = src->OriginalParms;
 696
 697             if (src->glIndex == -1 && dst->glIndex != -1)
 698             {
 699                 /* Light disabled. */
 700                 dst_state->lights[dst->glIndex] = NULL;
 701             }
 702             else if (src->glIndex != -1 && dst->glIndex == -1)
 703             {
 704                 /* Light enabled. */
 705                 dst_state->lights[src->glIndex] = dst;
 706             }
 707             dst->glIndex = src->glIndex;
 708         }
 709         else
 710         {
 711             /* This can happen if the light was originally created as a
 712              * default light for SetLightEnable() while recording. */
 713             WARN("Light %u in dst_state %p does not exist in src_state %p.\n",
 714                     dst->OriginalIndex, dst_state, src_state);
 715
 716             dst->OriginalParms = WINED3D_default_light;
 717             if (dst->glIndex != -1)
 718             {
 719                 dst_state->lights[dst->glIndex] = NULL;
 720                 dst->glIndex = -1;
 721             }
 722         }
 723     }
 724 }
 725
 726 void CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock,
 727         const struct wined3d_stateblock *device_state)
 728 {
 729     const struct wined3d_stateblock_state *state = &device_state->stateblock_state;
 730     struct wined3d_range range;
 731     unsigned int i, start;
 732     uint32_t map;
 733
 734     TRACE("stateblock %p, device_state %p.\n", stateblock, device_state);
 735
 736     if (stateblock->changed.vertexShader && stateblock->stateblock_state.vs != state->vs)
 737     {
 738         TRACE("Updating vertex shader from %p to %p.\n", stateblock->stateblock_state.vs, state->vs);
 739
 740         if (state->vs)
 741             wined3d_shader_incref(state->vs);
 742         if (stateblock->stateblock_state.vs)
 743             wined3d_shader_decref(stateblock->stateblock_state.vs);
 744         stateblock->stateblock_state.vs = state->vs;
 745     }
 746
 747     for (start = 0; ; start = range.offset + range.size)
 748     {
 749         if (!wined3d_bitmap_get_range(stateblock->changed.vs_consts_f, WINED3D_MAX_VS_CONSTS_F, start, &range))
 750             break;
 751
 752         memcpy(&stateblock->stateblock_state.vs_consts_f[range.offset], &state->vs_consts_f[range.offset],
 753                 sizeof(*state->vs_consts_f) * range.size);
 754     }
 755     map = stateblock->changed.vertexShaderConstantsI;
 756     for (start = 0; ; start = range.offset + range.size)
 757     {
 758         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_I, start, &range))
 759             break;
 760
 761         memcpy(&stateblock->stateblock_state.vs_consts_i[range.offset], &state->vs_consts_i[range.offset],
 762                 sizeof(*state->vs_consts_i) * range.size);
 763     }
 764     map = stateblock->changed.vertexShaderConstantsB;
 765     for (start = 0; ; start = range.offset + range.size)
 766     {
 767         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_B, start, &range))
 768             break;
 769
 770         memcpy(&stateblock->stateblock_state.vs_consts_b[range.offset], &state->vs_consts_b[range.offset],
 771                 sizeof(*state->vs_consts_b) * range.size);
 772     }
 773
 774     for (start = 0; ; start = range.offset + range.size)
 775     {
 776         if (!wined3d_bitmap_get_range(stateblock->changed.ps_consts_f, WINED3D_MAX_PS_CONSTS_F, start, &range))
 777             break;
 778
 779         memcpy(&stateblock->stateblock_state.ps_consts_f[range.offset], &state->ps_consts_f[range.offset],
 780                 sizeof(*state->ps_consts_f) * range.size);
 781     }
 782     map = stateblock->changed.pixelShaderConstantsI;
 783     for (start = 0; ; start = range.offset + range.size)
 784     {
 785         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_I, start, &range))
 786             break;
 787
 788         memcpy(&stateblock->stateblock_state.ps_consts_i[range.offset], &state->ps_consts_i[range.offset],
 789                 sizeof(*state->ps_consts_i) * range.size);
 790     }
 791     map = stateblock->changed.pixelShaderConstantsB;
 792     for (start = 0; ; start = range.offset + range.size)
 793     {
 794         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_B, start, &range))
 795             break;
 796
 797         memcpy(&stateblock->stateblock_state.ps_consts_b[range.offset], &state->ps_consts_b[range.offset],
 798                 sizeof(*state->ps_consts_b) * range.size);
 799     }
 800
 801     if (stateblock->changed.transforms)
 802     {
 803         for (i = 0; i < stateblock->num_contained_transform_states; ++i)
 804         {
 805             enum wined3d_transform_state transform = stateblock->contained_transform_states[i];
 806
 807             TRACE("Updating transform %#x.\n", transform);
 808
 809             stateblock->stateblock_state.transforms[transform] = state->transforms[transform];
 810         }
 811     }
 812
 813     if (stateblock->changed.indices
 814             && ((stateblock->stateblock_state.index_buffer != state->index_buffer)
 815                 || (stateblock->stateblock_state.base_vertex_index != state->base_vertex_index)
 816                 || (stateblock->stateblock_state.index_format != state->index_format)))
 817     {
 818         TRACE("Updating index buffer to %p, base vertex index to %d.\n",
 819                 state->index_buffer, state->base_vertex_index);
 820
 821         if (state->index_buffer)
 822             wined3d_buffer_incref(state->index_buffer);
 823         if (stateblock->stateblock_state.index_buffer)
 824             wined3d_buffer_decref(stateblock->stateblock_state.index_buffer);
 825         stateblock->stateblock_state.index_buffer = state->index_buffer;
 826         stateblock->stateblock_state.base_vertex_index = state->base_vertex_index;
 827         stateblock->stateblock_state.index_format = state->index_format;
 828     }
 829
 830     if (stateblock->changed.vertexDecl && stateblock->stateblock_state.vertex_declaration != state->vertex_declaration)
 831     {
 832         TRACE("Updating vertex declaration from %p to %p.\n",
 833                 stateblock->stateblock_state.vertex_declaration, state->vertex_declaration);
 834
 835         if (state->vertex_declaration)
 836                 wined3d_vertex_declaration_incref(state->vertex_declaration);
 837         if (stateblock->stateblock_state.vertex_declaration)
 838                 wined3d_vertex_declaration_decref(stateblock->stateblock_state.vertex_declaration);
 839         stateblock->stateblock_state.vertex_declaration = state->vertex_declaration;
 840     }
 841
 842     if (stateblock->changed.material
 843             && memcmp(&state->material, &stateblock->stateblock_state.material,
 844             sizeof(stateblock->stateblock_state.material)))
 845     {
 846         TRACE("Updating material.\n");
 847
 848         stateblock->stateblock_state.material = state->material;
 849     }
 850
 851     if (stateblock->changed.viewport
 852             && memcmp(&state->viewport, &stateblock->stateblock_state.viewport, sizeof(state->viewport)))
 853     {
 854         TRACE("Updating viewport.\n");
 855
 856         stateblock->stateblock_state.viewport = state->viewport;
 857     }
 858
 859     if (stateblock->changed.scissorRect
 860             && memcmp(&state->scissor_rect, &stateblock->stateblock_state.scissor_rect, sizeof(state->scissor_rect)))
 861     {
 862         TRACE("Updating scissor rect.\n");
 863
 864         stateblock->stateblock_state.scissor_rect = state->scissor_rect;
 865     }
 866
 867     map = stateblock->changed.streamSource;
 868     while (map)
 869     {
 870         i = wined3d_bit_scan(&map);
 871
 872         if (stateblock->stateblock_state.streams[i].stride != state->streams[i].stride
 873                 || stateblock->stateblock_state.streams[i].offset != state->streams[i].offset
 874                 || stateblock->stateblock_state.streams[i].buffer != state->streams[i].buffer)
 875         {
 876             TRACE("stateblock %p, stream source %u, buffer %p, stride %u, offset %u.\n",
 877                     stateblock, i, state->streams[i].buffer, state->streams[i].stride,
 878                     state->streams[i].offset);
 879
 880             stateblock->stateblock_state.streams[i].stride = state->streams[i].stride;
 881             if (stateblock->changed.store_stream_offset)
 882                 stateblock->stateblock_state.streams[i].offset = state->streams[i].offset;
 883
 884             if (state->streams[i].buffer)
 885                     wined3d_buffer_incref(state->streams[i].buffer);
 886             if (stateblock->stateblock_state.streams[i].buffer)
 887                     wined3d_buffer_decref(stateblock->stateblock_state.streams[i].buffer);
 888             stateblock->stateblock_state.streams[i].buffer = state->streams[i].buffer;
 889         }
 890     }
 891
 892     map = stateblock->changed.streamFreq;
 893     while (map)
 894     {
 895         i = wined3d_bit_scan(&map);
 896
 897         if (stateblock->stateblock_state.streams[i].frequency != state->streams[i].frequency
 898                 || stateblock->stateblock_state.streams[i].flags != state->streams[i].flags)
 899         {
 900             TRACE("Updating stream frequency %u to %u flags to %#x.\n",
 901                     i, state->streams[i].frequency, state->streams[i].flags);
 902
 903             stateblock->stateblock_state.streams[i].frequency = state->streams[i].frequency;
 904             stateblock->stateblock_state.streams[i].flags = state->streams[i].flags;
 905         }
 906     }
 907
 908     map = stateblock->changed.clipplane;
 909     while (map)
 910     {
 911         i = wined3d_bit_scan(&map);
 912
 913         if (memcmp(&stateblock->stateblock_state.clip_planes[i], &state->clip_planes[i], sizeof(state->clip_planes[i])))
 914         {
 915             TRACE("Updating clipplane %u.\n", i);
 916             stateblock->stateblock_state.clip_planes[i] = state->clip_planes[i];
 917         }
 918     }
 919
 920     /* Render */
 921     for (i = 0; i < stateblock->num_contained_render_states; ++i)
 922     {
 923         enum wined3d_render_state rs = stateblock->contained_render_states[i];
 924
 925         TRACE("Updating render state %#x to %u.\n", rs, state->rs[rs]);
 926
 927         stateblock->stateblock_state.rs[rs] = state->rs[rs];
 928     }
 929
 930     /* Texture states */
 931     for (i = 0; i < stateblock->num_contained_tss_states; ++i)
 932     {
 933         unsigned int stage = stateblock->contained_tss_states[i].stage;
 934         unsigned int texture_state = stateblock->contained_tss_states[i].state;
 935
 936         TRACE("Updating texturestage state %u, %u to %#x (was %#x).\n", stage, texture_state,
 937                 state->texture_states[stage][texture_state],
 938                 stateblock->stateblock_state.texture_states[stage][texture_state]);
 939
 940         stateblock->stateblock_state.texture_states[stage][texture_state] = state->texture_states[stage][texture_state];
 941     }
 942
 943     /* Samplers */
 944     map = stateblock->changed.textures;
 945     while (map)
 946     {
 947         i = wined3d_bit_scan(&map);
 948
 949         TRACE("Updating texture %u to %p (was %p).\n",
 950                 i, state->textures[i], stateblock->stateblock_state.textures[i]);
 951
 952         if (state->textures[i])
 953             wined3d_texture_incref(state->textures[i]);
 954         if (stateblock->stateblock_state.textures[i])
 955             wined3d_texture_decref(stateblock->stateblock_state.textures[i]);
 956         stateblock->stateblock_state.textures[i] = state->textures[i];
 957     }
 958
 959     for (i = 0; i < stateblock->num_contained_sampler_states; ++i)
 960     {
 961         unsigned int stage = stateblock->contained_sampler_states[i].stage;
 962         unsigned int sampler_state = stateblock->contained_sampler_states[i].state;
 963
 964         TRACE("Updating sampler state %u, %u to %#x (was %#x).\n", stage, sampler_state,
 965                 state->sampler_states[stage][sampler_state],
 966                 stateblock->stateblock_state.sampler_states[stage][sampler_state]);
 967
 968         stateblock->stateblock_state.sampler_states[stage][sampler_state] = state->sampler_states[stage][sampler_state];
 969     }
 970
 971     if (stateblock->changed.pixelShader && stateblock->stateblock_state.ps != state->ps)
 972     {
 973         if (state->ps)
 974             wined3d_shader_incref(state->ps);
 975         if (stateblock->stateblock_state.ps)
 976             wined3d_shader_decref(stateblock->stateblock_state.ps);
 977         stateblock->stateblock_state.ps = state->ps;
 978     }
 979
 980     if (stateblock->changed.lights)
 981         wined3d_state_record_lights(stateblock->stateblock_state.light_state, state->light_state);
 982
 983     if (stateblock->changed.alpha_to_coverage)
 984         stateblock->stateblock_state.alpha_to_coverage = state->alpha_to_coverage;
 985
 986     TRACE("Capture done.\n");
 987 }
 988
 989 void CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock,
 990         struct wined3d_stateblock *device_state)
 991 {
 992     const struct wined3d_stateblock_state *state = &stateblock->stateblock_state;
 993     struct wined3d_range range;
 994     unsigned int i, start;
 995     uint32_t map;
 996
 997     TRACE("stateblock %p, device_state %p.\n", stateblock, device_state);
 998
 999     if (stateblock->changed.vertexShader)
1000         wined3d_stateblock_set_vertex_shader(device_state, state->vs);
1001     if (stateblock->changed.pixelShader)
1002         wined3d_stateblock_set_pixel_shader(device_state, state->ps);
1003
1004     for (start = 0; ; start = range.offset + range.size)
1005     {
1006         if (!wined3d_bitmap_get_range(stateblock->changed.vs_consts_f, WINED3D_MAX_VS_CONSTS_F, start, &range))
1007             break;
1008         wined3d_stateblock_set_vs_consts_f(device_state, range.offset, range.size, &state->vs_consts_f[range.offset]);
1009     }
1010     map = stateblock->changed.vertexShaderConstantsI;
1011     for (start = 0; ; start = range.offset + range.size)
1012     {
1013         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_I, start, &range))
1014             break;
1015         wined3d_stateblock_set_vs_consts_i(device_state, range.offset, range.size, &state->vs_consts_i[range.offset]);
1016     }
1017     map = stateblock->changed.vertexShaderConstantsB;
1018     for (start = 0; ; start = range.offset + range.size)
1019     {
1020         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_B, start, &range))
1021             break;
1022         wined3d_stateblock_set_vs_consts_b(device_state, range.offset, range.size, &state->vs_consts_b[range.offset]);
1023     }
1024
1025     for (start = 0; ; start = range.offset + range.size)
1026     {
1027         if (!wined3d_bitmap_get_range(stateblock->changed.ps_consts_f, WINED3D_MAX_PS_CONSTS_F, start, &range))
1028             break;
1029         wined3d_stateblock_set_ps_consts_f(device_state, range.offset, range.size, &state->ps_consts_f[range.offset]);
1030     }
1031     map = stateblock->changed.pixelShaderConstantsI;
1032     for (start = 0; ; start = range.offset + range.size)
1033     {
1034         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_I, start, &range))
1035             break;
1036         wined3d_stateblock_set_ps_consts_i(device_state, range.offset, range.size, &state->ps_consts_i[range.offset]);
1037     }
1038     map = stateblock->changed.pixelShaderConstantsB;
1039     for (start = 0; ; start = range.offset + range.size)
1040     {
1041         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_B, start, &range))
1042             break;
1043         wined3d_stateblock_set_ps_consts_b(device_state, range.offset, range.size, &state->ps_consts_b[range.offset]);
1044     }
1045
1046     if (stateblock->changed.transforms)
1047     {
1048         for (i = 0; i < stateblock->num_contained_transform_states; ++i)
1049         {
1050             enum wined3d_transform_state transform = stateblock->contained_transform_states[i];
1051
1052             wined3d_stateblock_set_transform(device_state, transform, &state->transforms[transform]);
1053         }
1054     }
1055
1056     if (stateblock->changed.lights)
1057     {
1058         const struct wined3d_light_info *light;
1059
1060         LIST_FOR_EACH_ENTRY(light, &stateblock->changed.changed_lights, struct wined3d_light_info, changed_entry)
1061         {
1062             wined3d_stateblock_set_light(device_state, light->OriginalIndex, &light->OriginalParms);
1063             wined3d_stateblock_set_light_enable(device_state, light->OriginalIndex, light->glIndex != -1);
1064         }
1065     }
1066
1067     if (stateblock->changed.alpha_to_coverage)
1068     {
1069         device_state->stateblock_state.alpha_to_coverage = state->alpha_to_coverage;
1070         device_state->changed.alpha_to_coverage = 1;
1071     }
1072
1073     /* Render states. */
1074     for (i = 0; i < stateblock->num_contained_render_states; ++i)
1075     {
1076         enum wined3d_render_state rs = stateblock->contained_render_states[i];
1077
1078         wined3d_stateblock_set_render_state(device_state, rs, state->rs[rs]);
1079     }
1080
1081     /* Texture states. */
1082     for (i = 0; i < stateblock->num_contained_tss_states; ++i)
1083     {
1084         DWORD stage = stateblock->contained_tss_states[i].stage;
1085         DWORD texture_state = stateblock->contained_tss_states[i].state;
1086
1087         wined3d_stateblock_set_texture_stage_state(device_state, stage, texture_state,
1088                 state->texture_states[stage][texture_state]);
1089     }
1090
1091     /* Sampler states. */
1092     for (i = 0; i < stateblock->num_contained_sampler_states; ++i)
1093     {
1094         DWORD stage = stateblock->contained_sampler_states[i].stage;
1095         DWORD sampler_state = stateblock->contained_sampler_states[i].state;
1096
1097         wined3d_stateblock_set_sampler_state(device_state, stage, sampler_state,
1098                 state->sampler_states[stage][sampler_state]);
1099     }
1100
1101     if (stateblock->changed.indices)
1102     {
1103         wined3d_stateblock_set_index_buffer(device_state, state->index_buffer, state->index_format);
1104         wined3d_stateblock_set_base_vertex_index(device_state, state->base_vertex_index);
1105     }
1106
1107     if (stateblock->changed.vertexDecl && state->vertex_declaration)
1108         wined3d_stateblock_set_vertex_declaration(device_state, state->vertex_declaration);
1109
1110     if (stateblock->changed.material)
1111         wined3d_stateblock_set_material(device_state, &state->material);
1112
1113     if (stateblock->changed.viewport)
1114         wined3d_stateblock_set_viewport(device_state, &state->viewport);
1115
1116     if (stateblock->changed.scissorRect)
1117         wined3d_stateblock_set_scissor_rect(device_state, &state->scissor_rect);
1118
1119     map = stateblock->changed.streamSource;
1120     while (map)
1121     {
1122         i = wined3d_bit_scan(&map);
1123         wined3d_stateblock_set_stream_source(device_state, i, state->streams[i].buffer,
1124                 state->streams[i].offset, state->streams[i].stride);
1125     }
1126
1127     map = stateblock->changed.streamFreq;
1128     while (map)
1129     {
1130         i = wined3d_bit_scan(&map);
1131         wined3d_stateblock_set_stream_source_freq(device_state, i,
1132                 state->streams[i].frequency | state->streams[i].flags);
1133     }
1134
1135     map = stateblock->changed.textures;
1136     while (map)
1137     {
1138         i = wined3d_bit_scan(&map);
1139         wined3d_stateblock_set_texture(device_state, i, state->textures[i]);
1140     }
1141
1142     map = stateblock->changed.clipplane;
1143     while (map)
1144     {
1145         i = wined3d_bit_scan(&map);
1146         wined3d_stateblock_set_clip_plane(device_state, i, &state->clip_planes[i]);
1147     }
1148
1149     TRACE("Applied stateblock %p.\n", stateblock);
1150 }
1151
1152 void CDECL wined3d_stateblock_set_vertex_shader(struct wined3d_stateblock *stateblock, struct wined3d_shader *shader)
1153 {
1154     TRACE("stateblock %p, shader %p.\n", stateblock, shader);
1155
1156     if (shader)
1157         wined3d_shader_incref(shader);
1158     if (stateblock->stateblock_state.vs)
1159         wined3d_shader_decref(stateblock->stateblock_state.vs);
1160     stateblock->stateblock_state.vs = shader;
1161     stateblock->changed.vertexShader = TRUE;
1162 }
1163
1164 static void wined3d_bitmap_set_bits(uint32_t *bitmap, unsigned int start, unsigned int count)
1165 {
1166     const unsigned int word_bit_count = sizeof(*bitmap) * CHAR_BIT;
1167     const unsigned int shift = start % word_bit_count;
1168     uint32_t mask, last_mask;
1169     unsigned int mask_size;
1170
1171     bitmap += start / word_bit_count;
1172     mask = ~0u << shift;
1173     mask_size = word_bit_count - shift;
1174     last_mask = (1u << (start + count) % word_bit_count) - 1;
1175     if (mask_size <= count)
1176     {
1177         *bitmap |= mask;
1178         ++bitmap;
1179         count -= mask_size;
1180         mask = ~0u;
1181     }
1182     if (count >= word_bit_count)
1183     {
1184         memset(bitmap, 0xffu, count / word_bit_count * sizeof(*bitmap));
1185         bitmap += count / word_bit_count;
1186         count = count % word_bit_count;
1187     }
1188     if (count)
1189         *bitmap |= mask & last_mask;
1190 }
1191
1192 HRESULT CDECL wined3d_stateblock_set_vs_consts_f(struct wined3d_stateblock *stateblock,
1193         unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
1194 {
1195     const struct wined3d_d3d_info *d3d_info = &stateblock->device->adapter->d3d_info;
1196
1197     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n",
1198             stateblock, start_idx, count, constants);
1199
1200     if (!constants || !wined3d_bound_range(start_idx, count, d3d_info->limits.vs_uniform_count))
1201         return WINED3DERR_INVALIDCALL;
1202
1203     memcpy(&stateblock->stateblock_state.vs_consts_f[start_idx], constants, count * sizeof(*constants));
1204     wined3d_bitmap_set_bits(stateblock->changed.vs_consts_f, start_idx, count);
1205     return WINED3D_OK;
1206 }
1207
1208 HRESULT CDECL wined3d_stateblock_set_vs_consts_i(struct wined3d_stateblock *stateblock,
1209         unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
1210 {
1211     unsigned int i;
1212
1213     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n",
1214             stateblock, start_idx, count, constants);
1215
1216     if (!constants || start_idx >= WINED3D_MAX_CONSTS_I)
1217         return WINED3DERR_INVALIDCALL;
1218
1219     if (count > WINED3D_MAX_CONSTS_I - start_idx)
1220         count = WINED3D_MAX_CONSTS_I - start_idx;
1221
1222     memcpy(&stateblock->stateblock_state.vs_consts_i[start_idx], constants, count * sizeof(*constants));
1223     for (i = start_idx; i < count + start_idx; ++i)
1224         stateblock->changed.vertexShaderConstantsI |= (1u << i);
1225     return WINED3D_OK;
1226 }
1227
1228 HRESULT CDECL wined3d_stateblock_set_vs_consts_b(struct wined3d_stateblock *stateblock,
1229         unsigned int start_idx, unsigned int count, const BOOL *constants)
1230 {
1231     unsigned int i;
1232
1233     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n",
1234             stateblock, start_idx, count, constants);
1235
1236     if (!constants || start_idx >= WINED3D_MAX_CONSTS_B)
1237         return WINED3DERR_INVALIDCALL;
1238
1239     if (count > WINED3D_MAX_CONSTS_B - start_idx)
1240         count = WINED3D_MAX_CONSTS_B - start_idx;
1241
1242     memcpy(&stateblock->stateblock_state.vs_consts_b[start_idx], constants, count * sizeof(*constants));
1243     for (i = start_idx; i < count + start_idx; ++i)
1244         stateblock->changed.vertexShaderConstantsB |= (1u << i);
1245     return WINED3D_OK;
1246 }
1247
1248 HRESULT CDECL wined3d_stateblock_get_vs_consts_f(struct wined3d_stateblock *stateblock,
1249         unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants)
1250 {
1251     const struct wined3d_d3d_info *d3d_info = &stateblock->device->adapter->d3d_info;
1252
1253     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n", stateblock, start_idx, count, constants);
1254
1255     if (!constants || !wined3d_bound_range(start_idx, count, d3d_info->limits.vs_uniform_count))
1256         return WINED3DERR_INVALIDCALL;
1257
1258     memcpy(constants, &stateblock->stateblock_state.vs_consts_f[start_idx], count * sizeof(*constants));
1259     return WINED3D_OK;
1260 }
1261
1262 HRESULT CDECL wined3d_stateblock_get_vs_consts_i(struct wined3d_stateblock *stateblock,
1263         unsigned int start_idx, unsigned int count, struct wined3d_ivec4 *constants)
1264 {
1265     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n", stateblock, start_idx, count, constants);
1266
1267     if (!constants || start_idx >= WINED3D_MAX_CONSTS_I)
1268         return WINED3DERR_INVALIDCALL;
1269
1270     if (count > WINED3D_MAX_CONSTS_I - start_idx)
1271         count = WINED3D_MAX_CONSTS_I - start_idx;
1272
1273     memcpy(constants, &stateblock->stateblock_state.vs_consts_i[start_idx], count * sizeof(*constants));
1274     return WINED3D_OK;
1275 }
1276
1277 HRESULT CDECL wined3d_stateblock_get_vs_consts_b(struct wined3d_stateblock *stateblock,
1278         unsigned int start_idx, unsigned int count, BOOL *constants)
1279 {
1280     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n", stateblock, start_idx, count, constants);
1281
1282     if (!constants || start_idx >= WINED3D_MAX_CONSTS_B)
1283         return WINED3DERR_INVALIDCALL;
1284
1285     if (count > WINED3D_MAX_CONSTS_B - start_idx)
1286         count = WINED3D_MAX_CONSTS_B - start_idx;
1287
1288     memcpy(constants, &stateblock->stateblock_state.vs_consts_b[start_idx], count * sizeof(*constants));
1289     return WINED3D_OK;
1290 }
1291
1292 void CDECL wined3d_stateblock_set_pixel_shader(struct wined3d_stateblock *stateblock, struct wined3d_shader *shader)
1293 {
1294     TRACE("stateblock %p, shader %p.\n", stateblock, shader);
1295
1296     if (shader)
1297         wined3d_shader_incref(shader);
1298     if (stateblock->stateblock_state.ps)
1299         wined3d_shader_decref(stateblock->stateblock_state.ps);
1300     stateblock->stateblock_state.ps = shader;
1301     stateblock->changed.pixelShader = TRUE;
1302 }
1303
1304 HRESULT CDECL wined3d_stateblock_set_ps_consts_f(struct wined3d_stateblock *stateblock,
1305         unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
1306 {
1307     const struct wined3d_d3d_info *d3d_info = &stateblock->device->adapter->d3d_info;
1308
1309     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n",
1310             stateblock, start_idx, count, constants);
1311
1312     if (!constants || !wined3d_bound_range(start_idx, count, d3d_info->limits.ps_uniform_count))
1313         return WINED3DERR_INVALIDCALL;
1314
1315     memcpy(&stateblock->stateblock_state.ps_consts_f[start_idx], constants, count * sizeof(*constants));
1316     wined3d_bitmap_set_bits(stateblock->changed.ps_consts_f, start_idx, count);
1317     return WINED3D_OK;
1318 }
1319
1320 HRESULT CDECL wined3d_stateblock_set_ps_consts_i(struct wined3d_stateblock *stateblock,
1321         unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
1322 {
1323     unsigned int i;
1324
1325     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n",
1326             stateblock, start_idx, count, constants);
1327
1328     if (!constants || start_idx >= WINED3D_MAX_CONSTS_I)
1329         return WINED3DERR_INVALIDCALL;
1330
1331     if (count > WINED3D_MAX_CONSTS_I - start_idx)
1332         count = WINED3D_MAX_CONSTS_I - start_idx;
1333
1334     memcpy(&stateblock->stateblock_state.ps_consts_i[start_idx], constants, count * sizeof(*constants));
1335     for (i = start_idx; i < count + start_idx; ++i)
1336         stateblock->changed.pixelShaderConstantsI |= (1u << i);
1337     return WINED3D_OK;
1338 }
1339
1340 HRESULT CDECL wined3d_stateblock_set_ps_consts_b(struct wined3d_stateblock *stateblock,
1341         unsigned int start_idx, unsigned int count, const BOOL *constants)
1342 {
1343     unsigned int i;
1344
1345     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n",
1346             stateblock, start_idx, count, constants);
1347
1348     if (!constants || start_idx >= WINED3D_MAX_CONSTS_B)
1349         return WINED3DERR_INVALIDCALL;
1350
1351     if (count > WINED3D_MAX_CONSTS_B - start_idx)
1352         count = WINED3D_MAX_CONSTS_B - start_idx;
1353
1354     memcpy(&stateblock->stateblock_state.ps_consts_b[start_idx], constants, count * sizeof(*constants));
1355     for (i = start_idx; i < count + start_idx; ++i)
1356         stateblock->changed.pixelShaderConstantsB |= (1u << i);
1357     return WINED3D_OK;
1358 }
1359
1360 HRESULT CDECL wined3d_stateblock_get_ps_consts_f(struct wined3d_stateblock *stateblock,
1361         unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants)
1362 {
1363     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n", stateblock, start_idx, count, constants);
1364
1365     if (!constants || !wined3d_bound_range(start_idx, count, WINED3D_MAX_PS_CONSTS_F))
1366         return WINED3DERR_INVALIDCALL;
1367
1368     memcpy(constants, &stateblock->stateblock_state.ps_consts_f[start_idx], count * sizeof(*constants));
1369     return WINED3D_OK;
1370 }
1371
1372 HRESULT CDECL wined3d_stateblock_get_ps_consts_i(struct wined3d_stateblock *stateblock,
1373         unsigned int start_idx, unsigned int count, struct wined3d_ivec4 *constants)
1374 {
1375     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n", stateblock, start_idx, count, constants);
1376
1377     if (!constants || start_idx >= WINED3D_MAX_CONSTS_I)
1378         return WINED3DERR_INVALIDCALL;
1379
1380     if (count > WINED3D_MAX_CONSTS_I - start_idx)
1381         count = WINED3D_MAX_CONSTS_I - start_idx;
1382
1383     memcpy(constants, &stateblock->stateblock_state.ps_consts_i[start_idx], count * sizeof(*constants));
1384     return WINED3D_OK;
1385 }
1386
1387 HRESULT CDECL wined3d_stateblock_get_ps_consts_b(struct wined3d_stateblock *stateblock,
1388         unsigned int start_idx, unsigned int count, BOOL *constants)
1389 {
1390     TRACE("stateblock %p, start_idx %u, count %u, constants %p.\n", stateblock, start_idx, count, constants);
1391
1392     if (!constants || start_idx >= WINED3D_MAX_CONSTS_B)
1393         return WINED3DERR_INVALIDCALL;
1394
1395     if (count > WINED3D_MAX_CONSTS_B - start_idx)
1396         count = WINED3D_MAX_CONSTS_B - start_idx;
1397
1398     memcpy(constants, &stateblock->stateblock_state.ps_consts_b[start_idx], count * sizeof(*constants));
1399     return WINED3D_OK;
1400 }
1401
1402 void CDECL wined3d_stateblock_set_vertex_declaration(struct wined3d_stateblock *stateblock,
1403         struct wined3d_vertex_declaration *declaration)
1404 {
1405     TRACE("stateblock %p, declaration %p.\n", stateblock, declaration);
1406
1407     if (declaration)
1408         wined3d_vertex_declaration_incref(declaration);
1409     if (stateblock->stateblock_state.vertex_declaration)
1410         wined3d_vertex_declaration_decref(stateblock->stateblock_state.vertex_declaration);
1411     stateblock->stateblock_state.vertex_declaration = declaration;
1412     stateblock->changed.vertexDecl = TRUE;
1413 }
1414
1415 void CDECL wined3d_stateblock_set_render_state(struct wined3d_stateblock *stateblock,
1416         enum wined3d_render_state state, unsigned int value)
1417 {
1418     TRACE("stateblock %p, state %s (%#x), value %#x.\n", stateblock, debug_d3drenderstate(state), state, value);
1419
1420     if (state > WINEHIGHEST_RENDER_STATE)
1421     {
1422         WARN("Unhandled render state %#x.\n", state);
1423         return;
1424     }
1425
1426     stateblock->stateblock_state.rs[state] = value;
1427     stateblock->changed.renderState[state >> 5] |= 1u << (state & 0x1f);
1428
1429     if (state == WINED3D_RS_POINTSIZE
1430             && (value == WINED3D_ALPHA_TO_COVERAGE_ENABLE || value == WINED3D_ALPHA_TO_COVERAGE_DISABLE))
1431     {
1432         stateblock->changed.alpha_to_coverage = 1;
1433         stateblock->stateblock_state.alpha_to_coverage = (value == WINED3D_ALPHA_TO_COVERAGE_ENABLE);
1434     }
1435 }
1436
1437 void CDECL wined3d_stateblock_set_sampler_state(struct wined3d_stateblock *stateblock,
1438         UINT sampler_idx, enum wined3d_sampler_state state, unsigned int value)
1439 {
1440     TRACE("stateblock %p, sampler_idx %u, state %s, value %#x.\n",
1441             stateblock, sampler_idx, debug_d3dsamplerstate(state), value);
1442
1443     if (sampler_idx >= ARRAY_SIZE(stateblock->stateblock_state.sampler_states))
1444     {
1445         WARN("Invalid sampler %u.\n", sampler_idx);
1446         return;
1447     }
1448
1449     stateblock->stateblock_state.sampler_states[sampler_idx][state] = value;
1450     stateblock->changed.samplerState[sampler_idx] |= 1u << state;
1451 }
1452
1453 void CDECL wined3d_stateblock_set_texture_stage_state(struct wined3d_stateblock *stateblock,
1454         UINT stage, enum wined3d_texture_stage_state state, unsigned int value)
1455 {
1456     TRACE("stateblock %p, stage %u, state %s, value %#x.\n",
1457             stateblock, stage, debug_d3dtexturestate(state), value);
1458
1459     if (state > WINED3D_HIGHEST_TEXTURE_STATE)
1460     {
1461         WARN("Invalid state %#x passed.\n", state);
1462         return;
1463     }
1464
1465     if (stage >= WINED3D_MAX_TEXTURES)
1466     {
1467         WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring.\n",
1468                 stage, WINED3D_MAX_TEXTURES - 1);
1469         return;
1470     }
1471
1472     stateblock->stateblock_state.texture_states[stage][state] = value;
1473     stateblock->changed.textureState[stage] |= 1u << state;
1474 }
1475
1476 void CDECL wined3d_stateblock_set_texture(struct wined3d_stateblock *stateblock,
1477         UINT stage, struct wined3d_texture *texture)
1478 {
1479     TRACE("stateblock %p, stage %u, texture %p.\n", stateblock, stage, texture);
1480
1481     if (stage >= ARRAY_SIZE(stateblock->stateblock_state.textures))
1482     {
1483         WARN("Ignoring invalid stage %u.\n", stage);
1484         return;
1485     }
1486
1487     if (texture)
1488         wined3d_texture_incref(texture);
1489     if (stateblock->stateblock_state.textures[stage])
1490         wined3d_texture_decref(stateblock->stateblock_state.textures[stage]);
1491     stateblock->stateblock_state.textures[stage] = texture;
1492     stateblock->changed.textures |= 1u << stage;
1493 }
1494
1495 void CDECL wined3d_stateblock_set_transform(struct wined3d_stateblock *stateblock,
1496         enum wined3d_transform_state d3dts, const struct wined3d_matrix *matrix)
1497 {
1498     TRACE("stateblock %p, state %s, matrix %p.\n", stateblock, debug_d3dtstype(d3dts), matrix);
1499     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_11, matrix->_12, matrix->_13, matrix->_14);
1500     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_21, matrix->_22, matrix->_23, matrix->_24);
1501     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_31, matrix->_32, matrix->_33, matrix->_34);
1502     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_41, matrix->_42, matrix->_43, matrix->_44);
1503
1504     stateblock->stateblock_state.transforms[d3dts] = *matrix;
1505     stateblock->changed.transform[d3dts >> 5] |= 1u << (d3dts & 0x1f);
1506     stateblock->changed.transforms = 1;
1507 }
1508
1509 void CDECL wined3d_stateblock_multiply_transform(struct wined3d_stateblock *stateblock,
1510         enum wined3d_transform_state d3dts, const struct wined3d_matrix *matrix)
1511 {
1512     struct wined3d_matrix *mat = &stateblock->stateblock_state.transforms[d3dts];
1513
1514     TRACE("stateblock %p, state %s, matrix %p.\n", stateblock, debug_d3dtstype(d3dts), matrix);
1515     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_11, matrix->_12, matrix->_13, matrix->_14);
1516     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_21, matrix->_22, matrix->_23, matrix->_24);
1517     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_31, matrix->_32, matrix->_33, matrix->_34);
1518     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_41, matrix->_42, matrix->_43, matrix->_44);
1519
1520     multiply_matrix(mat, mat, matrix);
1521     stateblock->changed.transform[d3dts >> 5] |= 1u << (d3dts & 0x1f);
1522     stateblock->changed.transforms = 1;
1523 }
1524
1525 HRESULT CDECL wined3d_stateblock_set_clip_plane(struct wined3d_stateblock *stateblock,
1526         UINT plane_idx, const struct wined3d_vec4 *plane)
1527 {
1528     TRACE("stateblock %p, plane_idx %u, plane %p.\n", stateblock, plane_idx, plane);
1529
1530     if (plane_idx >= stateblock->device->adapter->d3d_info.limits.max_clip_distances)
1531     {
1532         TRACE("Application has requested clipplane this device doesn't support.\n");
1533         return WINED3DERR_INVALIDCALL;
1534     }
1535
1536     stateblock->stateblock_state.clip_planes[plane_idx] = *plane;
1537     stateblock->changed.clipplane |= 1u << plane_idx;
1538     return S_OK;
1539 }
1540
1541 void CDECL wined3d_stateblock_set_material(struct wined3d_stateblock *stateblock,
1542         const struct wined3d_material *material)
1543 {
1544     TRACE("stateblock %p, material %p.\n", stateblock, material);
1545
1546     stateblock->stateblock_state.material = *material;
1547     stateblock->changed.material = TRUE;
1548 }
1549
1550 void CDECL wined3d_stateblock_set_viewport(struct wined3d_stateblock *stateblock,
1551         const struct wined3d_viewport *viewport)
1552 {
1553     TRACE("stateblock %p, viewport %p.\n", stateblock, viewport);
1554
1555     stateblock->stateblock_state.viewport = *viewport;
1556     stateblock->changed.viewport = TRUE;
1557 }
1558
1559 void CDECL wined3d_stateblock_set_scissor_rect(struct wined3d_stateblock *stateblock, const RECT *rect)
1560 {
1561     TRACE("stateblock %p, rect %s.\n", stateblock, wine_dbgstr_rect(rect));
1562
1563     stateblock->stateblock_state.scissor_rect = *rect;
1564     stateblock->changed.scissorRect = TRUE;
1565 }
1566
1567 void CDECL wined3d_stateblock_set_index_buffer(struct wined3d_stateblock *stateblock,
1568         struct wined3d_buffer *buffer, enum wined3d_format_id format_id)
1569 {
1570     TRACE("stateblock %p, buffer %p, format %s.\n", stateblock, buffer, debug_d3dformat(format_id));
1571
1572     if (buffer)
1573         wined3d_buffer_incref(buffer);
1574     if (stateblock->stateblock_state.index_buffer)
1575         wined3d_buffer_decref(stateblock->stateblock_state.index_buffer);
1576     stateblock->stateblock_state.index_buffer = buffer;
1577     stateblock->stateblock_state.index_format = format_id;
1578     stateblock->changed.indices = TRUE;
1579 }
1580
1581 void CDECL wined3d_stateblock_set_base_vertex_index(struct wined3d_stateblock *stateblock, INT base_index)
1582 {
1583     TRACE("stateblock %p, base_index %d.\n", stateblock, base_index);
1584
1585     stateblock->stateblock_state.base_vertex_index = base_index;
1586 }
1587
1588 HRESULT CDECL wined3d_stateblock_set_stream_source(struct wined3d_stateblock *stateblock,
1589         UINT stream_idx, struct wined3d_buffer *buffer, UINT offset, UINT stride)
1590 {
1591     struct wined3d_stream_state *stream;
1592
1593     TRACE("stateblock %p, stream_idx %u, buffer %p, stride %u.\n",
1594             stateblock, stream_idx, buffer, stride);
1595
1596     if (stream_idx >= WINED3D_MAX_STREAMS)
1597     {
1598         WARN("Stream index %u out of range.\n", stream_idx);
1599         return WINED3DERR_INVALIDCALL;
1600     }
1601
1602     stream = &stateblock->stateblock_state.streams[stream_idx];
1603
1604     if (buffer)
1605         wined3d_buffer_incref(buffer);
1606     if (stream->buffer)
1607         wined3d_buffer_decref(stream->buffer);
1608     stream->buffer = buffer;
1609     stream->stride = stride;
1610     stream->offset = offset;
1611     stateblock->changed.streamSource |= 1u << stream_idx;
1612     return WINED3D_OK;
1613 }
1614
1615 HRESULT CDECL wined3d_stateblock_set_stream_source_freq(struct wined3d_stateblock *stateblock,
1616         UINT stream_idx, UINT divider)
1617 {
1618     struct wined3d_stream_state *stream;
1619
1620     TRACE("stateblock %p, stream_idx %u, divider %#x.\n", stateblock, stream_idx, divider);
1621
1622     if ((divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && (divider & WINED3DSTREAMSOURCE_INDEXEDDATA))
1623     {
1624         WARN("INSTANCEDATA and INDEXEDDATA were set, returning D3DERR_INVALIDCALL.\n");
1625         return WINED3DERR_INVALIDCALL;
1626     }
1627     if ((divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && !stream_idx)
1628     {
1629         WARN("INSTANCEDATA used on stream 0, returning D3DERR_INVALIDCALL.\n");
1630         return WINED3DERR_INVALIDCALL;
1631     }
1632     if (!divider)
1633     {
1634         WARN("Divider is 0, returning D3DERR_INVALIDCALL.\n");
1635         return WINED3DERR_INVALIDCALL;
1636     }
1637
1638     stream = &stateblock->stateblock_state.streams[stream_idx];
1639     stream->flags = divider & (WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA);
1640     stream->frequency = divider & 0x7fffff;
1641     stateblock->changed.streamFreq |= 1u << stream_idx;
1642     return WINED3D_OK;
1643 }
1644
1645 HRESULT CDECL wined3d_stateblock_set_light(struct wined3d_stateblock *stateblock,
1646         UINT light_idx, const struct wined3d_light *light)
1647 {
1648     struct wined3d_light_info *object = NULL;
1649     HRESULT hr;
1650
1651     TRACE("stateblock %p, light_idx %u, light %p.\n", stateblock, light_idx, light);
1652
1653     /* Check the parameter range. Need for speed most wanted sets junk lights
1654      * which confuse the GL driver. */
1655     if (!light)
1656         return WINED3DERR_INVALIDCALL;
1657
1658     switch (light->type)
1659     {
1660         case WINED3D_LIGHT_POINT:
1661         case WINED3D_LIGHT_SPOT:
1662         case WINED3D_LIGHT_GLSPOT:
1663             /* Incorrect attenuation values can cause the gl driver to crash.
1664              * Happens with Need for speed most wanted. */
1665             if (light->attenuation0 < 0.0f || light->attenuation1 < 0.0f || light->attenuation2 < 0.0f)
1666             {
1667                 WARN("Attenuation is negative, returning WINED3DERR_INVALIDCALL.\n");
1668                 return WINED3DERR_INVALIDCALL;
1669             }
1670             break;
1671
1672         case WINED3D_LIGHT_DIRECTIONAL:
1673         case WINED3D_LIGHT_PARALLELPOINT:
1674             /* Ignores attenuation */
1675             break;
1676
1677         default:
1678             WARN("Light type out of range, returning WINED3DERR_INVALIDCALL.\n");
1679             return WINED3DERR_INVALIDCALL;
1680     }
1681
1682     if (SUCCEEDED(hr = wined3d_light_state_set_light(stateblock->stateblock_state.light_state, light_idx, light, &object)))
1683         set_light_changed(stateblock, object);
1684     return hr;
1685 }
1686
1687 HRESULT CDECL wined3d_stateblock_set_light_enable(struct wined3d_stateblock *stateblock, UINT light_idx, BOOL enable)
1688 {
1689     struct wined3d_light_state *light_state = stateblock->stateblock_state.light_state;
1690     struct wined3d_light_info *light_info;
1691     HRESULT hr;
1692
1693     TRACE("stateblock %p, light_idx %u, enable %#x.\n", stateblock, light_idx, enable);
1694
1695     if (!(light_info = wined3d_light_state_get_light(light_state, light_idx)))
1696     {
1697         if (FAILED(hr = wined3d_light_state_set_light(light_state, light_idx, &WINED3D_default_light, &light_info)))
1698             return hr;
1699         set_light_changed(stateblock, light_info);
1700     }
1701
1702     if (wined3d_light_state_enable_light(light_state, &stateblock->device->adapter->d3d_info, light_info, enable))
1703         set_light_changed(stateblock, light_info);
1704
1705     return S_OK;
1706 }
1707
1708 const struct wined3d_stateblock_state * CDECL wined3d_stateblock_get_state(const struct wined3d_stateblock *stateblock)
1709 {
1710     return &stateblock->stateblock_state;
1711 }
1712
1713 HRESULT CDECL wined3d_stateblock_get_light(const struct wined3d_stateblock *stateblock,
1714         UINT light_idx, struct wined3d_light *light, BOOL *enabled)
1715 {
1716     struct wined3d_light_info *light_info;
1717
1718     if (!(light_info = wined3d_light_state_get_light(&stateblock->light_state, light_idx)))
1719     {
1720         TRACE("Light %u is not defined.\n", light_idx);
1721         return WINED3DERR_INVALIDCALL;
1722     }
1723     *light = light_info->OriginalParms;
1724     *enabled = light_info->enabled ? 128 : 0;
1725     return WINED3D_OK;
1726 }
1727
1728 static void init_default_render_states(unsigned int rs[WINEHIGHEST_RENDER_STATE + 1], const struct wined3d_d3d_info *d3d_info)
1729 {
1730     union
1731     {
1732         struct wined3d_line_pattern lp;
1733         DWORD d;
1734     } lp;
1735     union
1736     {
1737         float f;
1738         DWORD d;
1739     } tmpfloat;
1740
1741     rs[WINED3D_RS_ZENABLE] = WINED3D_ZB_TRUE;
1742     rs[WINED3D_RS_FILLMODE] = WINED3D_FILL_SOLID;
1743     rs[WINED3D_RS_SHADEMODE] = WINED3D_SHADE_GOURAUD;
1744     lp.lp.repeat_factor = 0;
1745     lp.lp.line_pattern = 0;
1746     rs[WINED3D_RS_LINEPATTERN] = lp.d;
1747     rs[WINED3D_RS_ZWRITEENABLE] = TRUE;
1748     rs[WINED3D_RS_ALPHATESTENABLE] = FALSE;
1749     rs[WINED3D_RS_LASTPIXEL] = TRUE;
1750     rs[WINED3D_RS_SRCBLEND] = WINED3D_BLEND_ONE;
1751     rs[WINED3D_RS_DESTBLEND] = WINED3D_BLEND_ZERO;
1752     rs[WINED3D_RS_CULLMODE] = WINED3D_CULL_BACK;
1753     rs[WINED3D_RS_ZFUNC] = WINED3D_CMP_LESSEQUAL;
1754     rs[WINED3D_RS_ALPHAFUNC] = WINED3D_CMP_ALWAYS;
1755     rs[WINED3D_RS_ALPHAREF] = 0;
1756     rs[WINED3D_RS_DITHERENABLE] = FALSE;
1757     rs[WINED3D_RS_ALPHABLENDENABLE] = FALSE;
1758     rs[WINED3D_RS_FOGENABLE] = FALSE;
1759     rs[WINED3D_RS_SPECULARENABLE] = FALSE;
1760     rs[WINED3D_RS_ZVISIBLE] = 0;
1761     rs[WINED3D_RS_FOGCOLOR] = 0;
1762     rs[WINED3D_RS_FOGTABLEMODE] = WINED3D_FOG_NONE;
1763     tmpfloat.f = 0.0f;
1764     rs[WINED3D_RS_FOGSTART] = tmpfloat.d;
1765     tmpfloat.f = 1.0f;
1766     rs[WINED3D_RS_FOGEND] = tmpfloat.d;
1767     tmpfloat.f = 1.0f;
1768     rs[WINED3D_RS_FOGDENSITY] = tmpfloat.d;
1769     rs[WINED3D_RS_RANGEFOGENABLE] = FALSE;
1770     rs[WINED3D_RS_STENCILENABLE] = FALSE;
1771     rs[WINED3D_RS_STENCILFAIL] = WINED3D_STENCIL_OP_KEEP;
1772     rs[WINED3D_RS_STENCILZFAIL] = WINED3D_STENCIL_OP_KEEP;
1773     rs[WINED3D_RS_STENCILPASS] = WINED3D_STENCIL_OP_KEEP;
1774     rs[WINED3D_RS_STENCILREF] = 0;
1775     rs[WINED3D_RS_STENCILMASK] = 0xffffffff;
1776     rs[WINED3D_RS_STENCILFUNC] = WINED3D_CMP_ALWAYS;
1777     rs[WINED3D_RS_STENCILWRITEMASK] = 0xffffffff;
1778     rs[WINED3D_RS_TEXTUREFACTOR] = 0xffffffff;
1779     rs[WINED3D_RS_WRAP0] = 0;
1780     rs[WINED3D_RS_WRAP1] = 0;
1781     rs[WINED3D_RS_WRAP2] = 0;
1782     rs[WINED3D_RS_WRAP3] = 0;
1783     rs[WINED3D_RS_WRAP4] = 0;
1784     rs[WINED3D_RS_WRAP5] = 0;
1785     rs[WINED3D_RS_WRAP6] = 0;
1786     rs[WINED3D_RS_WRAP7] = 0;
1787     rs[WINED3D_RS_CLIPPING] = TRUE;
1788     rs[WINED3D_RS_LIGHTING] = TRUE;
1789     rs[WINED3D_RS_AMBIENT] = 0;
1790     rs[WINED3D_RS_FOGVERTEXMODE] = WINED3D_FOG_NONE;
1791     rs[WINED3D_RS_COLORVERTEX] = TRUE;
1792     rs[WINED3D_RS_LOCALVIEWER] = TRUE;
1793     rs[WINED3D_RS_NORMALIZENORMALS] = FALSE;
1794     rs[WINED3D_RS_DIFFUSEMATERIALSOURCE] = WINED3D_MCS_COLOR1;
1795     rs[WINED3D_RS_SPECULARMATERIALSOURCE] = WINED3D_MCS_COLOR2;
1796     rs[WINED3D_RS_AMBIENTMATERIALSOURCE] = WINED3D_MCS_MATERIAL;
1797     rs[WINED3D_RS_EMISSIVEMATERIALSOURCE] = WINED3D_MCS_MATERIAL;
1798     rs[WINED3D_RS_VERTEXBLEND] = WINED3D_VBF_DISABLE;
1799     rs[WINED3D_RS_CLIPPLANEENABLE] = 0;
1800     rs[WINED3D_RS_SOFTWAREVERTEXPROCESSING] = FALSE;
1801     tmpfloat.f = 1.0f;
1802     rs[WINED3D_RS_POINTSIZE] = tmpfloat.d;
1803     tmpfloat.f = 1.0f;
1804     rs[WINED3D_RS_POINTSIZE_MIN] = tmpfloat.d;
1805     rs[WINED3D_RS_POINTSPRITEENABLE] = FALSE;
1806     rs[WINED3D_RS_POINTSCALEENABLE] = FALSE;
1807     tmpfloat.f = 1.0f;
1808     rs[WINED3D_RS_POINTSCALE_A] = tmpfloat.d;
1809     tmpfloat.f = 0.0f;
1810     rs[WINED3D_RS_POINTSCALE_B] = tmpfloat.d;
1811     tmpfloat.f = 0.0f;
1812     rs[WINED3D_RS_POINTSCALE_C] = tmpfloat.d;
1813     rs[WINED3D_RS_MULTISAMPLEANTIALIAS] = TRUE;
1814     rs[WINED3D_RS_MULTISAMPLEMASK] = 0xffffffff;
1815     rs[WINED3D_RS_PATCHEDGESTYLE] = WINED3D_PATCH_EDGE_DISCRETE;
1816     tmpfloat.f = 1.0f;
1817     rs[WINED3D_RS_PATCHSEGMENTS] = tmpfloat.d;
1818     rs[WINED3D_RS_DEBUGMONITORTOKEN] = 0xbaadcafe;
1819     tmpfloat.f = d3d_info->limits.pointsize_max;
1820     rs[WINED3D_RS_POINTSIZE_MAX] = tmpfloat.d;
1821     rs[WINED3D_RS_INDEXEDVERTEXBLENDENABLE] = FALSE;
1822     rs[WINED3D_RS_COLORWRITEENABLE] = 0x0000000f;
1823     tmpfloat.f = 0.0f;
1824     rs[WINED3D_RS_TWEENFACTOR] = tmpfloat.d;
1825     rs[WINED3D_RS_BLENDOP] = WINED3D_BLEND_OP_ADD;
1826     rs[WINED3D_RS_POSITIONDEGREE] = WINED3D_DEGREE_CUBIC;
1827     rs[WINED3D_RS_NORMALDEGREE] = WINED3D_DEGREE_LINEAR;
1828     /* states new in d3d9 */
1829     rs[WINED3D_RS_SCISSORTESTENABLE] = FALSE;
1830     rs[WINED3D_RS_SLOPESCALEDEPTHBIAS] = 0;
1831     tmpfloat.f = 1.0f;
1832     rs[WINED3D_RS_MINTESSELLATIONLEVEL] = tmpfloat.d;
1833     rs[WINED3D_RS_MAXTESSELLATIONLEVEL] = tmpfloat.d;
1834     rs[WINED3D_RS_ANTIALIASEDLINEENABLE] = FALSE;
1835     tmpfloat.f = 0.0f;
1836     rs[WINED3D_RS_ADAPTIVETESS_X] = tmpfloat.d;
1837     rs[WINED3D_RS_ADAPTIVETESS_Y] = tmpfloat.d;
1838     tmpfloat.f = 1.0f;
1839     rs[WINED3D_RS_ADAPTIVETESS_Z] = tmpfloat.d;
1840     tmpfloat.f = 0.0f;
1841     rs[WINED3D_RS_ADAPTIVETESS_W] = tmpfloat.d;
1842     rs[WINED3D_RS_ENABLEADAPTIVETESSELLATION] = FALSE;
1843     rs[WINED3D_RS_TWOSIDEDSTENCILMODE] = FALSE;
1844     rs[WINED3D_RS_BACK_STENCILFAIL] = WINED3D_STENCIL_OP_KEEP;
1845     rs[WINED3D_RS_BACK_STENCILZFAIL] = WINED3D_STENCIL_OP_KEEP;
1846     rs[WINED3D_RS_BACK_STENCILPASS] = WINED3D_STENCIL_OP_KEEP;
1847     rs[WINED3D_RS_BACK_STENCILFUNC] = WINED3D_CMP_ALWAYS;
1848     rs[WINED3D_RS_COLORWRITEENABLE1] = 0x0000000f;
1849     rs[WINED3D_RS_COLORWRITEENABLE2] = 0x0000000f;
1850     rs[WINED3D_RS_COLORWRITEENABLE3] = 0x0000000f;
1851     rs[WINED3D_RS_BLENDFACTOR] = 0xffffffff;
1852     rs[WINED3D_RS_SRGBWRITEENABLE] = 0;
1853     rs[WINED3D_RS_DEPTHBIAS] = 0;
1854     rs[WINED3D_RS_WRAP8] = 0;
1855     rs[WINED3D_RS_WRAP9] = 0;
1856     rs[WINED3D_RS_WRAP10] = 0;
1857     rs[WINED3D_RS_WRAP11] = 0;
1858     rs[WINED3D_RS_WRAP12] = 0;
1859     rs[WINED3D_RS_WRAP13] = 0;
1860     rs[WINED3D_RS_WRAP14] = 0;
1861     rs[WINED3D_RS_WRAP15] = 0;
1862     rs[WINED3D_RS_SEPARATEALPHABLENDENABLE] = FALSE;
1863     rs[WINED3D_RS_SRCBLENDALPHA] = WINED3D_BLEND_ONE;
1864     rs[WINED3D_RS_DESTBLENDALPHA] = WINED3D_BLEND_ZERO;
1865     rs[WINED3D_RS_BLENDOPALPHA] = WINED3D_BLEND_OP_ADD;
1866 }
1867
1868 static void init_default_texture_state(unsigned int i, uint32_t stage[WINED3D_HIGHEST_TEXTURE_STATE + 1])
1869 {
1870     stage[WINED3D_TSS_COLOR_OP] = i ? WINED3D_TOP_DISABLE : WINED3D_TOP_MODULATE;
1871     stage[WINED3D_TSS_COLOR_ARG1] = WINED3DTA_TEXTURE;
1872     stage[WINED3D_TSS_COLOR_ARG2] = WINED3DTA_CURRENT;
1873     stage[WINED3D_TSS_ALPHA_OP] = i ? WINED3D_TOP_DISABLE : WINED3D_TOP_SELECT_ARG1;
1874     stage[WINED3D_TSS_ALPHA_ARG1] = WINED3DTA_TEXTURE;
1875     stage[WINED3D_TSS_ALPHA_ARG2] = WINED3DTA_CURRENT;
1876     stage[WINED3D_TSS_BUMPENV_MAT00] = 0;
1877     stage[WINED3D_TSS_BUMPENV_MAT01] = 0;
1878     stage[WINED3D_TSS_BUMPENV_MAT10] = 0;
1879     stage[WINED3D_TSS_BUMPENV_MAT11] = 0;
1880     stage[WINED3D_TSS_TEXCOORD_INDEX] = i;
1881     stage[WINED3D_TSS_BUMPENV_LSCALE] = 0;
1882     stage[WINED3D_TSS_BUMPENV_LOFFSET] = 0;
1883     stage[WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS] = WINED3D_TTFF_DISABLE;
1884     stage[WINED3D_TSS_COLOR_ARG0] = WINED3DTA_CURRENT;
1885     stage[WINED3D_TSS_ALPHA_ARG0] = WINED3DTA_CURRENT;
1886     stage[WINED3D_TSS_RESULT_ARG] = WINED3DTA_CURRENT;
1887 }
1888
1889 static void init_default_sampler_states(uint32_t states[WINED3D_MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1])
1890 {
1891     unsigned int i;
1892
1893     for (i = 0 ; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
1894     {
1895         TRACE("Setting up default samplers states for sampler %u.\n", i);
1896         states[i][WINED3D_SAMP_ADDRESS_U] = WINED3D_TADDRESS_WRAP;
1897         states[i][WINED3D_SAMP_ADDRESS_V] = WINED3D_TADDRESS_WRAP;
1898         states[i][WINED3D_SAMP_ADDRESS_W] = WINED3D_TADDRESS_WRAP;
1899         states[i][WINED3D_SAMP_BORDER_COLOR] = 0;
1900         states[i][WINED3D_SAMP_MAG_FILTER] = WINED3D_TEXF_POINT;
1901         states[i][WINED3D_SAMP_MIN_FILTER] = WINED3D_TEXF_POINT;
1902         states[i][WINED3D_SAMP_MIP_FILTER] = WINED3D_TEXF_NONE;
1903         states[i][WINED3D_SAMP_MIPMAP_LOD_BIAS] = 0;
1904         states[i][WINED3D_SAMP_MAX_MIP_LEVEL] = 0;
1905         states[i][WINED3D_SAMP_MAX_ANISOTROPY] = 1;
1906         states[i][WINED3D_SAMP_SRGB_TEXTURE] = 0;
1907         /* TODO: Indicates which element of a multielement texture to use. */
1908         states[i][WINED3D_SAMP_ELEMENT_INDEX] = 0;
1909         /* TODO: Vertex offset in the presampled displacement map. */
1910         states[i][WINED3D_SAMP_DMAP_OFFSET] = 0;
1911     }
1912 }
1913
1914 static void state_init_default(struct wined3d_state *state, const struct wined3d_d3d_info *d3d_info)
1915 {
1916     struct wined3d_matrix identity;
1917     unsigned int i, j;
1918
1919     TRACE("state %p, d3d_info %p.\n", state, d3d_info);
1920
1921     get_identity_matrix(&identity);
1922     state->primitive_type = WINED3D_PT_UNDEFINED;
1923     state->patch_vertex_count = 0;
1924
1925     /* Set some of the defaults for lights, transforms etc */
1926     state->transforms[WINED3D_TS_PROJECTION] = identity;
1927     state->transforms[WINED3D_TS_VIEW] = identity;
1928     for (i = 0; i < 256; ++i)
1929     {
1930         state->transforms[WINED3D_TS_WORLD_MATRIX(i)] = identity;
1931     }
1932
1933     init_default_render_states(state->render_states, d3d_info);
1934
1935     /* Texture Stage States - Put directly into state block, we will call function below */
1936     for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
1937     {
1938         TRACE("Setting up default texture states for texture Stage %u.\n", i);
1939         state->transforms[WINED3D_TS_TEXTURE0 + i] = identity;
1940         init_default_texture_state(i, state->texture_states[i]);
1941     }
1942
1943     init_default_sampler_states(state->sampler_states);
1944
1945     state->blend_factor.r = 1.0f;
1946     state->blend_factor.g = 1.0f;
1947     state->blend_factor.b = 1.0f;
1948     state->blend_factor.a = 1.0f;
1949
1950     state->sample_mask = 0xffffffff;
1951
1952     for (i = 0; i < WINED3D_MAX_STREAMS; ++i)
1953         state->streams[i].frequency = 1;
1954
1955     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
1956     {
1957         for (j = 0; j < MAX_CONSTANT_BUFFERS; ++j)
1958             state->cb[i][j].size = WINED3D_MAX_CONSTANT_BUFFER_SIZE * 16;
1959     }
1960 }
1961
1962 static int lights_compare(const void *key, const struct rb_entry *entry)
1963 {
1964     const struct wined3d_light_info *light = RB_ENTRY_VALUE(entry, struct wined3d_light_info, entry);
1965     unsigned int original_index = (ULONG_PTR)key;
1966
1967     return wined3d_uint32_compare(light->OriginalIndex, original_index);
1968 }
1969
1970 void state_init(struct wined3d_state *state, const struct wined3d_d3d_info *d3d_info,
1971         uint32_t flags, enum wined3d_feature_level feature_level)
1972 {
1973     state->feature_level = feature_level;
1974     state->flags = flags;
1975
1976     rb_init(&state->light_state.lights_tree, lights_compare);
1977
1978     if (flags & WINED3D_STATE_INIT_DEFAULT)
1979         state_init_default(state, d3d_info);
1980 }
1981
1982 static bool wined3d_select_feature_level(const struct wined3d_adapter *adapter,
1983         const enum wined3d_feature_level *levels, unsigned int level_count,
1984         enum wined3d_feature_level *selected_level)
1985 {
1986     const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info;
1987     unsigned int i;
1988
1989     for (i = 0; i < level_count; ++i)
1990     {
1991         if (levels[i] && d3d_info->feature_level >= levels[i])
1992         {
1993             *selected_level = levels[i];
1994             return true;
1995         }
1996     }
1997
1998     FIXME_(winediag)("None of the requested D3D feature levels is supported on this GPU "
1999             "with the current shader backend.\n");
2000     return false;
2001 }
2002
2003 HRESULT CDECL wined3d_state_create(struct wined3d_device *device,
2004         const enum wined3d_feature_level *levels, unsigned int level_count, struct wined3d_state **state)
2005 {
2006     enum wined3d_feature_level feature_level;
2007     struct wined3d_state *object;
2008
2009     TRACE("device %p, levels %p, level_count %u, state %p.\n", device, levels, level_count, state);
2010
2011     if (!wined3d_select_feature_level(device->adapter, levels, level_count, &feature_level))
2012         return E_FAIL;
2013
2014     TRACE("Selected feature level %s.\n", wined3d_debug_feature_level(feature_level));
2015
2016     if (!(object = heap_alloc_zero(sizeof(*object))))
2017         return E_OUTOFMEMORY;
2018     state_init(object, &device->adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT, feature_level);
2019
2020     *state = object;
2021     return S_OK;
2022 }
2023
2024 enum wined3d_feature_level CDECL wined3d_state_get_feature_level(const struct wined3d_state *state)
2025 {
2026     TRACE("state %p.\n", state);
2027
2028     return state->feature_level;
2029 }
2030
2031 void CDECL wined3d_state_destroy(struct wined3d_state *state)
2032 {
2033     TRACE("state %p.\n", state);
2034
2035     state_cleanup(state);
2036     heap_free(state);
2037 }
2038
2039 static void stateblock_state_init_default(struct wined3d_stateblock_state *state,
2040         const struct wined3d_d3d_info *d3d_info)
2041 {
2042     struct wined3d_matrix identity;
2043     unsigned int i;
2044
2045     get_identity_matrix(&identity);
2046
2047     state->transforms[WINED3D_TS_PROJECTION] = identity;
2048     state->transforms[WINED3D_TS_VIEW] = identity;
2049     for (i = 0; i < 256; ++i)
2050     {
2051         state->transforms[WINED3D_TS_WORLD_MATRIX(i)] = identity;
2052     }
2053
2054     init_default_render_states(state->rs, d3d_info);
2055
2056     for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
2057     {
2058         state->transforms[WINED3D_TS_TEXTURE0 + i] = identity;
2059         init_default_texture_state(i, state->texture_states[i]);
2060     }
2061
2062     init_default_sampler_states(state->sampler_states);
2063
2064     for (i = 0; i < WINED3D_MAX_STREAMS; ++i)
2065         state->streams[i].frequency = 1;
2066 }
2067
2068 void wined3d_stateblock_state_init(struct wined3d_stateblock_state *state,
2069         const struct wined3d_device *device, uint32_t flags)
2070 {
2071     rb_init(&state->light_state->lights_tree, lights_compare);
2072
2073     if (flags & WINED3D_STATE_INIT_DEFAULT)
2074         stateblock_state_init_default(state, &device->adapter->d3d_info);
2075
2076 }
2077
2078 static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, const struct wined3d_stateblock *device_state,
2079         struct wined3d_device *device, enum wined3d_stateblock_type type)
2080 {
2081     const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
2082
2083     stateblock->ref = 1;
2084     stateblock->device = device;
2085     stateblock->stateblock_state.light_state = &stateblock->light_state;
2086     wined3d_stateblock_state_init(&stateblock->stateblock_state, device,
2087             type == WINED3D_SBT_PRIMARY ? WINED3D_STATE_INIT_DEFAULT : 0);
2088
2089     stateblock->changed.store_stream_offset = 1;
2090     list_init(&stateblock->changed.changed_lights);
2091
2092     if (type == WINED3D_SBT_RECORDED || type == WINED3D_SBT_PRIMARY)
2093         return WINED3D_OK;
2094
2095     TRACE("Updating changed flags appropriate for type %#x.\n", type);
2096
2097     switch (type)
2098     {
2099         case WINED3D_SBT_ALL:
2100             stateblock_init_lights(stateblock, &device_state->stateblock_state.light_state->lights_tree);
2101             stateblock_savedstates_set_all(&stateblock->changed,
2102                     d3d_info->limits.vs_uniform_count, d3d_info->limits.ps_uniform_count);
2103             break;
2104
2105         case WINED3D_SBT_PIXEL_STATE:
2106             stateblock_savedstates_set_pixel(&stateblock->changed,
2107                     d3d_info->limits.ps_uniform_count);
2108             break;
2109
2110         case WINED3D_SBT_VERTEX_STATE:
2111             stateblock_init_lights(stateblock, &device_state->stateblock_state.light_state->lights_tree);
2112             stateblock_savedstates_set_vertex(&stateblock->changed,
2113                     d3d_info->limits.vs_uniform_count);
2114             break;
2115
2116         default:
2117             FIXME("Unrecognized state block type %#x.\n", type);
2118             break;
2119     }
2120
2121     wined3d_stateblock_init_contained_states(stateblock);
2122     wined3d_stateblock_capture(stateblock, device_state);
2123
2124     /* According to the tests, stream offset is not updated in the captured state if
2125      * the state was captured on state block creation. This is not the case for
2126      * state blocks initialized with BeginStateBlock / EndStateBlock, multiple
2127      * captures get stream offsets updated. */
2128     stateblock->changed.store_stream_offset = 0;
2129
2130     return WINED3D_OK;
2131 }
2132
2133 HRESULT CDECL wined3d_stateblock_create(struct wined3d_device *device, const struct wined3d_stateblock *device_state,
2134         enum wined3d_stateblock_type type, struct wined3d_stateblock **stateblock)
2135 {
2136     struct wined3d_stateblock *object;
2137     HRESULT hr;
2138
2139     TRACE("device %p, device_state %p, type %#x, stateblock %p.\n",
2140             device, device_state, type, stateblock);
2141
2142     if (!(object = heap_alloc_zero(sizeof(*object))))
2143         return E_OUTOFMEMORY;
2144
2145     hr = stateblock_init(object, device_state, device, type);
2146     if (FAILED(hr))
2147     {
2148         WARN("Failed to initialize stateblock, hr %#lx.\n", hr);
2149         heap_free(object);
2150         return hr;
2151     }
2152
2153     TRACE("Created stateblock %p.\n", object);
2154     *stateblock = object;
2155
2156     return WINED3D_OK;
2157 }
2158
2159 void CDECL wined3d_stateblock_reset(struct wined3d_stateblock *stateblock)
2160 {
2161     TRACE("stateblock %p.\n", stateblock);
2162
2163     wined3d_stateblock_state_cleanup(&stateblock->stateblock_state);
2164     memset(&stateblock->stateblock_state, 0, sizeof(stateblock->stateblock_state));
2165     stateblock->stateblock_state.light_state = &stateblock->light_state;
2166     wined3d_stateblock_state_init(&stateblock->stateblock_state, stateblock->device, WINED3D_STATE_INIT_DEFAULT);
2167 }
2168
2169 static void wined3d_device_set_base_vertex_index(struct wined3d_device *device, int base_index)
2170 {
2171     TRACE("device %p, base_index %d.\n", device, base_index);
2172
2173     device->cs->c.state->base_vertex_index = base_index;
2174 }
2175
2176 static void wined3d_device_set_vs_consts_b(struct wined3d_device *device,
2177         unsigned int start_idx, unsigned int count, const BOOL *constants)
2178 {
2179     unsigned int i;
2180
2181     TRACE("device %p, start_idx %u, count %u, constants %p.\n", device, start_idx, count, constants);
2182
2183     if (TRACE_ON(d3d))
2184     {
2185         for (i = 0; i < count; ++i)
2186             TRACE("Set BOOL constant %u to %#x.\n", start_idx + i, constants[i]);
2187     }
2188
2189     wined3d_device_context_push_constants(&device->cs->c, WINED3D_PUSH_CONSTANTS_VS_B, start_idx, count, constants);
2190 }
2191
2192 static void wined3d_device_set_vs_consts_i(struct wined3d_device *device,
2193         unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
2194 {
2195     unsigned int i;
2196
2197     TRACE("device %p, start_idx %u, count %u, constants %p.\n", device, start_idx, count, constants);
2198
2199     if (TRACE_ON(d3d))
2200     {
2201         for (i = 0; i < count; ++i)
2202             TRACE("Set ivec4 constant %u to %s.\n", start_idx + i, debug_ivec4(&constants[i]));
2203     }
2204
2205     wined3d_device_context_push_constants(&device->cs->c, WINED3D_PUSH_CONSTANTS_VS_I, start_idx, count, constants);
2206 }
2207
2208 static void wined3d_device_set_vs_consts_f(struct wined3d_device *device,
2209         unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
2210 {
2211     unsigned int i;
2212
2213     TRACE("device %p, start_idx %u, count %u, constants %p.\n", device, start_idx, count, constants);
2214
2215     if (TRACE_ON(d3d))
2216     {
2217         for (i = 0; i < count; ++i)
2218             TRACE("Set vec4 constant %u to %s.\n", start_idx + i, debug_vec4(&constants[i]));
2219     }
2220
2221     wined3d_device_context_push_constants(&device->cs->c, WINED3D_PUSH_CONSTANTS_VS_F, start_idx, count, constants);
2222 }
2223
2224 static void wined3d_device_set_ps_consts_b(struct wined3d_device *device,
2225         unsigned int start_idx, unsigned int count, const BOOL *constants)
2226 {
2227     unsigned int i;
2228
2229     TRACE("device %p, start_idx %u, count %u, constants %p.\n", device, start_idx, count, constants);
2230
2231     if (TRACE_ON(d3d))
2232     {
2233         for (i = 0; i < count; ++i)
2234             TRACE("Set BOOL constant %u to %#x.\n", start_idx + i, constants[i]);
2235     }
2236
2237     wined3d_device_context_push_constants(&device->cs->c, WINED3D_PUSH_CONSTANTS_PS_B, start_idx, count, constants);
2238 }
2239
2240 static void wined3d_device_set_ps_consts_i(struct wined3d_device *device,
2241         unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
2242 {
2243     unsigned int i;
2244
2245     TRACE("device %p, start_idx %u, count %u, constants %p.\n", device, start_idx, count, constants);
2246
2247     if (TRACE_ON(d3d))
2248     {
2249         for (i = 0; i < count; ++i)
2250             TRACE("Set ivec4 constant %u to %s.\n", start_idx + i, debug_ivec4(&constants[i]));
2251     }
2252
2253     wined3d_device_context_push_constants(&device->cs->c, WINED3D_PUSH_CONSTANTS_PS_I, start_idx, count, constants);
2254 }
2255
2256 static void wined3d_device_set_ps_consts_f(struct wined3d_device *device,
2257         unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
2258 {
2259     unsigned int i;
2260
2261     TRACE("device %p, start_idx %u, count %u, constants %p.\n", device, start_idx, count, constants);
2262
2263     if (TRACE_ON(d3d))
2264     {
2265         for (i = 0; i < count; ++i)
2266             TRACE("Set vec4 constant %u to %s.\n", start_idx + i, debug_vec4(&constants[i]));
2267     }
2268
2269     wined3d_device_context_push_constants(&device->cs->c, WINED3D_PUSH_CONSTANTS_PS_F, start_idx, count, constants);
2270 }
2271
2272 /* Note lights are real special cases. Although the device caps state only
2273  * e.g. 8 are supported, you can reference any indexes you want as long as
2274  * that number max are enabled at any one point in time. Therefore since the
2275  * indices can be anything, we need a hashmap of them. However, this causes
2276  * stateblock problems. When capturing the state block, I duplicate the
2277  * hashmap, but when recording, just build a chain pretty much of commands to
2278  * be replayed. */
2279 static void wined3d_device_context_set_light(struct wined3d_device_context *context,
2280         unsigned int light_idx, const struct wined3d_light *light)
2281 {
2282     struct wined3d_light_info *object = NULL;
2283     float rho;
2284
2285     if (FAILED(wined3d_light_state_set_light(&context->state->light_state, light_idx, light, &object)))
2286         return;
2287
2288     /* Initialize the object. */
2289     TRACE("Light %u setting to type %#x, diffuse %s, specular %s, ambient %s, "
2290             "position {%.8e, %.8e, %.8e}, direction {%.8e, %.8e, %.8e}, "
2291             "range %.8e, falloff %.8e, theta %.8e, phi %.8e.\n",
2292             light_idx, light->type, debug_color(&light->diffuse),
2293             debug_color(&light->specular), debug_color(&light->ambient),
2294             light->position.x, light->position.y, light->position.z,
2295             light->direction.x, light->direction.y, light->direction.z,
2296             light->range, light->falloff, light->theta, light->phi);
2297
2298     switch (light->type)
2299     {
2300         case WINED3D_LIGHT_POINT:
2301             /* Position */
2302             object->position.x = light->position.x;
2303             object->position.y = light->position.y;
2304             object->position.z = light->position.z;
2305             object->position.w = 1.0f;
2306             object->cutoff = 180.0f;
2307             /* FIXME: Range */
2308             break;
2309
2310         case WINED3D_LIGHT_DIRECTIONAL:
2311             /* Direction */
2312             object->direction.x = -light->direction.x;
2313             object->direction.y = -light->direction.y;
2314             object->direction.z = -light->direction.z;
2315             object->direction.w = 0.0f;
2316             object->exponent = 0.0f;
2317             object->cutoff = 180.0f;
2318             break;
2319
2320         case WINED3D_LIGHT_SPOT:
2321             /* Position */
2322             object->position.x = light->position.x;
2323             object->position.y = light->position.y;
2324             object->position.z = light->position.z;
2325             object->position.w = 1.0f;
2326
2327             /* Direction */
2328             object->direction.x = light->direction.x;
2329             object->direction.y = light->direction.y;
2330             object->direction.z = light->direction.z;
2331             object->direction.w = 0.0f;
2332
2333             /* opengl-ish and d3d-ish spot lights use too different models
2334              * for the light "intensity" as a function of the angle towards
2335              * the main light direction, so we only can approximate very
2336              * roughly. However, spot lights are rather rarely used in games
2337              * (if ever used at all). Furthermore if still used, probably
2338              * nobody pays attention to such details. */
2339             if (!light->falloff)
2340             {
2341                 /* Falloff = 0 is easy, because d3d's and opengl's spot light
2342                  * equations have the falloff resp. exponent parameter as an
2343                  * exponent, so the spot light lighting will always be 1.0 for
2344                  * both of them, and we don't have to care for the rest of the
2345                  * rather complex calculation. */
2346                 object->exponent = 0.0f;
2347             }
2348             else
2349             {
2350                 rho = light->theta + (light->phi - light->theta) / (2 * light->falloff);
2351                 if (rho < 0.0001f)
2352                     rho = 0.0001f;
2353                 object->exponent = -0.3f / logf(cosf(rho / 2));
2354             }
2355
2356             if (object->exponent > 128.0f)
2357                 object->exponent = 128.0f;
2358
2359             object->cutoff = (float)(light->phi * 90 / M_PI);
2360             /* FIXME: Range */
2361             break;
2362
2363         case WINED3D_LIGHT_PARALLELPOINT:
2364             object->position.x = light->position.x;
2365             object->position.y = light->position.y;
2366             object->position.z = light->position.z;
2367             object->position.w = 1.0f;
2368             break;
2369
2370         default:
2371             FIXME("Unrecognized light type %#x.\n", light->type);
2372     }
2373
2374     wined3d_device_context_emit_set_light(context, object);
2375 }
2376
2377 static void wined3d_device_set_light_enable(struct wined3d_device *device, unsigned int light_idx, bool enable)
2378 {
2379     struct wined3d_light_state *light_state = &device->cs->c.state->light_state;
2380     struct wined3d_light_info *light_info;
2381
2382     TRACE("device %p, light_idx %u, enable %#x.\n", device, light_idx, enable);
2383
2384     /* Special case - enabling an undefined light creates one with a strict set of parameters. */
2385     if (!(light_info = wined3d_light_state_get_light(light_state, light_idx)))
2386     {
2387         TRACE("Light enabled requested but light not defined, so defining one!\n");
2388         wined3d_device_context_set_light(&device->cs->c, light_idx, &WINED3D_default_light);
2389
2390         if (!(light_info = wined3d_light_state_get_light(light_state, light_idx)))
2391         {
2392             ERR("Adding default lights has failed dismally.\n");
2393             return;
2394         }
2395     }
2396
2397     if (wined3d_light_state_enable_light(light_state, &device->adapter->d3d_info, light_info, enable))
2398         wined3d_device_context_emit_set_light_enable(&device->cs->c, light_idx, enable);
2399 }
2400
2401 static HRESULT wined3d_device_set_clip_plane(struct wined3d_device *device,
2402         unsigned int plane_idx, const struct wined3d_vec4 *plane)
2403 {
2404     struct wined3d_vec4 *clip_planes = device->cs->c.state->clip_planes;
2405
2406     TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
2407
2408     if (plane_idx >= device->adapter->d3d_info.limits.max_clip_distances)
2409     {
2410         TRACE("Application has requested clipplane this device doesn't support.\n");
2411         return WINED3DERR_INVALIDCALL;
2412     }
2413
2414     if (!memcmp(&clip_planes[plane_idx], plane, sizeof(*plane)))
2415     {
2416         TRACE("Application is setting old values over, nothing to do.\n");
2417         return WINED3D_OK;
2418     }
2419
2420     clip_planes[plane_idx] = *plane;
2421
2422     wined3d_device_context_emit_set_clip_plane(&device->cs->c, plane_idx, plane);
2423
2424     return WINED3D_OK;
2425 }
2426
2427 static void resolve_depth_buffer(struct wined3d_device *device)
2428 {
2429     const struct wined3d_state *state = device->cs->c.state;
2430     struct wined3d_rendertarget_view *src_view;
2431     struct wined3d_resource *dst_resource;
2432     struct wined3d_texture *dst_texture;
2433
2434     if (!(dst_texture = state->textures[0]))
2435         return;
2436     dst_resource = &dst_texture->resource;
2437     if (!dst_resource->format->depth_size)
2438         return;
2439     if (!(src_view = state->fb.depth_stencil))
2440         return;
2441
2442     wined3d_device_context_resolve_sub_resource(&device->cs->c, dst_resource, 0,
2443             src_view->resource, src_view->sub_resource_idx, dst_resource->format->id);
2444 }
2445
2446 static void wined3d_device_set_render_state(struct wined3d_device *device,
2447         enum wined3d_render_state state, unsigned int value)
2448 {
2449     if (state > WINEHIGHEST_RENDER_STATE)
2450     {
2451         WARN("Unhandled render state %#x.\n", state);
2452         return;
2453     }
2454
2455     if (value == device->cs->c.state->render_states[state])
2456     {
2457         TRACE("Application is setting the old value over, nothing to do.\n");
2458     }
2459     else
2460     {
2461         device->cs->c.state->render_states[state] = value;
2462         wined3d_device_context_emit_set_render_state(&device->cs->c, state, value);
2463     }
2464
2465     if (state == WINED3D_RS_POINTSIZE && value == WINED3D_RESZ_CODE)
2466     {
2467         TRACE("RESZ multisampled depth buffer resolve triggered.\n");
2468         resolve_depth_buffer(device);
2469     }
2470 }
2471
2472 static void wined3d_device_set_texture_stage_state(struct wined3d_device *device,
2473         unsigned int stage, enum wined3d_texture_stage_state state, uint32_t value)
2474 {
2475     const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
2476
2477     TRACE("device %p, stage %u, state %s, value %#x.\n",
2478             device, stage, debug_d3dtexturestate(state), value);
2479
2480     if (stage >= d3d_info->limits.ffp_blend_stages)
2481     {
2482         WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring.\n",
2483                 stage, d3d_info->limits.ffp_blend_stages - 1);
2484         return;
2485     }
2486
2487     if (value == device->cs->c.state->texture_states[stage][state])
2488     {
2489         TRACE("Application is setting the old value over, nothing to do.\n");
2490         return;
2491     }
2492
2493     device->cs->c.state->texture_states[stage][state] = value;
2494
2495     wined3d_device_context_emit_set_texture_state(&device->cs->c, stage, state, value);
2496 }
2497
2498 static void wined3d_device_set_sampler_state(struct wined3d_device *device,
2499         unsigned int sampler_idx, enum wined3d_sampler_state state, unsigned int value)
2500 {
2501     TRACE("device %p, sampler_idx %u, state %s, value %#x.\n",
2502             device, sampler_idx, debug_d3dsamplerstate(state), value);
2503
2504     if (value == device->cs->c.state->sampler_states[sampler_idx][state])
2505     {
2506         TRACE("Application is setting the old value over, nothing to do.\n");
2507         return;
2508     }
2509
2510     device->cs->c.state->sampler_states[sampler_idx][state] = value;
2511     wined3d_device_context_emit_set_sampler_state(&device->cs->c, sampler_idx, state, value);
2512 }
2513
2514 static void wined3d_device_set_texture(struct wined3d_device *device,
2515         unsigned int stage, struct wined3d_texture *texture)
2516 {
2517     struct wined3d_state *state = device->cs->c.state;
2518     struct wined3d_texture *prev;
2519
2520     TRACE("device %p, stage %u, texture %p.\n", device, stage, texture);
2521
2522     if (stage >= ARRAY_SIZE(state->textures))
2523     {
2524         WARN("Ignoring invalid stage %u.\n", stage);
2525         return;
2526     }
2527
2528     prev = state->textures[stage];
2529     TRACE("Previous texture %p.\n", prev);
2530
2531     if (texture == prev)
2532     {
2533         TRACE("App is setting the same texture again, nothing to do.\n");
2534         return;
2535     }
2536
2537     TRACE("Setting new texture to %p.\n", texture);
2538     state->textures[stage] = texture;
2539
2540     if (texture)
2541         wined3d_texture_incref(texture);
2542     wined3d_device_context_emit_set_texture(&device->cs->c, stage, texture);
2543     if (prev)
2544         wined3d_texture_decref(prev);
2545
2546     return;
2547 }
2548
2549 static void wined3d_device_set_material(struct wined3d_device *device, const struct wined3d_material *material)
2550 {
2551     TRACE("device %p, material %p.\n", device, material);
2552
2553     device->cs->c.state->material = *material;
2554     wined3d_device_context_emit_set_material(&device->cs->c, material);
2555 }
2556
2557 static void wined3d_device_set_transform(struct wined3d_device *device,
2558         enum wined3d_transform_state state, const struct wined3d_matrix *matrix)
2559 {
2560     TRACE("device %p, state %s, matrix %p.\n", device, debug_d3dtstype(state), matrix);
2561     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_11, matrix->_12, matrix->_13, matrix->_14);
2562     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_21, matrix->_22, matrix->_23, matrix->_24);
2563     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_31, matrix->_32, matrix->_33, matrix->_34);
2564     TRACE("%.8e %.8e %.8e %.8e\n", matrix->_41, matrix->_42, matrix->_43, matrix->_44);
2565
2566     /* If the new matrix is the same as the current one,
2567      * we cut off any further processing. this seems to be a reasonable
2568      * optimization because as was noticed, some apps (warcraft3 for example)
2569      * tend towards setting the same matrix repeatedly for some reason.
2570      *
2571      * From here on we assume that the new matrix is different, wherever it matters. */
2572     if (!memcmp(&device->cs->c.state->transforms[state], matrix, sizeof(*matrix)))
2573     {
2574         TRACE("The application is setting the same matrix over again.\n");
2575         return;
2576     }
2577
2578     device->cs->c.state->transforms[state] = *matrix;
2579     wined3d_device_context_emit_set_transform(&device->cs->c, state, matrix);
2580 }
2581
2582 void CDECL wined3d_device_apply_stateblock(struct wined3d_device *device,
2583         struct wined3d_stateblock *stateblock)
2584 {
2585     bool set_blend_state = false, set_depth_stencil_state = false, set_rasterizer_state = false;
2586     const struct wined3d_stateblock_state *state = &stateblock->stateblock_state;
2587     const struct wined3d_saved_states *changed = &stateblock->changed;
2588     const unsigned int word_bit_count = sizeof(DWORD) * CHAR_BIT;
2589     struct wined3d_device_context *context = &device->cs->c;
2590     unsigned int i, j, start, idx;
2591     bool set_depth_bounds = false;
2592     struct wined3d_range range;
2593     uint32_t map;
2594
2595     TRACE("device %p, stateblock %p.\n", device, stateblock);
2596
2597     if (changed->vertexShader)
2598         wined3d_device_context_set_shader(context, WINED3D_SHADER_TYPE_VERTEX, state->vs);
2599     if (changed->pixelShader)
2600         wined3d_device_context_set_shader(context, WINED3D_SHADER_TYPE_PIXEL, state->ps);
2601
2602     for (start = 0; ; start = range.offset + range.size)
2603     {
2604         if (!wined3d_bitmap_get_range(changed->vs_consts_f, WINED3D_MAX_VS_CONSTS_F, start, &range))
2605             break;
2606
2607         wined3d_device_set_vs_consts_f(device, range.offset, range.size, &state->vs_consts_f[range.offset]);
2608     }
2609
2610     map = changed->vertexShaderConstantsI;
2611     for (start = 0; ; start = range.offset + range.size)
2612     {
2613         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_I, start, &range))
2614             break;
2615
2616         wined3d_device_set_vs_consts_i(device, range.offset, range.size, &state->vs_consts_i[range.offset]);
2617     }
2618
2619     map = changed->vertexShaderConstantsB;
2620     for (start = 0; ; start = range.offset + range.size)
2621     {
2622         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_B, start, &range))
2623             break;
2624
2625         wined3d_device_set_vs_consts_b(device, range.offset, range.size, &state->vs_consts_b[range.offset]);
2626     }
2627
2628     for (start = 0; ; start = range.offset + range.size)
2629     {
2630         if (!wined3d_bitmap_get_range(changed->ps_consts_f, WINED3D_MAX_PS_CONSTS_F, start, &range))
2631             break;
2632
2633         wined3d_device_set_ps_consts_f(device, range.offset, range.size, &state->ps_consts_f[range.offset]);
2634     }
2635
2636     map = changed->pixelShaderConstantsI;
2637     for (start = 0; ; start = range.offset + range.size)
2638     {
2639         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_I, start, &range))
2640             break;
2641
2642         wined3d_device_set_ps_consts_i(device, range.offset, range.size, &state->ps_consts_i[range.offset]);
2643     }
2644
2645     map = changed->pixelShaderConstantsB;
2646     for (start = 0; ; start = range.offset + range.size)
2647     {
2648         if (!wined3d_bitmap_get_range(&map, WINED3D_MAX_CONSTS_B, start, &range))
2649             break;
2650
2651         wined3d_device_set_ps_consts_b(device, range.offset, range.size, &state->ps_consts_b[range.offset]);
2652     }
2653
2654     if (changed->lights)
2655     {
2656         struct wined3d_light_info *light, *cursor;
2657
2658         LIST_FOR_EACH_ENTRY_SAFE(light, cursor, &changed->changed_lights, struct wined3d_light_info, changed_entry)
2659         {
2660             wined3d_device_context_set_light(context, light->OriginalIndex, &light->OriginalParms);
2661             wined3d_device_set_light_enable(device, light->OriginalIndex, light->glIndex != -1);
2662             list_remove(&light->changed_entry);
2663             light->changed = false;
2664         }
2665     }
2666
2667     for (i = 0; i < ARRAY_SIZE(changed->renderState); ++i)
2668     {
2669         map = changed->renderState[i];
2670         while (map)
2671         {
2672             j = wined3d_bit_scan(&map);
2673             idx = i * word_bit_count + j;
2674
2675             switch (idx)
2676             {
2677                 case WINED3D_RS_BLENDFACTOR:
2678                 case WINED3D_RS_MULTISAMPLEMASK:
2679                 case WINED3D_RS_ALPHABLENDENABLE:
2680                 case WINED3D_RS_SRCBLEND:
2681                 case WINED3D_RS_DESTBLEND:
2682                 case WINED3D_RS_BLENDOP:
2683                 case WINED3D_RS_SEPARATEALPHABLENDENABLE:
2684                 case WINED3D_RS_SRCBLENDALPHA:
2685                 case WINED3D_RS_DESTBLENDALPHA:
2686                 case WINED3D_RS_BLENDOPALPHA:
2687                 case WINED3D_RS_COLORWRITEENABLE:
2688                 case WINED3D_RS_COLORWRITEENABLE1:
2689                 case WINED3D_RS_COLORWRITEENABLE2:
2690                 case WINED3D_RS_COLORWRITEENABLE3:
2691                     set_blend_state = true;
2692                     break;
2693
2694                 case WINED3D_RS_BACK_STENCILFAIL:
2695                 case WINED3D_RS_BACK_STENCILFUNC:
2696                 case WINED3D_RS_BACK_STENCILPASS:
2697                 case WINED3D_RS_BACK_STENCILZFAIL:
2698                 case WINED3D_RS_STENCILENABLE:
2699                 case WINED3D_RS_STENCILFAIL:
2700                 case WINED3D_RS_STENCILFUNC:
2701                 case WINED3D_RS_STENCILREF:
2702                 case WINED3D_RS_STENCILMASK:
2703                 case WINED3D_RS_STENCILPASS:
2704                 case WINED3D_RS_STENCILWRITEMASK:
2705                 case WINED3D_RS_STENCILZFAIL:
2706                 case WINED3D_RS_TWOSIDEDSTENCILMODE:
2707                 case WINED3D_RS_ZENABLE:
2708                 case WINED3D_RS_ZFUNC:
2709                 case WINED3D_RS_ZWRITEENABLE:
2710                     set_depth_stencil_state = true;
2711                     break;
2712
2713                 case WINED3D_RS_FILLMODE:
2714                 case WINED3D_RS_CULLMODE:
2715                 case WINED3D_RS_SLOPESCALEDEPTHBIAS:
2716                 case WINED3D_RS_DEPTHBIAS:
2717                 case WINED3D_RS_SCISSORTESTENABLE:
2718                 case WINED3D_RS_ANTIALIASEDLINEENABLE:
2719                     set_rasterizer_state = true;
2720                     break;
2721
2722                 case WINED3D_RS_ADAPTIVETESS_X:
2723                 case WINED3D_RS_ADAPTIVETESS_Z:
2724                 case WINED3D_RS_ADAPTIVETESS_W:
2725                     set_depth_bounds = true;
2726                     break;
2727
2728                 case WINED3D_RS_ADAPTIVETESS_Y:
2729                     break;
2730
2731                 case WINED3D_RS_ANTIALIAS:
2732                     if (state->rs[WINED3D_RS_ANTIALIAS])
2733                         FIXME("Antialias not supported yet.\n");
2734                     break;
2735
2736                 case WINED3D_RS_TEXTUREPERSPECTIVE:
2737                     break;
2738
2739                 case WINED3D_RS_WRAPU:
2740                     if (state->rs[WINED3D_RS_WRAPU])
2741                         FIXME("Render state WINED3D_RS_WRAPU not implemented yet.\n");
2742                     break;
2743
2744                 case WINED3D_RS_WRAPV:
2745                     if (state->rs[WINED3D_RS_WRAPV])
2746                         FIXME("Render state WINED3D_RS_WRAPV not implemented yet.\n");
2747                     break;
2748
2749                 case WINED3D_RS_MONOENABLE:
2750                     if (state->rs[WINED3D_RS_MONOENABLE])
2751                         FIXME("Render state WINED3D_RS_MONOENABLE not implemented yet.\n");
2752                     break;
2753
2754                 case WINED3D_RS_ROP2:
2755                     if (state->rs[WINED3D_RS_ROP2])
2756                         FIXME("Render state WINED3D_RS_ROP2 not implemented yet.\n");
2757                     break;
2758
2759                 case WINED3D_RS_PLANEMASK:
2760                     if (state->rs[WINED3D_RS_PLANEMASK])
2761                         FIXME("Render state WINED3D_RS_PLANEMASK not implemented yet.\n");
2762                     break;
2763
2764                 case WINED3D_RS_LASTPIXEL:
2765                     if (!state->rs[WINED3D_RS_LASTPIXEL])
2766                     {
2767                         static bool warned;
2768                         if (!warned)
2769                         {
2770                             FIXME("Last Pixel Drawing Disabled, not handled yet.\n");
2771                             warned = true;
2772                         }
2773                     }
2774                     break;
2775
2776                 case WINED3D_RS_ZVISIBLE:
2777                     if (state->rs[WINED3D_RS_ZVISIBLE])
2778                         FIXME("WINED3D_RS_ZVISIBLE not implemented.\n");
2779                     break;
2780
2781                 case WINED3D_RS_SUBPIXEL:
2782                     if (state->rs[WINED3D_RS_SUBPIXEL])
2783                         FIXME("Render state WINED3D_RS_SUBPIXEL not implemented yet.\n");
2784                     break;
2785
2786                 case WINED3D_RS_SUBPIXELX:
2787                     if (state->rs[WINED3D_RS_SUBPIXELX])
2788                         FIXME("Render state WINED3D_RS_SUBPIXELX not implemented yet.\n");
2789                     break;
2790
2791                 case WINED3D_RS_STIPPLEDALPHA:
2792                     if (state->rs[WINED3D_RS_STIPPLEDALPHA])
2793                         FIXME("Stippled Alpha not supported yet.\n");
2794                     break;
2795
2796                 case WINED3D_RS_STIPPLEENABLE:
2797                     if (state->rs[WINED3D_RS_STIPPLEENABLE])
2798                         FIXME("Render state WINED3D_RS_STIPPLEENABLE not implemented yet.\n");
2799                     break;
2800
2801                 case WINED3D_RS_MIPMAPLODBIAS:
2802                     if (state->rs[WINED3D_RS_MIPMAPLODBIAS])
2803                         FIXME("Render state WINED3D_RS_MIPMAPLODBIAS not implemented yet.\n");
2804                     break;
2805
2806                 case WINED3D_RS_ANISOTROPY:
2807                     if (state->rs[WINED3D_RS_ANISOTROPY])
2808                         FIXME("Render state WINED3D_RS_ANISOTROPY not implemented yet.\n");
2809                     break;
2810
2811                 case WINED3D_RS_FLUSHBATCH:
2812                     if (state->rs[WINED3D_RS_FLUSHBATCH])
2813                         FIXME("Render state WINED3D_RS_FLUSHBATCH not implemented yet.\n");
2814                     break;
2815
2816                 case WINED3D_RS_TRANSLUCENTSORTINDEPENDENT:
2817                     if (state->rs[WINED3D_RS_TRANSLUCENTSORTINDEPENDENT])
2818                         FIXME("Render state WINED3D_RS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
2819                     break;
2820
2821                 case WINED3D_RS_WRAP0:
2822                 case WINED3D_RS_WRAP1:
2823                 case WINED3D_RS_WRAP2:
2824                 case WINED3D_RS_WRAP3:
2825                 case WINED3D_RS_WRAP4:
2826                 case WINED3D_RS_WRAP5:
2827                 case WINED3D_RS_WRAP6:
2828                 case WINED3D_RS_WRAP7:
2829                 case WINED3D_RS_WRAP8:
2830                 case WINED3D_RS_WRAP9:
2831                 case WINED3D_RS_WRAP10:
2832                 case WINED3D_RS_WRAP11:
2833                 case WINED3D_RS_WRAP12:
2834                 case WINED3D_RS_WRAP13:
2835                 case WINED3D_RS_WRAP14:
2836                 case WINED3D_RS_WRAP15:
2837                 {
2838                     static unsigned int once;
2839
2840                     if ((state->rs[idx]) && !once++)
2841                         FIXME("(WINED3D_RS_WRAP0) Texture wrapping not yet supported.\n");
2842                     break;
2843                 }
2844
2845                 case WINED3D_RS_EXTENTS:
2846                     if (state->rs[WINED3D_RS_EXTENTS])
2847                         FIXME("Render state WINED3D_RS_EXTENTS not implemented yet.\n");
2848                     break;
2849
2850                 case WINED3D_RS_COLORKEYBLENDENABLE:
2851                     if (state->rs[WINED3D_RS_COLORKEYBLENDENABLE])
2852                         FIXME("Render state WINED3D_RS_COLORKEYBLENDENABLE not implemented yet.\n");
2853                     break;
2854
2855                 case WINED3D_RS_SOFTWAREVERTEXPROCESSING:
2856                 {
2857                     static unsigned int once;
2858
2859                     if ((state->rs[WINED3D_RS_SOFTWAREVERTEXPROCESSING]) && !once++)
2860                         FIXME("Software vertex processing not implemented.\n");
2861                     break;
2862                 }
2863
2864                 case WINED3D_RS_PATCHEDGESTYLE:
2865                     if (state->rs[WINED3D_RS_PATCHEDGESTYLE] != WINED3D_PATCH_EDGE_DISCRETE)
2866                         FIXME("WINED3D_RS_PATCHEDGESTYLE %#x not yet implemented.\n",
2867                                 state->rs[WINED3D_RS_PATCHEDGESTYLE]);
2868                     break;
2869
2870                 case WINED3D_RS_PATCHSEGMENTS:
2871                 {
2872                     union
2873                     {
2874                         uint32_t d;
2875                         float f;
2876                     } tmpvalue;
2877                     tmpvalue.f = 1.0f;
2878
2879                     if (state->rs[WINED3D_RS_PATCHSEGMENTS] != tmpvalue.d)
2880                     {
2881                         static bool displayed = false;
2882
2883                         tmpvalue.d = state->rs[WINED3D_RS_PATCHSEGMENTS];
2884                         if(!displayed)
2885                             FIXME("(WINED3D_RS_PATCHSEGMENTS,%f) not yet implemented.\n", tmpvalue.f);
2886
2887                         displayed = true;
2888                     }
2889                     break;
2890                 }
2891
2892                 case WINED3D_RS_DEBUGMONITORTOKEN:
2893                     WARN("token: %#x.\n", state->rs[WINED3D_RS_DEBUGMONITORTOKEN]);
2894                     break;
2895
2896                 case WINED3D_RS_INDEXEDVERTEXBLENDENABLE:
2897                     break;
2898
2899                 case WINED3D_RS_TWEENFACTOR:
2900                     break;
2901
2902                 case WINED3D_RS_POSITIONDEGREE:
2903                     if (state->rs[WINED3D_RS_POSITIONDEGREE] != WINED3D_DEGREE_CUBIC)
2904                         FIXME("WINED3D_RS_POSITIONDEGREE %#x not yet implemented.\n",
2905                                 state->rs[WINED3D_RS_POSITIONDEGREE]);
2906                     break;
2907
2908                 case WINED3D_RS_NORMALDEGREE:
2909                     if (state->rs[WINED3D_RS_NORMALDEGREE] != WINED3D_DEGREE_LINEAR)
2910                         FIXME("WINED3D_RS_NORMALDEGREE %#x not yet implemented.\n",
2911                                 state->rs[WINED3D_RS_NORMALDEGREE]);
2912                     break;
2913
2914                 case WINED3D_RS_MINTESSELLATIONLEVEL:
2915                     break;
2916
2917                 case WINED3D_RS_MAXTESSELLATIONLEVEL:
2918                     break;
2919
2920                 case WINED3D_RS_ENABLEADAPTIVETESSELLATION:
2921                     if (state->rs[WINED3D_RS_ENABLEADAPTIVETESSELLATION])
2922                         FIXME("WINED3D_RS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
2923                                 state->rs[WINED3D_RS_ENABLEADAPTIVETESSELLATION]);
2924                     break;
2925
2926                 default:
2927                     wined3d_device_set_render_state(device, idx, state->rs[idx]);
2928                     break;
2929             }
2930         }
2931     }
2932
2933     if (set_rasterizer_state)
2934     {
2935         struct wined3d_rasterizer_state *rasterizer_state;
2936         struct wined3d_rasterizer_state_desc desc;
2937         struct wine_rb_entry *entry;
2938         union
2939         {
2940             DWORD d;
2941             float f;
2942         } bias;
2943
2944         memset(&desc, 0, sizeof(desc));
2945         desc.fill_mode = state->rs[WINED3D_RS_FILLMODE];
2946         desc.cull_mode = state->rs[WINED3D_RS_CULLMODE];
2947         bias.d = state->rs[WINED3D_RS_DEPTHBIAS];
2948         desc.depth_bias = bias.f;
2949         bias.d = state->rs[WINED3D_RS_SLOPESCALEDEPTHBIAS];
2950         desc.scale_bias = bias.f;
2951         desc.depth_clip = TRUE;
2952         desc.scissor = state->rs[WINED3D_RS_SCISSORTESTENABLE];
2953         desc.line_antialias = state->rs[WINED3D_RS_ANTIALIASEDLINEENABLE];
2954
2955         if ((entry = wine_rb_get(&device->rasterizer_states, &desc)))
2956         {
2957             rasterizer_state = WINE_RB_ENTRY_VALUE(entry, struct wined3d_rasterizer_state, entry);
2958             wined3d_device_context_set_rasterizer_state(context, rasterizer_state);
2959         }
2960         else if (SUCCEEDED(wined3d_rasterizer_state_create(device, &desc, NULL,
2961                 &wined3d_null_parent_ops, &rasterizer_state)))
2962         {
2963             wined3d_device_context_set_rasterizer_state(context, rasterizer_state);
2964             if (wine_rb_put(&device->rasterizer_states, &desc, &rasterizer_state->entry) == -1)
2965             {
2966                 ERR("Failed to insert rasterizer state.\n");
2967                 wined3d_rasterizer_state_decref(rasterizer_state);
2968             }
2969         }
2970     }
2971
2972     if (set_blend_state || changed->alpha_to_coverage
2973             || wined3d_bitmap_is_set(changed->renderState, WINED3D_RS_ADAPTIVETESS_Y))
2974     {
2975         struct wined3d_blend_state *blend_state;
2976         struct wined3d_blend_state_desc desc;
2977         struct wine_rb_entry *entry;
2978         struct wined3d_color colour;
2979         unsigned int sample_mask;
2980
2981         memset(&desc, 0, sizeof(desc));
2982         desc.alpha_to_coverage = state->alpha_to_coverage;
2983         desc.independent = FALSE;
2984         if (state->rs[WINED3D_RS_ADAPTIVETESS_Y] == WINED3DFMT_ATOC)
2985             desc.alpha_to_coverage = TRUE;
2986         desc.rt[0].enable = state->rs[WINED3D_RS_ALPHABLENDENABLE];
2987         desc.rt[0].src = state->rs[WINED3D_RS_SRCBLEND];
2988         desc.rt[0].dst = state->rs[WINED3D_RS_DESTBLEND];
2989         desc.rt[0].op = state->rs[WINED3D_RS_BLENDOP];
2990         if (state->rs[WINED3D_RS_SEPARATEALPHABLENDENABLE])
2991         {
2992             desc.rt[0].src_alpha = state->rs[WINED3D_RS_SRCBLENDALPHA];
2993             desc.rt[0].dst_alpha = state->rs[WINED3D_RS_DESTBLENDALPHA];
2994             desc.rt[0].op_alpha = state->rs[WINED3D_RS_BLENDOPALPHA];
2995         }
2996         else
2997         {
2998             desc.rt[0].src_alpha = state->rs[WINED3D_RS_SRCBLEND];
2999             desc.rt[0].dst_alpha = state->rs[WINED3D_RS_DESTBLEND];
3000             desc.rt[0].op_alpha = state->rs[WINED3D_RS_BLENDOP];
3001         }
3002         desc.rt[0].writemask = state->rs[WINED3D_RS_COLORWRITEENABLE];
3003         desc.rt[1].writemask = state->rs[WINED3D_RS_COLORWRITEENABLE1];
3004         desc.rt[2].writemask = state->rs[WINED3D_RS_COLORWRITEENABLE2];
3005         desc.rt[3].writemask = state->rs[WINED3D_RS_COLORWRITEENABLE3];
3006         if (desc.rt[1].writemask != desc.rt[0].writemask
3007                 || desc.rt[2].writemask != desc.rt[0].writemask
3008                 || desc.rt[3].writemask != desc.rt[0].writemask)
3009         {
3010             desc.independent = TRUE;
3011             for (i = 1; i < 4; ++i)
3012             {
3013                 desc.rt[i].enable = desc.rt[0].enable;
3014                 desc.rt[i].src = desc.rt[0].src;
3015                 desc.rt[i].dst = desc.rt[0].dst;
3016                 desc.rt[i].op = desc.rt[0].op;
3017                 desc.rt[i].src_alpha = desc.rt[0].src_alpha;
3018                 desc.rt[i].dst_alpha = desc.rt[0].dst_alpha;
3019                 desc.rt[i].op_alpha = desc.rt[0].op_alpha;
3020             }
3021         }
3022
3023         if (wined3d_bitmap_is_set(changed->renderState, WINED3D_RS_BLENDFACTOR))
3024             wined3d_color_from_d3dcolor(&colour, state->rs[WINED3D_RS_BLENDFACTOR]);
3025         else
3026             wined3d_device_context_get_blend_state(context, &colour, &sample_mask);
3027
3028         if ((entry = wine_rb_get(&device->blend_states, &desc)))
3029         {
3030             blend_state = WINE_RB_ENTRY_VALUE(entry, struct wined3d_blend_state, entry);
3031             wined3d_device_context_set_blend_state(context, blend_state, &colour,
3032                     state->rs[WINED3D_RS_MULTISAMPLEMASK]);
3033         }
3034         else if (SUCCEEDED(wined3d_blend_state_create(device, &desc, NULL,
3035                 &wined3d_null_parent_ops, &blend_state)))
3036         {
3037             wined3d_device_context_set_blend_state(context, blend_state, &colour,
3038                     state->rs[WINED3D_RS_MULTISAMPLEMASK]);
3039             if (wine_rb_put(&device->blend_states, &desc, &blend_state->entry) == -1)
3040             {
3041                 ERR("Failed to insert blend state.\n");
3042                 wined3d_blend_state_decref(blend_state);
3043             }
3044         }
3045     }
3046
3047     if (set_depth_stencil_state)
3048     {
3049         struct wined3d_depth_stencil_state *depth_stencil_state;
3050         struct wined3d_depth_stencil_state_desc desc;
3051         struct wine_rb_entry *entry;
3052         unsigned int stencil_ref;
3053
3054         memset(&desc, 0, sizeof(desc));
3055         switch (state->rs[WINED3D_RS_ZENABLE])
3056         {
3057             case WINED3D_ZB_FALSE:
3058                 desc.depth = FALSE;
3059                 break;
3060
3061             case WINED3D_ZB_USEW:
3062                 FIXME("W buffer is not well handled.\n");
3063             case WINED3D_ZB_TRUE:
3064                 desc.depth = TRUE;
3065                 break;
3066
3067             default:
3068                 FIXME("Unrecognized depth buffer type %#x.\n", state->rs[WINED3D_RS_ZENABLE]);
3069         }
3070         desc.depth_write = state->rs[WINED3D_RS_ZWRITEENABLE];
3071         desc.depth_func = state->rs[WINED3D_RS_ZFUNC];
3072         desc.stencil = state->rs[WINED3D_RS_STENCILENABLE];
3073         desc.stencil_read_mask = state->rs[WINED3D_RS_STENCILMASK];
3074         desc.stencil_write_mask = state->rs[WINED3D_RS_STENCILWRITEMASK];
3075         desc.front.fail_op = state->rs[WINED3D_RS_STENCILFAIL];
3076         desc.front.depth_fail_op = state->rs[WINED3D_RS_STENCILZFAIL];
3077         desc.front.pass_op = state->rs[WINED3D_RS_STENCILPASS];
3078         desc.front.func = state->rs[WINED3D_RS_STENCILFUNC];
3079
3080         if (state->rs[WINED3D_RS_TWOSIDEDSTENCILMODE])
3081         {
3082             desc.back.fail_op = state->rs[WINED3D_RS_BACK_STENCILFAIL];
3083             desc.back.depth_fail_op = state->rs[WINED3D_RS_BACK_STENCILZFAIL];
3084             desc.back.pass_op = state->rs[WINED3D_RS_BACK_STENCILPASS];
3085             desc.back.func = state->rs[WINED3D_RS_BACK_STENCILFUNC];
3086         }
3087         else
3088         {
3089             desc.back = desc.front;
3090         }
3091
3092         if (wined3d_bitmap_is_set(changed->renderState, WINED3D_RS_STENCILREF))
3093             stencil_ref = state->rs[WINED3D_RS_STENCILREF];
3094         else
3095             wined3d_device_context_get_depth_stencil_state(context, &stencil_ref);
3096
3097         if ((entry = wine_rb_get(&device->depth_stencil_states, &desc)))
3098         {
3099             depth_stencil_state = WINE_RB_ENTRY_VALUE(entry, struct wined3d_depth_stencil_state, entry);
3100             wined3d_device_context_set_depth_stencil_state(context, depth_stencil_state, stencil_ref);
3101         }
3102         else if (SUCCEEDED(wined3d_depth_stencil_state_create(device, &desc, NULL,
3103                 &wined3d_null_parent_ops, &depth_stencil_state)))
3104         {
3105             wined3d_device_context_set_depth_stencil_state(context, depth_stencil_state, stencil_ref);
3106             if (wine_rb_put(&device->depth_stencil_states, &desc, &depth_stencil_state->entry) == -1)
3107             {
3108                 ERR("Failed to insert depth/stencil state.\n");
3109                 wined3d_depth_stencil_state_decref(depth_stencil_state);
3110             }
3111         }
3112     }
3113
3114     if (set_depth_bounds)
3115     {
3116         wined3d_device_context_set_depth_bounds(context,
3117                 state->rs[WINED3D_RS_ADAPTIVETESS_X] == WINED3DFMT_NVDB,
3118                 int_to_float(state->rs[WINED3D_RS_ADAPTIVETESS_Z]),
3119                 int_to_float(state->rs[WINED3D_RS_ADAPTIVETESS_W]));
3120     }
3121
3122     for (i = 0; i < ARRAY_SIZE(changed->textureState); ++i)
3123     {
3124         map = changed->textureState[i];
3125         while (map)
3126         {
3127             j = wined3d_bit_scan(&map);
3128             wined3d_device_set_texture_stage_state(device, i, j, state->texture_states[i][j]);
3129         }
3130     }
3131
3132     for (i = 0; i < ARRAY_SIZE(changed->samplerState); ++i)
3133     {
3134         map = changed->samplerState[i];
3135         while (map)
3136         {
3137             j = wined3d_bit_scan(&map);
3138             wined3d_device_set_sampler_state(device, i, j, state->sampler_states[i][j]);
3139         }
3140     }
3141
3142     if (changed->transforms)
3143     {
3144         for (i = 0; i < ARRAY_SIZE(changed->transform); ++i)
3145         {
3146             map = changed->transform[i];
3147             while (map)
3148             {
3149                 j = wined3d_bit_scan(&map);
3150                 idx = i * word_bit_count + j;
3151                 wined3d_device_set_transform(device, idx, &state->transforms[idx]);
3152             }
3153         }
3154     }
3155
3156     if (changed->indices)
3157         wined3d_device_context_set_index_buffer(context, state->index_buffer, state->index_format, 0);
3158     wined3d_device_set_base_vertex_index(device, state->base_vertex_index);
3159     if (changed->vertexDecl)
3160         wined3d_device_context_set_vertex_declaration(context, state->vertex_declaration);
3161     if (changed->material)
3162         wined3d_device_set_material(device, &state->material);
3163     if (changed->viewport)
3164         wined3d_device_context_set_viewports(context, 1, &state->viewport);
3165     if (changed->scissorRect)
3166         wined3d_device_context_set_scissor_rects(context, 1, &state->scissor_rect);
3167
3168     map = changed->streamSource | changed->streamFreq;
3169     while (map)
3170     {
3171         i = wined3d_bit_scan(&map);
3172         wined3d_device_context_set_stream_sources(context, i, 1, &state->streams[i]);
3173     }
3174
3175     map = changed->textures;
3176     while (map)
3177     {
3178         i = wined3d_bit_scan(&map);
3179         wined3d_device_set_texture(device, i, state->textures[i]);
3180     }
3181
3182     map = changed->clipplane;
3183     while (map)
3184     {
3185         i = wined3d_bit_scan(&map);
3186         wined3d_device_set_clip_plane(device, i, &state->clip_planes[i]);
3187     }
3188
3189     assert(list_empty(&stateblock->changed.changed_lights));
3190     memset(&stateblock->changed, 0, sizeof(stateblock->changed));
3191     list_init(&stateblock->changed.changed_lights);
3192
3193     TRACE("Applied stateblock %p.\n", stateblock);
3194 }