dlls/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 "wined3d_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  23 WINE_DECLARE_DEBUG_CHANNEL(d3d_sync);
  24 WINE_DECLARE_DEBUG_CHANNEL(fps);
  25
  26 #define WINED3D_INITIAL_CS_SIZE 4096
  27
  28 struct wined3d_deferred_upload
  29 {
  30     struct wined3d_resource *resource;
  31     unsigned int sub_resource_idx;
  32     uint8_t *sysmem;
  33     struct wined3d_box box;
  34     uint32_t upload_flags;
  35 };
  36
  37 struct wined3d_deferred_query_issue
  38 {
  39     struct wined3d_query *query;
  40     unsigned int flags;
  41 };
  42
  43 struct wined3d_command_list
  44 {
  45     LONG refcount;
  46
  47     struct wined3d_device *device;
  48
  49     SIZE_T data_size;
  50     void *data;
  51
  52     SIZE_T resource_count;
  53     struct wined3d_resource **resources;
  54
  55     SIZE_T upload_count;
  56     struct wined3d_deferred_upload *uploads;
  57
  58     /* List of command lists queued for execution on this command list. We might
  59      * be the only thing holding a pointer to another command list, so we need
  60      * to hold a reference here (and in wined3d_deferred_context) as well. */
  61     SIZE_T command_list_count;
  62     struct wined3d_command_list **command_lists;
  63
  64     SIZE_T query_count;
  65     struct wined3d_deferred_query_issue *queries;
  66 };
  67
  68 static void invalidate_client_address(struct wined3d_resource *resource)
  69 {
  70     struct wined3d_client_resource *client = &resource->client;
  71
  72     memset(&client->addr, 0, sizeof(client->addr));
  73 }
  74
  75 enum wined3d_cs_op
  76 {
  77     WINED3D_CS_OP_NOP,
  78     WINED3D_CS_OP_PRESENT,
  79     WINED3D_CS_OP_CLEAR,
  80     WINED3D_CS_OP_DISPATCH,
  81     WINED3D_CS_OP_DRAW,
  82     WINED3D_CS_OP_FLUSH,
  83     WINED3D_CS_OP_SET_PREDICATION,
  84     WINED3D_CS_OP_SET_VIEWPORTS,
  85     WINED3D_CS_OP_SET_SCISSOR_RECTS,
  86     WINED3D_CS_OP_SET_RENDERTARGET_VIEWS,
  87     WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW,
  88     WINED3D_CS_OP_SET_VERTEX_DECLARATION,
  89     WINED3D_CS_OP_SET_STREAM_SOURCES,
  90     WINED3D_CS_OP_SET_STREAM_OUTPUTS,
  91     WINED3D_CS_OP_SET_INDEX_BUFFER,
  92     WINED3D_CS_OP_SET_CONSTANT_BUFFERS,
  93     WINED3D_CS_OP_SET_TEXTURE,
  94     WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEWS,
  95     WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEWS,
  96     WINED3D_CS_OP_SET_SAMPLERS,
  97     WINED3D_CS_OP_SET_SHADER,
  98     WINED3D_CS_OP_SET_BLEND_STATE,
  99     WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE,
 100     WINED3D_CS_OP_SET_RASTERIZER_STATE,
 101     WINED3D_CS_OP_SET_RENDER_STATE,
 102     WINED3D_CS_OP_SET_TEXTURE_STATE,
 103     WINED3D_CS_OP_SET_SAMPLER_STATE,
 104     WINED3D_CS_OP_SET_TRANSFORM,
 105     WINED3D_CS_OP_SET_CLIP_PLANE,
 106     WINED3D_CS_OP_SET_COLOR_KEY,
 107     WINED3D_CS_OP_SET_MATERIAL,
 108     WINED3D_CS_OP_SET_LIGHT,
 109     WINED3D_CS_OP_SET_LIGHT_ENABLE,
 110     WINED3D_CS_OP_SET_FEATURE_LEVEL,
 111     WINED3D_CS_OP_PUSH_CONSTANTS,
 112     WINED3D_CS_OP_RESET_STATE,
 113     WINED3D_CS_OP_CALLBACK,
 114     WINED3D_CS_OP_QUERY_ISSUE,
 115     WINED3D_CS_OP_PRELOAD_RESOURCE,
 116     WINED3D_CS_OP_UNLOAD_RESOURCE,
 117     WINED3D_CS_OP_MAP,
 118     WINED3D_CS_OP_UNMAP,
 119     WINED3D_CS_OP_BLT_SUB_RESOURCE,
 120     WINED3D_CS_OP_UPDATE_SUB_RESOURCE,
 121     WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION,
 122     WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW,
 123     WINED3D_CS_OP_COPY_UAV_COUNTER,
 124     WINED3D_CS_OP_GENERATE_MIPMAPS,
 125     WINED3D_CS_OP_EXECUTE_COMMAND_LIST,
 126     WINED3D_CS_OP_STOP,
 127 };
 128
 129 struct wined3d_cs_packet
 130 {
 131     size_t size;
 132     BYTE data[1];
 133 };
 134
 135 struct wined3d_cs_nop
 136 {
 137     enum wined3d_cs_op opcode;
 138 };
 139
 140 struct wined3d_cs_present
 141 {
 142     enum wined3d_cs_op opcode;
 143     HWND dst_window_override;
 144     struct wined3d_swapchain *swapchain;
 145     RECT src_rect;
 146     RECT dst_rect;
 147     unsigned int swap_interval;
 148     DWORD flags;
 149 };
 150
 151 struct wined3d_cs_clear
 152 {
 153     enum wined3d_cs_op opcode;
 154     DWORD flags;
 155     unsigned int rt_count;
 156     struct wined3d_fb_state fb;
 157     RECT draw_rect;
 158     struct wined3d_color color;
 159     float depth;
 160     DWORD stencil;
 161     unsigned int rect_count;
 162     RECT rects[1];
 163 };
 164
 165 struct wined3d_cs_dispatch
 166 {
 167     enum wined3d_cs_op opcode;
 168     struct wined3d_dispatch_parameters parameters;
 169 };
 170
 171 struct wined3d_cs_draw
 172 {
 173     enum wined3d_cs_op opcode;
 174     enum wined3d_primitive_type primitive_type;
 175     GLint patch_vertex_count;
 176     struct wined3d_draw_parameters parameters;
 177 };
 178
 179 struct wined3d_cs_flush
 180 {
 181     enum wined3d_cs_op opcode;
 182 };
 183
 184 struct wined3d_cs_set_predication
 185 {
 186     enum wined3d_cs_op opcode;
 187     struct wined3d_query *predicate;
 188     BOOL value;
 189 };
 190
 191 struct wined3d_cs_set_viewports
 192 {
 193     enum wined3d_cs_op opcode;
 194     unsigned int viewport_count;
 195     struct wined3d_viewport viewports[1];
 196 };
 197
 198 struct wined3d_cs_set_scissor_rects
 199 {
 200     enum wined3d_cs_op opcode;
 201     unsigned int rect_count;
 202     RECT rects[1];
 203 };
 204
 205 struct wined3d_cs_set_rendertarget_views
 206 {
 207     enum wined3d_cs_op opcode;
 208     unsigned int start_idx;
 209     unsigned int count;
 210     struct wined3d_rendertarget_view *views[1];
 211 };
 212
 213 struct wined3d_cs_set_depth_stencil_view
 214 {
 215     enum wined3d_cs_op opcode;
 216     struct wined3d_rendertarget_view *view;
 217 };
 218
 219 struct wined3d_cs_set_vertex_declaration
 220 {
 221     enum wined3d_cs_op opcode;
 222     struct wined3d_vertex_declaration *declaration;
 223 };
 224
 225 struct wined3d_cs_set_stream_sources
 226 {
 227     enum wined3d_cs_op opcode;
 228     unsigned int start_idx;
 229     unsigned int count;
 230     struct wined3d_stream_state streams[1];
 231 };
 232
 233 struct wined3d_cs_set_stream_outputs
 234 {
 235     enum wined3d_cs_op opcode;
 236     struct wined3d_stream_output outputs[WINED3D_MAX_STREAM_OUTPUT_BUFFERS];
 237 };
 238
 239 struct wined3d_cs_set_index_buffer
 240 {
 241     enum wined3d_cs_op opcode;
 242     struct wined3d_buffer *buffer;
 243     enum wined3d_format_id format_id;
 244     unsigned int offset;
 245 };
 246
 247 struct wined3d_cs_set_constant_buffers
 248 {
 249     enum wined3d_cs_op opcode;
 250     enum wined3d_shader_type type;
 251     unsigned int start_idx;
 252     unsigned int count;
 253     struct wined3d_constant_buffer_state buffers[1];
 254 };
 255
 256 struct wined3d_cs_set_texture
 257 {
 258     enum wined3d_cs_op opcode;
 259     UINT stage;
 260     struct wined3d_texture *texture;
 261 };
 262
 263 struct wined3d_cs_set_color_key
 264 {
 265     enum wined3d_cs_op opcode;
 266     struct wined3d_texture *texture;
 267     WORD flags;
 268     WORD set;
 269     struct wined3d_color_key color_key;
 270 };
 271
 272 struct wined3d_cs_set_shader_resource_views
 273 {
 274     enum wined3d_cs_op opcode;
 275     enum wined3d_shader_type type;
 276     unsigned int start_idx;
 277     unsigned int count;
 278     struct wined3d_shader_resource_view *views[1];
 279 };
 280
 281 struct wined3d_cs_set_unordered_access_views
 282 {
 283     enum wined3d_cs_op opcode;
 284     enum wined3d_pipeline pipeline;
 285     unsigned int start_idx;
 286     unsigned int count;
 287     struct
 288     {
 289         struct wined3d_unordered_access_view *view;
 290         unsigned int initial_count;
 291     } uavs[1];
 292 };
 293
 294 struct wined3d_cs_set_samplers
 295 {
 296     enum wined3d_cs_op opcode;
 297     enum wined3d_shader_type type;
 298     unsigned int start_idx;
 299     unsigned int count;
 300     struct wined3d_sampler *samplers[1];
 301 };
 302
 303 struct wined3d_cs_set_shader
 304 {
 305     enum wined3d_cs_op opcode;
 306     enum wined3d_shader_type type;
 307     struct wined3d_shader *shader;
 308 };
 309
 310 struct wined3d_cs_set_blend_state
 311 {
 312     enum wined3d_cs_op opcode;
 313     struct wined3d_blend_state *state;
 314     struct wined3d_color factor;
 315     unsigned int sample_mask;
 316 };
 317
 318 struct wined3d_cs_set_depth_stencil_state
 319 {
 320     enum wined3d_cs_op opcode;
 321     struct wined3d_depth_stencil_state *state;
 322     unsigned int stencil_ref;
 323 };
 324
 325 struct wined3d_cs_set_rasterizer_state
 326 {
 327     enum wined3d_cs_op opcode;
 328     struct wined3d_rasterizer_state *state;
 329 };
 330
 331 struct wined3d_cs_set_render_state
 332 {
 333     enum wined3d_cs_op opcode;
 334     enum wined3d_render_state state;
 335     DWORD value;
 336 };
 337
 338 struct wined3d_cs_set_texture_state
 339 {
 340     enum wined3d_cs_op opcode;
 341     UINT stage;
 342     enum wined3d_texture_stage_state state;
 343     DWORD value;
 344 };
 345
 346 struct wined3d_cs_set_sampler_state
 347 {
 348     enum wined3d_cs_op opcode;
 349     UINT sampler_idx;
 350     enum wined3d_sampler_state state;
 351     DWORD value;
 352 };
 353
 354 struct wined3d_cs_set_transform
 355 {
 356     enum wined3d_cs_op opcode;
 357     enum wined3d_transform_state state;
 358     struct wined3d_matrix matrix;
 359 };
 360
 361 struct wined3d_cs_set_clip_plane
 362 {
 363     enum wined3d_cs_op opcode;
 364     UINT plane_idx;
 365     struct wined3d_vec4 plane;
 366 };
 367
 368 struct wined3d_cs_set_material
 369 {
 370     enum wined3d_cs_op opcode;
 371     struct wined3d_material material;
 372 };
 373
 374 struct wined3d_cs_set_light
 375 {
 376     enum wined3d_cs_op opcode;
 377     struct wined3d_light_info light;
 378 };
 379
 380 struct wined3d_cs_set_light_enable
 381 {
 382     enum wined3d_cs_op opcode;
 383     unsigned int idx;
 384     BOOL enable;
 385 };
 386
 387 struct wined3d_cs_set_feature_level
 388 {
 389     enum wined3d_cs_op opcode;
 390     enum wined3d_feature_level level;
 391 };
 392
 393 struct wined3d_cs_push_constants
 394 {
 395     enum wined3d_cs_op opcode;
 396     enum wined3d_push_constants type;
 397     unsigned int start_idx;
 398     unsigned int count;
 399     BYTE constants[1];
 400 };
 401
 402 struct wined3d_cs_reset_state
 403 {
 404     enum wined3d_cs_op opcode;
 405     bool invalidate;
 406 };
 407
 408 struct wined3d_cs_callback
 409 {
 410     enum wined3d_cs_op opcode;
 411     void (*callback)(void *object);
 412     void *object;
 413 };
 414
 415 struct wined3d_cs_query_issue
 416 {
 417     enum wined3d_cs_op opcode;
 418     struct wined3d_query *query;
 419     DWORD flags;
 420 };
 421
 422 struct wined3d_cs_preload_resource
 423 {
 424     enum wined3d_cs_op opcode;
 425     struct wined3d_resource *resource;
 426 };
 427
 428 struct wined3d_cs_unload_resource
 429 {
 430     enum wined3d_cs_op opcode;
 431     struct wined3d_resource *resource;
 432 };
 433
 434 struct wined3d_cs_map
 435 {
 436     enum wined3d_cs_op opcode;
 437     struct wined3d_resource *resource;
 438     unsigned int sub_resource_idx;
 439     void **map_ptr;
 440     const struct wined3d_box *box;
 441     DWORD flags;
 442     HRESULT *hr;
 443 };
 444
 445 struct wined3d_cs_unmap
 446 {
 447     enum wined3d_cs_op opcode;
 448     struct wined3d_resource *resource;
 449     unsigned int sub_resource_idx;
 450     HRESULT *hr;
 451 };
 452
 453 struct wined3d_cs_blt_sub_resource
 454 {
 455     enum wined3d_cs_op opcode;
 456     struct wined3d_resource *dst_resource;
 457     unsigned int dst_sub_resource_idx;
 458     struct wined3d_box dst_box;
 459     struct wined3d_resource *src_resource;
 460     unsigned int src_sub_resource_idx;
 461     struct wined3d_box src_box;
 462     DWORD flags;
 463     struct wined3d_blt_fx fx;
 464     enum wined3d_texture_filter_type filter;
 465 };
 466
 467 struct wined3d_cs_update_sub_resource
 468 {
 469     enum wined3d_cs_op opcode;
 470     struct wined3d_resource *resource;
 471     unsigned int sub_resource_idx;
 472     struct wined3d_box box;
 473     struct upload_bo bo;
 474     unsigned int row_pitch, slice_pitch;
 475 };
 476
 477 struct wined3d_cs_add_dirty_texture_region
 478 {
 479     enum wined3d_cs_op opcode;
 480     struct wined3d_texture *texture;
 481     unsigned int layer;
 482 };
 483
 484 struct wined3d_cs_clear_unordered_access_view
 485 {
 486     enum wined3d_cs_op opcode;
 487     struct wined3d_unordered_access_view *view;
 488     struct wined3d_uvec4 clear_value;
 489     bool fp;
 490 };
 491
 492 struct wined3d_cs_copy_uav_counter
 493 {
 494     enum wined3d_cs_op opcode;
 495     struct wined3d_buffer *buffer;
 496     unsigned int offset;
 497     struct wined3d_unordered_access_view *view;
 498 };
 499
 500 struct wined3d_cs_generate_mipmaps
 501 {
 502     enum wined3d_cs_op opcode;
 503     struct wined3d_shader_resource_view *view;
 504 };
 505
 506 struct wined3d_cs_execute_command_list
 507 {
 508     enum wined3d_cs_op opcode;
 509     struct wined3d_command_list *list;
 510 };
 511
 512 struct wined3d_cs_stop
 513 {
 514     enum wined3d_cs_op opcode;
 515 };
 516
 517 static inline void *wined3d_device_context_require_space(struct wined3d_device_context *context,
 518         size_t size, enum wined3d_cs_queue_id queue_id)
 519 {
 520     return context->ops->require_space(context, size, queue_id);
 521 }
 522
 523 static inline void wined3d_device_context_submit(struct wined3d_device_context *context,
 524         enum wined3d_cs_queue_id queue_id)
 525 {
 526     context->ops->submit(context, queue_id);
 527 }
 528
 529 static inline void wined3d_device_context_finish(struct wined3d_device_context *context,
 530         enum wined3d_cs_queue_id queue_id)
 531 {
 532     context->ops->finish(context, queue_id);
 533 }
 534
 535 static inline void wined3d_device_context_acquire_resource(struct wined3d_device_context *context,
 536         struct wined3d_resource *resource)
 537 {
 538     context->ops->acquire_resource(context, resource);
 539 }
 540
 541 static struct wined3d_cs *wined3d_cs_from_context(struct wined3d_device_context *context)
 542 {
 543     return CONTAINING_RECORD(context, struct wined3d_cs, c);
 544 }
 545
 546 static const char *debug_cs_op(enum wined3d_cs_op op)
 547 {
 548     switch (op)
 549     {
 550 #define WINED3D_TO_STR(type) case type: return #type
 551         WINED3D_TO_STR(WINED3D_CS_OP_NOP);
 552         WINED3D_TO_STR(WINED3D_CS_OP_PRESENT);
 553         WINED3D_TO_STR(WINED3D_CS_OP_CLEAR);
 554         WINED3D_TO_STR(WINED3D_CS_OP_DISPATCH);
 555         WINED3D_TO_STR(WINED3D_CS_OP_DRAW);
 556         WINED3D_TO_STR(WINED3D_CS_OP_FLUSH);
 557         WINED3D_TO_STR(WINED3D_CS_OP_SET_PREDICATION);
 558         WINED3D_TO_STR(WINED3D_CS_OP_SET_VIEWPORTS);
 559         WINED3D_TO_STR(WINED3D_CS_OP_SET_SCISSOR_RECTS);
 560         WINED3D_TO_STR(WINED3D_CS_OP_SET_RENDERTARGET_VIEWS);
 561         WINED3D_TO_STR(WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW);
 562         WINED3D_TO_STR(WINED3D_CS_OP_SET_VERTEX_DECLARATION);
 563         WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_SOURCES);
 564         WINED3D_TO_STR(WINED3D_CS_OP_SET_STREAM_OUTPUTS);
 565         WINED3D_TO_STR(WINED3D_CS_OP_SET_INDEX_BUFFER);
 566         WINED3D_TO_STR(WINED3D_CS_OP_SET_CONSTANT_BUFFERS);
 567         WINED3D_TO_STR(WINED3D_CS_OP_SET_TEXTURE);
 568         WINED3D_TO_STR(WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEWS);
 569         WINED3D_TO_STR(WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEWS);
 570         WINED3D_TO_STR(WINED3D_CS_OP_SET_SAMPLERS);
 571         WINED3D_TO_STR(WINED3D_CS_OP_SET_SHADER);
 572         WINED3D_TO_STR(WINED3D_CS_OP_SET_BLEND_STATE);
 573         WINED3D_TO_STR(WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE);
 574         WINED3D_TO_STR(WINED3D_CS_OP_SET_RASTERIZER_STATE);
 575         WINED3D_TO_STR(WINED3D_CS_OP_SET_RENDER_STATE);
 576         WINED3D_TO_STR(WINED3D_CS_OP_SET_TEXTURE_STATE);
 577         WINED3D_TO_STR(WINED3D_CS_OP_SET_SAMPLER_STATE);
 578         WINED3D_TO_STR(WINED3D_CS_OP_SET_TRANSFORM);
 579         WINED3D_TO_STR(WINED3D_CS_OP_SET_CLIP_PLANE);
 580         WINED3D_TO_STR(WINED3D_CS_OP_SET_COLOR_KEY);
 581         WINED3D_TO_STR(WINED3D_CS_OP_SET_MATERIAL);
 582         WINED3D_TO_STR(WINED3D_CS_OP_SET_LIGHT);
 583         WINED3D_TO_STR(WINED3D_CS_OP_SET_LIGHT_ENABLE);
 584         WINED3D_TO_STR(WINED3D_CS_OP_SET_FEATURE_LEVEL);
 585         WINED3D_TO_STR(WINED3D_CS_OP_PUSH_CONSTANTS);
 586         WINED3D_TO_STR(WINED3D_CS_OP_RESET_STATE);
 587         WINED3D_TO_STR(WINED3D_CS_OP_CALLBACK);
 588         WINED3D_TO_STR(WINED3D_CS_OP_QUERY_ISSUE);
 589         WINED3D_TO_STR(WINED3D_CS_OP_PRELOAD_RESOURCE);
 590         WINED3D_TO_STR(WINED3D_CS_OP_UNLOAD_RESOURCE);
 591         WINED3D_TO_STR(WINED3D_CS_OP_MAP);
 592         WINED3D_TO_STR(WINED3D_CS_OP_UNMAP);
 593         WINED3D_TO_STR(WINED3D_CS_OP_BLT_SUB_RESOURCE);
 594         WINED3D_TO_STR(WINED3D_CS_OP_UPDATE_SUB_RESOURCE);
 595         WINED3D_TO_STR(WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION);
 596         WINED3D_TO_STR(WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW);
 597         WINED3D_TO_STR(WINED3D_CS_OP_COPY_UAV_COUNTER);
 598         WINED3D_TO_STR(WINED3D_CS_OP_GENERATE_MIPMAPS);
 599         WINED3D_TO_STR(WINED3D_CS_OP_EXECUTE_COMMAND_LIST);
 600         WINED3D_TO_STR(WINED3D_CS_OP_STOP);
 601 #undef WINED3D_TO_STR
 602     }
 603     return wine_dbg_sprintf("UNKNOWN_OP(%#x)", op);
 604 }
 605
 606 static struct wined3d_cs_packet *wined3d_next_cs_packet(const uint8_t *data, SIZE_T *offset)
 607 {
 608     struct wined3d_cs_packet *packet = (struct wined3d_cs_packet *)&data[*offset];
 609
 610     *offset += offsetof(struct wined3d_cs_packet, data[packet->size]);
 611
 612     return packet;
 613 }
 614
 615 static void wined3d_cs_exec_nop(struct wined3d_cs *cs, const void *data)
 616 {
 617 }
 618
 619 static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
 620 {
 621     struct wined3d_texture *logo_texture, *cursor_texture, *back_buffer;
 622     struct wined3d_rendertarget_view *dsv = cs->state.fb.depth_stencil;
 623     const struct wined3d_cs_present *op = data;
 624     const struct wined3d_swapchain_desc *desc;
 625     struct wined3d_swapchain *swapchain;
 626     unsigned int i;
 627
 628     swapchain = op->swapchain;
 629     desc = &swapchain->state.desc;
 630     back_buffer = swapchain->back_buffers[0];
 631     wined3d_swapchain_set_window(swapchain, op->dst_window_override);
 632
 633     if ((logo_texture = swapchain->device->logo_texture))
 634     {
 635         RECT rect = {0, 0, logo_texture->resource.width, logo_texture->resource.height};
 636
 637         /* Blit the logo into the upper left corner of the back-buffer. */
 638         wined3d_device_context_blt(&cs->c, back_buffer, 0, &rect, logo_texture, 0,
 639                 &rect, WINED3D_BLT_SRC_CKEY, NULL, WINED3D_TEXF_POINT);
 640     }
 641
 642     if ((cursor_texture = swapchain->device->cursor_texture)
 643             && swapchain->device->bCursorVisible && !swapchain->device->hardwareCursor)
 644     {
 645         RECT dst_rect =
 646         {
 647             swapchain->device->xScreenSpace - swapchain->device->xHotSpot,
 648             swapchain->device->yScreenSpace - swapchain->device->yHotSpot,
 649             swapchain->device->xScreenSpace + swapchain->device->cursorWidth - swapchain->device->xHotSpot,
 650             swapchain->device->yScreenSpace + swapchain->device->cursorHeight - swapchain->device->yHotSpot,
 651         };
 652         RECT src_rect =
 653         {
 654             0, 0, cursor_texture->resource.width, cursor_texture->resource.height
 655         };
 656         const RECT clip_rect = {0, 0, back_buffer->resource.width, back_buffer->resource.height};
 657
 658         TRACE("Rendering the software cursor.\n");
 659
 660         if (desc->windowed)
 661             MapWindowPoints(NULL, swapchain->win_handle, (POINT *)&dst_rect, 2);
 662         if (wined3d_clip_blit(&clip_rect, &dst_rect, &src_rect))
 663             wined3d_device_context_blt(&cs->c, back_buffer, 0, &dst_rect, cursor_texture, 0,
 664                     &src_rect, WINED3D_BLT_ALPHA_TEST, NULL, WINED3D_TEXF_POINT);
 665     }
 666
 667     swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->swap_interval, op->flags);
 668
 669     /* Discard buffers if the swap effect allows it. */
 670     back_buffer = swapchain->back_buffers[desc->backbuffer_count - 1];
 671     if (desc->swap_effect == WINED3D_SWAP_EFFECT_DISCARD || desc->swap_effect == WINED3D_SWAP_EFFECT_FLIP_DISCARD)
 672         wined3d_texture_validate_location(back_buffer, 0, WINED3D_LOCATION_DISCARDED);
 673
 674     if (dsv && dsv->resource->type != WINED3D_RTYPE_BUFFER)
 675     {
 676         struct wined3d_texture *ds = texture_from_resource(dsv->resource);
 677
 678         if ((desc->flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL || ds->flags & WINED3D_TEXTURE_DISCARD))
 679             wined3d_rendertarget_view_validate_location(dsv, WINED3D_LOCATION_DISCARDED);
 680     }
 681
 682     if (TRACE_ON(fps))
 683     {
 684         DWORD time = GetTickCount();
 685         ++swapchain->frames;
 686
 687         /* every 1.5 seconds */
 688         if (time - swapchain->prev_time > 1500)
 689         {
 690             TRACE_(fps)("%p @ approx %.2ffps\n",
 691                     swapchain, 1000.0 * swapchain->frames / (time - swapchain->prev_time));
 692             swapchain->prev_time = time;
 693             swapchain->frames = 0;
 694         }
 695     }
 696
 697     wined3d_resource_release(&swapchain->front_buffer->resource);
 698     for (i = 0; i < desc->backbuffer_count; ++i)
 699     {
 700         wined3d_resource_release(&swapchain->back_buffers[i]->resource);
 701     }
 702
 703     InterlockedDecrement(&cs->pending_presents);
 704 }
 705
 706 void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain,
 707         const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override,
 708         unsigned int swap_interval, DWORD flags)
 709 {
 710     struct wined3d_cs_present *op;
 711     unsigned int i;
 712     LONG pending;
 713
 714     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 715     op->opcode = WINED3D_CS_OP_PRESENT;
 716     op->dst_window_override = dst_window_override;
 717     op->swapchain = swapchain;
 718     op->src_rect = *src_rect;
 719     op->dst_rect = *dst_rect;
 720     op->swap_interval = swap_interval;
 721     op->flags = flags;
 722
 723     pending = InterlockedIncrement(&cs->pending_presents);
 724
 725     wined3d_resource_acquire(&swapchain->front_buffer->resource);
 726     for (i = 0; i < swapchain->state.desc.backbuffer_count; ++i)
 727     {
 728         wined3d_resource_acquire(&swapchain->back_buffers[i]->resource);
 729     }
 730
 731     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
 732
 733     /* Limit input latency by limiting the number of presents that we can get
 734      * ahead of the worker thread. */
 735     while (pending >= swapchain->max_frame_latency)
 736     {
 737         YieldProcessor();
 738         pending = InterlockedCompareExchange(&cs->pending_presents, 0, 0);
 739     }
 740 }
 741
 742 static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
 743 {
 744     struct wined3d_device *device = cs->c.device;
 745     const struct wined3d_cs_clear *op = data;
 746     unsigned int i;
 747
 748     device->blitter->ops->blitter_clear(device->blitter, device, op->rt_count, &op->fb,
 749             op->rect_count, op->rects, &op->draw_rect, op->flags, &op->color, op->depth, op->stencil);
 750
 751     if (op->flags & WINED3DCLEAR_TARGET)
 752     {
 753         for (i = 0; i < op->rt_count; ++i)
 754         {
 755             if (op->fb.render_targets[i])
 756                 wined3d_resource_release(op->fb.render_targets[i]->resource);
 757         }
 758     }
 759     if (op->flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
 760         wined3d_resource_release(op->fb.depth_stencil->resource);
 761 }
 762
 763 void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
 764         DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 765 {
 766     const struct wined3d_state *state = cs->c.state;
 767     const struct wined3d_viewport *vp = &state->viewports[0];
 768     struct wined3d_rendertarget_view *view;
 769     struct wined3d_cs_clear *op;
 770     unsigned int rt_count, i;
 771
 772     rt_count = flags & WINED3DCLEAR_TARGET ? cs->c.device->adapter->d3d_info.limits.max_rt_count : 0;
 773
 774     op = wined3d_device_context_require_space(&cs->c, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]),
 775             WINED3D_CS_QUEUE_DEFAULT);
 776     op->opcode = WINED3D_CS_OP_CLEAR;
 777     op->flags = flags & (WINED3DCLEAR_TARGET | WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL);
 778     op->rt_count = rt_count;
 779     op->fb = state->fb;
 780     SetRect(&op->draw_rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
 781     if (state->rasterizer_state && state->rasterizer_state->desc.scissor)
 782         IntersectRect(&op->draw_rect, &op->draw_rect, &state->scissor_rects[0]);
 783     op->color = *color;
 784     op->depth = depth;
 785     op->stencil = stencil;
 786     op->rect_count = rect_count;
 787     memcpy(op->rects, rects, sizeof(*rects) * rect_count);
 788
 789     for (i = 0; i < rt_count; ++i)
 790     {
 791         if ((view = state->fb.render_targets[i]))
 792             wined3d_resource_acquire(view->resource);
 793     }
 794     if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
 795     {
 796         view = state->fb.depth_stencil;
 797         wined3d_resource_acquire(view->resource);
 798     }
 799
 800     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
 801 }
 802
 803 void wined3d_device_context_emit_clear_rendertarget_view(struct wined3d_device_context *context,
 804         struct wined3d_rendertarget_view *view, const RECT *rect, unsigned int flags,
 805         const struct wined3d_color *color, float depth, unsigned int stencil)
 806 {
 807     struct wined3d_cs_clear *op;
 808     size_t size;
 809
 810     size = FIELD_OFFSET(struct wined3d_cs_clear, rects[1]);
 811     op = wined3d_device_context_require_space(context, size, WINED3D_CS_QUEUE_DEFAULT);
 812
 813     op->opcode = WINED3D_CS_OP_CLEAR;
 814     op->flags = flags & (WINED3DCLEAR_TARGET | WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL);
 815     if (flags & WINED3DCLEAR_TARGET)
 816     {
 817         op->rt_count = 1;
 818         op->fb.render_targets[0] = view;
 819         op->fb.depth_stencil = NULL;
 820         op->color = *color;
 821     }
 822     else
 823     {
 824         op->rt_count = 0;
 825         op->fb.render_targets[0] = NULL;
 826         op->fb.depth_stencil = view;
 827         op->depth = depth;
 828         op->stencil = stencil;
 829     }
 830     SetRect(&op->draw_rect, 0, 0, view->width, view->height);
 831     op->rect_count = 1;
 832     op->rects[0] = *rect;
 833
 834     wined3d_device_context_acquire_resource(context, view->resource);
 835
 836     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
 837     if (flags & WINED3DCLEAR_SYNCHRONOUS)
 838         wined3d_device_context_finish(context, WINED3D_CS_QUEUE_DEFAULT);
 839 }
 840
 841 static void acquire_shader_resources(struct wined3d_device_context *context, unsigned int shader_mask)
 842 {
 843     const struct wined3d_state *state = context->state;
 844     struct wined3d_shader_sampler_map_entry *entry;
 845     struct wined3d_shader_resource_view *view;
 846     struct wined3d_shader *shader;
 847     unsigned int i, j;
 848
 849     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 850     {
 851         if (!(shader_mask & (1u << i)))
 852             continue;
 853
 854         if (!(shader = state->shader[i]))
 855             continue;
 856
 857         for (j = 0; j < WINED3D_MAX_CBS; ++j)
 858         {
 859             if (state->cb[i][j].buffer)
 860                 wined3d_device_context_acquire_resource(context, &state->cb[i][j].buffer->resource);
 861         }
 862
 863         for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
 864         {
 865             entry = &shader->reg_maps.sampler_map.entries[j];
 866
 867             if (!(view = state->shader_resource_view[i][entry->resource_idx]))
 868                 continue;
 869
 870             wined3d_device_context_acquire_resource(context, view->resource);
 871         }
 872     }
 873 }
 874
 875 static void release_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
 876 {
 877     struct wined3d_shader_sampler_map_entry *entry;
 878     struct wined3d_shader_resource_view *view;
 879     struct wined3d_shader *shader;
 880     unsigned int i, j;
 881
 882     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 883     {
 884         if (!(shader_mask & (1u << i)))
 885             continue;
 886
 887         if (!(shader = state->shader[i]))
 888             continue;
 889
 890         for (j = 0; j < WINED3D_MAX_CBS; ++j)
 891         {
 892             if (state->cb[i][j].buffer)
 893                 wined3d_resource_release(&state->cb[i][j].buffer->resource);
 894         }
 895
 896         for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
 897         {
 898             entry = &shader->reg_maps.sampler_map.entries[j];
 899
 900             if (!(view = state->shader_resource_view[i][entry->resource_idx]))
 901                 continue;
 902
 903             wined3d_resource_release(view->resource);
 904         }
 905     }
 906 }
 907
 908 static void acquire_unordered_access_resources(struct wined3d_device_context *context,
 909         const struct wined3d_shader *shader, struct wined3d_unordered_access_view * const *views)
 910 {
 911     unsigned int i;
 912
 913     if (!shader)
 914         return;
 915
 916     for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
 917     {
 918         if (!shader->reg_maps.uav_resource_info[i].type)
 919             continue;
 920
 921         if (!views[i])
 922             continue;
 923
 924         wined3d_device_context_acquire_resource(context, views[i]->resource);
 925     }
 926 }
 927
 928 static void release_unordered_access_resources(const struct wined3d_shader *shader,
 929         struct wined3d_unordered_access_view * const *views)
 930 {
 931     unsigned int i;
 932
 933     if (!shader)
 934         return;
 935
 936     for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
 937     {
 938         if (!shader->reg_maps.uav_resource_info[i].type)
 939             continue;
 940
 941         if (!views[i])
 942             continue;
 943
 944         wined3d_resource_release(views[i]->resource);
 945     }
 946 }
 947
 948 static void wined3d_cs_exec_dispatch(struct wined3d_cs *cs, const void *data)
 949 {
 950     const struct wined3d_cs_dispatch *op = data;
 951     struct wined3d_state *state = &cs->state;
 952
 953     if (!state->shader[WINED3D_SHADER_TYPE_COMPUTE])
 954         WARN("No compute shader bound, skipping dispatch.\n");
 955     else
 956         cs->c.device->adapter->adapter_ops->adapter_dispatch_compute(cs->c.device, state, &op->parameters);
 957
 958     if (op->parameters.indirect)
 959         wined3d_resource_release(&op->parameters.u.indirect.buffer->resource);
 960
 961     release_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
 962     release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
 963             state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
 964 }
 965
 966 static void acquire_compute_pipeline_resources(struct wined3d_device_context *context)
 967 {
 968     const struct wined3d_state *state = context->state;
 969
 970     acquire_shader_resources(context, 1u << WINED3D_SHADER_TYPE_COMPUTE);
 971     acquire_unordered_access_resources(context, state->shader[WINED3D_SHADER_TYPE_COMPUTE],
 972             state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
 973 }
 974
 975 void CDECL wined3d_device_context_dispatch(struct wined3d_device_context *context,
 976         unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
 977 {
 978     struct wined3d_cs_dispatch *op;
 979
 980     wined3d_device_context_lock(context);
 981     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
 982     op->opcode = WINED3D_CS_OP_DISPATCH;
 983     op->parameters.indirect = FALSE;
 984     op->parameters.u.direct.group_count_x = group_count_x;
 985     op->parameters.u.direct.group_count_y = group_count_y;
 986     op->parameters.u.direct.group_count_z = group_count_z;
 987
 988     acquire_compute_pipeline_resources(context);
 989
 990     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
 991     wined3d_device_context_unlock(context);
 992 }
 993
 994 void CDECL wined3d_device_context_dispatch_indirect(struct wined3d_device_context *context,
 995         struct wined3d_buffer *buffer, unsigned int offset)
 996 {
 997     struct wined3d_cs_dispatch *op;
 998
 999     wined3d_device_context_lock(context);
1000     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1001     op->opcode = WINED3D_CS_OP_DISPATCH;
1002     op->parameters.indirect = TRUE;
1003     op->parameters.u.indirect.buffer = buffer;
1004     op->parameters.u.indirect.offset = offset;
1005
1006     acquire_compute_pipeline_resources(context);
1007     wined3d_device_context_acquire_resource(context, &buffer->resource);
1008
1009     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1010     wined3d_device_context_unlock(context);
1011 }
1012
1013 static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
1014 {
1015     const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info;
1016     const struct wined3d_shader *geometry_shader;
1017     struct wined3d_device *device = cs->c.device;
1018     int base_vertex_idx, load_base_vertex_idx;
1019     struct wined3d_state *state = &cs->state;
1020     const struct wined3d_cs_draw *op = data;
1021     unsigned int i;
1022
1023     base_vertex_idx = 0;
1024     if (!op->parameters.indirect)
1025     {
1026         const struct wined3d_direct_draw_parameters *direct = &op->parameters.u.direct;
1027
1028         if (op->parameters.indexed && d3d_info->draw_base_vertex_offset)
1029             base_vertex_idx = direct->base_vertex_idx;
1030         else if (!op->parameters.indexed)
1031             base_vertex_idx = direct->start_idx;
1032     }
1033
1034     /* ARB_draw_indirect always supports a base vertex offset. */
1035     if (!op->parameters.indirect && !d3d_info->draw_base_vertex_offset)
1036         load_base_vertex_idx = op->parameters.u.direct.base_vertex_idx;
1037     else
1038         load_base_vertex_idx = 0;
1039
1040     if (state->base_vertex_index != base_vertex_idx)
1041     {
1042         state->base_vertex_index = base_vertex_idx;
1043         for (i = 0; i < device->context_count; ++i)
1044             device->contexts[i]->constant_update_mask |= WINED3D_SHADER_CONST_BASE_VERTEX_ID;
1045     }
1046
1047     if (state->load_base_vertex_index != load_base_vertex_idx)
1048     {
1049         state->load_base_vertex_index = load_base_vertex_idx;
1050         device_invalidate_state(cs->c.device, STATE_BASEVERTEXINDEX);
1051     }
1052
1053     if (state->primitive_type != op->primitive_type)
1054     {
1055         if ((geometry_shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY]) && !geometry_shader->function)
1056             device_invalidate_state(cs->c.device, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY));
1057         if (state->primitive_type == WINED3D_PT_POINTLIST || op->primitive_type == WINED3D_PT_POINTLIST)
1058             device_invalidate_state(cs->c.device, STATE_POINT_ENABLE);
1059         state->primitive_type = op->primitive_type;
1060     }
1061     state->patch_vertex_count = op->patch_vertex_count;
1062
1063     cs->c.device->adapter->adapter_ops->adapter_draw_primitive(cs->c.device, state, &op->parameters);
1064
1065     if (op->parameters.indirect)
1066     {
1067         struct wined3d_buffer *buffer = op->parameters.u.indirect.buffer;
1068         wined3d_resource_release(&buffer->resource);
1069     }
1070
1071     if (op->parameters.indexed)
1072         wined3d_resource_release(&state->index_buffer->resource);
1073     for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
1074     {
1075         if (state->streams[i].buffer)
1076             wined3d_resource_release(&state->streams[i].buffer->resource);
1077     }
1078     for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
1079     {
1080         if (state->stream_output[i].buffer)
1081             wined3d_resource_release(&state->stream_output[i].buffer->resource);
1082     }
1083     for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
1084     {
1085         if (state->textures[i])
1086             wined3d_resource_release(&state->textures[i]->resource);
1087     }
1088     for (i = 0; i < d3d_info->limits.max_rt_count; ++i)
1089     {
1090         if (state->fb.render_targets[i])
1091             wined3d_resource_release(state->fb.render_targets[i]->resource);
1092     }
1093     if (state->fb.depth_stencil)
1094         wined3d_resource_release(state->fb.depth_stencil->resource);
1095     release_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
1096     release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
1097             state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
1098 }
1099
1100 static void acquire_graphics_pipeline_resources(struct wined3d_device_context *context,
1101         BOOL indexed, const struct wined3d_d3d_info *d3d_info)
1102 {
1103     const struct wined3d_state *state = context->state;
1104     unsigned int i;
1105
1106     if (indexed)
1107         wined3d_device_context_acquire_resource(context, &state->index_buffer->resource);
1108     for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
1109     {
1110         if (state->streams[i].buffer)
1111             wined3d_device_context_acquire_resource(context, &state->streams[i].buffer->resource);
1112     }
1113     for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
1114     {
1115         if (state->stream_output[i].buffer)
1116             wined3d_device_context_acquire_resource(context, &state->stream_output[i].buffer->resource);
1117     }
1118     for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
1119     {
1120         if (state->textures[i])
1121             wined3d_device_context_acquire_resource(context, &state->textures[i]->resource);
1122     }
1123     for (i = 0; i < d3d_info->limits.max_rt_count; ++i)
1124     {
1125         if (state->fb.render_targets[i])
1126             wined3d_device_context_acquire_resource(context, state->fb.render_targets[i]->resource);
1127     }
1128     if (state->fb.depth_stencil)
1129         wined3d_device_context_acquire_resource(context, state->fb.depth_stencil->resource);
1130     acquire_shader_resources(context, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
1131     acquire_unordered_access_resources(context, state->shader[WINED3D_SHADER_TYPE_PIXEL],
1132             state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
1133 }
1134
1135 void wined3d_device_context_emit_draw(struct wined3d_device_context *context,
1136         enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count, int base_vertex_idx,
1137         unsigned int start_idx, unsigned int index_count, unsigned int start_instance, unsigned int instance_count,
1138         bool indexed)
1139 {
1140     const struct wined3d_d3d_info *d3d_info = &context->device->adapter->d3d_info;
1141     struct wined3d_cs_draw *op;
1142
1143     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1144     op->opcode = WINED3D_CS_OP_DRAW;
1145     op->primitive_type = primitive_type;
1146     op->patch_vertex_count = patch_vertex_count;
1147     op->parameters.indirect = FALSE;
1148     op->parameters.u.direct.base_vertex_idx = base_vertex_idx;
1149     op->parameters.u.direct.start_idx = start_idx;
1150     op->parameters.u.direct.index_count = index_count;
1151     op->parameters.u.direct.start_instance = start_instance;
1152     op->parameters.u.direct.instance_count = instance_count;
1153     op->parameters.indexed = indexed;
1154
1155     acquire_graphics_pipeline_resources(context, indexed, d3d_info);
1156
1157     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1158 }
1159
1160 void CDECL wined3d_device_context_draw_indirect(struct wined3d_device_context *context,
1161         struct wined3d_buffer *buffer, unsigned int offset, bool indexed)
1162 {
1163     const struct wined3d_d3d_info *d3d_info = &context->device->adapter->d3d_info;
1164     const struct wined3d_state *state = context->state;
1165     struct wined3d_cs_draw *op;
1166
1167     wined3d_device_context_lock(context);
1168     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1169     op->opcode = WINED3D_CS_OP_DRAW;
1170     op->primitive_type = state->primitive_type;
1171     op->patch_vertex_count = state->patch_vertex_count;
1172     op->parameters.indirect = TRUE;
1173     op->parameters.u.indirect.buffer = buffer;
1174     op->parameters.u.indirect.offset = offset;
1175     op->parameters.indexed = indexed;
1176
1177     acquire_graphics_pipeline_resources(context, indexed, d3d_info);
1178     wined3d_device_context_acquire_resource(context, &buffer->resource);
1179
1180     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1181     wined3d_device_context_unlock(context);
1182 }
1183
1184 static void wined3d_cs_exec_flush(struct wined3d_cs *cs, const void *data)
1185 {
1186     struct wined3d_context *context;
1187
1188     context = context_acquire(cs->c.device, NULL, 0);
1189     cs->c.device->adapter->adapter_ops->adapter_flush_context(context);
1190     context_release(context);
1191 }
1192
1193 static void wined3d_cs_flush(struct wined3d_device_context *context)
1194 {
1195     struct wined3d_cs *cs = wined3d_cs_from_context(context);
1196     struct wined3d_cs_flush *op;
1197
1198     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1199     op->opcode = WINED3D_CS_OP_FLUSH;
1200
1201     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1202     cs->queries_flushed = TRUE;
1203 }
1204
1205 static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
1206 {
1207     const struct wined3d_cs_set_predication *op = data;
1208
1209     cs->state.predicate = op->predicate;
1210     cs->state.predicate_value = op->value;
1211 }
1212
1213 void wined3d_device_context_emit_set_predication(struct wined3d_device_context *context,
1214         struct wined3d_query *predicate, BOOL value)
1215 {
1216     struct wined3d_cs_set_predication *op;
1217
1218     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1219     op->opcode = WINED3D_CS_OP_SET_PREDICATION;
1220     op->predicate = predicate;
1221     op->value = value;
1222
1223     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1224 }
1225
1226 static void wined3d_cs_exec_set_viewports(struct wined3d_cs *cs, const void *data)
1227 {
1228     const struct wined3d_cs_set_viewports *op = data;
1229
1230     if (op->viewport_count)
1231         memcpy(cs->state.viewports, op->viewports, op->viewport_count * sizeof(*op->viewports));
1232     else
1233         memset(cs->state.viewports, 0, sizeof(*cs->state.viewports));
1234     cs->state.viewport_count = op->viewport_count;
1235     device_invalidate_state(cs->c.device, STATE_VIEWPORT);
1236 }
1237
1238 void wined3d_device_context_emit_set_viewports(struct wined3d_device_context *context, unsigned int viewport_count,
1239         const struct wined3d_viewport *viewports)
1240 {
1241     struct wined3d_cs_set_viewports *op;
1242
1243     op = wined3d_device_context_require_space(context,
1244             FIELD_OFFSET(struct wined3d_cs_set_viewports,viewports[viewport_count]), WINED3D_CS_QUEUE_DEFAULT);
1245     op->opcode = WINED3D_CS_OP_SET_VIEWPORTS;
1246     memcpy(op->viewports, viewports, viewport_count * sizeof(*viewports));
1247     op->viewport_count = viewport_count;
1248
1249     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1250 }
1251
1252 static void wined3d_cs_exec_set_scissor_rects(struct wined3d_cs *cs, const void *data)
1253 {
1254     const struct wined3d_cs_set_scissor_rects *op = data;
1255
1256     if (op->rect_count)
1257         memcpy(cs->state.scissor_rects, op->rects, op->rect_count * sizeof(*op->rects));
1258     else
1259         SetRectEmpty(cs->state.scissor_rects);
1260     cs->state.scissor_rect_count = op->rect_count;
1261     device_invalidate_state(cs->c.device, STATE_SCISSORRECT);
1262 }
1263
1264 void wined3d_device_context_emit_set_scissor_rects(struct wined3d_device_context *context,
1265         unsigned int rect_count, const RECT *rects)
1266 {
1267     struct wined3d_cs_set_scissor_rects *op;
1268
1269     op = wined3d_device_context_require_space(context, FIELD_OFFSET(struct wined3d_cs_set_scissor_rects, rects[rect_count]),
1270             WINED3D_CS_QUEUE_DEFAULT);
1271     op->opcode = WINED3D_CS_OP_SET_SCISSOR_RECTS;
1272     memcpy(op->rects, rects, rect_count * sizeof(*rects));
1273     op->rect_count = rect_count;
1274
1275     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1276 }
1277
1278 static void wined3d_cs_exec_set_rendertarget_views(struct wined3d_cs *cs, const void *data)
1279 {
1280     const struct wined3d_cs_set_rendertarget_views *op = data;
1281     struct wined3d_device *device = cs->c.device;
1282     unsigned int i;
1283
1284     for (i = 0; i < op->count; ++i)
1285     {
1286         struct wined3d_rendertarget_view *prev = cs->state.fb.render_targets[op->start_idx + i];
1287         struct wined3d_rendertarget_view *view = op->views[i];
1288         bool prev_alpha_swizzle, curr_alpha_swizzle;
1289         bool prev_srgb_write, curr_srgb_write;
1290
1291         cs->state.fb.render_targets[op->start_idx + i] = view;
1292
1293         prev_alpha_swizzle = prev && prev->format->id == WINED3DFMT_A8_UNORM;
1294         curr_alpha_swizzle = view && view->format->id == WINED3DFMT_A8_UNORM;
1295         if (prev_alpha_swizzle != curr_alpha_swizzle)
1296             device_invalidate_state(device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
1297
1298         if (!(device->adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
1299                 || cs->state.render_states[WINED3D_RS_SRGBWRITEENABLE])
1300         {
1301             prev_srgb_write = prev && prev->format_flags & WINED3DFMT_FLAG_SRGB_WRITE;
1302             curr_srgb_write = view && view->format_flags & WINED3DFMT_FLAG_SRGB_WRITE;
1303             if (prev_srgb_write != curr_srgb_write)
1304                 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE));
1305         }
1306     }
1307
1308     device_invalidate_state(device, STATE_FRAMEBUFFER);
1309 }
1310
1311 void wined3d_device_context_emit_set_rendertarget_views(struct wined3d_device_context *context,
1312         unsigned int start_idx, unsigned int count, struct wined3d_rendertarget_view *const *views)
1313 {
1314     struct wined3d_cs_set_rendertarget_views *op;
1315
1316     op = wined3d_device_context_require_space(context,
1317             offsetof(struct wined3d_cs_set_rendertarget_views, views[count]), WINED3D_CS_QUEUE_DEFAULT);
1318     op->opcode = WINED3D_CS_OP_SET_RENDERTARGET_VIEWS;
1319     op->start_idx = start_idx;
1320     op->count = count;
1321     memcpy(op->views, views, count * sizeof(*views));
1322
1323     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1324 }
1325
1326 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
1327 {
1328     const struct wined3d_cs_set_depth_stencil_view *op = data;
1329     struct wined3d_device *device = cs->c.device;
1330     struct wined3d_rendertarget_view *prev;
1331
1332     if ((prev = cs->state.fb.depth_stencil) && prev->resource->type != WINED3D_RTYPE_BUFFER)
1333     {
1334         struct wined3d_texture *prev_texture = texture_from_resource(prev->resource);
1335
1336         if (device->swapchains[0]->state.desc.flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
1337                 || prev_texture->flags & WINED3D_TEXTURE_DISCARD)
1338             wined3d_texture_validate_location(prev_texture,
1339                     prev->sub_resource_idx, WINED3D_LOCATION_DISCARDED);
1340     }
1341
1342     cs->state.fb.depth_stencil = op->view;
1343
1344     if (!prev != !op->view)
1345     {
1346         /* Swapping NULL / non NULL depth stencil affects the depth and tests */
1347         device_invalidate_state(device, STATE_DEPTH_STENCIL);
1348         device_invalidate_state(device, STATE_STENCIL_REF);
1349         device_invalidate_state(device, STATE_RASTERIZER);
1350     }
1351     else if (prev)
1352     {
1353         if (prev->format->depth_bias_scale != op->view->format->depth_bias_scale)
1354             device_invalidate_state(device, STATE_RASTERIZER);
1355         if (prev->format->stencil_size != op->view->format->stencil_size)
1356             device_invalidate_state(device, STATE_STENCIL_REF);
1357     }
1358
1359     device_invalidate_state(device, STATE_FRAMEBUFFER);
1360 }
1361
1362 void wined3d_device_context_emit_set_depth_stencil_view(struct wined3d_device_context *context,
1363         struct wined3d_rendertarget_view *view)
1364 {
1365     struct wined3d_cs_set_depth_stencil_view *op;
1366
1367     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1368     op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
1369     op->view = view;
1370
1371     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1372 }
1373
1374 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
1375 {
1376     const struct wined3d_cs_set_vertex_declaration *op = data;
1377
1378     cs->state.vertex_declaration = op->declaration;
1379     device_invalidate_state(cs->c.device, STATE_VDECL);
1380 }
1381
1382 void wined3d_device_context_emit_set_vertex_declaration(struct wined3d_device_context *context,
1383         struct wined3d_vertex_declaration *declaration)
1384 {
1385     struct wined3d_cs_set_vertex_declaration *op;
1386
1387     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1388     op->opcode = WINED3D_CS_OP_SET_VERTEX_DECLARATION;
1389     op->declaration = declaration;
1390
1391     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1392 }
1393
1394 static void wined3d_cs_exec_set_stream_sources(struct wined3d_cs *cs, const void *data)
1395 {
1396     const struct wined3d_cs_set_stream_sources *op = data;
1397     unsigned int i;
1398
1399     for (i = 0; i < op->count; ++i)
1400     {
1401         struct wined3d_buffer *prev = cs->state.streams[op->start_idx + i].buffer;
1402         struct wined3d_buffer *buffer = op->streams[i].buffer;
1403
1404         if (buffer)
1405             InterlockedIncrement(&buffer->resource.bind_count);
1406         if (prev)
1407             InterlockedDecrement(&prev->resource.bind_count);
1408     }
1409
1410     memcpy(&cs->state.streams[op->start_idx], op->streams, op->count * sizeof(*op->streams));
1411     device_invalidate_state(cs->c.device, STATE_STREAMSRC);
1412 }
1413
1414 void wined3d_device_context_emit_set_stream_sources(struct wined3d_device_context *context,
1415         unsigned int start_idx, unsigned int count, const struct wined3d_stream_state *streams)
1416 {
1417     struct wined3d_cs_set_stream_sources *op;
1418
1419     op = wined3d_device_context_require_space(context,
1420             offsetof(struct wined3d_cs_set_stream_sources, streams[count]), WINED3D_CS_QUEUE_DEFAULT);
1421     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCES;
1422     op->start_idx = start_idx;
1423     op->count = count;
1424     memcpy(op->streams, streams, count * sizeof(*streams));
1425
1426     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1427 }
1428
1429 static void wined3d_cs_exec_set_stream_outputs(struct wined3d_cs *cs, const void *data)
1430 {
1431     const struct wined3d_cs_set_stream_outputs *op = data;
1432     unsigned int i;
1433
1434     for (i = 0; i < WINED3D_MAX_STREAM_OUTPUT_BUFFERS; ++i)
1435     {
1436         struct wined3d_buffer *prev = cs->state.stream_output[i].buffer;
1437         struct wined3d_buffer *buffer = op->outputs[i].buffer;
1438
1439         if (buffer)
1440             InterlockedIncrement(&buffer->resource.bind_count);
1441         if (prev)
1442             InterlockedDecrement(&prev->resource.bind_count);
1443     }
1444
1445     memcpy(cs->state.stream_output, op->outputs, sizeof(op->outputs));
1446     device_invalidate_state(cs->c.device, STATE_STREAM_OUTPUT);
1447 }
1448
1449 void wined3d_device_context_emit_set_stream_outputs(struct wined3d_device_context *context,
1450         const struct wined3d_stream_output outputs[WINED3D_MAX_STREAM_OUTPUT_BUFFERS])
1451 {
1452     struct wined3d_cs_set_stream_outputs *op;
1453
1454     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1455     op->opcode = WINED3D_CS_OP_SET_STREAM_OUTPUTS;
1456     memcpy(op->outputs, outputs, sizeof(op->outputs));
1457
1458     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1459 }
1460
1461 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
1462 {
1463     const struct wined3d_cs_set_index_buffer *op = data;
1464     struct wined3d_buffer *prev;
1465
1466     prev = cs->state.index_buffer;
1467     cs->state.index_buffer = op->buffer;
1468     cs->state.index_format = op->format_id;
1469     cs->state.index_offset = op->offset;
1470
1471     if (op->buffer)
1472         InterlockedIncrement(&op->buffer->resource.bind_count);
1473     if (prev)
1474         InterlockedDecrement(&prev->resource.bind_count);
1475
1476     device_invalidate_state(cs->c.device, STATE_INDEXBUFFER);
1477 }
1478
1479 void wined3d_device_context_emit_set_index_buffer(struct wined3d_device_context *context, struct wined3d_buffer *buffer,
1480         enum wined3d_format_id format_id, unsigned int offset)
1481 {
1482     struct wined3d_cs_set_index_buffer *op;
1483
1484     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1485     op->opcode = WINED3D_CS_OP_SET_INDEX_BUFFER;
1486     op->buffer = buffer;
1487     op->format_id = format_id;
1488     op->offset = offset;
1489
1490     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1491 }
1492
1493 static void wined3d_cs_exec_set_constant_buffers(struct wined3d_cs *cs, const void *data)
1494 {
1495     const struct wined3d_cs_set_constant_buffers *op = data;
1496     unsigned int i;
1497
1498     for (i = 0; i < op->count; ++i)
1499     {
1500         struct wined3d_buffer *prev = cs->state.cb[op->type][op->start_idx + i].buffer;
1501         struct wined3d_buffer *buffer = op->buffers[i].buffer;
1502
1503         cs->state.cb[op->type][op->start_idx + i] = op->buffers[i];
1504
1505         if (buffer)
1506             InterlockedIncrement(&buffer->resource.bind_count);
1507         if (prev)
1508             InterlockedDecrement(&prev->resource.bind_count);
1509     }
1510
1511     device_invalidate_state(cs->c.device, STATE_CONSTANT_BUFFER(op->type));
1512 }
1513
1514 void wined3d_device_context_emit_set_constant_buffers(struct wined3d_device_context *context,
1515         enum wined3d_shader_type type, unsigned int start_idx, unsigned int count,
1516         const struct wined3d_constant_buffer_state *buffers)
1517 {
1518     struct wined3d_cs_set_constant_buffers *op;
1519
1520     op = wined3d_device_context_require_space(context, offsetof(struct wined3d_cs_set_constant_buffers, buffers[count]),
1521             WINED3D_CS_QUEUE_DEFAULT);
1522     op->opcode = WINED3D_CS_OP_SET_CONSTANT_BUFFERS;
1523     op->type = type;
1524     op->start_idx = start_idx;
1525     op->count = count;
1526     memcpy(op->buffers, buffers, count * sizeof(*buffers));
1527
1528     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1529 }
1530
1531 static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
1532 {
1533     const struct wined3d_d3d_info *d3d_info = &cs->c.device->adapter->d3d_info;
1534     const struct wined3d_cs_set_texture *op = data;
1535     struct wined3d_texture *prev;
1536     BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
1537
1538     prev = cs->state.textures[op->stage];
1539     cs->state.textures[op->stage] = op->texture;
1540
1541     if (op->texture)
1542     {
1543         const struct wined3d_format *new_format = op->texture->resource.format;
1544         const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
1545         unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
1546         unsigned int new_fmt_flags = op->texture->resource.format_flags;
1547
1548         if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
1549             op->texture->sampler = op->stage;
1550
1551         if (!prev || wined3d_texture_gl(op->texture)->target != wined3d_texture_gl(prev)->target
1552                 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
1553                 && !(can_use_texture_swizzle(d3d_info, new_format) && can_use_texture_swizzle(d3d_info, old_format)))
1554                 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
1555             device_invalidate_state(cs->c.device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
1556
1557         if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
1558         {
1559             /* The source arguments for color and alpha ops have different
1560              * meanings when a NULL texture is bound, so the COLOR_OP and
1561              * ALPHA_OP have to be dirtified. */
1562             device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1563             device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1564         }
1565
1566         if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1567             new_use_color_key = TRUE;
1568     }
1569
1570     if (prev)
1571     {
1572         if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
1573         {
1574             unsigned int i;
1575
1576             /* Search for other stages the texture is bound to. Shouldn't
1577              * happen if applications bind textures to a single stage only. */
1578             TRACE("Searching for other stages the texture is bound to.\n");
1579             for (i = 0; i < WINED3D_MAX_COMBINED_SAMPLERS; ++i)
1580             {
1581                 if (cs->state.textures[i] == prev)
1582                 {
1583                     TRACE("Texture is also bound to stage %u.\n", i);
1584                     prev->sampler = i;
1585                     break;
1586                 }
1587             }
1588         }
1589
1590         if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
1591         {
1592             device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1593             device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1594         }
1595
1596         if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1597             old_use_color_key = TRUE;
1598     }
1599
1600     device_invalidate_state(cs->c.device, STATE_SAMPLER(op->stage));
1601
1602     if (new_use_color_key != old_use_color_key)
1603         device_invalidate_state(cs->c.device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1604
1605     if (new_use_color_key)
1606         device_invalidate_state(cs->c.device, STATE_COLOR_KEY);
1607 }
1608
1609 void wined3d_device_context_emit_set_texture(struct wined3d_device_context *context, unsigned int stage,
1610         struct wined3d_texture *texture)
1611 {
1612     struct wined3d_cs_set_texture *op;
1613
1614     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1615     op->opcode = WINED3D_CS_OP_SET_TEXTURE;
1616     op->stage = stage;
1617     op->texture = texture;
1618
1619     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1620 }
1621
1622 static void wined3d_cs_exec_set_shader_resource_views(struct wined3d_cs *cs, const void *data)
1623 {
1624     const struct wined3d_cs_set_shader_resource_views *op = data;
1625     unsigned int i;
1626
1627     for (i = 0; i < op->count; ++i)
1628     {
1629         struct wined3d_shader_resource_view *prev = cs->state.shader_resource_view[op->type][op->start_idx + i];
1630         struct wined3d_shader_resource_view *view = op->views[i];
1631
1632         cs->state.shader_resource_view[op->type][op->start_idx + i] = view;
1633
1634         if (view)
1635             InterlockedIncrement(&view->resource->bind_count);
1636         if (prev)
1637             InterlockedDecrement(&prev->resource->bind_count);
1638     }
1639
1640     if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1641         device_invalidate_state(cs->c.device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1642     else
1643         device_invalidate_state(cs->c.device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1644 }
1645
1646 void wined3d_device_context_emit_set_shader_resource_views(struct wined3d_device_context *context,
1647         enum wined3d_shader_type type, unsigned int start_idx, unsigned int count,
1648         struct wined3d_shader_resource_view *const *views)
1649 {
1650     struct wined3d_cs_set_shader_resource_views *op;
1651
1652     op = wined3d_device_context_require_space(context,
1653             offsetof(struct wined3d_cs_set_shader_resource_views, views[count]), WINED3D_CS_QUEUE_DEFAULT);
1654     op->opcode = WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEWS;
1655     op->type = type;
1656     op->start_idx = start_idx;
1657     op->count = count;
1658     memcpy(op->views, views, count * sizeof(*views));
1659
1660     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1661 }
1662
1663 static void wined3d_cs_exec_set_unordered_access_views(struct wined3d_cs *cs, const void *data)
1664 {
1665     const struct wined3d_cs_set_unordered_access_views *op = data;
1666     unsigned int i;
1667
1668     for (i = 0; i < op->count; ++i)
1669     {
1670         struct wined3d_unordered_access_view *prev = cs->state.unordered_access_view[op->pipeline][op->start_idx + i];
1671         struct wined3d_unordered_access_view *view = op->uavs[i].view;
1672         unsigned int initial_count = op->uavs[i].initial_count;
1673
1674         cs->state.unordered_access_view[op->pipeline][op->start_idx + i] = view;
1675
1676         if (view)
1677             InterlockedIncrement(&view->resource->bind_count);
1678         if (prev)
1679             InterlockedDecrement(&prev->resource->bind_count);
1680
1681         if (view && initial_count != ~0u)
1682             wined3d_unordered_access_view_set_counter(view, initial_count);
1683     }
1684
1685     device_invalidate_state(cs->c.device, STATE_UNORDERED_ACCESS_VIEW_BINDING(op->pipeline));
1686 }
1687
1688 void wined3d_device_context_emit_set_unordered_access_views(struct wined3d_device_context *context,
1689         enum wined3d_pipeline pipeline, unsigned int start_idx, unsigned int count,
1690         struct wined3d_unordered_access_view *const *views, const unsigned int *initial_counts)
1691 {
1692     struct wined3d_cs_set_unordered_access_views *op;
1693     unsigned int i;
1694
1695     op = wined3d_device_context_require_space(context,
1696             offsetof(struct wined3d_cs_set_unordered_access_views, uavs[count]), WINED3D_CS_QUEUE_DEFAULT);
1697     op->opcode = WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEWS;
1698     op->pipeline = pipeline;
1699     op->start_idx = start_idx;
1700     op->count = count;
1701     for (i = 0; i < count; ++i)
1702     {
1703         op->uavs[i].view = views[i];
1704         op->uavs[i].initial_count = initial_counts ? initial_counts[i] : ~0u;
1705     }
1706
1707     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1708 }
1709
1710 static void wined3d_cs_exec_set_samplers(struct wined3d_cs *cs, const void *data)
1711 {
1712     const struct wined3d_cs_set_samplers *op = data;
1713     unsigned int i;
1714
1715     for (i = 0; i < op->count; ++i)
1716         cs->state.sampler[op->type][op->start_idx + i] = op->samplers[i];
1717
1718     if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1719         device_invalidate_state(cs->c.device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1720     else
1721         device_invalidate_state(cs->c.device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1722 }
1723
1724 void wined3d_device_context_emit_set_samplers(struct wined3d_device_context *context, enum wined3d_shader_type type,
1725         unsigned int start_idx, unsigned int count, struct wined3d_sampler *const *samplers)
1726 {
1727     struct wined3d_cs_set_samplers *op;
1728
1729     op = wined3d_device_context_require_space(context, offsetof(struct wined3d_cs_set_samplers, samplers[count]),
1730             WINED3D_CS_QUEUE_DEFAULT);
1731     op->opcode = WINED3D_CS_OP_SET_SAMPLERS;
1732     op->type = type;
1733     op->start_idx = start_idx;
1734     op->count = count;
1735     memcpy(op->samplers, samplers, count * sizeof(*samplers));
1736
1737     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1738 }
1739
1740 static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
1741 {
1742     const struct wined3d_cs_set_shader *op = data;
1743
1744     /* CB binding may have been skipped earlier if the shader wasn't set, so make it happen. */
1745     if (!cs->state.shader[op->type] && op->shader)
1746         device_invalidate_state(cs->c.device, STATE_CONSTANT_BUFFER(op->type));
1747     cs->state.shader[op->type] = op->shader;
1748     device_invalidate_state(cs->c.device, STATE_SHADER(op->type));
1749     if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1750         device_invalidate_state(cs->c.device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1751     else
1752         device_invalidate_state(cs->c.device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1753 }
1754
1755 void wined3d_device_context_emit_set_shader(struct wined3d_device_context *context,
1756         enum wined3d_shader_type type, struct wined3d_shader *shader)
1757 {
1758     struct wined3d_cs_set_shader *op;
1759
1760     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1761     op->opcode = WINED3D_CS_OP_SET_SHADER;
1762     op->type = type;
1763     op->shader = shader;
1764
1765     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1766 }
1767
1768 static void wined3d_cs_exec_set_blend_state(struct wined3d_cs *cs, const void *data)
1769 {
1770     const struct wined3d_cs_set_blend_state *op = data;
1771     struct wined3d_state *state = &cs->state;
1772
1773     if (state->blend_state != op->state)
1774     {
1775         state->blend_state = op->state;
1776         device_invalidate_state(cs->c.device, STATE_BLEND);
1777     }
1778     state->blend_factor = op->factor;
1779     device_invalidate_state(cs->c.device, STATE_BLEND_FACTOR);
1780     state->sample_mask = op->sample_mask;
1781     device_invalidate_state(cs->c.device, STATE_SAMPLE_MASK);
1782 }
1783
1784 void wined3d_device_context_emit_set_blend_state(struct wined3d_device_context *context,
1785         struct wined3d_blend_state *state, const struct wined3d_color *blend_factor, unsigned int sample_mask)
1786 {
1787     struct wined3d_cs_set_blend_state *op;
1788
1789     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1790     op->opcode = WINED3D_CS_OP_SET_BLEND_STATE;
1791     op->state = state;
1792     op->factor = *blend_factor;
1793     op->sample_mask = sample_mask;
1794
1795     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1796 }
1797
1798 static void wined3d_cs_exec_set_depth_stencil_state(struct wined3d_cs *cs, const void *data)
1799 {
1800     const struct wined3d_cs_set_depth_stencil_state *op = data;
1801     struct wined3d_state *state = &cs->state;
1802
1803     if (state->depth_stencil_state != op->state)
1804     {
1805         state->depth_stencil_state = op->state;
1806         device_invalidate_state(cs->c.device, STATE_DEPTH_STENCIL);
1807     }
1808     state->stencil_ref = op->stencil_ref;
1809     device_invalidate_state(cs->c.device, STATE_STENCIL_REF);
1810 }
1811
1812 void wined3d_device_context_emit_set_depth_stencil_state(struct wined3d_device_context *context,
1813         struct wined3d_depth_stencil_state *state, unsigned int stencil_ref)
1814 {
1815     struct wined3d_cs_set_depth_stencil_state *op;
1816
1817     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1818     op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE;
1819     op->state = state;
1820     op->stencil_ref = stencil_ref;
1821
1822     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1823 }
1824
1825 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs *cs, const void *data)
1826 {
1827     const struct wined3d_cs_set_rasterizer_state *op = data;
1828
1829     cs->state.rasterizer_state = op->state;
1830     device_invalidate_state(cs->c.device, STATE_RASTERIZER);
1831 }
1832
1833 void wined3d_device_context_emit_set_rasterizer_state(struct wined3d_device_context *context,
1834         struct wined3d_rasterizer_state *rasterizer_state)
1835 {
1836     struct wined3d_cs_set_rasterizer_state *op;
1837
1838     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1839     op->opcode = WINED3D_CS_OP_SET_RASTERIZER_STATE;
1840     op->state = rasterizer_state;
1841
1842     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1843 }
1844
1845 static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
1846 {
1847     const struct wined3d_cs_set_render_state *op = data;
1848
1849     cs->state.render_states[op->state] = op->value;
1850     device_invalidate_state(cs->c.device, STATE_RENDER(op->state));
1851 }
1852
1853 void wined3d_device_context_emit_set_render_state(struct wined3d_device_context *context,
1854         enum wined3d_render_state state, unsigned int value)
1855 {
1856     struct wined3d_cs_set_render_state *op;
1857
1858     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1859     op->opcode = WINED3D_CS_OP_SET_RENDER_STATE;
1860     op->state = state;
1861     op->value = value;
1862
1863     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1864 }
1865
1866 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
1867 {
1868     const struct wined3d_cs_set_texture_state *op = data;
1869
1870     cs->state.texture_states[op->stage][op->state] = op->value;
1871     device_invalidate_state(cs->c.device, STATE_TEXTURESTAGE(op->stage, op->state));
1872 }
1873
1874 void wined3d_device_context_emit_set_texture_state(struct wined3d_device_context *context, unsigned int stage,
1875         enum wined3d_texture_stage_state state, unsigned int value)
1876 {
1877     struct wined3d_cs_set_texture_state *op;
1878
1879     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1880     op->opcode = WINED3D_CS_OP_SET_TEXTURE_STATE;
1881     op->stage = stage;
1882     op->state = state;
1883     op->value = value;
1884
1885     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1886 }
1887
1888 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
1889 {
1890     const struct wined3d_cs_set_sampler_state *op = data;
1891
1892     cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
1893     device_invalidate_state(cs->c.device, STATE_SAMPLER(op->sampler_idx));
1894 }
1895
1896 void wined3d_device_context_emit_set_sampler_state(struct wined3d_device_context *context, unsigned int sampler_idx,
1897         enum wined3d_sampler_state state, unsigned int value)
1898 {
1899     struct wined3d_cs_set_sampler_state *op;
1900
1901     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1902     op->opcode = WINED3D_CS_OP_SET_SAMPLER_STATE;
1903     op->sampler_idx = sampler_idx;
1904     op->state = state;
1905     op->value = value;
1906
1907     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1908 }
1909
1910 static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
1911 {
1912     const struct wined3d_cs_set_transform *op = data;
1913
1914     cs->state.transforms[op->state] = op->matrix;
1915     if (op->state < WINED3D_TS_WORLD_MATRIX(cs->c.device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
1916         device_invalidate_state(cs->c.device, STATE_TRANSFORM(op->state));
1917 }
1918
1919 void wined3d_device_context_emit_set_transform(struct wined3d_device_context *context,
1920         enum wined3d_transform_state state, const struct wined3d_matrix *matrix)
1921 {
1922     struct wined3d_cs_set_transform *op;
1923
1924     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1925     op->opcode = WINED3D_CS_OP_SET_TRANSFORM;
1926     op->state = state;
1927     op->matrix = *matrix;
1928
1929     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1930 }
1931
1932 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
1933 {
1934     const struct wined3d_cs_set_clip_plane *op = data;
1935
1936     cs->state.clip_planes[op->plane_idx] = op->plane;
1937     device_invalidate_state(cs->c.device, STATE_CLIPPLANE(op->plane_idx));
1938 }
1939
1940 void wined3d_device_context_emit_set_clip_plane(struct wined3d_device_context *context,
1941         unsigned int plane_idx, const struct wined3d_vec4 *plane)
1942 {
1943     struct wined3d_cs_set_clip_plane *op;
1944
1945     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1946     op->opcode = WINED3D_CS_OP_SET_CLIP_PLANE;
1947     op->plane_idx = plane_idx;
1948     op->plane = *plane;
1949
1950     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
1951 }
1952
1953 static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
1954 {
1955     const struct wined3d_cs_set_color_key *op = data;
1956     struct wined3d_texture *texture = op->texture;
1957
1958     if (op->set)
1959     {
1960         switch (op->flags)
1961         {
1962             case WINED3D_CKEY_DST_BLT:
1963                 texture->async.dst_blt_color_key = op->color_key;
1964                 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
1965                 break;
1966
1967             case WINED3D_CKEY_DST_OVERLAY:
1968                 texture->async.dst_overlay_color_key = op->color_key;
1969                 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
1970                 break;
1971
1972             case WINED3D_CKEY_SRC_BLT:
1973                 if (texture == cs->state.textures[0])
1974                 {
1975                     device_invalidate_state(cs->c.device, STATE_COLOR_KEY);
1976                     if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1977                         device_invalidate_state(cs->c.device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1978                 }
1979
1980                 texture->async.src_blt_color_key = op->color_key;
1981                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
1982                 break;
1983
1984             case WINED3D_CKEY_SRC_OVERLAY:
1985                 texture->async.src_overlay_color_key = op->color_key;
1986                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
1987                 break;
1988         }
1989     }
1990     else
1991     {
1992         switch (op->flags)
1993         {
1994             case WINED3D_CKEY_DST_BLT:
1995                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
1996                 break;
1997
1998             case WINED3D_CKEY_DST_OVERLAY:
1999                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
2000                 break;
2001
2002             case WINED3D_CKEY_SRC_BLT:
2003                 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
2004                     device_invalidate_state(cs->c.device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
2005
2006                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
2007                 break;
2008
2009             case WINED3D_CKEY_SRC_OVERLAY:
2010                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
2011                 break;
2012         }
2013     }
2014 }
2015
2016 void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
2017         WORD flags, const struct wined3d_color_key *color_key)
2018 {
2019     struct wined3d_cs_set_color_key *op;
2020
2021     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2022     op->opcode = WINED3D_CS_OP_SET_COLOR_KEY;
2023     op->texture = texture;
2024     op->flags = flags;
2025     if (color_key)
2026     {
2027         op->color_key = *color_key;
2028         op->set = 1;
2029     }
2030     else
2031         op->set = 0;
2032
2033     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2034 }
2035
2036 static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
2037 {
2038     const struct wined3d_cs_set_material *op = data;
2039
2040     cs->state.material = op->material;
2041     device_invalidate_state(cs->c.device, STATE_MATERIAL);
2042 }
2043
2044 void wined3d_device_context_emit_set_material(struct wined3d_device_context *context,
2045         const struct wined3d_material *material)
2046 {
2047     struct wined3d_cs_set_material *op;
2048
2049     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2050     op->opcode = WINED3D_CS_OP_SET_MATERIAL;
2051     op->material = *material;
2052
2053     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2054 }
2055
2056 static void wined3d_cs_exec_set_light(struct wined3d_cs *cs, const void *data)
2057 {
2058     const struct wined3d_cs_set_light *op = data;
2059     struct wined3d_light_info *light_info;
2060     unsigned int light_idx, hash_idx;
2061
2062     light_idx = op->light.OriginalIndex;
2063
2064     if (!(light_info = wined3d_light_state_get_light(&cs->state.light_state, light_idx)))
2065     {
2066         TRACE("Adding new light.\n");
2067         if (!(light_info = heap_alloc_zero(sizeof(*light_info))))
2068         {
2069             ERR("Failed to allocate light info.\n");
2070             return;
2071         }
2072
2073         hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2074         list_add_head(&cs->state.light_state.light_map[hash_idx], &light_info->entry);
2075         light_info->glIndex = -1;
2076         light_info->OriginalIndex = light_idx;
2077     }
2078
2079     if (light_info->glIndex != -1)
2080     {
2081         if (light_info->OriginalParms.type != op->light.OriginalParms.type)
2082             device_invalidate_state(cs->c.device, STATE_LIGHT_TYPE);
2083         device_invalidate_state(cs->c.device, STATE_ACTIVELIGHT(light_info->glIndex));
2084     }
2085
2086     light_info->OriginalParms = op->light.OriginalParms;
2087     light_info->position = op->light.position;
2088     light_info->direction = op->light.direction;
2089     light_info->exponent = op->light.exponent;
2090     light_info->cutoff = op->light.cutoff;
2091 }
2092
2093 void wined3d_device_context_emit_set_light(struct wined3d_device_context *context,
2094         const struct wined3d_light_info *light)
2095 {
2096     struct wined3d_cs_set_light *op;
2097
2098     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2099     op->opcode = WINED3D_CS_OP_SET_LIGHT;
2100     op->light = *light;
2101
2102     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2103 }
2104
2105 static void wined3d_cs_exec_set_light_enable(struct wined3d_cs *cs, const void *data)
2106 {
2107     const struct wined3d_cs_set_light_enable *op = data;
2108     struct wined3d_device *device = cs->c.device;
2109     struct wined3d_light_info *light_info;
2110     int prev_idx;
2111
2112     if (!(light_info = wined3d_light_state_get_light(&cs->state.light_state, op->idx)))
2113     {
2114         ERR("Light doesn't exist.\n");
2115         return;
2116     }
2117
2118     prev_idx = light_info->glIndex;
2119     wined3d_light_state_enable_light(&cs->state.light_state, &device->adapter->d3d_info, light_info, op->enable);
2120     if (light_info->glIndex != prev_idx)
2121     {
2122         device_invalidate_state(device, STATE_LIGHT_TYPE);
2123         device_invalidate_state(device, STATE_ACTIVELIGHT(op->enable ? light_info->glIndex : prev_idx));
2124     }
2125 }
2126
2127 void wined3d_device_context_emit_set_light_enable(struct wined3d_device_context *context, unsigned int idx, BOOL enable)
2128 {
2129     struct wined3d_cs_set_light_enable *op;
2130
2131     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2132     op->opcode = WINED3D_CS_OP_SET_LIGHT_ENABLE;
2133     op->idx = idx;
2134     op->enable = enable;
2135
2136     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2137 }
2138
2139 static void wined3d_cs_exec_set_feature_level(struct wined3d_cs *cs, const void *data)
2140 {
2141     const struct wined3d_cs_set_feature_level *op = data;
2142
2143     cs->state.feature_level = op->level;
2144 }
2145
2146 void wined3d_device_context_emit_set_feature_level(struct wined3d_device_context *context,
2147         enum wined3d_feature_level level)
2148 {
2149     struct wined3d_cs_set_feature_level *op;
2150
2151     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2152     op->opcode = WINED3D_CS_OP_SET_FEATURE_LEVEL;
2153     op->level = level;
2154
2155     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2156 }
2157
2158 static const struct
2159 {
2160     size_t offset;
2161     size_t size;
2162     DWORD mask;
2163 }
2164 wined3d_cs_push_constant_info[] =
2165 {
2166     /* WINED3D_PUSH_CONSTANTS_VS_F */
2167     {FIELD_OFFSET(struct wined3d_state, vs_consts_f), sizeof(struct wined3d_vec4),  WINED3D_SHADER_CONST_VS_F},
2168     /* WINED3D_PUSH_CONSTANTS_PS_F */
2169     {FIELD_OFFSET(struct wined3d_state, ps_consts_f), sizeof(struct wined3d_vec4),  WINED3D_SHADER_CONST_PS_F},
2170     /* WINED3D_PUSH_CONSTANTS_VS_I */
2171     {FIELD_OFFSET(struct wined3d_state, vs_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_VS_I},
2172     /* WINED3D_PUSH_CONSTANTS_PS_I */
2173     {FIELD_OFFSET(struct wined3d_state, ps_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_PS_I},
2174     /* WINED3D_PUSH_CONSTANTS_VS_B */
2175     {FIELD_OFFSET(struct wined3d_state, vs_consts_b), sizeof(BOOL),                 WINED3D_SHADER_CONST_VS_B},
2176     /* WINED3D_PUSH_CONSTANTS_PS_B */
2177     {FIELD_OFFSET(struct wined3d_state, ps_consts_b), sizeof(BOOL),                 WINED3D_SHADER_CONST_PS_B},
2178 };
2179
2180 static void wined3d_cs_st_push_constants(struct wined3d_device_context *context, enum wined3d_push_constants p,
2181         unsigned int start_idx, unsigned int count, const void *constants)
2182 {
2183     struct wined3d_cs *cs = wined3d_cs_from_context(context);
2184     struct wined3d_device *device = cs->c.device;
2185     unsigned int context_count;
2186     unsigned int i;
2187     size_t offset;
2188
2189     if (p == WINED3D_PUSH_CONSTANTS_VS_F)
2190         device->shader_backend->shader_update_float_vertex_constants(device, start_idx, count);
2191     else if (p == WINED3D_PUSH_CONSTANTS_PS_F)
2192         device->shader_backend->shader_update_float_pixel_constants(device, start_idx, count);
2193
2194     offset = wined3d_cs_push_constant_info[p].offset + start_idx * wined3d_cs_push_constant_info[p].size;
2195     memcpy((BYTE *)&cs->state + offset, constants, count * wined3d_cs_push_constant_info[p].size);
2196     for (i = 0, context_count = device->context_count; i < context_count; ++i)
2197     {
2198         device->contexts[i]->constant_update_mask |= wined3d_cs_push_constant_info[p].mask;
2199     }
2200 }
2201
2202 static void wined3d_cs_exec_push_constants(struct wined3d_cs *cs, const void *data)
2203 {
2204     const struct wined3d_cs_push_constants *op = data;
2205
2206     wined3d_cs_st_push_constants(&cs->c, op->type, op->start_idx, op->count, op->constants);
2207 }
2208
2209 static void wined3d_cs_mt_push_constants(struct wined3d_device_context *context, enum wined3d_push_constants p,
2210         unsigned int start_idx, unsigned int count, const void *constants)
2211 {
2212     struct wined3d_cs *cs = wined3d_cs_from_context(context);
2213     struct wined3d_cs_push_constants *op;
2214     size_t size;
2215
2216     size = count * wined3d_cs_push_constant_info[p].size;
2217     op = wined3d_device_context_require_space(&cs->c, FIELD_OFFSET(struct wined3d_cs_push_constants, constants[size]),
2218             WINED3D_CS_QUEUE_DEFAULT);
2219     op->opcode = WINED3D_CS_OP_PUSH_CONSTANTS;
2220     op->type = p;
2221     op->start_idx = start_idx;
2222     op->count = count;
2223     memcpy(op->constants, constants, size);
2224
2225     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2226 }
2227
2228 static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
2229 {
2230     const struct wined3d_device *device = cs->c.device;
2231     const struct wined3d_cs_reset_state *op = data;
2232     const struct wined3d_state_entry *state_table;
2233     unsigned int state;
2234
2235     state_cleanup(&cs->state);
2236     wined3d_state_reset(&cs->state, &device->adapter->d3d_info);
2237     if (op->invalidate)
2238     {
2239         state_table = device->state_table;
2240         for (state = 0; state <= STATE_HIGHEST; ++state)
2241         {
2242             if (state_table[state].representative)
2243                 device_invalidate_state(device, state);
2244         }
2245     }
2246 }
2247
2248 void wined3d_device_context_emit_reset_state(struct wined3d_device_context *context, bool invalidate)
2249 {
2250     struct wined3d_cs_reset_state *op;
2251
2252     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2253     op->opcode = WINED3D_CS_OP_RESET_STATE;
2254     op->invalidate = invalidate;
2255
2256     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2257 }
2258
2259 static void wined3d_cs_exec_callback(struct wined3d_cs *cs, const void *data)
2260 {
2261     const struct wined3d_cs_callback *op = data;
2262
2263     op->callback(op->object);
2264 }
2265
2266 static void wined3d_cs_emit_callback(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
2267 {
2268     struct wined3d_cs_callback *op;
2269
2270     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2271     op->opcode = WINED3D_CS_OP_CALLBACK;
2272     op->callback = callback;
2273     op->object = object;
2274
2275     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2276 }
2277
2278 void wined3d_cs_destroy_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
2279 {
2280     wined3d_cs_emit_callback(cs, callback, object);
2281 }
2282
2283 void wined3d_cs_init_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
2284 {
2285     wined3d_cs_emit_callback(cs, callback, object);
2286 }
2287
2288 static void wined3d_cs_exec_query_issue(struct wined3d_cs *cs, const void *data)
2289 {
2290     const struct wined3d_cs_query_issue *op = data;
2291     struct wined3d_query *query = op->query;
2292     BOOL poll;
2293
2294     poll = query->query_ops->query_issue(query, op->flags);
2295
2296     if (!cs->thread)
2297         return;
2298
2299     if (poll && list_empty(&query->poll_list_entry))
2300     {
2301         if (query->buffer_object)
2302             InterlockedIncrement(&query->counter_retrieved);
2303         else
2304             list_add_tail(&cs->query_poll_list, &query->poll_list_entry);
2305         return;
2306     }
2307
2308     /* This can happen if occlusion queries are restarted. This discards the
2309      * old result, since polling it could result in a GL error. */
2310     if ((op->flags & WINED3DISSUE_BEGIN) && !poll && !list_empty(&query->poll_list_entry))
2311     {
2312         list_remove(&query->poll_list_entry);
2313         list_init(&query->poll_list_entry);
2314         InterlockedIncrement(&query->counter_retrieved);
2315         return;
2316     }
2317
2318     /* This can happen when an occlusion query is ended without being started,
2319      * in which case we don't want to poll, but still have to counter-balance
2320      * the increment of the main counter.
2321      *
2322      * This can also happen if an event query is re-issued before the first
2323      * fence was reached. In this case the query is already in the list and
2324      * the poll function will check the new fence. We have to counter-balance
2325      * the discarded increment. */
2326     if (op->flags & WINED3DISSUE_END)
2327         InterlockedIncrement(&query->counter_retrieved);
2328 }
2329
2330 static void wined3d_cs_issue_query(struct wined3d_device_context *context,
2331         struct wined3d_query *query, unsigned int flags)
2332 {
2333     struct wined3d_cs *cs = wined3d_cs_from_context(context);
2334     struct wined3d_cs_query_issue *op;
2335
2336     if (flags & WINED3DISSUE_END)
2337         ++query->counter_main;
2338
2339     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2340     op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
2341     op->query = query;
2342     op->flags = flags;
2343
2344     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2345     cs->queries_flushed = FALSE;
2346
2347     if (flags & WINED3DISSUE_BEGIN)
2348         query->state = QUERY_BUILDING;
2349     else
2350         query->state = QUERY_SIGNALLED;
2351 }
2352
2353 static void wined3d_cs_acquire_command_list(struct wined3d_device_context *context, struct wined3d_command_list *list)
2354 {
2355     struct wined3d_cs *cs = wined3d_cs_from_context(context);
2356     SIZE_T i;
2357
2358     if (list->query_count)
2359     {
2360         cs->queries_flushed = FALSE;
2361
2362         for (i = 0; i < list->query_count; ++i)
2363         {
2364             if (list->queries[i].flags & WINED3DISSUE_END)
2365             {
2366                 list->queries[i].query->counter_main++;
2367                 list->queries[i].query->state = QUERY_SIGNALLED;
2368             }
2369             else
2370             {
2371                 list->queries[i].query->state = QUERY_BUILDING;
2372             }
2373         }
2374     }
2375
2376     for (i = 0; i < list->resource_count; ++i)
2377         wined3d_resource_acquire(list->resources[i]);
2378
2379     for (i = 0; i < list->command_list_count; ++i)
2380         wined3d_cs_acquire_command_list(context, list->command_lists[i]);
2381
2382     for (i = 0; i < list->upload_count; ++i)
2383         invalidate_client_address(list->uploads[i].resource);
2384 }
2385
2386 static void wined3d_cs_exec_preload_resource(struct wined3d_cs *cs, const void *data)
2387 {
2388     const struct wined3d_cs_preload_resource *op = data;
2389     struct wined3d_resource *resource = op->resource;
2390
2391     resource->resource_ops->resource_preload(resource);
2392     wined3d_resource_release(resource);
2393 }
2394
2395 void wined3d_cs_emit_preload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
2396 {
2397     struct wined3d_cs_preload_resource *op;
2398
2399     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2400     op->opcode = WINED3D_CS_OP_PRELOAD_RESOURCE;
2401     op->resource = resource;
2402
2403     wined3d_resource_acquire(resource);
2404
2405     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2406 }
2407
2408 static void wined3d_cs_exec_unload_resource(struct wined3d_cs *cs, const void *data)
2409 {
2410     const struct wined3d_cs_unload_resource *op = data;
2411     struct wined3d_resource *resource = op->resource;
2412
2413     resource->resource_ops->resource_unload(resource);
2414     wined3d_resource_release(resource);
2415 }
2416
2417 void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
2418 {
2419     struct wined3d_cs_unload_resource *op;
2420
2421     invalidate_client_address(resource);
2422
2423     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2424     op->opcode = WINED3D_CS_OP_UNLOAD_RESOURCE;
2425     op->resource = resource;
2426
2427     wined3d_resource_acquire(resource);
2428
2429     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2430 }
2431
2432 static void wined3d_device_context_upload_bo(struct wined3d_device_context *context,
2433         struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box,
2434         const struct upload_bo *bo, unsigned int row_pitch, unsigned int slice_pitch)
2435 {
2436     struct wined3d_cs_update_sub_resource *op;
2437
2438     TRACE("context %p, resource %p, sub_resource_idx %u, box %s, bo %s, flags %#x, row_pitch %u, slice_pitch %u.\n",
2439             context, resource, sub_resource_idx, debug_box(box),
2440             debug_const_bo_address(&bo->addr), bo->flags, row_pitch, slice_pitch);
2441
2442     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2443     op->opcode = WINED3D_CS_OP_UPDATE_SUB_RESOURCE;
2444     op->resource = resource;
2445     op->sub_resource_idx = sub_resource_idx;
2446     op->box = *box;
2447     op->bo = *bo;
2448     op->row_pitch = row_pitch;
2449     op->slice_pitch = slice_pitch;
2450
2451     wined3d_device_context_acquire_resource(context, resource);
2452
2453     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2454 }
2455
2456 static void wined3d_cs_exec_map(struct wined3d_cs *cs, const void *data)
2457 {
2458     const struct wined3d_cs_map *op = data;
2459     struct wined3d_resource *resource = op->resource;
2460
2461     *op->hr = resource->resource_ops->resource_sub_resource_map(resource,
2462             op->sub_resource_idx, op->map_ptr, op->box, op->flags);
2463 }
2464
2465 HRESULT wined3d_device_context_emit_map(struct wined3d_device_context *context,
2466         struct wined3d_resource *resource, unsigned int sub_resource_idx,
2467         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, unsigned int flags)
2468 {
2469     struct wined3d_cs_map *op;
2470     HRESULT hr;
2471
2472     /* Mapping resources from the worker thread isn't an issue by itself, but
2473      * increasing the map count would be visible to applications. */
2474     wined3d_not_from_cs(context->device->cs);
2475
2476     if ((flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
2477             && context->ops->map_upload_bo(context, resource, sub_resource_idx, map_desc, box, flags))
2478     {
2479         TRACE("Returning map pointer %p, row pitch %u, slice pitch %u.\n",
2480                 map_desc->data, map_desc->row_pitch, map_desc->slice_pitch);
2481         return WINED3D_OK;
2482     }
2483
2484     wined3d_resource_wait_idle(resource);
2485
2486     /* We might end up invalidating the resource on the CS thread. */
2487     invalidate_client_address(resource);
2488
2489     if (!(op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_MAP)))
2490         return E_OUTOFMEMORY;
2491     op->opcode = WINED3D_CS_OP_MAP;
2492     op->resource = resource;
2493     op->sub_resource_idx = sub_resource_idx;
2494     op->map_ptr = &map_desc->data;
2495     op->box = box;
2496     op->flags = flags;
2497     op->hr = &hr;
2498
2499     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_MAP);
2500     wined3d_device_context_finish(context, WINED3D_CS_QUEUE_MAP);
2501
2502     if (SUCCEEDED(hr))
2503         wined3d_resource_get_sub_resource_map_pitch(resource, sub_resource_idx,
2504                 &map_desc->row_pitch, &map_desc->slice_pitch);
2505     return hr;
2506 }
2507
2508 static void wined3d_cs_exec_unmap(struct wined3d_cs *cs, const void *data)
2509 {
2510     const struct wined3d_cs_unmap *op = data;
2511     struct wined3d_resource *resource = op->resource;
2512
2513     *op->hr = resource->resource_ops->resource_sub_resource_unmap(resource, op->sub_resource_idx);
2514 }
2515
2516 HRESULT wined3d_device_context_emit_unmap(struct wined3d_device_context *context,
2517         struct wined3d_resource *resource, unsigned int sub_resource_idx)
2518 {
2519     struct wined3d_cs_unmap *op;
2520     struct wined3d_box box;
2521     struct upload_bo bo;
2522     HRESULT hr;
2523
2524     if (context->ops->unmap_upload_bo(context, resource, sub_resource_idx, &box, &bo))
2525     {
2526         unsigned int row_pitch, slice_pitch;
2527
2528         wined3d_resource_get_sub_resource_map_pitch(resource, sub_resource_idx, &row_pitch, &slice_pitch);
2529         if (bo.flags & UPLOAD_BO_UPLOAD_ON_UNMAP)
2530             wined3d_device_context_upload_bo(context, resource, sub_resource_idx, &box, &bo, row_pitch, slice_pitch);
2531         return WINED3D_OK;
2532     }
2533
2534     wined3d_not_from_cs(context->device->cs);
2535
2536     if (!(op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_MAP)))
2537         return E_OUTOFMEMORY;
2538     op->opcode = WINED3D_CS_OP_UNMAP;
2539     op->resource = resource;
2540     op->sub_resource_idx = sub_resource_idx;
2541     op->hr = &hr;
2542
2543     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_MAP);
2544     wined3d_device_context_finish(context, WINED3D_CS_QUEUE_MAP);
2545
2546     return hr;
2547 }
2548
2549 static void wined3d_cs_exec_blt_sub_resource(struct wined3d_cs *cs, const void *data)
2550 {
2551     const struct wined3d_cs_blt_sub_resource *op = data;
2552
2553     if (op->dst_resource->type == WINED3D_RTYPE_BUFFER)
2554     {
2555         wined3d_buffer_copy(buffer_from_resource(op->dst_resource), op->dst_box.left,
2556                 buffer_from_resource(op->src_resource), op->src_box.left,
2557                 op->src_box.right - op->src_box.left);
2558     }
2559     else if (op->dst_resource->type == WINED3D_RTYPE_TEXTURE_3D)
2560     {
2561         struct wined3d_texture *src_texture, *dst_texture;
2562         unsigned int level, update_w, update_h, update_d;
2563         unsigned int row_pitch, slice_pitch;
2564         struct wined3d_context *context;
2565         struct wined3d_bo_address addr;
2566         unsigned int location;
2567
2568         if (op->flags & ~WINED3D_BLT_RAW)
2569         {
2570             FIXME("Flags %#x not implemented for %s resources.\n",
2571                     op->flags, debug_d3dresourcetype(op->dst_resource->type));
2572             goto error;
2573         }
2574
2575         if (!(op->flags & WINED3D_BLT_RAW) && op->src_resource->format != op->dst_resource->format)
2576         {
2577             FIXME("Format conversion not implemented for %s resources.\n",
2578                     debug_d3dresourcetype(op->dst_resource->type));
2579             goto error;
2580         }
2581
2582         update_w = op->dst_box.right - op->dst_box.left;
2583         update_h = op->dst_box.bottom - op->dst_box.top;
2584         update_d = op->dst_box.back - op->dst_box.front;
2585         if (op->src_box.right - op->src_box.left != update_w
2586                 || op->src_box.bottom - op->src_box.top != update_h
2587                 || op->src_box.back - op->src_box.front != update_d)
2588         {
2589             FIXME("Stretching not implemented for %s resources.\n",
2590                     debug_d3dresourcetype(op->dst_resource->type));
2591             goto error;
2592         }
2593
2594         dst_texture = texture_from_resource(op->dst_resource);
2595         src_texture = texture_from_resource(op->src_resource);
2596
2597         context = context_acquire(cs->c.device, NULL, 0);
2598
2599         location = src_texture->resource.map_binding;
2600         if (location == WINED3D_LOCATION_SYSMEM
2601                 && wined3d_texture_can_use_pbo(src_texture, &context->device->adapter->d3d_info))
2602             location = WINED3D_LOCATION_BUFFER;
2603
2604         if (!wined3d_texture_load_location(src_texture, op->src_sub_resource_idx,
2605                 context, location))
2606         {
2607             ERR("Failed to load source sub-resource into %s.\n",
2608                     wined3d_debug_location(location));
2609             context_release(context);
2610             goto error;
2611         }
2612
2613         level = op->dst_sub_resource_idx % dst_texture->level_count;
2614         if (update_w == wined3d_texture_get_level_width(dst_texture, level)
2615                 && update_h == wined3d_texture_get_level_height(dst_texture, level)
2616                 && update_d == wined3d_texture_get_level_depth(dst_texture, level))
2617         {
2618             wined3d_texture_prepare_location(dst_texture, op->dst_sub_resource_idx,
2619                     context, WINED3D_LOCATION_TEXTURE_RGB);
2620         }
2621         else if (!wined3d_texture_load_location(dst_texture, op->dst_sub_resource_idx,
2622                 context, WINED3D_LOCATION_TEXTURE_RGB))
2623         {
2624             ERR("Failed to load destination sub-resource.\n");
2625             context_release(context);
2626             goto error;
2627         }
2628
2629         wined3d_texture_get_memory(src_texture, op->src_sub_resource_idx, &addr, location);
2630         wined3d_texture_get_pitch(src_texture, op->src_sub_resource_idx % src_texture->level_count,
2631                 &row_pitch, &slice_pitch);
2632
2633         dst_texture->texture_ops->texture_upload_data(context, wined3d_const_bo_address(&addr),
2634                 dst_texture->resource.format, &op->src_box, row_pitch, slice_pitch, dst_texture,
2635                 op->dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB,
2636                 op->dst_box.left, op->dst_box.top, op->dst_box.front);
2637         wined3d_texture_validate_location(dst_texture, op->dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2638         wined3d_texture_invalidate_location(dst_texture, op->dst_sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2639
2640         context_release(context);
2641     }
2642     else
2643     {
2644         if (FAILED(texture2d_blt(texture_from_resource(op->dst_resource), op->dst_sub_resource_idx,
2645                 &op->dst_box, texture_from_resource(op->src_resource), op->src_sub_resource_idx,
2646                 &op->src_box, op->flags, &op->fx, op->filter)))
2647             FIXME("Blit failed.\n");
2648     }
2649
2650 error:
2651     if (op->src_resource)
2652         wined3d_resource_release(op->src_resource);
2653     wined3d_resource_release(op->dst_resource);
2654 }
2655
2656 void wined3d_device_context_emit_blt_sub_resource(struct wined3d_device_context *context,
2657         struct wined3d_resource *dst_resource, unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box,
2658         struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, const struct wined3d_box *src_box,
2659         unsigned int flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
2660 {
2661     struct wined3d_cs_blt_sub_resource *op;
2662
2663     /* If we are replacing the whole resource, the CS thread might discard and
2664      * rename the buffer object, in which case ours is no longer valid. */
2665     if (dst_resource->type == WINED3D_RTYPE_BUFFER && dst_box->right - dst_box->left == dst_resource->size)
2666         invalidate_client_address(dst_resource);
2667
2668     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2669     op->opcode = WINED3D_CS_OP_BLT_SUB_RESOURCE;
2670     op->dst_resource = dst_resource;
2671     op->dst_sub_resource_idx = dst_sub_resource_idx;
2672     op->dst_box = *dst_box;
2673     op->src_resource = src_resource;
2674     op->src_sub_resource_idx = src_sub_resource_idx;
2675     op->src_box = *src_box;
2676     op->flags = flags;
2677     if (fx)
2678         op->fx = *fx;
2679     else
2680         memset(&op->fx, 0, sizeof(op->fx));
2681     op->filter = filter;
2682
2683     wined3d_device_context_acquire_resource(context, dst_resource);
2684     if (src_resource)
2685         wined3d_device_context_acquire_resource(context, src_resource);
2686
2687     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2688     if (flags & WINED3D_BLT_SYNCHRONOUS)
2689         wined3d_device_context_finish(context, WINED3D_CS_QUEUE_DEFAULT);
2690 }
2691
2692 static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const void *data)
2693 {
2694     const struct wined3d_cs_update_sub_resource *op = data;
2695     struct wined3d_resource *resource = op->resource;
2696     const struct wined3d_box *box = &op->box;
2697     unsigned int width, height, depth, level;
2698     struct wined3d_context *context;
2699     struct wined3d_texture *texture;
2700     struct wined3d_box src_box;
2701
2702     context = context_acquire(cs->c.device, NULL, 0);
2703
2704     if (resource->type == WINED3D_RTYPE_BUFFER)
2705     {
2706         wined3d_buffer_update_sub_resource(buffer_from_resource(resource),
2707                 context, &op->bo, box->left, box->right - box->left);
2708         goto done;
2709     }
2710
2711     texture = wined3d_texture_from_resource(resource);
2712
2713     level = op->sub_resource_idx % texture->level_count;
2714     width = wined3d_texture_get_level_width(texture, level);
2715     height = wined3d_texture_get_level_height(texture, level);
2716     depth = wined3d_texture_get_level_depth(texture, level);
2717
2718     /* Only load the sub-resource for partial updates. */
2719     if (!box->left && !box->top && !box->front
2720             && box->right == width && box->bottom == height && box->back == depth)
2721         wined3d_texture_prepare_location(texture, op->sub_resource_idx, context, WINED3D_LOCATION_TEXTURE_RGB);
2722     else
2723         wined3d_texture_load_location(texture, op->sub_resource_idx, context, WINED3D_LOCATION_TEXTURE_RGB);
2724
2725     wined3d_box_set(&src_box, 0, 0, box->right - box->left, box->bottom - box->top, 0, box->back - box->front);
2726     texture->texture_ops->texture_upload_data(context, &op->bo.addr, texture->resource.format, &src_box,
2727             op->row_pitch, op->slice_pitch, texture, op->sub_resource_idx,
2728             WINED3D_LOCATION_TEXTURE_RGB, box->left, box->top, box->front);
2729
2730     wined3d_texture_validate_location(texture, op->sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2731     wined3d_texture_invalidate_location(texture, op->sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2732
2733 done:
2734     context_release(context);
2735
2736     wined3d_resource_release(resource);
2737 }
2738
2739 void wined3d_device_context_emit_update_sub_resource(struct wined3d_device_context *context,
2740         struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box,
2741         const void *data, unsigned int row_pitch, unsigned int slice_pitch)
2742 {
2743     struct wined3d_cs_update_sub_resource *op;
2744     struct wined3d_map_desc map_desc;
2745     struct wined3d_box dummy_box;
2746     struct upload_bo bo;
2747
2748     /* If we are replacing the whole resource, the CS thread might discard and
2749      * rename the buffer object, in which case ours is no longer valid. */
2750     if (resource->type == WINED3D_RTYPE_BUFFER && box->right - box->left == resource->size)
2751         invalidate_client_address(resource);
2752
2753     if (context->ops->map_upload_bo(context, resource, sub_resource_idx, &map_desc, box, WINED3D_MAP_WRITE))
2754     {
2755         wined3d_format_copy_data(resource->format, data, row_pitch, slice_pitch, map_desc.data, map_desc.row_pitch,
2756                 map_desc.slice_pitch, box->right - box->left, box->bottom - box->top, box->back - box->front);
2757         context->ops->unmap_upload_bo(context, resource, sub_resource_idx, &dummy_box, &bo);
2758         wined3d_device_context_upload_bo(context, resource, sub_resource_idx,
2759                 box, &bo, map_desc.row_pitch, map_desc.slice_pitch);
2760         return;
2761     }
2762
2763     wined3d_resource_wait_idle(resource);
2764
2765     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2766     op->opcode = WINED3D_CS_OP_UPDATE_SUB_RESOURCE;
2767     op->resource = resource;
2768     op->sub_resource_idx = sub_resource_idx;
2769     op->box = *box;
2770     op->bo.addr.buffer_object = 0;
2771     op->bo.addr.addr = data;
2772     op->bo.flags = 0;
2773     op->row_pitch = row_pitch;
2774     op->slice_pitch = slice_pitch;
2775
2776     wined3d_device_context_acquire_resource(context, resource);
2777
2778     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_MAP);
2779     /* The data pointer may go away, so we need to wait until it is read.
2780      * Copying the data may be faster if it's small. */
2781     wined3d_device_context_finish(context, WINED3D_CS_QUEUE_MAP);
2782 }
2783
2784 static void wined3d_cs_exec_add_dirty_texture_region(struct wined3d_cs *cs, const void *data)
2785 {
2786     const struct wined3d_cs_add_dirty_texture_region *op = data;
2787     struct wined3d_texture *texture = op->texture;
2788     unsigned int sub_resource_idx, i;
2789     struct wined3d_context *context;
2790
2791     context = context_acquire(cs->c.device, NULL, 0);
2792     sub_resource_idx = op->layer * texture->level_count;
2793     for (i = 0; i < texture->level_count; ++i, ++sub_resource_idx)
2794     {
2795         if (wined3d_texture_load_location(texture, sub_resource_idx, context, texture->resource.map_binding))
2796             wined3d_texture_invalidate_location(texture, sub_resource_idx, ~texture->resource.map_binding);
2797         else
2798             ERR("Failed to load location %s.\n", wined3d_debug_location(texture->resource.map_binding));
2799     }
2800     context_release(context);
2801
2802     wined3d_resource_release(&texture->resource);
2803 }
2804
2805 void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs *cs,
2806         struct wined3d_texture *texture, unsigned int layer)
2807 {
2808     struct wined3d_cs_add_dirty_texture_region *op;
2809
2810     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2811     op->opcode = WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION;
2812     op->texture = texture;
2813     op->layer = layer;
2814
2815     wined3d_resource_acquire(&texture->resource);
2816
2817     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2818 }
2819
2820 static void wined3d_cs_exec_clear_unordered_access_view(struct wined3d_cs *cs, const void *data)
2821 {
2822     const struct wined3d_cs_clear_unordered_access_view *op = data;
2823     struct wined3d_unordered_access_view *view = op->view;
2824     struct wined3d_context *context;
2825
2826     context = context_acquire(cs->c.device, NULL, 0);
2827     cs->c.device->adapter->adapter_ops->adapter_clear_uav(context, view, &op->clear_value, op->fp);
2828     context_release(context);
2829
2830     wined3d_resource_release(view->resource);
2831 }
2832
2833 void wined3d_device_context_emit_clear_uav(struct wined3d_device_context *context,
2834         struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value, bool fp)
2835 {
2836     struct wined3d_cs_clear_unordered_access_view *op;
2837
2838     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2839     op->opcode = WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW;
2840     op->view = view;
2841     op->clear_value = *clear_value;
2842     op->fp = fp;
2843
2844     wined3d_device_context_acquire_resource(context, view->resource);
2845
2846     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2847 }
2848
2849 static void wined3d_cs_exec_copy_uav_counter(struct wined3d_cs *cs, const void *data)
2850 {
2851     const struct wined3d_cs_copy_uav_counter *op = data;
2852     struct wined3d_unordered_access_view *view = op->view;
2853     struct wined3d_context *context;
2854
2855     context = context_acquire(cs->c.device, NULL, 0);
2856     wined3d_unordered_access_view_copy_counter(view, op->buffer, op->offset, context);
2857     context_release(context);
2858
2859     wined3d_resource_release(&op->buffer->resource);
2860 }
2861
2862 void wined3d_device_context_emit_copy_uav_counter(struct wined3d_device_context *context,
2863         struct wined3d_buffer *dst_buffer, unsigned int offset, struct wined3d_unordered_access_view *uav)
2864 {
2865     struct wined3d_cs_copy_uav_counter *op;
2866
2867     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2868     op->opcode = WINED3D_CS_OP_COPY_UAV_COUNTER;
2869     op->buffer = dst_buffer;
2870     op->offset = offset;
2871     op->view = uav;
2872
2873     wined3d_device_context_acquire_resource(context, &dst_buffer->resource);
2874
2875     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2876 }
2877
2878 static void wined3d_cs_exec_generate_mipmaps(struct wined3d_cs *cs, const void *data)
2879 {
2880     const struct wined3d_cs_generate_mipmaps *op = data;
2881     struct wined3d_shader_resource_view *view = op->view;
2882     struct wined3d_context *context;
2883
2884     context = context_acquire(cs->c.device, NULL, 0);
2885     cs->c.device->adapter->adapter_ops->adapter_generate_mipmap(context, view);
2886     context_release(context);
2887
2888     wined3d_resource_release(view->resource);
2889 }
2890
2891 void wined3d_device_context_emit_generate_mipmaps(struct wined3d_device_context *context,
2892         struct wined3d_shader_resource_view *view)
2893 {
2894     struct wined3d_cs_generate_mipmaps *op;
2895
2896     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2897     op->opcode = WINED3D_CS_OP_GENERATE_MIPMAPS;
2898     op->view = view;
2899
2900     wined3d_device_context_acquire_resource(context, view->resource);
2901
2902     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
2903 }
2904
2905 static void wined3d_cs_emit_stop(struct wined3d_cs *cs)
2906 {
2907     struct wined3d_cs_stop *op;
2908
2909     op = wined3d_device_context_require_space(&cs->c, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2910     op->opcode = WINED3D_CS_OP_STOP;
2911
2912     wined3d_device_context_submit(&cs->c, WINED3D_CS_QUEUE_DEFAULT);
2913     wined3d_cs_finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2914 }
2915
2916 static void wined3d_cs_acquire_resource(struct wined3d_device_context *context, struct wined3d_resource *resource)
2917 {
2918     wined3d_resource_acquire(resource);
2919 }
2920
2921 static void wined3d_cs_exec_execute_command_list(struct wined3d_cs *cs, const void *data);
2922
2923 static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data) =
2924 {
2925     /* WINED3D_CS_OP_NOP                         */ wined3d_cs_exec_nop,
2926     /* WINED3D_CS_OP_PRESENT                     */ wined3d_cs_exec_present,
2927     /* WINED3D_CS_OP_CLEAR                       */ wined3d_cs_exec_clear,
2928     /* WINED3D_CS_OP_DISPATCH                    */ wined3d_cs_exec_dispatch,
2929     /* WINED3D_CS_OP_DRAW                        */ wined3d_cs_exec_draw,
2930     /* WINED3D_CS_OP_FLUSH                       */ wined3d_cs_exec_flush,
2931     /* WINED3D_CS_OP_SET_PREDICATION             */ wined3d_cs_exec_set_predication,
2932     /* WINED3D_CS_OP_SET_VIEWPORTS               */ wined3d_cs_exec_set_viewports,
2933     /* WINED3D_CS_OP_SET_SCISSOR_RECTS           */ wined3d_cs_exec_set_scissor_rects,
2934     /* WINED3D_CS_OP_SET_RENDERTARGET_VIEWS      */ wined3d_cs_exec_set_rendertarget_views,
2935     /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW      */ wined3d_cs_exec_set_depth_stencil_view,
2936     /* WINED3D_CS_OP_SET_VERTEX_DECLARATION      */ wined3d_cs_exec_set_vertex_declaration,
2937     /* WINED3D_CS_OP_SET_STREAM_SOURCES          */ wined3d_cs_exec_set_stream_sources,
2938     /* WINED3D_CS_OP_SET_STREAM_OUTPUTS          */ wined3d_cs_exec_set_stream_outputs,
2939     /* WINED3D_CS_OP_SET_INDEX_BUFFER            */ wined3d_cs_exec_set_index_buffer,
2940     /* WINED3D_CS_OP_SET_CONSTANT_BUFFERS        */ wined3d_cs_exec_set_constant_buffers,
2941     /* WINED3D_CS_OP_SET_TEXTURE                 */ wined3d_cs_exec_set_texture,
2942     /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEWS   */ wined3d_cs_exec_set_shader_resource_views,
2943     /* WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEWS  */ wined3d_cs_exec_set_unordered_access_views,
2944     /* WINED3D_CS_OP_SET_SAMPLERS                */ wined3d_cs_exec_set_samplers,
2945     /* WINED3D_CS_OP_SET_SHADER                  */ wined3d_cs_exec_set_shader,
2946     /* WINED3D_CS_OP_SET_BLEND_STATE             */ wined3d_cs_exec_set_blend_state,
2947     /* WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE     */ wined3d_cs_exec_set_depth_stencil_state,
2948     /* WINED3D_CS_OP_SET_RASTERIZER_STATE        */ wined3d_cs_exec_set_rasterizer_state,
2949     /* WINED3D_CS_OP_SET_RENDER_STATE            */ wined3d_cs_exec_set_render_state,
2950     /* WINED3D_CS_OP_SET_TEXTURE_STATE           */ wined3d_cs_exec_set_texture_state,
2951     /* WINED3D_CS_OP_SET_SAMPLER_STATE           */ wined3d_cs_exec_set_sampler_state,
2952     /* WINED3D_CS_OP_SET_TRANSFORM               */ wined3d_cs_exec_set_transform,
2953     /* WINED3D_CS_OP_SET_CLIP_PLANE              */ wined3d_cs_exec_set_clip_plane,
2954     /* WINED3D_CS_OP_SET_COLOR_KEY               */ wined3d_cs_exec_set_color_key,
2955     /* WINED3D_CS_OP_SET_MATERIAL                */ wined3d_cs_exec_set_material,
2956     /* WINED3D_CS_OP_SET_LIGHT                   */ wined3d_cs_exec_set_light,
2957     /* WINED3D_CS_OP_SET_LIGHT_ENABLE            */ wined3d_cs_exec_set_light_enable,
2958     /* WINED3D_CS_OP_SET_FEATURE_LEVEL           */ wined3d_cs_exec_set_feature_level,
2959     /* WINED3D_CS_OP_PUSH_CONSTANTS              */ wined3d_cs_exec_push_constants,
2960     /* WINED3D_CS_OP_RESET_STATE                 */ wined3d_cs_exec_reset_state,
2961     /* WINED3D_CS_OP_CALLBACK                    */ wined3d_cs_exec_callback,
2962     /* WINED3D_CS_OP_QUERY_ISSUE                 */ wined3d_cs_exec_query_issue,
2963     /* WINED3D_CS_OP_PRELOAD_RESOURCE            */ wined3d_cs_exec_preload_resource,
2964     /* WINED3D_CS_OP_UNLOAD_RESOURCE             */ wined3d_cs_exec_unload_resource,
2965     /* WINED3D_CS_OP_MAP                         */ wined3d_cs_exec_map,
2966     /* WINED3D_CS_OP_UNMAP                       */ wined3d_cs_exec_unmap,
2967     /* WINED3D_CS_OP_BLT_SUB_RESOURCE            */ wined3d_cs_exec_blt_sub_resource,
2968     /* WINED3D_CS_OP_UPDATE_SUB_RESOURCE         */ wined3d_cs_exec_update_sub_resource,
2969     /* WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION    */ wined3d_cs_exec_add_dirty_texture_region,
2970     /* WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_clear_unordered_access_view,
2971     /* WINED3D_CS_OP_COPY_UAV_COUNTER            */ wined3d_cs_exec_copy_uav_counter,
2972     /* WINED3D_CS_OP_GENERATE_MIPMAPS            */ wined3d_cs_exec_generate_mipmaps,
2973     /* WINED3D_CS_OP_EXECUTE_COMMAND_LIST        */ wined3d_cs_exec_execute_command_list,
2974 };
2975
2976 static void wined3d_cs_exec_execute_command_list(struct wined3d_cs *cs, const void *data)
2977 {
2978     const struct wined3d_cs_execute_command_list *op = data;
2979     SIZE_T start = 0, end = op->list->data_size;
2980     const BYTE *cs_data = op->list->data;
2981
2982     TRACE("Executing command list %p.\n", op->list);
2983
2984     while (start < end)
2985     {
2986         const struct wined3d_cs_packet *packet = wined3d_next_cs_packet(cs_data, &start);
2987         enum wined3d_cs_op opcode = *(const enum wined3d_cs_op *)packet->data;
2988
2989         if (opcode >= WINED3D_CS_OP_STOP)
2990             ERR("Invalid opcode %#x.\n", opcode);
2991         else
2992             wined3d_cs_op_handlers[opcode](cs, packet->data);
2993         TRACE("%s executed.\n", debug_cs_op(opcode));
2994     }
2995 }
2996
2997 void wined3d_device_context_emit_execute_command_list(struct wined3d_device_context *context,
2998         struct wined3d_command_list *list, bool restore_state)
2999 {
3000     struct wined3d_cs_execute_command_list *op;
3001
3002     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
3003     op->opcode = WINED3D_CS_OP_EXECUTE_COMMAND_LIST;
3004     op->list = list;
3005
3006     context->ops->acquire_command_list(context, list);
3007
3008     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
3009
3010     if (restore_state)
3011         wined3d_device_context_set_state(context, context->state);
3012     else
3013         wined3d_device_context_reset_state(context);
3014 }
3015
3016 static void *wined3d_cs_st_require_space(struct wined3d_device_context *context,
3017         size_t size, enum wined3d_cs_queue_id queue_id)
3018 {
3019     struct wined3d_cs *cs = wined3d_cs_from_context(context);
3020
3021     if (size > (cs->data_size - cs->end))
3022     {
3023         size_t new_size;
3024         void *new_data;
3025
3026         new_size = max(size, cs->data_size * 2);
3027         if (!cs->end)
3028             new_data = heap_realloc(cs->data, new_size);
3029         else
3030             new_data = heap_alloc(new_size);
3031         if (!new_data)
3032             return NULL;
3033
3034         cs->data_size = new_size;
3035         cs->start = cs->end = 0;
3036         cs->data = new_data;
3037     }
3038
3039     cs->end += size;
3040
3041     return (BYTE *)cs->data + cs->start;
3042 }
3043
3044 static void wined3d_cs_st_submit(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
3045 {
3046     struct wined3d_cs *cs = wined3d_cs_from_context(context);
3047     enum wined3d_cs_op opcode;
3048     size_t start;
3049     BYTE *data;
3050
3051     data = cs->data;
3052     start = cs->start;
3053     cs->start = cs->end;
3054
3055     opcode = *(const enum wined3d_cs_op *)&data[start];
3056     if (opcode >= WINED3D_CS_OP_STOP)
3057         ERR("Invalid opcode %#x.\n", opcode);
3058     else
3059         wined3d_cs_op_handlers[opcode](cs, &data[start]);
3060
3061     if (cs->data == data)
3062         cs->start = cs->end = start;
3063     else if (!start)
3064         heap_free(data);
3065 }
3066
3067 static void wined3d_cs_st_finish(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
3068 {
3069 }
3070
3071 static bool wined3d_cs_map_upload_bo(struct wined3d_device_context *context, struct wined3d_resource *resource,
3072         unsigned int sub_resource_idx, struct wined3d_map_desc *map_desc, const struct wined3d_box *box, uint32_t flags)
3073 {
3074     /* Limit NOOVERWRITE maps to buffers for now; there are too many ways that
3075      * a texture can be invalidated to even count. */
3076     if (wined3d_map_persistent() && resource->type == WINED3D_RTYPE_BUFFER
3077             && (flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE)))
3078     {
3079         struct wined3d_client_resource *client = &resource->client;
3080         struct wined3d_device *device = context->device;
3081         const struct wined3d_bo *bo;
3082         uint8_t *map_ptr;
3083
3084         if (flags & WINED3D_MAP_DISCARD)
3085         {
3086             if (!device->adapter->adapter_ops->adapter_alloc_bo(device, resource, sub_resource_idx, &client->addr))
3087                 return false;
3088         }
3089
3090         bo = client->addr.buffer_object;
3091         map_ptr = bo ? bo->map_ptr : NULL;
3092         map_ptr += (uintptr_t)client->addr.addr;
3093
3094         if (!map_ptr)
3095         {
3096             TRACE("Sub-resource is not persistently mapped.\n");
3097             return false;
3098         }
3099
3100         wined3d_resource_get_sub_resource_map_pitch(resource, sub_resource_idx,
3101                 &map_desc->row_pitch, &map_desc->slice_pitch);
3102
3103         client->mapped_upload.addr = *wined3d_const_bo_address(&client->addr);
3104         client->mapped_upload.flags = 0;
3105         if (bo)
3106         {
3107             map_ptr += bo->memory_offset;
3108             if (!bo->coherent)
3109                 client->mapped_upload.flags |= UPLOAD_BO_UPLOAD_ON_UNMAP;
3110         }
3111         map_desc->data = resource_offset_map_pointer(resource, sub_resource_idx, map_ptr, box);
3112
3113         if (flags & WINED3D_MAP_DISCARD)
3114             client->mapped_upload.flags |= UPLOAD_BO_UPLOAD_ON_UNMAP | UPLOAD_BO_RENAME_ON_UNMAP;
3115
3116         client->mapped_box = *box;
3117
3118         TRACE("Returning bo %s, flags %#x.\n", debug_const_bo_address(&client->mapped_upload.addr),
3119                 client->mapped_upload.flags);
3120         return true;
3121     }
3122
3123     return false;
3124 }
3125
3126 static bool wined3d_bo_address_is_null(struct wined3d_const_bo_address *addr)
3127 {
3128     return !addr->buffer_object && !addr->addr;
3129 }
3130
3131 static bool wined3d_cs_unmap_upload_bo(struct wined3d_device_context *context, struct wined3d_resource *resource,
3132         unsigned int sub_resource_idx, struct wined3d_box *box, struct upload_bo *bo)
3133 {
3134     struct wined3d_client_resource *client = &resource->client;
3135
3136     if (wined3d_bo_address_is_null(&client->mapped_upload.addr))
3137         return false;
3138
3139     *bo = client->mapped_upload;
3140     *box = client->mapped_box;
3141     memset(&client->mapped_upload, 0, sizeof(client->mapped_upload));
3142     memset(&client->mapped_box, 0, sizeof(client->mapped_box));
3143     return true;
3144 }
3145
3146 static const struct wined3d_device_context_ops wined3d_cs_st_ops =
3147 {
3148     wined3d_cs_st_require_space,
3149     wined3d_cs_st_submit,
3150     wined3d_cs_st_finish,
3151     wined3d_cs_st_push_constants,
3152     wined3d_cs_map_upload_bo,
3153     wined3d_cs_unmap_upload_bo,
3154     wined3d_cs_issue_query,
3155     wined3d_cs_flush,
3156     wined3d_cs_acquire_resource,
3157     wined3d_cs_acquire_command_list,
3158 };
3159
3160 static BOOL wined3d_cs_queue_is_empty(const struct wined3d_cs *cs, const struct wined3d_cs_queue *queue)
3161 {
3162     wined3d_from_cs(cs);
3163     return *(volatile LONG *)&queue->head == queue->tail;
3164 }
3165
3166 static void wined3d_cs_queue_submit(struct wined3d_cs_queue *queue, struct wined3d_cs *cs)
3167 {
3168     struct wined3d_cs_packet *packet;
3169     size_t packet_size;
3170
3171     packet = (struct wined3d_cs_packet *)&queue->data[queue->head];
3172     TRACE("Queuing op %s at %p.\n", debug_cs_op(*(const enum wined3d_cs_op *)packet->data), packet);
3173     packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[packet->size]);
3174     InterlockedExchange(&queue->head, (queue->head + packet_size) & (WINED3D_CS_QUEUE_SIZE - 1));
3175
3176     if (InterlockedCompareExchange(&cs->waiting_for_event, FALSE, TRUE))
3177         SetEvent(cs->event);
3178 }
3179
3180 static void wined3d_cs_mt_submit(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
3181 {
3182     struct wined3d_cs *cs = wined3d_cs_from_context(context);
3183
3184     if (cs->thread_id == GetCurrentThreadId())
3185         return wined3d_cs_st_submit(context, queue_id);
3186
3187     wined3d_cs_queue_submit(&cs->queue[queue_id], cs);
3188 }
3189
3190 static void *wined3d_cs_queue_require_space(struct wined3d_cs_queue *queue, size_t size, struct wined3d_cs *cs)
3191 {
3192     size_t queue_size = ARRAY_SIZE(queue->data);
3193     size_t header_size, packet_size, remaining;
3194     struct wined3d_cs_packet *packet;
3195
3196     header_size = FIELD_OFFSET(struct wined3d_cs_packet, data[0]);
3197     packet_size = FIELD_OFFSET(struct wined3d_cs_packet, data[size]);
3198     packet_size = (packet_size + header_size - 1) & ~(header_size - 1);
3199     size = packet_size - header_size;
3200     if (packet_size >= WINED3D_CS_QUEUE_SIZE)
3201     {
3202         ERR("Packet size %lu >= queue size %u.\n",
3203                 (unsigned long)packet_size, WINED3D_CS_QUEUE_SIZE);
3204         return NULL;
3205     }
3206
3207     remaining = queue_size - queue->head;
3208     if (remaining < packet_size)
3209     {
3210         size_t nop_size = remaining - header_size;
3211         struct wined3d_cs_nop *nop;
3212
3213         TRACE("Inserting a nop for %lu + %lu bytes.\n",
3214                 (unsigned long)header_size, (unsigned long)nop_size);
3215
3216         nop = wined3d_cs_queue_require_space(queue, nop_size, cs);
3217         if (nop_size)
3218             nop->opcode = WINED3D_CS_OP_NOP;
3219
3220         wined3d_cs_queue_submit(queue, cs);
3221         assert(!queue->head);
3222     }
3223
3224     for (;;)
3225     {
3226         LONG tail = *(volatile LONG *)&queue->tail;
3227         LONG head = queue->head;
3228         LONG new_pos;
3229
3230         /* Empty. */
3231         if (head == tail)
3232             break;
3233         new_pos = (head + packet_size) & (WINED3D_CS_QUEUE_SIZE - 1);
3234         /* Head ahead of tail. We checked the remaining size above, so we only
3235          * need to make sure we don't make head equal to tail. */
3236         if (head > tail && (new_pos != tail))
3237             break;
3238         /* Tail ahead of head. Make sure the new head is before the tail as
3239          * well. Note that new_pos is 0 when it's at the end of the queue. */
3240         if (new_pos < tail && new_pos)
3241             break;
3242
3243         TRACE("Waiting for free space. Head %u, tail %u, packet size %lu.\n",
3244                 head, tail, (unsigned long)packet_size);
3245     }
3246
3247     packet = (struct wined3d_cs_packet *)&queue->data[queue->head];
3248     packet->size = size;
3249     return packet->data;
3250 }
3251
3252 static void *wined3d_cs_mt_require_space(struct wined3d_device_context *context,
3253         size_t size, enum wined3d_cs_queue_id queue_id)
3254 {
3255     struct wined3d_cs *cs = wined3d_cs_from_context(context);
3256
3257     if (cs->thread_id == GetCurrentThreadId())
3258         return wined3d_cs_st_require_space(context, size, queue_id);
3259
3260     return wined3d_cs_queue_require_space(&cs->queue[queue_id], size, cs);
3261 }
3262
3263 static void wined3d_cs_mt_finish(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
3264 {
3265     struct wined3d_cs *cs = wined3d_cs_from_context(context);
3266
3267     if (cs->thread_id == GetCurrentThreadId())
3268         return wined3d_cs_st_finish(context, queue_id);
3269
3270     while (cs->queue[queue_id].head != *(volatile LONG *)&cs->queue[queue_id].tail)
3271         YieldProcessor();
3272 }
3273
3274 static const struct wined3d_device_context_ops wined3d_cs_mt_ops =
3275 {
3276     wined3d_cs_mt_require_space,
3277     wined3d_cs_mt_submit,
3278     wined3d_cs_mt_finish,
3279     wined3d_cs_mt_push_constants,
3280     wined3d_cs_map_upload_bo,
3281     wined3d_cs_unmap_upload_bo,
3282     wined3d_cs_issue_query,
3283     wined3d_cs_flush,
3284     wined3d_cs_acquire_resource,
3285     wined3d_cs_acquire_command_list,
3286 };
3287
3288 static void poll_queries(struct wined3d_cs *cs)
3289 {
3290     struct wined3d_query *query, *cursor;
3291
3292     LIST_FOR_EACH_ENTRY_SAFE(query, cursor, &cs->query_poll_list, struct wined3d_query, poll_list_entry)
3293     {
3294         if (!query->query_ops->query_poll(query, 0))
3295             continue;
3296
3297         list_remove(&query->poll_list_entry);
3298         list_init(&query->poll_list_entry);
3299         InterlockedIncrement(&query->counter_retrieved);
3300     }
3301 }
3302
3303 static void wined3d_cs_wait_event(struct wined3d_cs *cs)
3304 {
3305     InterlockedExchange(&cs->waiting_for_event, TRUE);
3306
3307     /* The main thread might have enqueued a command and blocked on it after
3308      * the CS thread decided to enter wined3d_cs_wait_event(), but before
3309      * "waiting_for_event" was set.
3310      *
3311      * Likewise, we can race with the main thread when resetting
3312      * "waiting_for_event", in which case we would need to call
3313      * WaitForSingleObject() because the main thread called SetEvent(). */
3314     if (!(wined3d_cs_queue_is_empty(cs, &cs->queue[WINED3D_CS_QUEUE_DEFAULT])
3315             && wined3d_cs_queue_is_empty(cs, &cs->queue[WINED3D_CS_QUEUE_MAP]))
3316             && InterlockedCompareExchange(&cs->waiting_for_event, FALSE, TRUE))
3317         return;
3318
3319     WaitForSingleObject(cs->event, INFINITE);
3320 }
3321
3322 static void wined3d_cs_command_lock(const struct wined3d_cs *cs)
3323 {
3324     if (cs->serialize_commands)
3325         EnterCriticalSection(&wined3d_command_cs);
3326 }
3327
3328 static void wined3d_cs_command_unlock(const struct wined3d_cs *cs)
3329 {
3330     if (cs->serialize_commands)
3331         LeaveCriticalSection(&wined3d_command_cs);
3332 }
3333
3334 static DWORD WINAPI wined3d_cs_run(void *ctx)
3335 {
3336     struct wined3d_cs_packet *packet;
3337     struct wined3d_cs_queue *queue;
3338     unsigned int spin_count = 0;
3339     struct wined3d_cs *cs = ctx;
3340     enum wined3d_cs_op opcode;
3341     HMODULE wined3d_module;
3342     unsigned int poll = 0;
3343     SIZE_T tail;
3344
3345     TRACE("Started.\n");
3346
3347     /* Copy the module handle to a local variable to avoid racing with the
3348      * thread freeing "cs" before the FreeLibraryAndExitThread() call. */
3349     wined3d_module = cs->wined3d_module;
3350
3351     list_init(&cs->query_poll_list);
3352     cs->thread_id = GetCurrentThreadId();
3353     for (;;)
3354     {
3355         if (++poll == WINED3D_CS_QUERY_POLL_INTERVAL)
3356         {
3357             wined3d_cs_command_lock(cs);
3358             poll_queries(cs);
3359             wined3d_cs_command_unlock(cs);
3360             poll = 0;
3361         }
3362
3363         queue = &cs->queue[WINED3D_CS_QUEUE_MAP];
3364         if (wined3d_cs_queue_is_empty(cs, queue))
3365         {
3366             queue = &cs->queue[WINED3D_CS_QUEUE_DEFAULT];
3367             if (wined3d_cs_queue_is_empty(cs, queue))
3368             {
3369                 if (++spin_count >= WINED3D_CS_SPIN_COUNT && list_empty(&cs->query_poll_list))
3370                     wined3d_cs_wait_event(cs);
3371                 continue;
3372             }
3373         }
3374         spin_count = 0;
3375
3376         tail = queue->tail;
3377         packet = wined3d_next_cs_packet(queue->data, &tail);
3378         if (packet->size)
3379         {
3380             opcode = *(const enum wined3d_cs_op *)packet->data;
3381
3382             TRACE("Executing %s at %p.\n", debug_cs_op(opcode), packet);
3383             if (opcode >= WINED3D_CS_OP_STOP)
3384             {
3385                 if (opcode > WINED3D_CS_OP_STOP)
3386                     ERR("Invalid opcode %#x.\n", opcode);
3387                 break;
3388             }
3389
3390             wined3d_cs_command_lock(cs);
3391             wined3d_cs_op_handlers[opcode](cs, packet->data);
3392             wined3d_cs_command_unlock(cs);
3393             TRACE("%s at %p executed.\n", debug_cs_op(opcode), packet);
3394         }
3395
3396         tail &= (WINED3D_CS_QUEUE_SIZE - 1);
3397         InterlockedExchange(&queue->tail, tail);
3398     }
3399
3400     cs->queue[WINED3D_CS_QUEUE_MAP].tail = cs->queue[WINED3D_CS_QUEUE_MAP].head;
3401     cs->queue[WINED3D_CS_QUEUE_DEFAULT].tail = cs->queue[WINED3D_CS_QUEUE_DEFAULT].head;
3402     TRACE("Stopped.\n");
3403     FreeLibraryAndExitThread(wined3d_module, 0);
3404 }
3405
3406 struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device,
3407         const enum wined3d_feature_level *levels, unsigned int level_count)
3408 {
3409     const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
3410     struct wined3d_cs *cs;
3411
3412     if (!(cs = heap_alloc_zero(sizeof(*cs))))
3413         return NULL;
3414
3415     if (FAILED(wined3d_state_create(device, levels, level_count, &cs->c.state)))
3416     {
3417         heap_free(cs);
3418         return NULL;
3419     }
3420
3421     cs->c.ops = &wined3d_cs_st_ops;
3422     cs->c.device = device;
3423     cs->serialize_commands = TRACE_ON(d3d_sync) || wined3d_settings.cs_multithreaded & WINED3D_CSMT_SERIALIZE;
3424
3425     if (cs->serialize_commands)
3426         ERR_(d3d_sync)("Forcing serialization of all command streams.\n");
3427
3428     state_init(&cs->state, d3d_info, WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT, cs->c.state->feature_level);
3429
3430     cs->data_size = WINED3D_INITIAL_CS_SIZE;
3431     if (!(cs->data = heap_alloc(cs->data_size)))
3432         goto fail;
3433
3434     if (wined3d_settings.cs_multithreaded & WINED3D_CSMT_ENABLE
3435             && !RtlIsCriticalSectionLockedByThread(NtCurrentTeb()->Peb->LoaderLock))
3436     {
3437         cs->c.ops = &wined3d_cs_mt_ops;
3438
3439         if (!(cs->event = CreateEventW(NULL, FALSE, FALSE, NULL)))
3440         {
3441             ERR("Failed to create command stream event.\n");
3442             heap_free(cs->data);
3443             goto fail;
3444         }
3445
3446         if (!(GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
3447                 (const WCHAR *)wined3d_cs_run, &cs->wined3d_module)))
3448         {
3449             ERR("Failed to get wined3d module handle.\n");
3450             CloseHandle(cs->event);
3451             heap_free(cs->data);
3452             goto fail;
3453         }
3454
3455         if (!(cs->thread = CreateThread(NULL, 0, wined3d_cs_run, cs, 0, NULL)))
3456         {
3457             ERR("Failed to create wined3d command stream thread.\n");
3458             FreeLibrary(cs->wined3d_module);
3459             CloseHandle(cs->event);
3460             heap_free(cs->data);
3461             goto fail;
3462         }
3463     }
3464
3465     return cs;
3466
3467 fail:
3468     wined3d_state_destroy(cs->c.state);
3469     state_cleanup(&cs->state);
3470     heap_free(cs);
3471     return NULL;
3472 }
3473
3474 void wined3d_cs_destroy(struct wined3d_cs *cs)
3475 {
3476     if (cs->thread)
3477     {
3478         wined3d_cs_emit_stop(cs);
3479         CloseHandle(cs->thread);
3480         if (!CloseHandle(cs->event))
3481             ERR("Closing event failed.\n");
3482     }
3483
3484     wined3d_state_destroy(cs->c.state);
3485     state_cleanup(&cs->state);
3486     heap_free(cs->data);
3487     heap_free(cs);
3488 }
3489
3490 static void wined3d_cs_packet_decref_objects(const struct wined3d_cs_packet *packet)
3491 {
3492     enum wined3d_cs_op opcode = *(const enum wined3d_cs_op *)packet->data;
3493     unsigned int i;
3494
3495     switch (opcode)
3496     {
3497         case WINED3D_CS_OP_SET_SAMPLERS:
3498         {
3499             struct wined3d_cs_set_samplers *op = (struct wined3d_cs_set_samplers *)packet->data;
3500
3501             for (i = 0; i < op->count; ++i)
3502             {
3503                 if (op->samplers[i])
3504                     wined3d_sampler_decref(op->samplers[i]);
3505             }
3506             break;
3507         }
3508
3509         case WINED3D_CS_OP_SET_SHADER:
3510         {
3511             struct wined3d_cs_set_shader *op = (struct wined3d_cs_set_shader *)packet->data;
3512
3513             if (op->shader)
3514                 wined3d_shader_decref(op->shader);
3515             break;
3516         }
3517
3518         case WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE:
3519         {
3520             struct wined3d_cs_set_depth_stencil_state *op;
3521
3522             op = (struct wined3d_cs_set_depth_stencil_state *)packet->data;
3523             if (op->state)
3524                 wined3d_depth_stencil_state_decref(op->state);
3525             break;
3526         }
3527
3528         case WINED3D_CS_OP_SET_RASTERIZER_STATE:
3529         {
3530             struct wined3d_cs_set_rasterizer_state *op;
3531
3532             op = (struct wined3d_cs_set_rasterizer_state *)packet->data;
3533             if (op->state)
3534                 wined3d_rasterizer_state_decref(op->state);
3535             break;
3536         }
3537
3538         case WINED3D_CS_OP_SET_BLEND_STATE:
3539         {
3540             struct wined3d_cs_set_blend_state *op;
3541
3542             op = (struct wined3d_cs_set_blend_state *)packet->data;
3543             if (op->state)
3544                 wined3d_blend_state_decref(op->state);
3545             break;
3546         }
3547
3548         case WINED3D_CS_OP_SET_RENDERTARGET_VIEWS:
3549         {
3550             struct wined3d_cs_set_rendertarget_views *op;
3551
3552             op = (struct wined3d_cs_set_rendertarget_views *)packet->data;
3553             for (i = 0; i < op->count; ++i)
3554             {
3555                 if (op->views[i])
3556                     wined3d_rendertarget_view_decref(op->views[i]);
3557             }
3558             break;
3559         }
3560
3561         case WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEWS:
3562         {
3563             struct wined3d_cs_set_shader_resource_views *op;
3564
3565             op = (struct wined3d_cs_set_shader_resource_views *)packet->data;
3566             for (i = 0; i < op->count; ++i)
3567             {
3568                 if (op->views[i])
3569                     wined3d_shader_resource_view_decref(op->views[i]);
3570             }
3571             break;
3572         }
3573
3574         case WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEWS:
3575         {
3576             struct wined3d_cs_set_unordered_access_views *op;
3577
3578             op = (struct wined3d_cs_set_unordered_access_views *)packet->data;
3579             for (i = 0; i < op->count; ++i)
3580             {
3581                 if (op->uavs[i].view)
3582                     wined3d_unordered_access_view_decref(op->uavs[i].view);
3583             }
3584             break;
3585         }
3586
3587         case WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW:
3588         {
3589             struct wined3d_cs_set_depth_stencil_view *op;
3590
3591             op = (struct wined3d_cs_set_depth_stencil_view *)packet->data;
3592             if (op->view)
3593                 wined3d_rendertarget_view_decref(op->view);
3594             break;
3595         }
3596
3597         case WINED3D_CS_OP_SET_CONSTANT_BUFFERS:
3598         {
3599             struct wined3d_cs_set_constant_buffers *op;
3600
3601             op = (struct wined3d_cs_set_constant_buffers *)packet->data;
3602             for (i = 0; i < op->count; ++i)
3603             {
3604                 if (op->buffers[i].buffer)
3605                     wined3d_buffer_decref(op->buffers[i].buffer);
3606             }
3607             break;
3608         }
3609
3610         case WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW:
3611         {
3612             struct wined3d_cs_clear_unordered_access_view *op;
3613
3614             op = (struct wined3d_cs_clear_unordered_access_view *)packet->data;
3615             wined3d_unordered_access_view_decref(op->view);
3616             break;
3617         }
3618
3619         case WINED3D_CS_OP_CLEAR:
3620         {
3621             struct wined3d_cs_clear *op = (struct wined3d_cs_clear *)packet->data;
3622
3623             for (i = 0; i < op->rt_count; ++i)
3624             {
3625                 if (op->fb.render_targets[i])
3626                     wined3d_rendertarget_view_decref(op->fb.render_targets[i]);
3627             }
3628             if (op->fb.depth_stencil)
3629                 wined3d_rendertarget_view_decref(op->fb.depth_stencil);
3630             break;
3631         }
3632
3633         case WINED3D_CS_OP_DISPATCH:
3634         {
3635             struct wined3d_cs_dispatch *op = (struct wined3d_cs_dispatch *)packet->data;
3636
3637             if (op->parameters.indirect)
3638                 wined3d_buffer_decref(op->parameters.u.indirect.buffer);
3639             break;
3640         }
3641
3642         case WINED3D_CS_OP_DRAW:
3643         {
3644             struct wined3d_cs_draw *op = (struct wined3d_cs_draw *)packet->data;
3645
3646             if (op->parameters.indirect)
3647                 wined3d_buffer_decref(op->parameters.u.indirect.buffer);
3648             break;
3649         }
3650
3651         case WINED3D_CS_OP_SET_INDEX_BUFFER:
3652         {
3653             struct wined3d_cs_set_index_buffer *op;
3654
3655             op = (struct wined3d_cs_set_index_buffer *)packet->data;
3656             if (op->buffer)
3657                 wined3d_buffer_decref(op->buffer);
3658             break;
3659         }
3660
3661         case WINED3D_CS_OP_SET_STREAM_OUTPUTS:
3662         {
3663             struct wined3d_cs_set_stream_outputs *op;
3664
3665             op = (struct wined3d_cs_set_stream_outputs *)packet->data;
3666             for (i = 0; i < ARRAY_SIZE(op->outputs); ++i)
3667             {
3668                 if (op->outputs[i].buffer)
3669                     wined3d_buffer_decref(op->outputs[i].buffer);
3670             }
3671             break;
3672         }
3673
3674         case WINED3D_CS_OP_SET_STREAM_SOURCES:
3675         {
3676             struct wined3d_cs_set_stream_sources *op;
3677
3678             op = (struct wined3d_cs_set_stream_sources *)packet->data;
3679             for (i = 0; i < op->count; ++i)
3680             {
3681                 if (op->streams[i].buffer)
3682                     wined3d_buffer_decref(op->streams[i].buffer);
3683             }
3684             break;
3685         }
3686
3687         case WINED3D_CS_OP_UPDATE_SUB_RESOURCE:
3688         {
3689             struct wined3d_cs_update_sub_resource *op;
3690
3691             op = (struct wined3d_cs_update_sub_resource *)packet->data;
3692             wined3d_resource_decref(op->resource);
3693             break;
3694         }
3695
3696         default:
3697             break;
3698     }
3699 }
3700
3701 static void wined3d_cs_packet_incref_objects(struct wined3d_cs_packet *packet)
3702 {
3703     enum wined3d_cs_op opcode = *(const enum wined3d_cs_op *)packet->data;
3704     unsigned int i;
3705
3706     switch (opcode)
3707     {
3708         case WINED3D_CS_OP_SET_SAMPLERS:
3709         {
3710             struct wined3d_cs_set_samplers *op = (struct wined3d_cs_set_samplers *)packet->data;
3711
3712             for (i = 0; i < op->count; ++i)
3713             {
3714                 if (op->samplers[i])
3715                     wined3d_sampler_incref(op->samplers[i]);
3716             }
3717             break;
3718         }
3719
3720         case WINED3D_CS_OP_SET_SHADER:
3721         {
3722             struct wined3d_cs_set_shader *op = (struct wined3d_cs_set_shader *)packet->data;
3723
3724             if (op->shader)
3725                 wined3d_shader_incref(op->shader);
3726             break;
3727         }
3728
3729         case WINED3D_CS_OP_SET_DEPTH_STENCIL_STATE:
3730         {
3731             struct wined3d_cs_set_depth_stencil_state *op;
3732
3733             op = (struct wined3d_cs_set_depth_stencil_state *)packet->data;
3734             if (op->state)
3735                 wined3d_depth_stencil_state_incref(op->state);
3736             break;
3737         }
3738
3739         case WINED3D_CS_OP_SET_RASTERIZER_STATE:
3740         {
3741             struct wined3d_cs_set_rasterizer_state *op;
3742
3743             op = (struct wined3d_cs_set_rasterizer_state *)packet->data;
3744             if (op->state)
3745                 wined3d_rasterizer_state_incref(op->state);
3746             break;
3747         }
3748
3749         case WINED3D_CS_OP_SET_BLEND_STATE:
3750         {
3751             struct wined3d_cs_set_blend_state *op;
3752
3753             op = (struct wined3d_cs_set_blend_state *)packet->data;
3754             if (op->state)
3755                 wined3d_blend_state_incref(op->state);
3756             break;
3757         }
3758
3759         case WINED3D_CS_OP_SET_RENDERTARGET_VIEWS:
3760         {
3761             struct wined3d_cs_set_rendertarget_views *op;
3762
3763             op = (struct wined3d_cs_set_rendertarget_views *)packet->data;
3764             for (i = 0; i < op->count; ++i)
3765             {
3766                 if (op->views[i])
3767                     wined3d_rendertarget_view_incref(op->views[i]);
3768             }
3769             break;
3770         }
3771
3772         case WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEWS:
3773         {
3774             struct wined3d_cs_set_shader_resource_views *op;
3775
3776             op = (struct wined3d_cs_set_shader_resource_views *)packet->data;
3777             for (i = 0; i < op->count; ++i)
3778             {
3779                 if (op->views[i])
3780                     wined3d_shader_resource_view_incref(op->views[i]);
3781             }
3782             break;
3783         }
3784
3785         case WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEWS:
3786         {
3787             struct wined3d_cs_set_unordered_access_views *op;
3788
3789             op = (struct wined3d_cs_set_unordered_access_views *)packet->data;
3790             for (i = 0; i < op->count; ++i)
3791             {
3792                 if (op->uavs[i].view)
3793                     wined3d_unordered_access_view_incref(op->uavs[i].view);
3794             }
3795             break;
3796         }
3797
3798         case WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW:
3799         {
3800             struct wined3d_cs_set_depth_stencil_view *op;
3801
3802             op = (struct wined3d_cs_set_depth_stencil_view *)packet->data;
3803             if (op->view)
3804                 wined3d_rendertarget_view_incref(op->view);
3805             break;
3806         }
3807
3808         case WINED3D_CS_OP_SET_CONSTANT_BUFFERS:
3809         {
3810             struct wined3d_cs_set_constant_buffers *op;
3811
3812             op = (struct wined3d_cs_set_constant_buffers *)packet->data;
3813             for (i = 0; i < op->count; ++i)
3814             {
3815                 if (op->buffers[i].buffer)
3816                     wined3d_buffer_incref(op->buffers[i].buffer);
3817             }
3818             break;
3819         }
3820
3821         case WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW:
3822         {
3823             struct wined3d_cs_clear_unordered_access_view *op;
3824
3825             op = (struct wined3d_cs_clear_unordered_access_view *)packet->data;
3826             wined3d_unordered_access_view_incref(op->view);
3827             break;
3828         }
3829
3830         case WINED3D_CS_OP_CLEAR:
3831         {
3832             struct wined3d_cs_clear *op = (struct wined3d_cs_clear *)packet->data;
3833
3834             for (i = 0; i < op->rt_count; ++i)
3835             {
3836                 if (op->fb.render_targets[i])
3837                     wined3d_rendertarget_view_incref(op->fb.render_targets[i]);
3838             }
3839             if (op->fb.depth_stencil)
3840                 wined3d_rendertarget_view_incref(op->fb.depth_stencil);
3841             break;
3842         }
3843
3844         case WINED3D_CS_OP_DISPATCH:
3845         {
3846             struct wined3d_cs_dispatch *op = (struct wined3d_cs_dispatch *)packet->data;
3847
3848             if (op->parameters.indirect)
3849                 wined3d_buffer_incref(op->parameters.u.indirect.buffer);
3850             break;
3851         }
3852
3853         case WINED3D_CS_OP_DRAW:
3854         {
3855             struct wined3d_cs_draw *op = (struct wined3d_cs_draw *)packet->data;
3856
3857             if (op->parameters.indirect)
3858                 wined3d_buffer_incref(op->parameters.u.indirect.buffer);
3859             break;
3860         }
3861
3862         case WINED3D_CS_OP_SET_INDEX_BUFFER:
3863         {
3864             struct wined3d_cs_set_index_buffer *op;
3865
3866             op = (struct wined3d_cs_set_index_buffer *)packet->data;
3867             if (op->buffer)
3868                 wined3d_buffer_incref(op->buffer);
3869             break;
3870         }
3871
3872         case WINED3D_CS_OP_SET_STREAM_OUTPUTS:
3873         {
3874             struct wined3d_cs_set_stream_outputs *op;
3875
3876             op = (struct wined3d_cs_set_stream_outputs *)packet->data;
3877             for (i = 0; i < ARRAY_SIZE(op->outputs); ++i)
3878             {
3879                 if (op->outputs[i].buffer)
3880                     wined3d_buffer_incref(op->outputs[i].buffer);
3881             }
3882             break;
3883         }
3884
3885         case WINED3D_CS_OP_SET_STREAM_SOURCES:
3886         {
3887             struct wined3d_cs_set_stream_sources *op;
3888
3889             op  = (struct wined3d_cs_set_stream_sources *)packet->data;
3890             for (i = 0; i < op->count; ++i)
3891             {
3892                 if (op->streams[i].buffer)
3893                     wined3d_buffer_incref(op->streams[i].buffer);
3894             }
3895             break;
3896         }
3897
3898         case WINED3D_CS_OP_UPDATE_SUB_RESOURCE:
3899         {
3900             struct wined3d_cs_update_sub_resource *op;
3901
3902             op = (struct wined3d_cs_update_sub_resource *)packet->data;
3903             wined3d_resource_incref(op->resource);
3904             break;
3905         }
3906
3907         default:
3908             break;
3909     }
3910 }
3911
3912 struct wined3d_deferred_context
3913 {
3914     struct wined3d_device_context c;
3915
3916     SIZE_T data_size, data_capacity;
3917     void *data;
3918
3919     SIZE_T resource_count, resources_capacity;
3920     struct wined3d_resource **resources;
3921
3922     SIZE_T upload_count, uploads_capacity;
3923     struct wined3d_deferred_upload *uploads;
3924
3925     /* List of command lists queued for execution on this context. A command
3926      * list can be the only thing holding a pointer to another command list, so
3927      * we need to hold a reference here and in wined3d_command_list as well. */
3928     SIZE_T command_list_count, command_lists_capacity;
3929     struct wined3d_command_list **command_lists;
3930
3931     SIZE_T query_count, queries_capacity;
3932     struct wined3d_deferred_query_issue *queries;
3933 };
3934
3935 static struct wined3d_deferred_context *wined3d_deferred_context_from_context(struct wined3d_device_context *context)
3936 {
3937     return CONTAINING_RECORD(context, struct wined3d_deferred_context, c);
3938 }
3939
3940 static void *wined3d_deferred_context_require_space(struct wined3d_device_context *context,
3941         size_t size, enum wined3d_cs_queue_id queue_id)
3942 {
3943     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
3944     struct wined3d_cs_packet *packet;
3945     size_t header_size, packet_size;
3946
3947     if (queue_id != WINED3D_CS_QUEUE_DEFAULT)
3948         return NULL;
3949
3950     header_size = offsetof(struct wined3d_cs_packet, data[0]);
3951     packet_size = offsetof(struct wined3d_cs_packet, data[size]);
3952     packet_size = (packet_size + header_size - 1) & ~(header_size - 1);
3953
3954     if (!wined3d_array_reserve(&deferred->data, &deferred->data_capacity, deferred->data_size + packet_size, 1))
3955         return NULL;
3956
3957     packet = (struct wined3d_cs_packet *)((BYTE *)deferred->data + deferred->data_size);
3958     TRACE("size was %zu, adding %zu\n", (size_t)deferred->data_size, packet_size);
3959     packet->size = packet_size - header_size;
3960     return &packet->data;
3961 }
3962
3963 static void wined3d_deferred_context_submit(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
3964 {
3965     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
3966     struct wined3d_cs_packet *packet;
3967
3968     assert(queue_id == WINED3D_CS_QUEUE_DEFAULT);
3969     packet = wined3d_next_cs_packet(deferred->data, &deferred->data_size);
3970     wined3d_cs_packet_incref_objects(packet);
3971 }
3972
3973 static void wined3d_deferred_context_finish(struct wined3d_device_context *context, enum wined3d_cs_queue_id queue_id)
3974 {
3975     /* This should not happen; we cannot meaningfully finish a deferred context. */
3976     ERR("Ignoring finish() on a deferred context.\n");
3977 }
3978
3979 static void wined3d_deferred_context_push_constants(struct wined3d_device_context *context,
3980         enum wined3d_push_constants p, unsigned int start_idx, unsigned int count, const void *constants)
3981 {
3982     FIXME("context %p, p %#x, start_idx %u, count %u, constants %p, stub!\n", context, p, start_idx, count, constants);
3983 }
3984
3985 static struct wined3d_deferred_upload *deferred_context_get_upload(struct wined3d_deferred_context *deferred,
3986         struct wined3d_resource *resource, unsigned int sub_resource_idx)
3987 {
3988     SIZE_T i = deferred->upload_count;
3989
3990     while (i--)
3991     {
3992         struct wined3d_deferred_upload *upload = &deferred->uploads[i];
3993
3994         if (upload->resource == resource && upload->sub_resource_idx == sub_resource_idx)
3995             return upload;
3996     }
3997
3998     return NULL;
3999 }
4000
4001 static bool wined3d_deferred_context_map_upload_bo(struct wined3d_device_context *context,
4002         struct wined3d_resource *resource, unsigned int sub_resource_idx,
4003         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, uint32_t flags)
4004 {
4005     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4006     const struct wined3d_format *format = resource->format;
4007     struct wined3d_deferred_upload *upload;
4008     uint8_t *sysmem;
4009     size_t size;
4010
4011     wined3d_format_calculate_pitch(format, 1, box->right - box->left,
4012             box->bottom - box->top, &map_desc->row_pitch, &map_desc->slice_pitch);
4013
4014     size = (box->back - box->front - 1) * map_desc->slice_pitch
4015             + ((box->bottom - box->top - 1) / format->block_height) * map_desc->row_pitch
4016             + ((box->right - box->left + format->block_width - 1) / format->block_width) * format->block_byte_count;
4017
4018     if (!(flags & WINED3D_MAP_WRITE))
4019     {
4020         WARN("Flags %#x are not valid on a deferred context.\n", flags);
4021         return false;
4022     }
4023
4024     if (flags & ~(WINED3D_MAP_WRITE | WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
4025     {
4026         FIXME("Unhandled flags %#x.\n", flags);
4027         return false;
4028     }
4029
4030     if (flags & WINED3D_MAP_NOOVERWRITE)
4031     {
4032         if (!(upload = deferred_context_get_upload(deferred, resource, sub_resource_idx)))
4033             return false;
4034
4035         upload->upload_flags = 0;
4036         map_desc->data = (void *)align((size_t)upload->sysmem, RESOURCE_ALIGNMENT);
4037         return true;
4038     }
4039
4040     if (!wined3d_array_reserve((void **)&deferred->uploads, &deferred->uploads_capacity,
4041             deferred->upload_count + 1, sizeof(*deferred->uploads)))
4042         return false;
4043
4044     if (!(sysmem = heap_alloc(size + RESOURCE_ALIGNMENT - 1)))
4045         return false;
4046
4047     upload = &deferred->uploads[deferred->upload_count++];
4048     upload->upload_flags = UPLOAD_BO_UPLOAD_ON_UNMAP;
4049     upload->resource = resource;
4050     wined3d_resource_incref(resource);
4051     upload->sub_resource_idx = sub_resource_idx;
4052     upload->sysmem = sysmem;
4053     upload->box = *box;
4054
4055     map_desc->data = (void *)align((size_t)upload->sysmem, RESOURCE_ALIGNMENT);
4056     return true;
4057 }
4058
4059 static bool wined3d_deferred_context_unmap_upload_bo(struct wined3d_device_context *context,
4060         struct wined3d_resource *resource, unsigned int sub_resource_idx, struct wined3d_box *box, struct upload_bo *bo)
4061 {
4062     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4063     const struct wined3d_deferred_upload *upload;
4064
4065     if ((upload = deferred_context_get_upload(deferred, resource, sub_resource_idx)))
4066     {
4067         *box = upload->box;
4068         bo->addr.buffer_object = 0;
4069         bo->addr.addr = (uint8_t *)align((size_t)upload->sysmem, RESOURCE_ALIGNMENT);
4070         bo->flags = upload->upload_flags;
4071         return true;
4072     }
4073
4074     return false;
4075 }
4076
4077 static void wined3d_deferred_context_issue_query(struct wined3d_device_context *context,
4078         struct wined3d_query *query, unsigned int flags)
4079 {
4080     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4081     struct wined3d_cs_query_issue *op;
4082
4083     op = wined3d_device_context_require_space(context, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
4084     op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
4085     op->query = query;
4086     op->flags = flags;
4087
4088     wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT);
4089
4090     if (!wined3d_array_reserve((void **)&deferred->queries, &deferred->queries_capacity,
4091             deferred->query_count + 1, sizeof(*deferred->queries)))
4092     {
4093         ERR("Failed to reserve memory.\n");
4094         return;
4095     }
4096
4097     deferred->queries[deferred->query_count].flags = flags;
4098     wined3d_query_incref(deferred->queries[deferred->query_count++].query = query);
4099 }
4100
4101 static void wined3d_deferred_context_flush(struct wined3d_device_context *context)
4102 {
4103     FIXME("context %p, stub!\n", context);
4104 }
4105
4106 static void wined3d_deferred_context_acquire_resource(struct wined3d_device_context *context,
4107         struct wined3d_resource *resource)
4108 {
4109     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4110
4111     if (!wined3d_array_reserve((void **)&deferred->resources, &deferred->resources_capacity,
4112             deferred->resource_count + 1, sizeof(*deferred->resources)))
4113         return;
4114
4115     deferred->resources[deferred->resource_count++] = resource;
4116     wined3d_resource_incref(resource);
4117 }
4118
4119 static void wined3d_deferred_context_acquire_command_list(struct wined3d_device_context *context,
4120         struct wined3d_command_list *list)
4121 {
4122     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4123
4124     /* Grab a reference to the command list. Note that this implicitly prevents
4125      * any dependent command lists or resources from being freed as well. */
4126     if (!wined3d_array_reserve((void **)&deferred->command_lists, &deferred->command_lists_capacity,
4127             deferred->command_list_count + 1, sizeof(*deferred->command_lists)))
4128         return;
4129
4130     wined3d_command_list_incref(deferred->command_lists[deferred->command_list_count++] = list);
4131 }
4132
4133 static const struct wined3d_device_context_ops wined3d_deferred_context_ops =
4134 {
4135     wined3d_deferred_context_require_space,
4136     wined3d_deferred_context_submit,
4137     wined3d_deferred_context_finish,
4138     wined3d_deferred_context_push_constants,
4139     wined3d_deferred_context_map_upload_bo,
4140     wined3d_deferred_context_unmap_upload_bo,
4141     wined3d_deferred_context_issue_query,
4142     wined3d_deferred_context_flush,
4143     wined3d_deferred_context_acquire_resource,
4144     wined3d_deferred_context_acquire_command_list,
4145 };
4146
4147 HRESULT CDECL wined3d_deferred_context_create(struct wined3d_device *device, struct wined3d_device_context **context)
4148 {
4149     struct wined3d_deferred_context *object;
4150     HRESULT hr;
4151
4152     TRACE("device %p, context %p.\n", device, context);
4153
4154     if (!(object = heap_alloc_zero(sizeof(*object))))
4155         return E_OUTOFMEMORY;
4156
4157     if (FAILED(hr = wined3d_state_create(device, &device->cs->c.state->feature_level, 1, &object->c.state)))
4158     {
4159         heap_free(object);
4160         return hr;
4161     }
4162
4163     object->c.ops = &wined3d_deferred_context_ops;
4164     object->c.device = device;
4165
4166     /* Make sure the first command list gets the state reset when executed.
4167      * Resets for subsequent command lists are encoded in wined3d_deferred_context_record_command_list(). */
4168     wined3d_device_context_emit_reset_state(&object->c, true);
4169
4170     TRACE("Created deferred context %p.\n", object);
4171     *context = &object->c;
4172
4173     return S_OK;
4174 }
4175
4176 void CDECL wined3d_deferred_context_destroy(struct wined3d_device_context *context)
4177 {
4178     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4179     const struct wined3d_cs_packet *packet;
4180     SIZE_T i, offset = 0;
4181
4182     TRACE("context %p.\n", context);
4183
4184     for (i = 0; i < deferred->resource_count; ++i)
4185         wined3d_resource_decref(deferred->resources[i]);
4186     heap_free(deferred->resources);
4187
4188     for (i = 0; i < deferred->upload_count; ++i)
4189     {
4190         wined3d_resource_decref(deferred->uploads[i].resource);
4191         heap_free(deferred->uploads[i].sysmem);
4192     }
4193     heap_free(deferred->uploads);
4194
4195     for (i = 0; i < deferred->command_list_count; ++i)
4196         wined3d_command_list_decref(deferred->command_lists[i]);
4197     heap_free(deferred->command_lists);
4198
4199     for (i = 0; i < deferred->query_count; ++i)
4200         wined3d_query_decref(deferred->queries[i].query);
4201     heap_free(deferred->queries);
4202
4203     while (offset < deferred->data_size)
4204     {
4205         packet = wined3d_next_cs_packet(deferred->data, &offset);
4206         wined3d_cs_packet_decref_objects(packet);
4207     }
4208
4209     wined3d_state_destroy(deferred->c.state);
4210     heap_free(deferred->data);
4211     heap_free(deferred);
4212 }
4213
4214 HRESULT CDECL wined3d_deferred_context_record_command_list(struct wined3d_device_context *context,
4215         bool restore, struct wined3d_command_list **list)
4216 {
4217     struct wined3d_deferred_context *deferred = wined3d_deferred_context_from_context(context);
4218     struct wined3d_command_list *object;
4219     void *memory;
4220
4221     TRACE("context %p, list %p.\n", context, list);
4222
4223     wined3d_device_context_lock(context);
4224     memory = heap_alloc(sizeof(*object) + deferred->resource_count * sizeof(*object->resources)
4225             + deferred->upload_count * sizeof(*object->uploads)
4226             + deferred->command_list_count * sizeof(*object->command_lists)
4227             + deferred->query_count * sizeof(*object->queries)
4228             + deferred->data_size);
4229
4230     if (!memory)
4231     {
4232         wined3d_device_context_unlock(context);
4233         return E_OUTOFMEMORY;
4234     }
4235
4236     object = memory;
4237     memory = &object[1];
4238     memset(object, 0, sizeof(*object));
4239     object->refcount = 1;
4240     object->device = deferred->c.device;
4241
4242     object->resources = memory;
4243     memory = &object->resources[deferred->resource_count];
4244     object->resource_count = deferred->resource_count;
4245     memcpy(object->resources, deferred->resources, deferred->resource_count * sizeof(*object->resources));
4246     /* Transfer our references to the resources to the command list. */
4247
4248     object->uploads = memory;
4249     memory = &object->uploads[deferred->upload_count];
4250     object->upload_count = deferred->upload_count;
4251     memcpy(object->uploads, deferred->uploads, deferred->upload_count * sizeof(*object->uploads));
4252     /* Transfer our references to the resources to the command list. */
4253
4254     object->command_lists = memory;
4255     memory = &object->command_lists[deferred->command_list_count];
4256     object->command_list_count = deferred->command_list_count;
4257     memcpy(object->command_lists, deferred->command_lists,
4258             deferred->command_list_count * sizeof(*object->command_lists));
4259     /* Transfer our references to the command lists to the command list. */
4260
4261     object->queries = memory;
4262     memory = &object->queries[deferred->query_count];
4263     object->query_count = deferred->query_count;
4264     memcpy(object->queries, deferred->queries, deferred->query_count * sizeof(*object->queries));
4265     /* Transfer our references to the queries to the command list. */
4266
4267     object->data = memory;
4268     object->data_size = deferred->data_size;
4269     memcpy(object->data, deferred->data, deferred->data_size);
4270
4271     deferred->data_size = 0;
4272     deferred->resource_count = 0;
4273     deferred->upload_count = 0;
4274     deferred->command_list_count = 0;
4275     deferred->query_count = 0;
4276
4277     /* This is in fact recorded into a subsequent command list. */
4278     if (restore)
4279         wined3d_device_context_set_state(&deferred->c, deferred->c.state);
4280     else
4281         wined3d_device_context_reset_state(&deferred->c);
4282
4283     TRACE("Created command list %p.\n", object);
4284     *list = object;
4285     wined3d_device_context_unlock(context);
4286
4287     return S_OK;
4288 }
4289
4290 static void wined3d_command_list_destroy_object(void *object)
4291 {
4292     struct wined3d_command_list *list = object;
4293     SIZE_T i;
4294
4295     TRACE("list %p.\n", list);
4296
4297     for (i = 0; i < list->upload_count; ++i)
4298         heap_free(list->uploads[i].sysmem);
4299
4300     heap_free(list);
4301 }
4302
4303 ULONG CDECL wined3d_command_list_incref(struct wined3d_command_list *list)
4304 {
4305     ULONG refcount = InterlockedIncrement(&list->refcount);
4306
4307     TRACE("%p increasing refcount to %u.\n", list, refcount);
4308
4309     return refcount;
4310 }
4311
4312 ULONG CDECL wined3d_command_list_decref(struct wined3d_command_list *list)
4313 {
4314     ULONG refcount = InterlockedDecrement(&list->refcount);
4315     struct wined3d_device *device = list->device;
4316     const struct wined3d_cs_packet *packet;
4317     SIZE_T i, offset;
4318
4319     TRACE("%p decreasing refcount to %u.\n", list, refcount);
4320
4321     if (!refcount)
4322     {
4323         for (i = 0; i < list->command_list_count; ++i)
4324             wined3d_command_list_decref(list->command_lists[i]);
4325         for (i = 0; i < list->resource_count; ++i)
4326             wined3d_resource_decref(list->resources[i]);
4327         for (i = 0; i < list->upload_count; ++i)
4328             wined3d_resource_decref(list->uploads[i].resource);
4329         for (i = 0; i < list->query_count; ++i)
4330             wined3d_query_decref(list->queries[i].query);
4331
4332         offset = 0;
4333         while (offset < list->data_size)
4334         {
4335             packet = wined3d_next_cs_packet(list->data, &offset);
4336             wined3d_cs_packet_decref_objects(packet);
4337         }
4338
4339         wined3d_mutex_lock();
4340         wined3d_cs_destroy_object(device->cs, wined3d_command_list_destroy_object, list);
4341         wined3d_mutex_unlock();
4342     }
4343
4344     return refcount;
4345 }