dll/directx/wine/wined3d/cs.c

   1 /*
   2  * Copyright 2013 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21 #include "wined3d_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  24
  25 #define WINED3D_INITIAL_CS_SIZE 4096
  26
  27 enum wined3d_cs_op
  28 {
  29     WINED3D_CS_OP_NOP,
  30     WINED3D_CS_OP_PRESENT,
  31     WINED3D_CS_OP_CLEAR,
  32     WINED3D_CS_OP_DISPATCH,
  33     WINED3D_CS_OP_DRAW,
  34     WINED3D_CS_OP_FLUSH,
  35     WINED3D_CS_OP_SET_PREDICATION,
  36     WINED3D_CS_OP_SET_VIEWPORT,
  37     WINED3D_CS_OP_SET_SCISSOR_RECT,
  38     WINED3D_CS_OP_SET_RENDERTARGET_VIEW,
  39     WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW,
  40     WINED3D_CS_OP_SET_VERTEX_DECLARATION,
  41     WINED3D_CS_OP_SET_STREAM_SOURCE,
  42     WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ,
  43     WINED3D_CS_OP_SET_STREAM_OUTPUT,
  44     WINED3D_CS_OP_SET_INDEX_BUFFER,
  45     WINED3D_CS_OP_SET_CONSTANT_BUFFER,
  46     WINED3D_CS_OP_SET_TEXTURE,
  47     WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW,
  48     WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW,
  49     WINED3D_CS_OP_SET_SAMPLER,
  50     WINED3D_CS_OP_SET_SHADER,
  51     WINED3D_CS_OP_SET_BLEND_STATE,
  52     WINED3D_CS_OP_SET_RASTERIZER_STATE,
  53     WINED3D_CS_OP_SET_RENDER_STATE,
  54     WINED3D_CS_OP_SET_TEXTURE_STATE,
  55     WINED3D_CS_OP_SET_SAMPLER_STATE,
  56     WINED3D_CS_OP_SET_TRANSFORM,
  57     WINED3D_CS_OP_SET_CLIP_PLANE,
  58     WINED3D_CS_OP_SET_COLOR_KEY,
  59     WINED3D_CS_OP_SET_MATERIAL,
  60     WINED3D_CS_OP_SET_LIGHT,
  61     WINED3D_CS_OP_SET_LIGHT_ENABLE,
  62     WINED3D_CS_OP_PUSH_CONSTANTS,
  63     WINED3D_CS_OP_RESET_STATE,
  64     WINED3D_CS_OP_CALLBACK,
  65     WINED3D_CS_OP_QUERY_ISSUE,
  66     WINED3D_CS_OP_PRELOAD_RESOURCE,
  67     WINED3D_CS_OP_UNLOAD_RESOURCE,
  68     WINED3D_CS_OP_MAP,
  69     WINED3D_CS_OP_UNMAP,
  70     WINED3D_CS_OP_BLT_SUB_RESOURCE,
  71     WINED3D_CS_OP_UPDATE_SUB_RESOURCE,
  72     WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION,
  73     WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW,
  74     WINED3D_CS_OP_COPY_UAV_COUNTER,
  75     WINED3D_CS_OP_GENERATE_MIPMAPS,
  76     WINED3D_CS_OP_STOP,
  77 };
  78
  79 struct wined3d_cs_packet
  80 {
  81     size_t size;
  82     BYTE data[1];
  83 };
  84
  85 struct wined3d_cs_nop
  86 {
  87     enum wined3d_cs_op opcode;
  88 };
  89
  90 struct wined3d_cs_present
  91 {
  92     enum wined3d_cs_op opcode;
  93     HWND dst_window_override;
  94     struct wined3d_swapchain *swapchain;
  95     RECT src_rect;
  96     RECT dst_rect;
  97     DWORD swap_interval;
  98     DWORD flags;
  99 };
 100
 101 struct wined3d_cs_clear
 102 {
 103     enum wined3d_cs_op opcode;
 104     DWORD flags;
 105     unsigned int rt_count;
 106     struct wined3d_fb_state *fb;
 107     RECT draw_rect;
 108     struct wined3d_color color;
 109     float depth;
 110     DWORD stencil;
 111     unsigned int rect_count;
 112     RECT rects[1];
 113 };
 114
 115 struct wined3d_cs_dispatch
 116 {
 117     enum wined3d_cs_op opcode;
 118     struct wined3d_dispatch_parameters parameters;
 119 };
 120
 121 struct wined3d_cs_draw
 122 {
 123     enum wined3d_cs_op opcode;
 124     GLenum primitive_type;
 125     GLint patch_vertex_count;
 126     struct wined3d_draw_parameters parameters;
 127 };
 128
 129 struct wined3d_cs_flush
 130 {
 131     enum wined3d_cs_op opcode;
 132 };
 133
 134 struct wined3d_cs_set_predication
 135 {
 136     enum wined3d_cs_op opcode;
 137     struct wined3d_query *predicate;
 138     BOOL value;
 139 };
 140
 141 struct wined3d_cs_set_viewport
 142 {
 143     enum wined3d_cs_op opcode;
 144     struct wined3d_viewport viewport;
 145 };
 146
 147 struct wined3d_cs_set_scissor_rect
 148 {
 149     enum wined3d_cs_op opcode;
 150     RECT rect;
 151 };
 152
 153 struct wined3d_cs_set_rendertarget_view
 154 {
 155     enum wined3d_cs_op opcode;
 156     unsigned int view_idx;
 157     struct wined3d_rendertarget_view *view;
 158 };
 159
 160 struct wined3d_cs_set_depth_stencil_view
 161 {
 162     enum wined3d_cs_op opcode;
 163     struct wined3d_rendertarget_view *view;
 164 };
 165
 166 struct wined3d_cs_set_vertex_declaration
 167 {
 168     enum wined3d_cs_op opcode;
 169     struct wined3d_vertex_declaration *declaration;
 170 };
 171
 172 struct wined3d_cs_set_stream_source
 173 {
 174     enum wined3d_cs_op opcode;
 175     UINT stream_idx;
 176     struct wined3d_buffer *buffer;
 177     UINT offset;
 178     UINT stride;
 179 };
 180
 181 struct wined3d_cs_set_stream_source_freq
 182 {
 183     enum wined3d_cs_op opcode;
 184     UINT stream_idx;
 185     UINT frequency;
 186     UINT flags;
 187 };
 188
 189 struct wined3d_cs_set_stream_output
 190 {
 191     enum wined3d_cs_op opcode;
 192     UINT stream_idx;
 193     struct wined3d_buffer *buffer;
 194     UINT offset;
 195 };
 196
 197 struct wined3d_cs_set_index_buffer
 198 {
 199     enum wined3d_cs_op opcode;
 200     struct wined3d_buffer *buffer;
 201     enum wined3d_format_id format_id;
 202     unsigned int offset;
 203 };
 204
 205 struct wined3d_cs_set_constant_buffer
 206 {
 207     enum wined3d_cs_op opcode;
 208     enum wined3d_shader_type type;
 209     UINT cb_idx;
 210     struct wined3d_buffer *buffer;
 211 };
 212
 213 struct wined3d_cs_set_texture
 214 {
 215     enum wined3d_cs_op opcode;
 216     UINT stage;
 217     struct wined3d_texture *texture;
 218 };
 219
 220 struct wined3d_cs_set_color_key
 221 {
 222     enum wined3d_cs_op opcode;
 223     struct wined3d_texture *texture;
 224     WORD flags;
 225     WORD set;
 226     struct wined3d_color_key color_key;
 227 };
 228
 229 struct wined3d_cs_set_shader_resource_view
 230 {
 231     enum wined3d_cs_op opcode;
 232     enum wined3d_shader_type type;
 233     UINT view_idx;
 234     struct wined3d_shader_resource_view *view;
 235 };
 236
 237 struct wined3d_cs_set_unordered_access_view
 238 {
 239     enum wined3d_cs_op opcode;
 240     enum wined3d_pipeline pipeline;
 241     unsigned int view_idx;
 242     struct wined3d_unordered_access_view *view;
 243     unsigned int initial_count;
 244 };
 245
 246 struct wined3d_cs_set_sampler
 247 {
 248     enum wined3d_cs_op opcode;
 249     enum wined3d_shader_type type;
 250     UINT sampler_idx;
 251     struct wined3d_sampler *sampler;
 252 };
 253
 254 struct wined3d_cs_set_shader
 255 {
 256     enum wined3d_cs_op opcode;
 257     enum wined3d_shader_type type;
 258     struct wined3d_shader *shader;
 259 };
 260
 261 struct wined3d_cs_set_blend_state
 262 {
 263     enum wined3d_cs_op opcode;
 264     struct wined3d_blend_state *state;
 265 };
 266
 267 struct wined3d_cs_set_rasterizer_state
 268 {
 269     enum wined3d_cs_op opcode;
 270     struct wined3d_rasterizer_state *state;
 271 };
 272
 273 struct wined3d_cs_set_render_state
 274 {
 275     enum wined3d_cs_op opcode;
 276     enum wined3d_render_state state;
 277     DWORD value;
 278 };
 279
 280 struct wined3d_cs_set_texture_state
 281 {
 282     enum wined3d_cs_op opcode;
 283     UINT stage;
 284     enum wined3d_texture_stage_state state;
 285     DWORD value;
 286 };
 287
 288 struct wined3d_cs_set_sampler_state
 289 {
 290     enum wined3d_cs_op opcode;
 291     UINT sampler_idx;
 292     enum wined3d_sampler_state state;
 293     DWORD value;
 294 };
 295
 296 struct wined3d_cs_set_transform
 297 {
 298     enum wined3d_cs_op opcode;
 299     enum wined3d_transform_state state;
 300     struct wined3d_matrix matrix;
 301 };
 302
 303 struct wined3d_cs_set_clip_plane
 304 {
 305     enum wined3d_cs_op opcode;
 306     UINT plane_idx;
 307     struct wined3d_vec4 plane;
 308 };
 309
 310 struct wined3d_cs_set_material
 311 {
 312     enum wined3d_cs_op opcode;
 313     struct wined3d_material material;
 314 };
 315
 316 struct wined3d_cs_set_light
 317 {
 318     enum wined3d_cs_op opcode;
 319     struct wined3d_light_info light;
 320 };
 321
 322 struct wined3d_cs_set_light_enable
 323 {
 324     enum wined3d_cs_op opcode;
 325     unsigned int idx;
 326     BOOL enable;
 327 };
 328
 329 struct wined3d_cs_push_constants
 330 {
 331     enum wined3d_cs_op opcode;
 332     enum wined3d_push_constants type;
 333     unsigned int start_idx;
 334     unsigned int count;
 335     BYTE constants[1];
 336 };
 337
 338 struct wined3d_cs_reset_state
 339 {
 340     enum wined3d_cs_op opcode;
 341 };
 342
 343 struct wined3d_cs_callback
 344 {
 345     enum wined3d_cs_op opcode;
 346     void (*callback)(void *object);
 347     void *object;
 348 };
 349
 350 struct wined3d_cs_query_issue
 351 {
 352     enum wined3d_cs_op opcode;
 353     struct wined3d_query *query;
 354     DWORD flags;
 355 };
 356
 357 struct wined3d_cs_preload_resource
 358 {
 359     enum wined3d_cs_op opcode;
 360     struct wined3d_resource *resource;
 361 };
 362
 363 struct wined3d_cs_unload_resource
 364 {
 365     enum wined3d_cs_op opcode;
 366     struct wined3d_resource *resource;
 367 };
 368
 369 struct wined3d_cs_map
 370 {
 371     enum wined3d_cs_op opcode;
 372     struct wined3d_resource *resource;
 373     unsigned int sub_resource_idx;
 374     struct wined3d_map_desc *map_desc;
 375     const struct wined3d_box *box;
 376     DWORD flags;
 377     HRESULT *hr;
 378 };
 379
 380 struct wined3d_cs_unmap
 381 {
 382     enum wined3d_cs_op opcode;
 383     struct wined3d_resource *resource;
 384     unsigned int sub_resource_idx;
 385     HRESULT *hr;
 386 };
 387
 388 struct wined3d_cs_blt_sub_resource
 389 {
 390     enum wined3d_cs_op opcode;
 391     struct wined3d_resource *dst_resource;
 392     unsigned int dst_sub_resource_idx;
 393     struct wined3d_box dst_box;
 394     struct wined3d_resource *src_resource;
 395     unsigned int src_sub_resource_idx;
 396     struct wined3d_box src_box;
 397     DWORD flags;
 398     struct wined3d_blt_fx fx;
 399     enum wined3d_texture_filter_type filter;
 400 };
 401
 402 struct wined3d_cs_update_sub_resource
 403 {
 404     enum wined3d_cs_op opcode;
 405     struct wined3d_resource *resource;
 406     unsigned int sub_resource_idx;
 407     struct wined3d_box box;
 408     struct wined3d_sub_resource_data data;
 409 #if defined(STAGING_CSMT)
 410     BYTE copy_data[1];
 411 #endif /* STAGING_CSMT */
 412 };
 413
 414 struct wined3d_cs_add_dirty_texture_region
 415 {
 416     enum wined3d_cs_op opcode;
 417     struct wined3d_texture *texture;
 418     unsigned int layer;
 419 };
 420
 421 struct wined3d_cs_clear_unordered_access_view
 422 {
 423     enum wined3d_cs_op opcode;
 424     struct wined3d_unordered_access_view *view;
 425     struct wined3d_uvec4 clear_value;
 426 };
 427
 428 struct wined3d_cs_copy_uav_counter
 429 {
 430     enum wined3d_cs_op opcode;
 431     struct wined3d_buffer *buffer;
 432     unsigned int offset;
 433     struct wined3d_unordered_access_view *view;
 434 };
 435
 436 struct wined3d_cs_generate_mipmaps
 437 {
 438     enum wined3d_cs_op opcode;
 439     struct wined3d_shader_resource_view *view;
 440 };
 441
 442 struct wined3d_cs_stop
 443 {
 444     enum wined3d_cs_op opcode;
 445 };
 446
 447 static void wined3d_cs_exec_nop(struct wined3d_cs *cs, const void *data)
 448 {
 449 }
 450
 451 static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
 452 {
 453     const struct wined3d_cs_present *op = data;
 454     struct wined3d_swapchain *swapchain;
 455     unsigned int i;
 456
 457     swapchain = op->swapchain;
 458     wined3d_swapchain_set_window(swapchain, op->dst_window_override);
 459
 460     if (op->swap_interval && swapchain->desc.swap_interval != op->swap_interval)
 461     {
 462         swapchain->desc.swap_interval = op->swap_interval;
 463         swapchain_update_swap_interval(swapchain);
 464     }
 465
 466     swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->flags);
 467
 468     wined3d_resource_release(&swapchain->front_buffer->resource);
 469     for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
 470     {
 471         wined3d_resource_release(&swapchain->back_buffers[i]->resource);
 472     }
 473
 474     InterlockedDecrement(&cs->pending_presents);
 475 }
 476
 477 void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain,
 478         const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override,
 479         DWORD swap_interval, DWORD flags)
 480 {
 481     struct wined3d_cs_present *op;
 482     unsigned int i;
 483     LONG pending;
 484
 485     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 486     op->opcode = WINED3D_CS_OP_PRESENT;
 487     op->dst_window_override = dst_window_override;
 488     op->swapchain = swapchain;
 489     op->src_rect = *src_rect;
 490     op->dst_rect = *dst_rect;
 491     op->swap_interval = swap_interval;
 492     op->flags = flags;
 493
 494     pending = InterlockedIncrement(&cs->pending_presents);
 495
 496     wined3d_resource_acquire(&swapchain->front_buffer->resource);
 497     for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
 498     {
 499         wined3d_resource_acquire(&swapchain->back_buffers[i]->resource);
 500     }
 501
 502     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 503
 504     /* Limit input latency by limiting the number of presents that we can get
 505      * ahead of the worker thread. We have a constant limit here, but
 506      * IDXGIDevice1 allows tuning this. */
 507     while (pending > 1)
 508     {
 509         wined3d_pause();
 510         pending = InterlockedCompareExchange(&cs->pending_presents, 0, 0);
 511     }
 512 }
 513
 514 static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
 515 {
 516     const struct wined3d_cs_clear *op = data;
 517     struct wined3d_device *device;
 518     unsigned int i;
 519
 520     device = cs->device;
 521     device->blitter->ops->blitter_clear(device->blitter, device, op->rt_count, op->fb,
 522             op->rect_count, op->rects, &op->draw_rect, op->flags, &op->color, op->depth, op->stencil);
 523
 524     if (op->flags & WINED3DCLEAR_TARGET)
 525     {
 526         for (i = 0; i < op->rt_count; ++i)
 527         {
 528             if (op->fb->render_targets[i])
 529                 wined3d_resource_release(op->fb->render_targets[i]->resource);
 530         }
 531     }
 532     if (op->flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
 533         wined3d_resource_release(op->fb->depth_stencil->resource);
 534 }
 535
 536 void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
 537         DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 538 {
 539     unsigned int rt_count = cs->device->adapter->gl_info.limits.buffers;
 540     const struct wined3d_state *state = &cs->device->state;
 541     const struct wined3d_viewport *vp = &state->viewport;
 542     struct wined3d_cs_clear *op;
 543     unsigned int i;
 544
 545     op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]),
 546             WINED3D_CS_QUEUE_DEFAULT);
 547     op->opcode = WINED3D_CS_OP_CLEAR;
 548     op->flags = flags;
 549     op->rt_count = rt_count;
 550     op->fb = &cs->fb;
 551     SetRect(&op->draw_rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
 552     if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
 553         IntersectRect(&op->draw_rect, &op->draw_rect, &state->scissor_rect);
 554     op->color = *color;
 555     op->depth = depth;
 556     op->stencil = stencil;
 557     op->rect_count = rect_count;
 558     memcpy(op->rects, rects, sizeof(*rects) * rect_count);
 559
 560     if (flags & WINED3DCLEAR_TARGET)
 561     {
 562         for (i = 0; i < rt_count; ++i)
 563         {
 564             if (state->fb->render_targets[i])
 565                 wined3d_resource_acquire(state->fb->render_targets[i]->resource);
 566         }
 567     }
 568     if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
 569         wined3d_resource_acquire(state->fb->depth_stencil->resource);
 570
 571     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 572 }
 573
 574 void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view,
 575         const RECT *rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 576 {
 577     struct wined3d_cs_clear *op;
 578     size_t size;
 579
 580     size = FIELD_OFFSET(struct wined3d_cs_clear, rects[1]) + sizeof(struct wined3d_fb_state);
 581     op = cs->ops->require_space(cs, size, WINED3D_CS_QUEUE_DEFAULT);
 582     op->fb = (void *)&op->rects[1];
 583
 584     op->opcode = WINED3D_CS_OP_CLEAR;
 585     op->flags = flags;
 586     if (flags & WINED3DCLEAR_TARGET)
 587     {
 588         op->rt_count = 1;
 589         op->fb->render_targets[0] = view;
 590         op->fb->depth_stencil = NULL;
 591         op->color = *color;
 592     }
 593     else
 594     {
 595         op->rt_count = 0;
 596         op->fb->render_targets[0] = NULL;
 597         op->fb->depth_stencil = view;
 598         op->depth = depth;
 599         op->stencil = stencil;
 600     }
 601     SetRect(&op->draw_rect, 0, 0, view->width, view->height);
 602     op->rect_count = 1;
 603     op->rects[0] = *rect;
 604
 605     wined3d_resource_acquire(view->resource);
 606
 607     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 608 }
 609
 610 static void acquire_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
 611 {
 612     struct wined3d_shader_sampler_map_entry *entry;
 613     struct wined3d_shader_resource_view *view;
 614     struct wined3d_shader *shader;
 615     unsigned int i, j;
 616
 617     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 618     {
 619         if (!(shader_mask & (1u << i)))
 620             continue;
 621
 622         if (!(shader = state->shader[i]))
 623             continue;
 624
 625         for (j = 0; j < WINED3D_MAX_CBS; ++j)
 626         {
 627             if (state->cb[i][j])
 628                 wined3d_resource_acquire(&state->cb[i][j]->resource);
 629         }
 630
 631         for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
 632         {
 633             entry = &shader->reg_maps.sampler_map.entries[j];
 634
 635             if (!(view = state->shader_resource_view[i][entry->resource_idx]))
 636                 continue;
 637
 638             wined3d_resource_acquire(view->resource);
 639         }
 640     }
 641 }
 642
 643 static void release_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
 644 {
 645     struct wined3d_shader_sampler_map_entry *entry;
 646     struct wined3d_shader_resource_view *view;
 647     struct wined3d_shader *shader;
 648     unsigned int i, j;
 649
 650     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 651     {
 652         if (!(shader_mask & (1u << i)))
 653             continue;
 654
 655         if (!(shader = state->shader[i]))
 656             continue;
 657
 658         for (j = 0; j < WINED3D_MAX_CBS; ++j)
 659         {
 660             if (state->cb[i][j])
 661                 wined3d_resource_release(&state->cb[i][j]->resource);
 662         }
 663
 664         for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
 665         {
 666             entry = &shader->reg_maps.sampler_map.entries[j];
 667
 668             if (!(view = state->shader_resource_view[i][entry->resource_idx]))
 669                 continue;
 670
 671             wined3d_resource_release(view->resource);
 672         }
 673     }
 674 }
 675
 676 static void acquire_unordered_access_resources(const struct wined3d_shader *shader,
 677         struct wined3d_unordered_access_view * const *views)
 678 {
 679     unsigned int i;
 680
 681     if (!shader)
 682         return;
 683
 684     for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
 685     {
 686         if (!shader->reg_maps.uav_resource_info[i].type)
 687             continue;
 688
 689         if (!views[i])
 690             continue;
 691
 692         wined3d_resource_acquire(views[i]->resource);
 693     }
 694 }
 695
 696 static void release_unordered_access_resources(const struct wined3d_shader *shader,
 697         struct wined3d_unordered_access_view * const *views)
 698 {
 699     unsigned int i;
 700
 701     if (!shader)
 702         return;
 703
 704     for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
 705     {
 706         if (!shader->reg_maps.uav_resource_info[i].type)
 707             continue;
 708
 709         if (!views[i])
 710             continue;
 711
 712         wined3d_resource_release(views[i]->resource);
 713     }
 714 }
 715
 716 static void wined3d_cs_exec_dispatch(struct wined3d_cs *cs, const void *data)
 717 {
 718     const struct wined3d_cs_dispatch *op = data;
 719     struct wined3d_state *state = &cs->state;
 720
 721     dispatch_compute(cs->device, state, &op->parameters);
 722
 723     if (op->parameters.indirect)
 724         wined3d_resource_release(&op->parameters.u.indirect.buffer->resource);
 725
 726     release_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
 727     release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
 728             state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
 729 }
 730
 731 static void acquire_compute_pipeline_resources(const struct wined3d_state *state)
 732 {
 733     acquire_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
 734     acquire_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
 735             state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
 736 }
 737
 738 void wined3d_cs_emit_dispatch(struct wined3d_cs *cs,
 739         unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
 740 {
 741     const struct wined3d_state *state = &cs->device->state;
 742     struct wined3d_cs_dispatch *op;
 743
 744     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 745     op->opcode = WINED3D_CS_OP_DISPATCH;
 746     op->parameters.indirect = FALSE;
 747     op->parameters.u.direct.group_count_x = group_count_x;
 748     op->parameters.u.direct.group_count_y = group_count_y;
 749     op->parameters.u.direct.group_count_z = group_count_z;
 750
 751     acquire_compute_pipeline_resources(state);
 752
 753     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 754 }
 755
 756 void wined3d_cs_emit_dispatch_indirect(struct wined3d_cs *cs,
 757         struct wined3d_buffer *buffer, unsigned int offset)
 758 {
 759     const struct wined3d_state *state = &cs->device->state;
 760     struct wined3d_cs_dispatch *op;
 761
 762     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 763     op->opcode = WINED3D_CS_OP_DISPATCH;
 764     op->parameters.indirect = TRUE;
 765     op->parameters.u.indirect.buffer = buffer;
 766     op->parameters.u.indirect.offset = offset;
 767
 768     acquire_compute_pipeline_resources(state);
 769     wined3d_resource_acquire(&buffer->resource);
 770
 771     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 772 }
 773
 774 static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
 775 {
 776     const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
 777     struct wined3d_state *state = &cs->state;
 778     const struct wined3d_cs_draw *op = data;
 779     int load_base_vertex_idx;
 780     unsigned int i;
 781
 782     /* ARB_draw_indirect always supports a base vertex offset. */
 783     if (!op->parameters.indirect && !gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
 784         load_base_vertex_idx = op->parameters.u.direct.base_vertex_idx;
 785     else
 786         load_base_vertex_idx = 0;
 787
 788     if (state->load_base_vertex_index != load_base_vertex_idx)
 789     {
 790         state->load_base_vertex_index = load_base_vertex_idx;
 791         device_invalidate_state(cs->device, STATE_BASEVERTEXINDEX);
 792     }
 793
 794     if (state->gl_primitive_type != op->primitive_type)
 795     {
 796         if (state->gl_primitive_type == GL_POINTS || op->primitive_type == GL_POINTS)
 797             device_invalidate_state(cs->device, STATE_POINT_ENABLE);
 798         state->gl_primitive_type = op->primitive_type;
 799     }
 800     state->gl_patch_vertices = op->patch_vertex_count;
 801
 802     draw_primitive(cs->device, state, &op->parameters);
 803
 804     if (op->parameters.indirect)
 805     {
 806         struct wined3d_buffer *buffer = op->parameters.u.indirect.buffer;
 807         wined3d_resource_release(&buffer->resource);
 808     }
 809
 810     if (op->parameters.indexed)
 811         wined3d_resource_release(&state->index_buffer->resource);
 812     for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
 813     {
 814         if (state->streams[i].buffer)
 815             wined3d_resource_release(&state->streams[i].buffer->resource);
 816     }
 817     for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
 818     {
 819         if (state->stream_output[i].buffer)
 820             wined3d_resource_release(&state->stream_output[i].buffer->resource);
 821     }
 822     for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
 823     {
 824         if (state->textures[i])
 825             wined3d_resource_release(&state->textures[i]->resource);
 826     }
 827     for (i = 0; i < gl_info->limits.buffers; ++i)
 828     {
 829         if (state->fb->render_targets[i])
 830             wined3d_resource_release(state->fb->render_targets[i]->resource);
 831     }
 832     if (state->fb->depth_stencil)
 833         wined3d_resource_release(state->fb->depth_stencil->resource);
 834     release_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
 835     release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
 836             state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
 837 }
 838
 839 static void acquire_graphics_pipeline_resources(const struct wined3d_state *state,
 840         BOOL indexed, const struct wined3d_gl_info *gl_info)
 841 {
 842     unsigned int i;
 843
 844     if (indexed)
 845         wined3d_resource_acquire(&state->index_buffer->resource);
 846     for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
 847     {
 848         if (state->streams[i].buffer)
 849             wined3d_resource_acquire(&state->streams[i].buffer->resource);
 850     }
 851     for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
 852     {
 853         if (state->stream_output[i].buffer)
 854             wined3d_resource_acquire(&state->stream_output[i].buffer->resource);
 855     }
 856     for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
 857     {
 858         if (state->textures[i])
 859             wined3d_resource_acquire(&state->textures[i]->resource);
 860     }
 861     for (i = 0; i < gl_info->limits.buffers; ++i)
 862     {
 863         if (state->fb->render_targets[i])
 864             wined3d_resource_acquire(state->fb->render_targets[i]->resource);
 865     }
 866     if (state->fb->depth_stencil)
 867         wined3d_resource_acquire(state->fb->depth_stencil->resource);
 868     acquire_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
 869     acquire_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
 870             state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
 871 }
 872
 873 void wined3d_cs_emit_draw(struct wined3d_cs *cs, GLenum primitive_type, unsigned int patch_vertex_count,
 874         int base_vertex_idx, unsigned int start_idx, unsigned int index_count,
 875         unsigned int start_instance, unsigned int instance_count, BOOL indexed)
 876 {
 877     const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
 878     const struct wined3d_state *state = &cs->device->state;
 879     struct wined3d_cs_draw *op;
 880
 881     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 882     op->opcode = WINED3D_CS_OP_DRAW;
 883     op->primitive_type = primitive_type;
 884     op->patch_vertex_count = patch_vertex_count;
 885     op->parameters.indirect = FALSE;
 886     op->parameters.u.direct.base_vertex_idx = base_vertex_idx;
 887     op->parameters.u.direct.start_idx = start_idx;
 888     op->parameters.u.direct.index_count = index_count;
 889     op->parameters.u.direct.start_instance = start_instance;
 890     op->parameters.u.direct.instance_count = instance_count;
 891     op->parameters.indexed = indexed;
 892
 893     acquire_graphics_pipeline_resources(state, indexed, gl_info);
 894
 895     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 896 }
 897
 898 void wined3d_cs_emit_draw_indirect(struct wined3d_cs *cs, GLenum primitive_type, unsigned int patch_vertex_count,
 899         struct wined3d_buffer *buffer, unsigned int offset, BOOL indexed)
 900 {
 901     const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
 902     const struct wined3d_state *state = &cs->device->state;
 903     struct wined3d_cs_draw *op;
 904
 905     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 906     op->opcode = WINED3D_CS_OP_DRAW;
 907     op->primitive_type = primitive_type;
 908     op->patch_vertex_count = patch_vertex_count;
 909     op->parameters.indirect = TRUE;
 910     op->parameters.u.indirect.buffer = buffer;
 911     op->parameters.u.indirect.offset = offset;
 912     op->parameters.indexed = indexed;
 913
 914     acquire_graphics_pipeline_resources(state, indexed, gl_info);
 915     wined3d_resource_acquire(&buffer->resource);
 916
 917     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 918 }
 919
 920 static void wined3d_cs_exec_flush(struct wined3d_cs *cs, const void *data)
 921 {
 922     struct wined3d_context *context;
 923
 924     context = context_acquire(cs->device, NULL, 0);
 925     if (context->valid)
 926         context->gl_info->gl_ops.gl.p_glFlush();
 927     context_release(context);
 928 }
 929
 930 void wined3d_cs_emit_flush(struct wined3d_cs *cs)
 931 {
 932     struct wined3d_cs_flush *op;
 933
 934     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 935     op->opcode = WINED3D_CS_OP_FLUSH;
 936
 937     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 938     cs->queries_flushed = TRUE;
 939 }
 940
 941 static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
 942 {
 943     const struct wined3d_cs_set_predication *op = data;
 944
 945     cs->state.predicate = op->predicate;
 946     cs->state.predicate_value = op->value;
 947 }
 948
 949 void wined3d_cs_emit_set_predication(struct wined3d_cs *cs, struct wined3d_query *predicate, BOOL value)
 950 {
 951     struct wined3d_cs_set_predication *op;
 952
 953     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 954     op->opcode = WINED3D_CS_OP_SET_PREDICATION;
 955     op->predicate = predicate;
 956     op->value = value;
 957
 958     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 959 }
 960
 961 static void wined3d_cs_exec_set_viewport(struct wined3d_cs *cs, const void *data)
 962 {
 963     const struct wined3d_cs_set_viewport *op = data;
 964
 965     cs->state.viewport = op->viewport;
 966     device_invalidate_state(cs->device, STATE_VIEWPORT);
 967 }
 968
 969 void wined3d_cs_emit_set_viewport(struct wined3d_cs *cs, const struct wined3d_viewport *viewport)
 970 {
 971     struct wined3d_cs_set_viewport *op;
 972
 973     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 974     op->opcode = WINED3D_CS_OP_SET_VIEWPORT;
 975     op->viewport = *viewport;
 976
 977     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 978 }
 979
 980 static void wined3d_cs_exec_set_scissor_rect(struct wined3d_cs *cs, const void *data)
 981 {
 982     const struct wined3d_cs_set_scissor_rect *op = data;
 983
 984     cs->state.scissor_rect = op->rect;
 985     device_invalidate_state(cs->device, STATE_SCISSORRECT);
 986 }
 987
 988 void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs *cs, const RECT *rect)
 989 {
 990     struct wined3d_cs_set_scissor_rect *op;
 991
 992     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 993     op->opcode = WINED3D_CS_OP_SET_SCISSOR_RECT;
 994     op->rect = *rect;
 995
 996     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
 997 }
 998
 999 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data)
1000 {
1001     const struct wined3d_cs_set_rendertarget_view *op = data;
1002
1003     cs->fb.render_targets[op->view_idx] = op->view;
1004     device_invalidate_state(cs->device, STATE_FRAMEBUFFER);
1005 }
1006
1007 void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx,
1008         struct wined3d_rendertarget_view *view)
1009 {
1010     struct wined3d_cs_set_rendertarget_view *op;
1011
1012     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1013     op->opcode = WINED3D_CS_OP_SET_RENDERTARGET_VIEW;
1014     op->view_idx = view_idx;
1015     op->view = view;
1016
1017     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1018 }
1019
1020 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
1021 {
1022     const struct wined3d_cs_set_depth_stencil_view *op = data;
1023     struct wined3d_device *device = cs->device;
1024     struct wined3d_rendertarget_view *prev;
1025
1026     if ((prev = cs->state.fb->depth_stencil))
1027     {
1028         struct wined3d_surface *prev_surface = wined3d_rendertarget_view_get_surface(prev);
1029
1030         if (prev_surface && (device->swapchains[0]->desc.flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
1031                 || prev_surface->container->flags & WINED3D_TEXTURE_DISCARD))
1032         {
1033             wined3d_texture_validate_location(prev_surface->container,
1034                     prev->sub_resource_idx, WINED3D_LOCATION_DISCARDED);
1035         }
1036     }
1037
1038     cs->fb.depth_stencil = op->view;
1039
1040     if (!prev != !op->view)
1041     {
1042         /* Swapping NULL / non NULL depth stencil affects the depth and tests */
1043         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
1044         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILENABLE));
1045         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
1046         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
1047         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIASCLAMP));
1048     }
1049     else if (prev && prev->format->depth_bias_scale != op->view->format->depth_bias_scale)
1050     {
1051         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
1052     }
1053
1054     device_invalidate_state(device, STATE_FRAMEBUFFER);
1055 }
1056
1057 void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
1058 {
1059     struct wined3d_cs_set_depth_stencil_view *op;
1060
1061     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1062     op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
1063     op->view = view;
1064
1065     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1066 }
1067
1068 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
1069 {
1070     const struct wined3d_cs_set_vertex_declaration *op = data;
1071
1072     cs->state.vertex_declaration = op->declaration;
1073     device_invalidate_state(cs->device, STATE_VDECL);
1074 }
1075
1076 void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs, struct wined3d_vertex_declaration *declaration)
1077 {
1078     struct wined3d_cs_set_vertex_declaration *op;
1079
1080     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1081     op->opcode = WINED3D_CS_OP_SET_VERTEX_DECLARATION;
1082     op->declaration = declaration;
1083
1084     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1085 }
1086
1087 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs *cs, const void *data)
1088 {
1089     const struct wined3d_cs_set_stream_source *op = data;
1090     struct wined3d_stream_state *stream;
1091     struct wined3d_buffer *prev;
1092
1093     stream = &cs->state.streams[op->stream_idx];
1094     prev = stream->buffer;
1095     stream->buffer = op->buffer;
1096     stream->offset = op->offset;
1097     stream->stride = op->stride;
1098
1099     if (op->buffer)
1100         InterlockedIncrement(&op->buffer->resource.bind_count);
1101     if (prev)
1102         InterlockedDecrement(&prev->resource.bind_count);
1103
1104     device_invalidate_state(cs->device, STATE_STREAMSRC);
1105 }
1106
1107 void wined3d_cs_emit_set_stream_source(struct wined3d_cs *cs, UINT stream_idx,
1108         struct wined3d_buffer *buffer, UINT offset, UINT stride)
1109 {
1110     struct wined3d_cs_set_stream_source *op;
1111
1112     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1113     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE;
1114     op->stream_idx = stream_idx;
1115     op->buffer = buffer;
1116     op->offset = offset;
1117     op->stride = stride;
1118
1119     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1120 }
1121
1122 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs *cs, const void *data)
1123 {
1124     const struct wined3d_cs_set_stream_source_freq *op = data;
1125     struct wined3d_stream_state *stream;
1126
1127     stream = &cs->state.streams[op->stream_idx];
1128     stream->frequency = op->frequency;
1129     stream->flags = op->flags;
1130
1131     device_invalidate_state(cs->device, STATE_STREAMSRC);
1132 }
1133
1134 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx, UINT frequency, UINT flags)
1135 {
1136     struct wined3d_cs_set_stream_source_freq *op;
1137
1138     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1139     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ;
1140     op->stream_idx = stream_idx;
1141     op->frequency = frequency;
1142     op->flags = flags;
1143
1144     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1145 }
1146
1147 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs *cs, const void *data)
1148 {
1149     const struct wined3d_cs_set_stream_output *op = data;
1150     struct wined3d_stream_output *stream;
1151     struct wined3d_buffer *prev;
1152
1153     stream = &cs->state.stream_output[op->stream_idx];
1154     prev = stream->buffer;
1155     stream->buffer = op->buffer;
1156     stream->offset = op->offset;
1157
1158     if (op->buffer)
1159         InterlockedIncrement(&op->buffer->resource.bind_count);
1160     if (prev)
1161         InterlockedDecrement(&prev->resource.bind_count);
1162
1163     device_invalidate_state(cs->device, STATE_STREAM_OUTPUT);
1164 }
1165
1166 void wined3d_cs_emit_set_stream_output(struct wined3d_cs *cs, UINT stream_idx,
1167         struct wined3d_buffer *buffer, UINT offset)
1168 {
1169     struct wined3d_cs_set_stream_output *op;
1170
1171     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1172     op->opcode = WINED3D_CS_OP_SET_STREAM_OUTPUT;
1173     op->stream_idx = stream_idx;
1174     op->buffer = buffer;
1175     op->offset = offset;
1176
1177     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1178 }
1179
1180 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
1181 {
1182     const struct wined3d_cs_set_index_buffer *op = data;
1183     struct wined3d_buffer *prev;
1184
1185     prev = cs->state.index_buffer;
1186     cs->state.index_buffer = op->buffer;
1187     cs->state.index_format = op->format_id;
1188     cs->state.index_offset = op->offset;
1189
1190     if (op->buffer)
1191         InterlockedIncrement(&op->buffer->resource.bind_count);
1192     if (prev)
1193         InterlockedDecrement(&prev->resource.bind_count);
1194
1195     device_invalidate_state(cs->device, STATE_INDEXBUFFER);
1196 }
1197
1198 void wined3d_cs_emit_set_index_buffer(struct wined3d_cs *cs, struct wined3d_buffer *buffer,
1199         enum wined3d_format_id format_id, unsigned int offset)
1200 {
1201     struct wined3d_cs_set_index_buffer *op;
1202
1203     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1204     op->opcode = WINED3D_CS_OP_SET_INDEX_BUFFER;
1205     op->buffer = buffer;
1206     op->format_id = format_id;
1207     op->offset = offset;
1208
1209     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1210 }
1211
1212 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs *cs, const void *data)
1213 {
1214     const struct wined3d_cs_set_constant_buffer *op = data;
1215     struct wined3d_buffer *prev;
1216
1217     prev = cs->state.cb[op->type][op->cb_idx];
1218     cs->state.cb[op->type][op->cb_idx] = op->buffer;
1219
1220     if (op->buffer)
1221         InterlockedIncrement(&op->buffer->resource.bind_count);
1222     if (prev)
1223         InterlockedDecrement(&prev->resource.bind_count);
1224
1225     device_invalidate_state(cs->device, STATE_CONSTANT_BUFFER(op->type));
1226 }
1227
1228 void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs *cs, enum wined3d_shader_type type,
1229         UINT cb_idx, struct wined3d_buffer *buffer)
1230 {
1231     struct wined3d_cs_set_constant_buffer *op;
1232
1233     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1234     op->opcode = WINED3D_CS_OP_SET_CONSTANT_BUFFER;
1235     op->type = type;
1236     op->cb_idx = cb_idx;
1237     op->buffer = buffer;
1238
1239     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1240 }
1241
1242 static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
1243 {
1244     const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
1245     const struct wined3d_d3d_info *d3d_info = &cs->device->adapter->d3d_info;
1246     const struct wined3d_cs_set_texture *op = data;
1247     struct wined3d_texture *prev;
1248     BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
1249
1250     prev = cs->state.textures[op->stage];
1251     cs->state.textures[op->stage] = op->texture;
1252
1253     if (op->texture)
1254     {
1255         const struct wined3d_format *new_format = op->texture->resource.format;
1256         const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
1257         unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
1258         unsigned int new_fmt_flags = op->texture->resource.format_flags;
1259
1260         if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
1261             op->texture->sampler = op->stage;
1262
1263         if (!prev || op->texture->target != prev->target
1264                 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
1265                 && !(can_use_texture_swizzle(gl_info, new_format) && can_use_texture_swizzle(gl_info, old_format)))
1266                 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
1267             device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
1268
1269         if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
1270         {
1271             /* The source arguments for color and alpha ops have different
1272              * meanings when a NULL texture is bound, so the COLOR_OP and
1273              * ALPHA_OP have to be dirtified. */
1274             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1275             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1276         }
1277
1278         if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1279             new_use_color_key = TRUE;
1280     }
1281
1282     if (prev)
1283     {
1284         if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
1285         {
1286             unsigned int i;
1287
1288             /* Search for other stages the texture is bound to. Shouldn't
1289              * happen if applications bind textures to a single stage only. */
1290             TRACE("Searching for other stages the texture is bound to.\n");
1291             for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
1292             {
1293                 if (cs->state.textures[i] == prev)
1294                 {
1295                     TRACE("Texture is also bound to stage %u.\n", i);
1296                     prev->sampler = i;
1297                     break;
1298                 }
1299             }
1300         }
1301
1302         if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
1303         {
1304             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1305             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1306         }
1307
1308         if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1309             old_use_color_key = TRUE;
1310     }
1311
1312     device_invalidate_state(cs->device, STATE_SAMPLER(op->stage));
1313
1314     if (new_use_color_key != old_use_color_key)
1315         device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1316
1317     if (new_use_color_key)
1318         device_invalidate_state(cs->device, STATE_COLOR_KEY);
1319 }
1320
1321 void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
1322 {
1323     struct wined3d_cs_set_texture *op;
1324
1325     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1326     op->opcode = WINED3D_CS_OP_SET_TEXTURE;
1327     op->stage = stage;
1328     op->texture = texture;
1329
1330     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1331 }
1332
1333 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs *cs, const void *data)
1334 {
1335     const struct wined3d_cs_set_shader_resource_view *op = data;
1336     struct wined3d_shader_resource_view *prev;
1337
1338     prev = cs->state.shader_resource_view[op->type][op->view_idx];
1339     cs->state.shader_resource_view[op->type][op->view_idx] = op->view;
1340
1341     if (op->view)
1342         InterlockedIncrement(&op->view->resource->bind_count);
1343     if (prev)
1344         InterlockedDecrement(&prev->resource->bind_count);
1345
1346     if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1347         device_invalidate_state(cs->device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1348     else
1349         device_invalidate_state(cs->device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1350 }
1351
1352 void wined3d_cs_emit_set_shader_resource_view(struct wined3d_cs *cs, enum wined3d_shader_type type,
1353         UINT view_idx, struct wined3d_shader_resource_view *view)
1354 {
1355     struct wined3d_cs_set_shader_resource_view *op;
1356
1357     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1358     op->opcode = WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW;
1359     op->type = type;
1360     op->view_idx = view_idx;
1361     op->view = view;
1362
1363     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1364 }
1365
1366 static void wined3d_cs_exec_set_unordered_access_view(struct wined3d_cs *cs, const void *data)
1367 {
1368     const struct wined3d_cs_set_unordered_access_view *op = data;
1369     struct wined3d_unordered_access_view *prev;
1370
1371     prev = cs->state.unordered_access_view[op->pipeline][op->view_idx];
1372     cs->state.unordered_access_view[op->pipeline][op->view_idx] = op->view;
1373
1374     if (op->view)
1375         InterlockedIncrement(&op->view->resource->bind_count);
1376     if (prev)
1377         InterlockedDecrement(&prev->resource->bind_count);
1378
1379     if (op->view && op->initial_count != ~0u)
1380         wined3d_unordered_access_view_set_counter(op->view, op->initial_count);
1381
1382     device_invalidate_state(cs->device, STATE_UNORDERED_ACCESS_VIEW_BINDING(op->pipeline));
1383 }
1384
1385 void wined3d_cs_emit_set_unordered_access_view(struct wined3d_cs *cs, enum wined3d_pipeline pipeline,
1386         unsigned int view_idx, struct wined3d_unordered_access_view *view, unsigned int initial_count)
1387 {
1388     struct wined3d_cs_set_unordered_access_view *op;
1389
1390     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1391     op->opcode = WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW;
1392     op->pipeline = pipeline;
1393     op->view_idx = view_idx;
1394     op->view = view;
1395     op->initial_count = initial_count;
1396
1397     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1398 }
1399
1400 static void wined3d_cs_exec_set_sampler(struct wined3d_cs *cs, const void *data)
1401 {
1402     const struct wined3d_cs_set_sampler *op = data;
1403
1404     cs->state.sampler[op->type][op->sampler_idx] = op->sampler;
1405     if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1406         device_invalidate_state(cs->device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1407     else
1408         device_invalidate_state(cs->device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1409 }
1410
1411 void wined3d_cs_emit_set_sampler(struct wined3d_cs *cs, enum wined3d_shader_type type,
1412         UINT sampler_idx, struct wined3d_sampler *sampler)
1413 {
1414     struct wined3d_cs_set_sampler *op;
1415
1416     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1417     op->opcode = WINED3D_CS_OP_SET_SAMPLER;
1418     op->type = type;
1419     op->sampler_idx = sampler_idx;
1420     op->sampler = sampler;
1421
1422     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1423 }
1424
1425 static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
1426 {
1427     const struct wined3d_cs_set_shader *op = data;
1428
1429     cs->state.shader[op->type] = op->shader;
1430     device_invalidate_state(cs->device, STATE_SHADER(op->type));
1431     if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1432         device_invalidate_state(cs->device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1433     else
1434         device_invalidate_state(cs->device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1435 }
1436
1437 void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
1438 {
1439     struct wined3d_cs_set_shader *op;
1440
1441     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1442     op->opcode = WINED3D_CS_OP_SET_SHADER;
1443     op->type = type;
1444     op->shader = shader;
1445
1446     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1447 }
1448
1449 static void wined3d_cs_exec_set_blend_state(struct wined3d_cs *cs, const void *data)
1450 {
1451     const struct wined3d_cs_set_blend_state *op = data;
1452
1453     cs->state.blend_state = op->state;
1454     device_invalidate_state(cs->device, STATE_BLEND);
1455 }
1456
1457 void wined3d_cs_emit_set_blend_state(struct wined3d_cs *cs, struct wined3d_blend_state *state)
1458 {
1459     struct wined3d_cs_set_blend_state *op;
1460
1461     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1462     op->opcode = WINED3D_CS_OP_SET_BLEND_STATE;
1463     op->state = state;
1464
1465     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1466 }
1467
1468 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs *cs, const void *data)
1469 {
1470     const struct wined3d_cs_set_rasterizer_state *op = data;
1471
1472     cs->state.rasterizer_state = op->state;
1473     device_invalidate_state(cs->device, STATE_FRONTFACE);
1474 }
1475
1476 void wined3d_cs_emit_set_rasterizer_state(struct wined3d_cs *cs,
1477         struct wined3d_rasterizer_state *rasterizer_state)
1478 {
1479     struct wined3d_cs_set_rasterizer_state *op;
1480
1481     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1482     op->opcode = WINED3D_CS_OP_SET_RASTERIZER_STATE;
1483     op->state = rasterizer_state;
1484
1485     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1486 }
1487
1488 static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
1489 {
1490     const struct wined3d_cs_set_render_state *op = data;
1491
1492     cs->state.render_states[op->state] = op->value;
1493     device_invalidate_state(cs->device, STATE_RENDER(op->state));
1494 }
1495
1496 void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
1497 {
1498     struct wined3d_cs_set_render_state *op;
1499
1500     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1501     op->opcode = WINED3D_CS_OP_SET_RENDER_STATE;
1502     op->state = state;
1503     op->value = value;
1504
1505     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1506 }
1507
1508 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
1509 {
1510     const struct wined3d_cs_set_texture_state *op = data;
1511
1512     cs->state.texture_states[op->stage][op->state] = op->value;
1513     device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, op->state));
1514 }
1515
1516 void wined3d_cs_emit_set_texture_state(struct wined3d_cs *cs, UINT stage,
1517         enum wined3d_texture_stage_state state, DWORD value)
1518 {
1519     struct wined3d_cs_set_texture_state *op;
1520
1521     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1522     op->opcode = WINED3D_CS_OP_SET_TEXTURE_STATE;
1523     op->stage = stage;
1524     op->state = state;
1525     op->value = value;
1526
1527     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1528 }
1529
1530 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
1531 {
1532     const struct wined3d_cs_set_sampler_state *op = data;
1533
1534     cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
1535     device_invalidate_state(cs->device, STATE_SAMPLER(op->sampler_idx));
1536 }
1537
1538 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
1539         enum wined3d_sampler_state state, DWORD value)
1540 {
1541     struct wined3d_cs_set_sampler_state *op;
1542
1543     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1544     op->opcode = WINED3D_CS_OP_SET_SAMPLER_STATE;
1545     op->sampler_idx = sampler_idx;
1546     op->state = state;
1547     op->value = value;
1548
1549     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1550 }
1551
1552 static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
1553 {
1554     const struct wined3d_cs_set_transform *op = data;
1555
1556     cs->state.transforms[op->state] = op->matrix;
1557     if (op->state < WINED3D_TS_WORLD_MATRIX(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
1558         device_invalidate_state(cs->device, STATE_TRANSFORM(op->state));
1559 }
1560
1561 void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform_state state,
1562         const struct wined3d_matrix *matrix)
1563 {
1564     struct wined3d_cs_set_transform *op;
1565
1566     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1567     op->opcode = WINED3D_CS_OP_SET_TRANSFORM;
1568     op->state = state;
1569     op->matrix = *matrix;
1570
1571     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1572 }
1573
1574 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
1575 {
1576     const struct wined3d_cs_set_clip_plane *op = data;
1577
1578     cs->state.clip_planes[op->plane_idx] = op->plane;
1579     device_invalidate_state(cs->device, STATE_CLIPPLANE(op->plane_idx));
1580 }
1581
1582 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
1583 {
1584     struct wined3d_cs_set_clip_plane *op;
1585
1586     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1587     op->opcode = WINED3D_CS_OP_SET_CLIP_PLANE;
1588     op->plane_idx = plane_idx;
1589     op->plane = *plane;
1590
1591     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1592 }
1593
1594 static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
1595 {
1596     const struct wined3d_cs_set_color_key *op = data;
1597     struct wined3d_texture *texture = op->texture;
1598
1599     if (op->set)
1600     {
1601         switch (op->flags)
1602         {
1603             case WINED3D_CKEY_DST_BLT:
1604                 texture->async.dst_blt_color_key = op->color_key;
1605                 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
1606                 break;
1607
1608             case WINED3D_CKEY_DST_OVERLAY:
1609                 texture->async.dst_overlay_color_key = op->color_key;
1610                 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
1611                 break;
1612
1613             case WINED3D_CKEY_SRC_BLT:
1614                 if (texture == cs->state.textures[0])
1615                 {
1616                     device_invalidate_state(cs->device, STATE_COLOR_KEY);
1617                     if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1618                         device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1619                 }
1620
1621                 texture->async.src_blt_color_key = op->color_key;
1622                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
1623                 break;
1624
1625             case WINED3D_CKEY_SRC_OVERLAY:
1626                 texture->async.src_overlay_color_key = op->color_key;
1627                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
1628                 break;
1629         }
1630     }
1631     else
1632     {
1633         switch (op->flags)
1634         {
1635             case WINED3D_CKEY_DST_BLT:
1636                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
1637                 break;
1638
1639             case WINED3D_CKEY_DST_OVERLAY:
1640                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
1641                 break;
1642
1643             case WINED3D_CKEY_SRC_BLT:
1644                 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1645                     device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1646
1647                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
1648                 break;
1649
1650             case WINED3D_CKEY_SRC_OVERLAY:
1651                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
1652                 break;
1653         }
1654     }
1655 }
1656
1657 void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
1658         WORD flags, const struct wined3d_color_key *color_key)
1659 {
1660     struct wined3d_cs_set_color_key *op;
1661
1662     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1663     op->opcode = WINED3D_CS_OP_SET_COLOR_KEY;
1664     op->texture = texture;
1665     op->flags = flags;
1666     if (color_key)
1667     {
1668         op->color_key = *color_key;
1669         op->set = 1;
1670     }
1671     else
1672         op->set = 0;
1673
1674     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1675 }
1676
1677 static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
1678 {
1679     const struct wined3d_cs_set_material *op = data;
1680
1681     cs->state.material = op->material;
1682     device_invalidate_state(cs->device, STATE_MATERIAL);
1683 }
1684
1685 void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material)
1686 {
1687     struct wined3d_cs_set_material *op;
1688
1689     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1690     op->opcode = WINED3D_CS_OP_SET_MATERIAL;
1691     op->material = *material;
1692
1693     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1694 }
1695
1696 static void wined3d_cs_exec_set_light(struct wined3d_cs *cs, const void *data)
1697 {
1698     const struct wined3d_cs_set_light *op = data;
1699     struct wined3d_light_info *light_info;
1700     unsigned int light_idx, hash_idx;
1701
1702     light_idx = op->light.OriginalIndex;
1703
1704     if (!(light_info = wined3d_state_get_light(&cs->state, light_idx)))
1705     {
1706         TRACE("Adding new light.\n");
1707         if (!(light_info = heap_alloc_zero(sizeof(*light_info))))
1708         {
1709             ERR("Failed to allocate light info.\n");
1710             return;
1711         }
1712
1713         hash_idx = LIGHTMAP_HASHFUNC(light_idx);
1714         list_add_head(&cs->state.light_map[hash_idx], &light_info->entry);
1715         light_info->glIndex = -1;
1716         light_info->OriginalIndex = light_idx;
1717     }
1718
1719     if (light_info->glIndex != -1)
1720     {
1721         if (light_info->OriginalParms.type != op->light.OriginalParms.type)
1722             device_invalidate_state(cs->device, STATE_LIGHT_TYPE);
1723         device_invalidate_state(cs->device, STATE_ACTIVELIGHT(light_info->glIndex));
1724     }
1725
1726     light_info->OriginalParms = op->light.OriginalParms;
1727     light_info->position = op->light.position;
1728     light_info->direction = op->light.direction;
1729     light_info->exponent = op->light.exponent;
1730     light_info->cutoff = op->light.cutoff;
1731 }
1732
1733 void wined3d_cs_emit_set_light(struct wined3d_cs *cs, const struct wined3d_light_info *light)
1734 {
1735     struct wined3d_cs_set_light *op;
1736
1737     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1738     op->opcode = WINED3D_CS_OP_SET_LIGHT;
1739     op->light = *light;
1740
1741     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1742 }
1743
1744 static void wined3d_cs_exec_set_light_enable(struct wined3d_cs *cs, const void *data)
1745 {
1746     const struct wined3d_cs_set_light_enable *op = data;
1747     struct wined3d_device *device = cs->device;
1748     struct wined3d_light_info *light_info;
1749     int prev_idx;
1750
1751     if (!(light_info = wined3d_state_get_light(&cs->state, op->idx)))
1752     {
1753         ERR("Light doesn't exist.\n");
1754         return;
1755     }
1756
1757     prev_idx = light_info->glIndex;
1758     wined3d_state_enable_light(&cs->state, &device->adapter->d3d_info, light_info, op->enable);
1759     if (light_info->glIndex != prev_idx)
1760     {
1761         device_invalidate_state(device, STATE_LIGHT_TYPE);
1762         device_invalidate_state(device, STATE_ACTIVELIGHT(op->enable ? light_info->glIndex : prev_idx));
1763     }
1764 }
1765
1766 void wined3d_cs_emit_set_light_enable(struct wined3d_cs *cs, unsigned int idx, BOOL enable)
1767 {
1768     struct wined3d_cs_set_light_enable *op;
1769
1770     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1771     op->opcode = WINED3D_CS_OP_SET_LIGHT_ENABLE;
1772     op->idx = idx;
1773     op->enable = enable;
1774
1775     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1776 }
1777
1778 static const struct
1779 {
1780     size_t offset;
1781     size_t size;
1782     DWORD mask;
1783 }
1784 wined3d_cs_push_constant_info[] =
1785 {
1786     /* WINED3D_PUSH_CONSTANTS_VS_F */
1787     {FIELD_OFFSET(struct wined3d_state, vs_consts_f), sizeof(struct wined3d_vec4),  WINED3D_SHADER_CONST_VS_F},
1788     /* WINED3D_PUSH_CONSTANTS_PS_F */
1789     {FIELD_OFFSET(struct wined3d_state, ps_consts_f), sizeof(struct wined3d_vec4),  WINED3D_SHADER_CONST_PS_F},
1790     /* WINED3D_PUSH_CONSTANTS_VS_I */
1791     {FIELD_OFFSET(struct wined3d_state, vs_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_VS_I},
1792     /* WINED3D_PUSH_CONSTANTS_PS_I */
1793     {FIELD_OFFSET(struct wined3d_state, ps_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_PS_I},
1794     /* WINED3D_PUSH_CONSTANTS_VS_B */
1795     {FIELD_OFFSET(struct wined3d_state, vs_consts_b), sizeof(BOOL),                 WINED3D_SHADER_CONST_VS_B},
1796     /* WINED3D_PUSH_CONSTANTS_PS_B */
1797     {FIELD_OFFSET(struct wined3d_state, ps_consts_b), sizeof(BOOL),                 WINED3D_SHADER_CONST_PS_B},
1798 };
1799
1800 static void wined3d_cs_st_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p,
1801         unsigned int start_idx, unsigned int count, const void *constants)
1802 {
1803     struct wined3d_device *device = cs->device;
1804     unsigned int context_count;
1805     unsigned int i;
1806     size_t offset;
1807
1808     if (p == WINED3D_PUSH_CONSTANTS_VS_F)
1809         device->shader_backend->shader_update_float_vertex_constants(device, start_idx, count);
1810     else if (p == WINED3D_PUSH_CONSTANTS_PS_F)
1811         device->shader_backend->shader_update_float_pixel_constants(device, start_idx, count);
1812
1813     offset = wined3d_cs_push_constant_info[p].offset + start_idx * wined3d_cs_push_constant_info[p].size;
1814     memcpy((BYTE *)&cs->state + offset, constants, count * wined3d_cs_push_constant_info[p].size);
1815     for (i = 0, context_count = device->context_count; i < context_count; ++i)
1816     {
1817         device->contexts[i]->constant_update_mask |= wined3d_cs_push_constant_info[p].mask;
1818     }
1819 }
1820
1821 static void wined3d_cs_exec_push_constants(struct wined3d_cs *cs, const void *data)
1822 {
1823     const struct wined3d_cs_push_constants *op = data;
1824
1825     wined3d_cs_st_push_constants(cs, op->type, op->start_idx, op->count, op->constants);
1826 }
1827
1828 static void wined3d_cs_mt_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p,
1829         unsigned int start_idx, unsigned int count, const void *constants)
1830 {
1831     struct wined3d_cs_push_constants *op;
1832     size_t size;
1833
1834     size = count * wined3d_cs_push_constant_info[p].size;
1835     op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_push_constants, constants[size]),
1836             WINED3D_CS_QUEUE_DEFAULT);
1837     op->opcode = WINED3D_CS_OP_PUSH_CONSTANTS;
1838     op->type = p;
1839     op->start_idx = start_idx;
1840     op->count = count;
1841     memcpy(op->constants, constants, size);
1842
1843     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1844 }
1845
1846 static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
1847 {
1848     struct wined3d_adapter *adapter = cs->device->adapter;
1849
1850     state_cleanup(&cs->state);
1851     memset(&cs->state, 0, sizeof(cs->state));
1852     state_init(&cs->state, &cs->fb, &adapter->gl_info, &adapter->d3d_info,
1853             WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
1854 }
1855
1856 void wined3d_cs_emit_reset_state(struct wined3d_cs *cs)
1857 {
1858     struct wined3d_cs_reset_state *op;
1859
1860     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1861     op->opcode = WINED3D_CS_OP_RESET_STATE;
1862
1863     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1864 }
1865
1866 static void wined3d_cs_exec_callback(struct wined3d_cs *cs, const void *data)
1867 {
1868     const struct wined3d_cs_callback *op = data;
1869
1870     op->callback(op->object);
1871 }
1872
1873 static void wined3d_cs_emit_callback(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1874 {
1875     struct wined3d_cs_callback *op;
1876
1877     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1878     op->opcode = WINED3D_CS_OP_CALLBACK;
1879     op->callback = callback;
1880     op->object = object;
1881
1882     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1883 }
1884
1885 void wined3d_cs_destroy_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1886 {
1887     wined3d_cs_emit_callback(cs, callback, object);
1888 }
1889
1890 void wined3d_cs_init_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1891 {
1892     wined3d_cs_emit_callback(cs, callback, object);
1893 }
1894
1895 static void wined3d_cs_exec_query_issue(struct wined3d_cs *cs, const void *data)
1896 {
1897     const struct wined3d_cs_query_issue *op = data;
1898     struct wined3d_query *query = op->query;
1899     BOOL poll;
1900
1901     poll = query->query_ops->query_issue(query, op->flags);
1902
1903     if (!cs->thread)
1904         return;
1905
1906     if (poll && list_empty(&query->poll_list_entry))
1907     {
1908         list_add_tail(&cs->query_poll_list, &query->poll_list_entry);
1909         return;
1910     }
1911
1912     /* This can happen if occlusion queries are restarted. This discards the
1913      * old result, since polling it could result in a GL error. */
1914     if ((op->flags & WINED3DISSUE_BEGIN) && !poll && !list_empty(&query->poll_list_entry))
1915     {
1916         list_remove(&query->poll_list_entry);
1917         list_init(&query->poll_list_entry);
1918         InterlockedIncrement(&query->counter_retrieved);
1919         return;
1920     }
1921
1922     /* This can happen when an occlusion query is ended without being started,
1923      * in which case we don't want to poll, but still have to counter-balance
1924      * the increment of the main counter.
1925      *
1926      * This can also happen if an event query is re-issued before the first
1927      * fence was reached. In this case the query is already in the list and
1928      * the poll function will check the new fence. We have to counter-balance
1929      * the discarded increment. */
1930     if (op->flags & WINED3DISSUE_END)
1931         InterlockedIncrement(&query->counter_retrieved);
1932 }
1933
1934 void wined3d_cs_emit_query_issue(struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags)
1935 {
1936     struct wined3d_cs_query_issue *op;
1937
1938     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1939     op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
1940     op->query = query;
1941     op->flags = flags;
1942
1943     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1944     cs->queries_flushed = FALSE;
1945 }
1946
1947 static void wined3d_cs_exec_preload_resource(struct wined3d_cs *cs, const void *data)
1948 {
1949     const struct wined3d_cs_preload_resource *op = data;
1950     struct wined3d_resource *resource = op->resource;
1951
1952     resource->resource_ops->resource_preload(resource);
1953     wined3d_resource_release(resource);
1954 }
1955
1956 void wined3d_cs_emit_preload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
1957 {
1958     struct wined3d_cs_preload_resource *op;
1959
1960     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1961     op->opcode = WINED3D_CS_OP_PRELOAD_RESOURCE;
1962     op->resource = resource;
1963
1964     wined3d_resource_acquire(resource);
1965
1966     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1967 }
1968
1969 static void wined3d_cs_exec_unload_resource(struct wined3d_cs *cs, const void *data)
1970 {
1971     const struct wined3d_cs_unload_resource *op = data;
1972     struct wined3d_resource *resource = op->resource;
1973
1974     resource->resource_ops->resource_unload(resource);
1975     wined3d_resource_release(resource);
1976 }
1977
1978 void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
1979 {
1980     struct wined3d_cs_unload_resource *op;
1981
1982     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1983     op->opcode = WINED3D_CS_OP_UNLOAD_RESOURCE;
1984     op->resource = resource;
1985
1986     wined3d_resource_acquire(resource);
1987
1988     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1989 }
1990
1991 static void wined3d_cs_exec_map(struct wined3d_cs *cs, const void *data)
1992 {
1993     const struct wined3d_cs_map *op = data;
1994     struct wined3d_resource *resource = op->resource;
1995
1996     *op->hr = resource->resource_ops->resource_sub_resource_map(resource,
1997             op->sub_resource_idx, op->map_desc, op->box, op->flags);
1998 }
1999
2000 HRESULT wined3d_cs_map(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx,
2001         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, unsigned int flags)
2002 {
2003     struct wined3d_cs_map *op;
2004     HRESULT hr;
2005
2006     /* Mapping resources from the worker thread isn't an issue by itself, but
2007      * increasing the map count would be visible to applications. */
2008     wined3d_not_from_cs(cs);
2009
2010     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2011     op->opcode = WINED3D_CS_OP_MAP;
2012     op->resource = resource;
2013     op->sub_resource_idx = sub_resource_idx;
2014     op->map_desc = map_desc;
2015     op->box = box;
2016     op->flags = flags;
2017     op->hr = &hr;
2018
2019     cs->ops->submit(cs, WINED3D_CS_QUEUE_MAP);
2020     cs->ops->finish(cs, WINED3D_CS_QUEUE_MAP);
2021
2022     return hr;
2023 }
2024
2025 static void wined3d_cs_exec_unmap(struct wined3d_cs *cs, const void *data)
2026 {
2027     const struct wined3d_cs_unmap *op = data;
2028     struct wined3d_resource *resource = op->resource;
2029
2030     *op->hr = resource->resource_ops->resource_sub_resource_unmap(resource, op->sub_resource_idx);
2031 }
2032
2033 HRESULT wined3d_cs_unmap(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx)
2034 {
2035     struct wined3d_cs_unmap *op;
2036     HRESULT hr;
2037
2038     wined3d_not_from_cs(cs);
2039
2040     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2041     op->opcode = WINED3D_CS_OP_UNMAP;
2042     op->resource = resource;
2043     op->sub_resource_idx = sub_resource_idx;
2044     op->hr = &hr;
2045
2046     cs->ops->submit(cs, WINED3D_CS_QUEUE_MAP);
2047     cs->ops->finish(cs, WINED3D_CS_QUEUE_MAP);
2048
2049     return hr;
2050 }
2051
2052 static void wined3d_cs_exec_blt_sub_resource(struct wined3d_cs *cs, const void *data)
2053 {
2054     const struct wined3d_cs_blt_sub_resource *op = data;
2055
2056     if (op->dst_resource->type == WINED3D_RTYPE_BUFFER)
2057     {
2058         wined3d_buffer_copy(buffer_from_resource(op->dst_resource), op->dst_box.left,
2059                 buffer_from_resource(op->src_resource), op->src_box.left,
2060                 op->src_box.right - op->src_box.left);
2061     }
2062     else if (op->dst_resource->type == WINED3D_RTYPE_TEXTURE_2D)
2063     {
2064         struct wined3d_surface *dst_surface, *src_surface;
2065         struct wined3d_texture *dst_texture, *src_texture;
2066         RECT dst_rect, src_rect;
2067
2068         dst_texture = texture_from_resource(op->dst_resource);
2069         src_texture = texture_from_resource(op->src_resource);
2070         dst_surface = dst_texture->sub_resources[op->dst_sub_resource_idx].u.surface;
2071         src_surface = src_texture->sub_resources[op->src_sub_resource_idx].u.surface;
2072         SetRect(&dst_rect, op->dst_box.left, op->dst_box.top, op->dst_box.right, op->dst_box.bottom);
2073         SetRect(&src_rect, op->src_box.left, op->src_box.top, op->src_box.right, op->src_box.bottom);
2074
2075         if (FAILED(wined3d_surface_blt(dst_surface, &dst_rect, src_surface,
2076                 &src_rect, op->flags, &op->fx, op->filter)))
2077             FIXME("Blit failed.\n");
2078     }
2079     else if (op->dst_resource->type == WINED3D_RTYPE_TEXTURE_3D)
2080     {
2081         struct wined3d_texture *src_texture, *dst_texture;
2082         unsigned int level, update_w, update_h, update_d;
2083         unsigned int row_pitch, slice_pitch;
2084         struct wined3d_context *context;
2085         struct wined3d_bo_address addr;
2086
2087         if (op->flags & ~WINED3D_BLT_RAW)
2088         {
2089             FIXME("Flags %#x not implemented for %s resources.\n",
2090                     op->flags, debug_d3dresourcetype(op->dst_resource->type));
2091             goto error;
2092         }
2093
2094         if (!(op->flags & WINED3D_BLT_RAW) && op->src_resource->format != op->dst_resource->format)
2095         {
2096             FIXME("Format conversion not implemented for %s resources.\n",
2097                     debug_d3dresourcetype(op->dst_resource->type));
2098             goto error;
2099         }
2100
2101         update_w = op->dst_box.right - op->dst_box.left;
2102         update_h = op->dst_box.bottom - op->dst_box.top;
2103         update_d = op->dst_box.back - op->dst_box.front;
2104         if (op->src_box.right - op->src_box.left != update_w
2105                 || op->src_box.bottom - op->src_box.top != update_h
2106                 || op->src_box.back - op->src_box.front != update_d)
2107         {
2108             FIXME("Stretching not implemented for %s resources.\n",
2109                     debug_d3dresourcetype(op->dst_resource->type));
2110             goto error;
2111         }
2112
2113         if (op->src_box.left || op->src_box.top || op->src_box.front)
2114         {
2115             FIXME("Source box %s not supported for %s resources.\n",
2116                     debug_box(&op->src_box), debug_d3dresourcetype(op->dst_resource->type));
2117             goto error;
2118         }
2119
2120         dst_texture = texture_from_resource(op->dst_resource);
2121         src_texture = texture_from_resource(op->src_resource);
2122
2123         context = context_acquire(cs->device, NULL, 0);
2124
2125         if (!wined3d_texture_load_location(src_texture, op->src_sub_resource_idx,
2126                 context, src_texture->resource.map_binding))
2127         {
2128             ERR("Failed to load source sub-resource into %s.\n",
2129                     wined3d_debug_location(src_texture->resource.map_binding));
2130             context_release(context);
2131             goto error;
2132         }
2133
2134         level = op->dst_sub_resource_idx % dst_texture->level_count;
2135         if (update_w == wined3d_texture_get_level_width(dst_texture, level)
2136                 && update_h == wined3d_texture_get_level_height(dst_texture, level)
2137                 && update_d == wined3d_texture_get_level_depth(dst_texture, level))
2138         {
2139             wined3d_texture_prepare_texture(dst_texture, context, FALSE);
2140         }
2141         else if (!wined3d_texture_load_location(dst_texture, op->dst_sub_resource_idx,
2142                 context, WINED3D_LOCATION_TEXTURE_RGB))
2143         {
2144             ERR("Failed to load destination sub-resource.\n");
2145             context_release(context);
2146             goto error;
2147         }
2148
2149         wined3d_texture_get_memory(src_texture, op->src_sub_resource_idx, &addr, src_texture->resource.map_binding);
2150         wined3d_texture_get_pitch(src_texture, op->src_sub_resource_idx % src_texture->level_count,
2151                 &row_pitch, &slice_pitch);
2152
2153         wined3d_texture_bind_and_dirtify(dst_texture, context, FALSE);
2154         wined3d_texture_upload_data(dst_texture, op->dst_sub_resource_idx, context, &op->dst_box,
2155                 wined3d_const_bo_address(&addr), row_pitch, slice_pitch);
2156         wined3d_texture_validate_location(dst_texture, op->dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2157         wined3d_texture_invalidate_location(dst_texture, op->dst_sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2158
2159         context_release(context);
2160     }
2161     else
2162     {
2163         FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(op->dst_resource->type));
2164     }
2165
2166 error:
2167     if (op->src_resource)
2168         wined3d_resource_release(op->src_resource);
2169     wined3d_resource_release(op->dst_resource);
2170 }
2171
2172 void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *dst_resource,
2173         unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box, struct wined3d_resource *src_resource,
2174         unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags,
2175         const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
2176 {
2177     struct wined3d_cs_blt_sub_resource *op;
2178
2179     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2180     op->opcode = WINED3D_CS_OP_BLT_SUB_RESOURCE;
2181     op->dst_resource = dst_resource;
2182     op->dst_sub_resource_idx = dst_sub_resource_idx;
2183     op->dst_box = *dst_box;
2184     op->src_resource = src_resource;
2185     op->src_sub_resource_idx = src_sub_resource_idx;
2186     op->src_box = *src_box;
2187     op->flags = flags;
2188     if (fx)
2189         op->fx = *fx;
2190     else
2191         memset(&op->fx, 0, sizeof(op->fx));
2192     op->filter = filter;
2193
2194     wined3d_resource_acquire(dst_resource);
2195     if (src_resource)
2196         wined3d_resource_acquire(src_resource);
2197
2198     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2199     if (flags & WINED3D_BLT_SYNCHRONOUS)
2200         cs->ops->finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2201 }
2202
2203 static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const void *data)
2204 {
2205     const struct wined3d_cs_update_sub_resource *op = data;
2206     struct wined3d_resource *resource = op->resource;
2207     const struct wined3d_box *box = &op->box;
2208     unsigned int width, height, depth, level;
2209     struct wined3d_const_bo_address addr;
2210     struct wined3d_context *context;
2211     struct wined3d_texture *texture;
2212
2213     context = context_acquire(cs->device, NULL, 0);
2214
2215     if (resource->type == WINED3D_RTYPE_BUFFER)
2216     {
2217         struct wined3d_buffer *buffer = buffer_from_resource(resource);
2218
2219         if (!wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER))
2220         {
2221             ERR("Failed to load buffer location.\n");
2222             goto done;
2223         }
2224
2225         wined3d_buffer_upload_data(buffer, context, box, op->data.data);
2226         wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER);
2227         goto done;
2228     }
2229
2230     texture = wined3d_texture_from_resource(resource);
2231
2232     level = op->sub_resource_idx % texture->level_count;
2233     width = wined3d_texture_get_level_width(texture, level);
2234     height = wined3d_texture_get_level_height(texture, level);
2235     depth = wined3d_texture_get_level_depth(texture, level);
2236
2237     addr.buffer_object = 0;
2238     addr.addr = op->data.data;
2239
2240     /* Only load the sub-resource for partial updates. */
2241     if (!box->left && !box->top && !box->front
2242             && box->right == width && box->bottom == height && box->back == depth)
2243         wined3d_texture_prepare_texture(texture, context, FALSE);
2244     else
2245         wined3d_texture_load_location(texture, op->sub_resource_idx, context, WINED3D_LOCATION_TEXTURE_RGB);
2246     wined3d_texture_bind_and_dirtify(texture, context, FALSE);
2247
2248     wined3d_texture_upload_data(texture, op->sub_resource_idx, context,
2249             box, &addr, op->data.row_pitch, op->data.slice_pitch);
2250
2251     wined3d_texture_validate_location(texture, op->sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2252     wined3d_texture_invalidate_location(texture, op->sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2253
2254 done:
2255     context_release(context);
2256
2257     wined3d_resource_release(resource);
2258 }
2259
2260 void wined3d_cs_emit_update_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *resource,
2261         unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch,
2262         unsigned int slice_pitch)
2263 {
2264     struct wined3d_cs_update_sub_resource *op;
2265 #if defined(STAGING_CSMT)
2266     size_t data_size, size;
2267
2268     if (resource->type != WINED3D_RTYPE_BUFFER && resource->format_flags & WINED3DFMT_FLAG_BLOCKS)
2269         goto no_async;
2270
2271     data_size = 0;
2272     switch (resource->type)
2273     {
2274         case WINED3D_RTYPE_TEXTURE_3D:
2275             data_size += (box->back - box->front - 1) * slice_pitch;
2276             /* fall-through */
2277         case WINED3D_RTYPE_TEXTURE_2D:
2278             data_size += (box->bottom - box->top - 1) * row_pitch;
2279             /* fall-through */
2280         case WINED3D_RTYPE_TEXTURE_1D:
2281             data_size += (box->right - box->left) * resource->format->byte_count;
2282             break;
2283         case WINED3D_RTYPE_BUFFER:
2284             data_size = box->right - box->left;
2285             break;
2286         case WINED3D_RTYPE_NONE:
2287             return;
2288     }
2289
2290     size = FIELD_OFFSET(struct wined3d_cs_update_sub_resource, copy_data[data_size]);
2291     if (!cs->ops->check_space(cs, size, WINED3D_CS_QUEUE_DEFAULT))
2292         goto no_async;
2293
2294     op = cs->ops->require_space(cs, size, WINED3D_CS_QUEUE_DEFAULT);
2295     op->opcode = WINED3D_CS_OP_UPDATE_SUB_RESOURCE;
2296     op->resource = resource;
2297     op->sub_resource_idx = sub_resource_idx;
2298     op->box = *box;
2299     op->data.row_pitch = row_pitch;
2300     op->data.slice_pitch = slice_pitch;
2301     op->data.data = op->copy_data;
2302     memcpy(op->copy_data, data, data_size);
2303
2304     wined3d_resource_acquire(resource);
2305
2306     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2307     return;
2308
2309 no_async:
2310     wined3d_resource_wait_idle(resource);
2311 #endif /* STAGING_CSMT */
2312
2313     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2314     op->opcode = WINED3D_CS_OP_UPDATE_SUB_RESOURCE;
2315     op->resource = resource;
2316     op->sub_resource_idx = sub_resource_idx;
2317     op->box = *box;
2318     op->data.row_pitch = row_pitch;
2319     op->data.slice_pitch = slice_pitch;
2320     op->data.data = data;
2321
2322     wined3d_resource_acquire(resource);
2323
2324     cs->ops->submit(cs, WINED3D_CS_QUEUE_MAP);
2325 #if !defined(STAGING_CSMT)
2326     /* The data pointer may go away, so we need to wait until it is read.
2327      * Copying the data may be faster if it's small. */
2328 #endif /* STAGING_CSMT */
2329     cs->ops->finish(cs, WINED3D_CS_QUEUE_MAP);
2330 }
2331
2332 static void wined3d_cs_exec_add_dirty_texture_region(struct wined3d_cs *cs, const void *data)
2333 {
2334     const struct wined3d_cs_add_dirty_texture_region *op = data;
2335     struct wined3d_texture *texture = op->texture;
2336     unsigned int sub_resource_idx, i;
2337     struct wined3d_context *context;
2338
2339     context = context_acquire(cs->device, NULL, 0);
2340     sub_resource_idx = op->layer * texture->level_count;
2341     for (i = 0; i < texture->level_count; ++i, ++sub_resource_idx)
2342     {
2343         if (wined3d_texture_load_location(texture, sub_resource_idx, context, texture->resource.map_binding))
2344             wined3d_texture_invalidate_location(texture, sub_resource_idx, ~texture->resource.map_binding);
2345         else
2346             ERR("Failed to load location %s.\n", wined3d_debug_location(texture->resource.map_binding));
2347     }
2348     context_release(context);
2349
2350     wined3d_resource_release(&texture->resource);
2351 }
2352
2353 void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs *cs,
2354         struct wined3d_texture *texture, unsigned int layer)
2355 {
2356     struct wined3d_cs_add_dirty_texture_region *op;
2357
2358     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2359     op->opcode = WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION;
2360     op->texture = texture;
2361     op->layer = layer;
2362
2363     wined3d_resource_acquire(&texture->resource);
2364
2365     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2366 }
2367
2368 static void wined3d_cs_exec_clear_unordered_access_view(struct wined3d_cs *cs, const void *data)
2369 {
2370     const struct wined3d_cs_clear_unordered_access_view *op = data;
2371     struct wined3d_unordered_access_view *view = op->view;
2372     struct wined3d_context *context;
2373
2374     context = context_acquire(cs->device, NULL, 0);
2375     wined3d_unordered_access_view_clear_uint(view, &op->clear_value, context);
2376     context_release(context);
2377
2378     wined3d_resource_release(view->resource);
2379 }
2380
2381 void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs *cs,
2382         struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value)
2383 {
2384     struct wined3d_cs_clear_unordered_access_view *op;
2385
2386     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2387     op->opcode = WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW;
2388     op->view = view;
2389     op->clear_value = *clear_value;
2390
2391     wined3d_resource_acquire(view->resource);
2392
2393     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2394 }
2395
2396 static void wined3d_cs_exec_copy_uav_counter(struct wined3d_cs *cs, const void *data)
2397 {
2398     const struct wined3d_cs_copy_uav_counter *op = data;
2399     struct wined3d_unordered_access_view *view = op->view;
2400     struct wined3d_context *context;
2401
2402     context = context_acquire(cs->device, NULL, 0);
2403     wined3d_unordered_access_view_copy_counter(view, op->buffer, op->offset, context);
2404     context_release(context);
2405
2406     wined3d_resource_release(&op->buffer->resource);
2407     wined3d_resource_release(view->resource);
2408 }
2409
2410 void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs *cs, struct wined3d_buffer *dst_buffer,
2411         unsigned int offset, struct wined3d_unordered_access_view *uav)
2412 {
2413     struct wined3d_cs_copy_uav_counter *op;
2414
2415     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2416     op->opcode = WINED3D_CS_OP_COPY_UAV_COUNTER;
2417     op->buffer = dst_buffer;
2418     op->offset = offset;
2419     op->view = uav;
2420
2421     wined3d_resource_acquire(&dst_buffer->resource);
2422     wined3d_resource_acquire(uav->resource);
2423
2424     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2425 }
2426
2427 static void wined3d_cs_exec_generate_mipmaps(struct wined3d_cs *cs, const void *data)
2428 {
2429     const struct wined3d_cs_generate_mipmaps *op = data;
2430     struct wined3d_shader_resource_view *view = op->view;
2431
2432     shader_resource_view_generate_mipmaps(view);
2433     wined3d_resource_release(view->resource);
2434 }
2435
2436 void wined3d_cs_emit_generate_mipmaps(struct wined3d_cs *cs, struct wined3d_shader_resource_view *view)
2437 {
2438     struct wined3d_cs_generate_mipmaps *op;
2439
2440     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2441     op->opcode = WINED3D_CS_OP_GENERATE_MIPMAPS;
2442     op->view = view;
2443
2444     wined3d_resource_acquire(view->resource);
2445
2446     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2447 }
2448
2449 static void wined3d_cs_emit_stop(struct wined3d_cs *cs)
2450 {
2451     struct wined3d_cs_stop *op;
2452
2453     op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2454     op->opcode = WINED3D_CS_OP_STOP;
2455
2456     cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2457     cs->ops->finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2458 }
2459
2460 static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data) =
2461 {
2462     /* WINED3D_CS_OP_NOP                         */ wined3d_cs_exec_nop,
2463     /* WINED3D_CS_OP_PRESENT                     */ wined3d_cs_exec_present,
2464     /* WINED3D_CS_OP_CLEAR                       */ wined3d_cs_exec_clear,
2465     /* WINED3D_CS_OP_DISPATCH                    */ wined3d_cs_exec_dispatch,
2466     /* WINED3D_CS_OP_DRAW                        */ wined3d_cs_exec_draw,
2467     /* WINED3D_CS_OP_FLUSH                       */ wined3d_cs_exec_flush,
2468     /* WINED3D_CS_OP_SET_PREDICATION             */ wined3d_cs_exec_set_predication,
2469     /* WINED3D_CS_OP_SET_VIEWPORT                */ wined3d_cs_exec_set_viewport,
2470     /* WINED3D_CS_OP_SET_SCISSOR_RECT            */ wined3d_cs_exec_set_scissor_rect,
2471     /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW       */ wined3d_cs_exec_set_rendertarget_view,
2472     /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW      */ wined3d_cs_exec_set_depth_stencil_view,
2473     /* WINED3D_CS_OP_SET_VERTEX_DECLARATION      */ wined3d_cs_exec_set_vertex_declaration,
2474     /* WINED3D_CS_OP_SET_STREAM_SOURCE           */ wined3d_cs_exec_set_stream_source,
2475     /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ      */ wined3d_cs_exec_set_stream_source_freq,
2476     /* WINED3D_CS_OP_SET_STREAM_OUTPUT           */ wined3d_cs_exec_set_stream_output,
2477     /* WINED3D_CS_OP_SET_INDEX_BUFFER            */ wined3d_cs_exec_set_index_buffer,
2478     /* WINED3D_CS_OP_SET_CONSTANT_BUFFER         */ wined3d_cs_exec_set_constant_buffer,
2479     /* WINED3D_CS_OP_SET_TEXTURE                 */ wined3d_cs_exec_set_texture,
2480     /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW    */ wined3d_cs_exec_set_shader_resource_view,
2481     /* WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW   */ wined3d_cs_exec_set_unordered_access_view,
2482     /* WINED3D_CS_OP_SET_SAMPLER                 */ wined3d_cs_exec_set_sampler,
2483     /* WINED3D_CS_OP_SET_SHADER                  */ wined3d_cs_exec_set_shader,
2484     /* WINED3D_CS_OP_SET_BLEND_STATE             */ wined3d_cs_exec_set_blend_state,
2485     /* WINED3D_CS_OP_SET_RASTERIZER_STATE        */ wined3d_cs_exec_set_rasterizer_state,
2486     /* WINED3D_CS_OP_SET_RENDER_STATE            */ wined3d_cs_exec_set_render_state,
2487     /* WINED3D_CS_OP_SET_TEXTURE_STATE           */ wined3d_cs_exec_set_texture_state,
2488     /* WINED3D_CS_OP_SET_SAMPLER_STATE           */ wined3d_cs_exec_set_sampler_state,
2489     /* WINED3D_CS_OP_SET_TRANSFORM               */ wined3d_cs_exec_set_transform,
2490     /* WINED3D_CS_OP_SET_CLIP_PLANE              */ wined3d_cs_exec_set_clip_plane,
2491     /* WINED3D_CS_OP_SET_COLOR_KEY               */ wined3d_cs_exec_set_color_key,
2492     /* WINED3D_CS_OP_SET_MATERIAL                */ wined3d_cs_exec_set_material,
2493     /* WINED3D_CS_OP_SET_LIGHT                   */ wined3d_cs_exec_set_light,
2494     /* WINED3D_CS_OP_SET_LIGHT_ENABLE            */ wined3d_cs_exec_set_light_enable,
2495     /* WINED3D_CS_OP_PUSH_CONSTANTS              */ wined3d_cs_exec_push_constants,
2496     /* WINED3D_CS_OP_RESET_STATE                 */ wined3d_cs_exec_reset_state,
2497     /* WINED3D_CS_OP_CALLBACK                    */ wined3d_cs_exec_callback,
2498     /* WINED3D_CS_OP_QUERY_ISSUE                 */ wined3d_cs_exec_query_issue,
2499     /* WINED3D_CS_OP_PRELOAD_RESOURCE            */ wined3d_cs_exec_preload_resource,
2500     /* WINED3D_CS_OP_UNLOAD_RESOURCE             */ wined3d_cs_exec_unload_resource,
2501     /* WINED3D_CS_OP_MAP                         */ wined3d_cs_exec_map,
2502     /* WINED3D_CS_OP_UNMAP                       */ wined3d_cs_exec_unmap,
2503     /* WINED3D_CS_OP_BLT_SUB_RESOURCE            */ wined3d_cs_exec_blt_sub_resource,
2504     /* WINED3D_CS_OP_UPDATE_SUB_RESOURCE         */ wined3d_cs_exec_update_sub_resource,
2505     /* WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION    */ wined3d_cs_exec_add_dirty_texture_region,
2506     /* WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_clear_unordered_access_view,
2507     /* WINED3D_CS_OP_COPY_UAV_COUNTER            */ wined3d_cs_exec_copy_uav_counter,
2508     /* WINED3D_CS_OP_GENERATE_MIPMAPS            */ wined3d_cs_exec_generate_mipmaps,
2509 };
2510
2511 #if defined(STAGING_CSMT)
2512 static BOOL wined3d_cs_st_check_space(struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
2513 {
2514     return TRUE;
2515 }
2516
2517 #endif /* STAGING_CSMT */
2518 static void *wined3d_cs_st_require_space(struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
2519 {
2520     if (size > (cs->data_size - cs->end))
2521     {
2522         size_t new_size;
2523         void *new_data;
2524
2525         new_size = max(size, cs->data_size * 2);
2526         if (!cs->end)
2527             new_data = heap_realloc(cs->data, new_size);
2528         else
2529             new_data = heap_alloc(new_size);
2530         if (!new_data)
2531             return NULL;
2532
2533         cs->data_size = new_size;
2534         cs->start = cs->end = 0;
2535         cs->data = new_data;
2536     }
2537
2538     cs->end += size;
2539
2540     return (BYTE *)cs->data + cs->start;
2541 }
2542
2543 static void wined3d_cs_st_submit(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
2544 {
2545     enum wined3d_cs_op opcode;
2546     size_t start;
2547     BYTE *data;
2548
2549     data = cs->data;
2550     start = cs->start;
2551     cs->start = cs->end;
2552
2553     opcode = *(const enum wined3d_cs_op *)&data[start];
2554     if (opcode >= WINED3D_CS_OP_STOP)
2555         ERR("Invalid opcode %#x.\n", opcode);
2556     else
2557         wined3d_cs_op_handlers[opcode](cs, &data[start]);
2558
2559     if (cs->data == data)
2560         cs->start = cs->end = start;
2561     else if (!start)
2562         heap_free(data);
2563 }
2564
2565 static void wined3d_cs_st_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
2566 {
2567 }
2568
2569 static const struct wined3d_cs_ops wined3d_cs_st_ops =
2570 {
2571 #if defined(STAGING_CSMT)
2572     wined3d_cs_st_check_space,
2573 #endif /* STAGING_CSMT */
2574     wined3d_cs_st_require_space,
2575     wined3d_cs_st_submit,
2576     wined3d_cs_st_finish,
2577     wined3d_cs_st_push_constants,
2578 };
2579
2580 static BOOL wined3d_cs_queue_is_empty(const struct wined3d_cs *cs, const struct wined3d_cs_queue *queue)
2581 {
2582     wined3d_from_cs(cs);
2583     return *(volatile LONG *)&queue->head == queue->tail;
2584 }
2585
2586 static void wined3d_cs_queue_submit(struct wined3d_cs_queue *queue, struct wined3d_cs *cs)
2587 {
2588     struct wined3d_cs_packet *packet;
2589     size_t packet_size;
2590
2591     packet = (struct wined3d_cs_packet *)&queue->data[queue->head];
2592     packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[packet->size]);
2593     InterlockedExchange(&queue->head, (queue->head + packet_size) & (WINED3D_CS_QUEUE_SIZE - 1));
2594
2595     if (InterlockedCompareExchange(&cs->waiting_for_event, FALSE, TRUE))
2596         SetEvent(cs->event);
2597 }
2598
2599 static void wined3d_cs_mt_submit(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
2600 {
2601     if (cs->thread_id == GetCurrentThreadId())
2602     {
2603         wined3d_cs_st_submit(cs, queue_id);
2604         return;
2605     }
2606
2607     wined3d_cs_queue_submit(&cs->queue[queue_id], cs);
2608 }
2609
2610 #if defined(STAGING_CSMT)
2611 static BOOL wined3d_cs_queue_check_space(struct wined3d_cs_queue *queue, size_t size)
2612 {
2613     size_t queue_size = ARRAY_SIZE(queue->data);
2614     size_t header_size, packet_size, remaining;
2615
2616     header_size = FIELD_OFFSET(struct wined3d_cs_packet, data[0]);
2617     size = (size + header_size - 1) & ~(header_size - 1);
2618     packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[size]);
2619
2620     remaining = queue_size - queue->head;
2621     return (remaining >= packet_size);
2622 }
2623
2624 #endif /* STAGING_CSMT */
2625 static void *wined3d_cs_queue_require_space(struct wined3d_cs_queue *queue, size_t size, struct wined3d_cs *cs)
2626 {
2627     size_t queue_size = ARRAY_SIZE(queue->data);
2628     size_t header_size, packet_size, remaining;
2629     struct wined3d_cs_packet *packet;
2630
2631     header_size = FIELD_OFFSET(struct wined3d_cs_packet, data[0]);
2632     size = (size + header_size - 1) & ~(header_size - 1);
2633     packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[size]);
2634     if (packet_size >= WINED3D_CS_QUEUE_SIZE)
2635     {
2636         ERR("Packet size %lu >= queue size %u.\n",
2637                 (unsigned long)packet_size, WINED3D_CS_QUEUE_SIZE);
2638         return NULL;
2639     }
2640
2641     remaining = queue_size - queue->head;
2642     if (remaining < packet_size)
2643     {
2644         size_t nop_size = remaining - header_size;
2645         struct wined3d_cs_nop *nop;
2646
2647         TRACE("Inserting a nop for %lu + %lu bytes.\n",
2648                 (unsigned long)header_size, (unsigned long)nop_size);
2649
2650         nop = wined3d_cs_queue_require_space(queue, nop_size, cs);
2651         if (nop_size)
2652             nop->opcode = WINED3D_CS_OP_NOP;
2653
2654         wined3d_cs_queue_submit(queue, cs);
2655         assert(!queue->head);
2656     }
2657
2658     for (;;)
2659     {
2660         LONG tail = *(volatile LONG *)&queue->tail;
2661         LONG head = queue->head;
2662         LONG new_pos;
2663
2664         /* Empty. */
2665         if (head == tail)
2666             break;
2667         new_pos = (head + packet_size) & (WINED3D_CS_QUEUE_SIZE - 1);
2668         /* Head ahead of tail. We checked the remaining size above, so we only
2669          * need to make sure we don't make head equal to tail. */
2670         if (head > tail && (new_pos != tail))
2671             break;
2672         /* Tail ahead of head. Make sure the new head is before the tail as
2673          * well. Note that new_pos is 0 when it's at the end of the queue. */
2674         if (new_pos < tail && new_pos)
2675             break;
2676
2677         TRACE("Waiting for free space. Head %u, tail %u, packet size %lu.\n",
2678                 head, tail, (unsigned long)packet_size);
2679     }
2680
2681     packet = (struct wined3d_cs_packet *)&queue->data[queue->head];
2682     packet->size = size;
2683     return packet->data;
2684 }
2685
2686 #if defined(STAGING_CSMT)
2687 static BOOL wined3d_cs_mt_check_space(struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
2688 {
2689     if (cs->thread_id == GetCurrentThreadId())
2690         return wined3d_cs_st_check_space(cs, size, queue_id);
2691
2692     return wined3d_cs_queue_check_space(&cs->queue[queue_id], size);
2693 }
2694
2695 #endif /* STAGING_CSMT */
2696 static void *wined3d_cs_mt_require_space(struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
2697 {
2698     if (cs->thread_id == GetCurrentThreadId())
2699         return wined3d_cs_st_require_space(cs, size, queue_id);
2700
2701     return wined3d_cs_queue_require_space(&cs->queue[queue_id], size, cs);
2702 }
2703
2704 static void wined3d_cs_mt_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
2705 {
2706     if (cs->thread_id == GetCurrentThreadId())
2707     {
2708         wined3d_cs_st_finish(cs, queue_id);
2709         return;
2710     }
2711
2712     while (cs->queue[queue_id].head != *(volatile LONG *)&cs->queue[queue_id].tail)
2713         wined3d_pause();
2714 }
2715
2716 static const struct wined3d_cs_ops wined3d_cs_mt_ops =
2717 {
2718 #if defined(STAGING_CSMT)
2719     wined3d_cs_mt_check_space,
2720 #endif /* STAGING_CSMT */
2721     wined3d_cs_mt_require_space,
2722     wined3d_cs_mt_submit,
2723     wined3d_cs_mt_finish,
2724     wined3d_cs_mt_push_constants,
2725 };
2726
2727 static void poll_queries(struct wined3d_cs *cs)
2728 {
2729     struct wined3d_query *query, *cursor;
2730
2731     LIST_FOR_EACH_ENTRY_SAFE(query, cursor, &cs->query_poll_list, struct wined3d_query, poll_list_entry)
2732     {
2733         if (!query->query_ops->query_poll(query, 0))
2734             continue;
2735
2736         list_remove(&query->poll_list_entry);
2737         list_init(&query->poll_list_entry);
2738         InterlockedIncrement(&query->counter_retrieved);
2739     }
2740 }
2741
2742 static void wined3d_cs_wait_event(struct wined3d_cs *cs)
2743 {
2744     InterlockedExchange(&cs->waiting_for_event, TRUE);
2745
2746     /* The main thread might have enqueued a command and blocked on it after
2747      * the CS thread decided to enter wined3d_cs_wait_event(), but before
2748      * "waiting_for_event" was set.
2749      *
2750      * Likewise, we can race with the main thread when resetting
2751      * "waiting_for_event", in which case we would need to call
2752      * WaitForSingleObject() because the main thread called SetEvent(). */
2753     if (!(wined3d_cs_queue_is_empty(cs, &cs->queue[WINED3D_CS_QUEUE_DEFAULT])
2754             && wined3d_cs_queue_is_empty(cs, &cs->queue[WINED3D_CS_QUEUE_MAP]))
2755             && InterlockedCompareExchange(&cs->waiting_for_event, FALSE, TRUE))
2756         return;
2757
2758     WaitForSingleObject(cs->event, INFINITE);
2759 }
2760
2761 static DWORD WINAPI wined3d_cs_run(void *ctx)
2762 {
2763     struct wined3d_cs_packet *packet;
2764     struct wined3d_cs_queue *queue;
2765     unsigned int spin_count = 0;
2766     struct wined3d_cs *cs = ctx;
2767     enum wined3d_cs_op opcode;
2768     HMODULE wined3d_module;
2769     unsigned int poll = 0;
2770     LONG tail;
2771
2772     TRACE("Started.\n");
2773
2774     /* Copy the module handle to a local variable to avoid racing with the
2775      * thread freeing "cs" before the FreeLibraryAndExitThread() call. */
2776     wined3d_module = cs->wined3d_module;
2777
2778     list_init(&cs->query_poll_list);
2779     cs->thread_id = GetCurrentThreadId();
2780     for (;;)
2781     {
2782         if (++poll == WINED3D_CS_QUERY_POLL_INTERVAL)
2783         {
2784             poll_queries(cs);
2785             poll = 0;
2786         }
2787
2788         queue = &cs->queue[WINED3D_CS_QUEUE_MAP];
2789         if (wined3d_cs_queue_is_empty(cs, queue))
2790         {
2791             queue = &cs->queue[WINED3D_CS_QUEUE_DEFAULT];
2792             if (wined3d_cs_queue_is_empty(cs, queue))
2793             {
2794                 if (++spin_count >= WINED3D_CS_SPIN_COUNT && list_empty(&cs->query_poll_list))
2795                     wined3d_cs_wait_event(cs);
2796                 continue;
2797             }
2798         }
2799         spin_count = 0;
2800
2801         tail = queue->tail;
2802         packet = (struct wined3d_cs_packet *)&queue->data[tail];
2803         if (packet->size)
2804         {
2805             opcode = *(const enum wined3d_cs_op *)packet->data;
2806
2807             if (opcode >= WINED3D_CS_OP_STOP)
2808             {
2809                 if (opcode > WINED3D_CS_OP_STOP)
2810                     ERR("Invalid opcode %#x.\n", opcode);
2811                 break;
2812             }
2813
2814             wined3d_cs_op_handlers[opcode](cs, packet->data);
2815         }
2816
2817         tail += FIELD_OFFSET(struct wined3d_cs_packet, data[packet->size]);
2818         tail &= (WINED3D_CS_QUEUE_SIZE - 1);
2819         InterlockedExchange(&queue->tail, tail);
2820     }
2821
2822     cs->queue[WINED3D_CS_QUEUE_MAP].tail = cs->queue[WINED3D_CS_QUEUE_MAP].head;
2823     cs->queue[WINED3D_CS_QUEUE_DEFAULT].tail = cs->queue[WINED3D_CS_QUEUE_DEFAULT].head;
2824     TRACE("Stopped.\n");
2825     FreeLibraryAndExitThread(wined3d_module, 0);
2826 }
2827
2828 struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
2829 {
2830     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2831     struct wined3d_cs *cs;
2832
2833     if (!(cs = heap_alloc_zero(sizeof(*cs))))
2834         return NULL;
2835
2836     cs->ops = &wined3d_cs_st_ops;
2837     cs->device = device;
2838
2839     state_init(&cs->state, &cs->fb, gl_info, &device->adapter->d3d_info,
2840             WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
2841
2842     cs->data_size = WINED3D_INITIAL_CS_SIZE;
2843     if (!(cs->data = heap_alloc(cs->data_size)))
2844         goto fail;
2845
2846     if (wined3d_settings.cs_multithreaded
2847             && !RtlIsCriticalSectionLockedByThread(NtCurrentTeb()->Peb->LoaderLock))
2848     {
2849         cs->ops = &wined3d_cs_mt_ops;
2850
2851         if (!(cs->event = CreateEventW(NULL, FALSE, FALSE, NULL)))
2852         {
2853             ERR("Failed to create command stream event.\n");
2854             heap_free(cs->data);
2855             goto fail;
2856         }
2857
2858         if (!(GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
2859                 (const WCHAR *)wined3d_cs_run, &cs->wined3d_module)))
2860         {
2861             ERR("Failed to get wined3d module handle.\n");
2862             CloseHandle(cs->event);
2863             heap_free(cs->data);
2864             goto fail;
2865         }
2866
2867         if (!(cs->thread = CreateThread(NULL, 0, wined3d_cs_run, cs, 0, NULL)))
2868         {
2869             ERR("Failed to create wined3d command stream thread.\n");
2870             FreeLibrary(cs->wined3d_module);
2871             CloseHandle(cs->event);
2872             heap_free(cs->data);
2873             goto fail;
2874         }
2875     }
2876
2877     return cs;
2878
2879 fail:
2880     state_cleanup(&cs->state);
2881     heap_free(cs);
2882     return NULL;
2883 }
2884
2885 void wined3d_cs_destroy(struct wined3d_cs *cs)
2886 {
2887     if (cs->thread)
2888     {
2889         wined3d_cs_emit_stop(cs);
2890         CloseHandle(cs->thread);
2891         if (!CloseHandle(cs->event))
2892             ERR("Closing event failed.\n");
2893     }
2894
2895     state_cleanup(&cs->state);
2896     heap_free(cs->data);
2897     heap_free(cs);
2898 }