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 "wine/port.h"
  21 #include "wined3d_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  24
  25 #define WINED3D_INITIAL_CS_SIZE 4096
  26
  27 enum wined3d_cs_op
  28 {
  29     WINED3D_CS_OP_PRESENT,
  30     WINED3D_CS_OP_CLEAR,
  31     WINED3D_CS_OP_DRAW,
  32     WINED3D_CS_OP_SET_PREDICATION,
  33     WINED3D_CS_OP_SET_VIEWPORT,
  34     WINED3D_CS_OP_SET_SCISSOR_RECT,
  35     WINED3D_CS_OP_SET_RENDERTARGET_VIEW,
  36     WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW,
  37     WINED3D_CS_OP_SET_VERTEX_DECLARATION,
  38     WINED3D_CS_OP_SET_STREAM_SOURCE,
  39     WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ,
  40     WINED3D_CS_OP_SET_STREAM_OUTPUT,
  41     WINED3D_CS_OP_SET_INDEX_BUFFER,
  42     WINED3D_CS_OP_SET_CONSTANT_BUFFER,
  43     WINED3D_CS_OP_SET_TEXTURE,
  44     WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW,
  45     WINED3D_CS_OP_SET_SAMPLER,
  46     WINED3D_CS_OP_SET_SHADER,
  47     WINED3D_CS_OP_SET_RASTERIZER_STATE,
  48     WINED3D_CS_OP_SET_RENDER_STATE,
  49     WINED3D_CS_OP_SET_TEXTURE_STATE,
  50     WINED3D_CS_OP_SET_SAMPLER_STATE,
  51     WINED3D_CS_OP_SET_TRANSFORM,
  52     WINED3D_CS_OP_SET_CLIP_PLANE,
  53     WINED3D_CS_OP_SET_COLOR_KEY,
  54     WINED3D_CS_OP_SET_MATERIAL,
  55     WINED3D_CS_OP_RESET_STATE,
  56     WINED3D_CS_OP_DESTROY_OBJECT,
  57     WINED3D_CS_OP_QUERY_ISSUE,
  58     WINED3D_CS_OP_UNLOAD_RESOURCE,
  59 };
  60
  61 struct wined3d_cs_present
  62 {
  63     enum wined3d_cs_op opcode;
  64     HWND dst_window_override;
  65     struct wined3d_swapchain *swapchain;
  66     RECT src_rect;
  67     RECT dst_rect;
  68     DWORD flags;
  69 };
  70
  71 struct wined3d_cs_clear
  72 {
  73     enum wined3d_cs_op opcode;
  74     DWORD flags;
  75     struct wined3d_color color;
  76     float depth;
  77     DWORD stencil;
  78     unsigned int rect_count;
  79     RECT rects[1];
  80 };
  81
  82 struct wined3d_cs_draw
  83 {
  84     enum wined3d_cs_op opcode;
  85     int base_vertex_idx;
  86     unsigned int start_idx;
  87     unsigned int index_count;
  88     unsigned int start_instance;
  89     unsigned int instance_count;
  90     BOOL indexed;
  91 };
  92
  93 struct wined3d_cs_set_predication
  94 {
  95     enum wined3d_cs_op opcode;
  96     struct wined3d_query *predicate;
  97     BOOL value;
  98 };
  99
 100 struct wined3d_cs_set_viewport
 101 {
 102     enum wined3d_cs_op opcode;
 103     struct wined3d_viewport viewport;
 104 };
 105
 106 struct wined3d_cs_set_scissor_rect
 107 {
 108     enum wined3d_cs_op opcode;
 109     RECT rect;
 110 };
 111
 112 struct wined3d_cs_set_rendertarget_view
 113 {
 114     enum wined3d_cs_op opcode;
 115     unsigned int view_idx;
 116     struct wined3d_rendertarget_view *view;
 117 };
 118
 119 struct wined3d_cs_set_depth_stencil_view
 120 {
 121     enum wined3d_cs_op opcode;
 122     struct wined3d_rendertarget_view *view;
 123 };
 124
 125 struct wined3d_cs_set_vertex_declaration
 126 {
 127     enum wined3d_cs_op opcode;
 128     struct wined3d_vertex_declaration *declaration;
 129 };
 130
 131 struct wined3d_cs_set_stream_source
 132 {
 133     enum wined3d_cs_op opcode;
 134     UINT stream_idx;
 135     struct wined3d_buffer *buffer;
 136     UINT offset;
 137     UINT stride;
 138 };
 139
 140 struct wined3d_cs_set_stream_source_freq
 141 {
 142     enum wined3d_cs_op opcode;
 143     UINT stream_idx;
 144     UINT frequency;
 145     UINT flags;
 146 };
 147
 148 struct wined3d_cs_set_stream_output
 149 {
 150     enum wined3d_cs_op opcode;
 151     UINT stream_idx;
 152     struct wined3d_buffer *buffer;
 153     UINT offset;
 154 };
 155
 156 struct wined3d_cs_set_index_buffer
 157 {
 158     enum wined3d_cs_op opcode;
 159     struct wined3d_buffer *buffer;
 160     enum wined3d_format_id format_id;
 161     unsigned int offset;
 162 };
 163
 164 struct wined3d_cs_set_constant_buffer
 165 {
 166     enum wined3d_cs_op opcode;
 167     enum wined3d_shader_type type;
 168     UINT cb_idx;
 169     struct wined3d_buffer *buffer;
 170 };
 171
 172 struct wined3d_cs_set_texture
 173 {
 174     enum wined3d_cs_op opcode;
 175     UINT stage;
 176     struct wined3d_texture *texture;
 177 };
 178
 179 struct wined3d_cs_set_color_key
 180 {
 181     enum wined3d_cs_op opcode;
 182     struct wined3d_texture *texture;
 183     WORD flags;
 184     WORD set;
 185     struct wined3d_color_key color_key;
 186 };
 187
 188 struct wined3d_cs_set_shader_resource_view
 189 {
 190     enum wined3d_cs_op opcode;
 191     enum wined3d_shader_type type;
 192     UINT view_idx;
 193     struct wined3d_shader_resource_view *view;
 194 };
 195
 196 struct wined3d_cs_set_sampler
 197 {
 198     enum wined3d_cs_op opcode;
 199     enum wined3d_shader_type type;
 200     UINT sampler_idx;
 201     struct wined3d_sampler *sampler;
 202 };
 203
 204 struct wined3d_cs_set_shader
 205 {
 206     enum wined3d_cs_op opcode;
 207     enum wined3d_shader_type type;
 208     struct wined3d_shader *shader;
 209 };
 210
 211 struct wined3d_cs_set_rasterizer_state
 212 {
 213     enum wined3d_cs_op opcode;
 214     struct wined3d_rasterizer_state *state;
 215 };
 216
 217 struct wined3d_cs_set_render_state
 218 {
 219     enum wined3d_cs_op opcode;
 220     enum wined3d_render_state state;
 221     DWORD value;
 222 };
 223
 224 struct wined3d_cs_set_texture_state
 225 {
 226     enum wined3d_cs_op opcode;
 227     UINT stage;
 228     enum wined3d_texture_stage_state state;
 229     DWORD value;
 230 };
 231
 232 struct wined3d_cs_set_sampler_state
 233 {
 234     enum wined3d_cs_op opcode;
 235     UINT sampler_idx;
 236     enum wined3d_sampler_state state;
 237     DWORD value;
 238 };
 239
 240 struct wined3d_cs_set_transform
 241 {
 242     enum wined3d_cs_op opcode;
 243     enum wined3d_transform_state state;
 244     struct wined3d_matrix matrix;
 245 };
 246
 247 struct wined3d_cs_set_clip_plane
 248 {
 249     enum wined3d_cs_op opcode;
 250     UINT plane_idx;
 251     struct wined3d_vec4 plane;
 252 };
 253
 254 struct wined3d_cs_set_material
 255 {
 256     enum wined3d_cs_op opcode;
 257     struct wined3d_material material;
 258 };
 259
 260 struct wined3d_cs_reset_state
 261 {
 262     enum wined3d_cs_op opcode;
 263 };
 264
 265 struct wined3d_cs_destroy_object
 266 {
 267     enum wined3d_cs_op opcode;
 268     void (*callback)(void *object);
 269     void *object;
 270 };
 271
 272 struct wined3d_cs_query_issue
 273 {
 274     enum wined3d_cs_op opcode;
 275     struct wined3d_query *query;
 276     DWORD flags;
 277 };
 278
 279 struct wined3d_cs_unload_resource
 280 {
 281     enum wined3d_cs_op opcode;
 282     struct wined3d_resource *resource;
 283 };
 284
 285 static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
 286 {
 287     const struct wined3d_cs_present *op = data;
 288     struct wined3d_swapchain *swapchain;
 289     unsigned int i;
 290
 291     swapchain = op->swapchain;
 292     wined3d_swapchain_set_window(swapchain, op->dst_window_override);
 293
 294     swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->flags);
 295
 296     wined3d_resource_release(&swapchain->front_buffer->resource);
 297     for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
 298     {
 299         wined3d_resource_release(&swapchain->back_buffers[i]->resource);
 300     }
 301 }
 302
 303 void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain,
 304         const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, DWORD flags)
 305 {
 306     struct wined3d_cs_present *op;
 307     unsigned int i;
 308
 309     op = cs->ops->require_space(cs, sizeof(*op));
 310     op->opcode = WINED3D_CS_OP_PRESENT;
 311     op->dst_window_override = dst_window_override;
 312     op->swapchain = swapchain;
 313     op->src_rect = *src_rect;
 314     op->dst_rect = *dst_rect;
 315     op->flags = flags;
 316
 317     wined3d_resource_acquire(&swapchain->front_buffer->resource);
 318     for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
 319     {
 320         wined3d_resource_acquire(&swapchain->back_buffers[i]->resource);
 321     }
 322
 323     cs->ops->submit(cs);
 324 }
 325
 326 static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
 327 {
 328     const struct wined3d_cs_clear *op = data;
 329     const struct wined3d_state *state;
 330     struct wined3d_device *device;
 331     unsigned int i;
 332     RECT draw_rect;
 333
 334     device = cs->device;
 335     state = &device->state;
 336     wined3d_get_draw_rect(state, &draw_rect);
 337     device_clear_render_targets(device, device->adapter->gl_info.limits.buffers,
 338             &device->fb, op->rect_count, op->rects, &draw_rect, op->flags,
 339             &op->color, op->depth, op->stencil);
 340
 341     if (op->flags & WINED3DCLEAR_TARGET)
 342     {
 343         for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
 344         {
 345             if (state->fb->render_targets[i])
 346                 wined3d_resource_release(state->fb->render_targets[i]->resource);
 347         }
 348     }
 349     if (op->flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
 350         wined3d_resource_release(state->fb->depth_stencil->resource);
 351 }
 352
 353 void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
 354         DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 355 {
 356     const struct wined3d_state *state = &cs->device->state;
 357     struct wined3d_cs_clear *op;
 358     unsigned int i;
 359
 360     op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]));
 361     op->opcode = WINED3D_CS_OP_CLEAR;
 362     op->flags = flags;
 363     op->color = *color;
 364     op->depth = depth;
 365     op->stencil = stencil;
 366     op->rect_count = rect_count;
 367     memcpy(op->rects, rects, sizeof(*rects) * rect_count);
 368
 369     if (flags & WINED3DCLEAR_TARGET)
 370     {
 371         for (i = 0; i < cs->device->adapter->gl_info.limits.buffers; ++i)
 372         {
 373             if (state->fb->render_targets[i])
 374                 wined3d_resource_acquire(state->fb->render_targets[i]->resource);
 375         }
 376     }
 377     if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
 378         wined3d_resource_acquire(state->fb->depth_stencil->resource);
 379
 380     cs->ops->submit(cs);
 381 }
 382
 383 static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
 384 {
 385     struct wined3d_state *state = &cs->device->state;
 386     struct wined3d_shader_sampler_map_entry *entry;
 387     struct wined3d_shader_resource_view *view;
 388     const struct wined3d_cs_draw *op = data;
 389     struct wined3d_shader *shader;
 390     unsigned int i, j;
 391
 392     if (!cs->device->adapter->gl_info.supported[ARB_DRAW_ELEMENTS_BASE_VERTEX]
 393             && state->load_base_vertex_index != op->base_vertex_idx)
 394     {
 395         state->load_base_vertex_index = op->base_vertex_idx;
 396         device_invalidate_state(cs->device, STATE_BASEVERTEXINDEX);
 397     }
 398
 399     draw_primitive(cs->device, state, op->base_vertex_idx, op->start_idx,
 400             op->index_count, op->start_instance, op->instance_count, op->indexed);
 401
 402     if (op->indexed)
 403         wined3d_resource_release(&state->index_buffer->resource);
 404     for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
 405     {
 406         if (state->streams[i].buffer)
 407             wined3d_resource_release(&state->streams[i].buffer->resource);
 408     }
 409     for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
 410     {
 411         if (state->textures[i])
 412             wined3d_resource_release(&state->textures[i]->resource);
 413     }
 414     for (i = 0; i < cs->device->adapter->gl_info.limits.buffers; ++i)
 415     {
 416         if (state->fb->render_targets[i])
 417             wined3d_resource_release(state->fb->render_targets[i]->resource);
 418     }
 419     if (state->fb->depth_stencil)
 420         wined3d_resource_release(state->fb->depth_stencil->resource);
 421     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 422     {
 423         if (!(shader = state->shader[i]))
 424             continue;
 425
 426         for (j = 0; j < WINED3D_MAX_CBS; ++j)
 427         {
 428             if (state->cb[i][j])
 429                 wined3d_resource_release(&state->cb[i][j]->resource);
 430         }
 431
 432         for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
 433         {
 434             entry = &shader->reg_maps.sampler_map.entries[j];
 435
 436             if (!(view = state->shader_resource_view[i][entry->resource_idx]))
 437                 continue;
 438
 439             wined3d_resource_release(view->resource);
 440         }
 441     }
 442 }
 443
 444 void wined3d_cs_emit_draw(struct wined3d_cs *cs, int base_vertex_idx, unsigned int start_idx,
 445         unsigned int index_count, unsigned int start_instance, unsigned int instance_count, BOOL indexed)
 446 {
 447     const struct wined3d_state *state = &cs->device->state;
 448     struct wined3d_shader_sampler_map_entry *entry;
 449     struct wined3d_shader_resource_view *view;
 450     struct wined3d_shader *shader;
 451     struct wined3d_cs_draw *op;
 452     unsigned int i, j;
 453
 454     op = cs->ops->require_space(cs, sizeof(*op));
 455     op->opcode = WINED3D_CS_OP_DRAW;
 456     op->base_vertex_idx = base_vertex_idx;
 457     op->start_idx = start_idx;
 458     op->index_count = index_count;
 459     op->start_instance = start_instance;
 460     op->instance_count = instance_count;
 461     op->indexed = indexed;
 462
 463     if (indexed)
 464         wined3d_resource_acquire(&state->index_buffer->resource);
 465     for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
 466     {
 467         if (state->streams[i].buffer)
 468             wined3d_resource_acquire(&state->streams[i].buffer->resource);
 469     }
 470     for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
 471     {
 472         if (state->textures[i])
 473             wined3d_resource_acquire(&state->textures[i]->resource);
 474     }
 475     for (i = 0; i < cs->device->adapter->gl_info.limits.buffers; ++i)
 476     {
 477         if (state->fb->render_targets[i])
 478             wined3d_resource_acquire(state->fb->render_targets[i]->resource);
 479     }
 480     if (state->fb->depth_stencil)
 481         wined3d_resource_acquire(state->fb->depth_stencil->resource);
 482     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
 483     {
 484         if (!(shader = state->shader[i]))
 485             continue;
 486
 487         for (j = 0; j < WINED3D_MAX_CBS; ++j)
 488         {
 489             if (state->cb[i][j])
 490                 wined3d_resource_acquire(&state->cb[i][j]->resource);
 491         }
 492
 493         for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
 494         {
 495             entry = &shader->reg_maps.sampler_map.entries[j];
 496
 497             if (!(view = state->shader_resource_view[i][entry->resource_idx]))
 498                 continue;
 499
 500             wined3d_resource_acquire(view->resource);
 501         }
 502     }
 503
 504     cs->ops->submit(cs);
 505 }
 506
 507 static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
 508 {
 509     const struct wined3d_cs_set_predication *op = data;
 510
 511     cs->state.predicate = op->predicate;
 512     cs->state.predicate_value = op->value;
 513 }
 514
 515 void wined3d_cs_emit_set_predication(struct wined3d_cs *cs, struct wined3d_query *predicate, BOOL value)
 516 {
 517     struct wined3d_cs_set_predication *op;
 518
 519     op = cs->ops->require_space(cs, sizeof(*op));
 520     op->opcode = WINED3D_CS_OP_SET_PREDICATION;
 521     op->predicate = predicate;
 522     op->value = value;
 523
 524     cs->ops->submit(cs);
 525 }
 526
 527 static void wined3d_cs_exec_set_viewport(struct wined3d_cs *cs, const void *data)
 528 {
 529     const struct wined3d_cs_set_viewport *op = data;
 530
 531     cs->state.viewport = op->viewport;
 532     device_invalidate_state(cs->device, STATE_VIEWPORT);
 533 }
 534
 535 void wined3d_cs_emit_set_viewport(struct wined3d_cs *cs, const struct wined3d_viewport *viewport)
 536 {
 537     struct wined3d_cs_set_viewport *op;
 538
 539     op = cs->ops->require_space(cs, sizeof(*op));
 540     op->opcode = WINED3D_CS_OP_SET_VIEWPORT;
 541     op->viewport = *viewport;
 542
 543     cs->ops->submit(cs);
 544 }
 545
 546 static void wined3d_cs_exec_set_scissor_rect(struct wined3d_cs *cs, const void *data)
 547 {
 548     const struct wined3d_cs_set_scissor_rect *op = data;
 549
 550     cs->state.scissor_rect = op->rect;
 551     device_invalidate_state(cs->device, STATE_SCISSORRECT);
 552 }
 553
 554 void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs *cs, const RECT *rect)
 555 {
 556     struct wined3d_cs_set_scissor_rect *op;
 557
 558     op = cs->ops->require_space(cs, sizeof(*op));
 559     op->opcode = WINED3D_CS_OP_SET_SCISSOR_RECT;
 560     op->rect = *rect;
 561
 562     cs->ops->submit(cs);
 563 }
 564
 565 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data)
 566 {
 567     const struct wined3d_cs_set_rendertarget_view *op = data;
 568
 569     cs->state.fb->render_targets[op->view_idx] = op->view;
 570     device_invalidate_state(cs->device, STATE_FRAMEBUFFER);
 571 }
 572
 573 void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx,
 574         struct wined3d_rendertarget_view *view)
 575 {
 576     struct wined3d_cs_set_rendertarget_view *op;
 577
 578     op = cs->ops->require_space(cs, sizeof(*op));
 579     op->opcode = WINED3D_CS_OP_SET_RENDERTARGET_VIEW;
 580     op->view_idx = view_idx;
 581     op->view = view;
 582
 583     cs->ops->submit(cs);
 584 }
 585
 586 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
 587 {
 588     const struct wined3d_cs_set_depth_stencil_view *op = data;
 589     struct wined3d_device *device = cs->device;
 590     struct wined3d_rendertarget_view *prev;
 591
 592     if ((prev = cs->state.fb->depth_stencil))
 593     {
 594         struct wined3d_surface *prev_surface = wined3d_rendertarget_view_get_surface(prev);
 595
 596         if (prev_surface && (device->swapchains[0]->desc.flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
 597                 || prev_surface->container->flags & WINED3D_TEXTURE_DISCARD))
 598         {
 599             surface_modify_ds_location(prev_surface, WINED3D_LOCATION_DISCARDED, prev->width, prev->height);
 600             if (prev_surface == device->onscreen_depth_stencil)
 601             {
 602                 wined3d_texture_decref(device->onscreen_depth_stencil->container);
 603                 device->onscreen_depth_stencil = NULL;
 604             }
 605         }
 606     }
 607
 608     cs->fb.depth_stencil = op->view;
 609
 610     if (!prev != !op->view)
 611     {
 612         /* Swapping NULL / non NULL depth stencil affects the depth and tests */
 613         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
 614         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILENABLE));
 615         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
 616         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
 617     }
 618     else if (prev && (prev->format_flags & WINED3DFMT_FLAG_FLOAT)
 619             != (op->view->format_flags & WINED3DFMT_FLAG_FLOAT))
 620     {
 621         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
 622     }
 623
 624     device_invalidate_state(device, STATE_FRAMEBUFFER);
 625 }
 626
 627 void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
 628 {
 629     struct wined3d_cs_set_depth_stencil_view *op;
 630
 631     op = cs->ops->require_space(cs, sizeof(*op));
 632     op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
 633     op->view = view;
 634
 635     cs->ops->submit(cs);
 636 }
 637
 638 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
 639 {
 640     const struct wined3d_cs_set_vertex_declaration *op = data;
 641
 642     cs->state.vertex_declaration = op->declaration;
 643     device_invalidate_state(cs->device, STATE_VDECL);
 644 }
 645
 646 void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs, struct wined3d_vertex_declaration *declaration)
 647 {
 648     struct wined3d_cs_set_vertex_declaration *op;
 649
 650     op = cs->ops->require_space(cs, sizeof(*op));
 651     op->opcode = WINED3D_CS_OP_SET_VERTEX_DECLARATION;
 652     op->declaration = declaration;
 653
 654     cs->ops->submit(cs);
 655 }
 656
 657 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs *cs, const void *data)
 658 {
 659     const struct wined3d_cs_set_stream_source *op = data;
 660     struct wined3d_stream_state *stream;
 661     struct wined3d_buffer *prev;
 662
 663     stream = &cs->state.streams[op->stream_idx];
 664     prev = stream->buffer;
 665     stream->buffer = op->buffer;
 666     stream->offset = op->offset;
 667     stream->stride = op->stride;
 668
 669     if (op->buffer)
 670         InterlockedIncrement(&op->buffer->resource.bind_count);
 671     if (prev)
 672         InterlockedDecrement(&prev->resource.bind_count);
 673
 674     device_invalidate_state(cs->device, STATE_STREAMSRC);
 675 }
 676
 677 void wined3d_cs_emit_set_stream_source(struct wined3d_cs *cs, UINT stream_idx,
 678         struct wined3d_buffer *buffer, UINT offset, UINT stride)
 679 {
 680     struct wined3d_cs_set_stream_source *op;
 681
 682     op = cs->ops->require_space(cs, sizeof(*op));
 683     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE;
 684     op->stream_idx = stream_idx;
 685     op->buffer = buffer;
 686     op->offset = offset;
 687     op->stride = stride;
 688
 689     cs->ops->submit(cs);
 690 }
 691
 692 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs *cs, const void *data)
 693 {
 694     const struct wined3d_cs_set_stream_source_freq *op = data;
 695     struct wined3d_stream_state *stream;
 696
 697     stream = &cs->state.streams[op->stream_idx];
 698     stream->frequency = op->frequency;
 699     stream->flags = op->flags;
 700
 701     device_invalidate_state(cs->device, STATE_STREAMSRC);
 702 }
 703
 704 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx, UINT frequency, UINT flags)
 705 {
 706     struct wined3d_cs_set_stream_source_freq *op;
 707
 708     op = cs->ops->require_space(cs, sizeof(*op));
 709     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ;
 710     op->stream_idx = stream_idx;
 711     op->frequency = frequency;
 712     op->flags = flags;
 713
 714     cs->ops->submit(cs);
 715 }
 716
 717 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs *cs, const void *data)
 718 {
 719     const struct wined3d_cs_set_stream_output *op = data;
 720     struct wined3d_stream_output *stream;
 721     struct wined3d_buffer *prev;
 722
 723     stream = &cs->state.stream_output[op->stream_idx];
 724     prev = stream->buffer;
 725     stream->buffer = op->buffer;
 726     stream->offset = op->offset;
 727
 728     if (op->buffer)
 729         InterlockedIncrement(&op->buffer->resource.bind_count);
 730     if (prev)
 731         InterlockedDecrement(&prev->resource.bind_count);
 732 }
 733
 734 void wined3d_cs_emit_set_stream_output(struct wined3d_cs *cs, UINT stream_idx,
 735         struct wined3d_buffer *buffer, UINT offset)
 736 {
 737     struct wined3d_cs_set_stream_output *op;
 738
 739     op = cs->ops->require_space(cs, sizeof(*op));
 740     op->opcode = WINED3D_CS_OP_SET_STREAM_OUTPUT;
 741     op->stream_idx = stream_idx;
 742     op->buffer = buffer;
 743     op->offset = offset;
 744
 745     cs->ops->submit(cs);
 746 }
 747
 748 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
 749 {
 750     const struct wined3d_cs_set_index_buffer *op = data;
 751     struct wined3d_buffer *prev;
 752
 753     prev = cs->state.index_buffer;
 754     cs->state.index_buffer = op->buffer;
 755     cs->state.index_format = op->format_id;
 756     cs->state.index_offset = op->offset;
 757
 758     if (op->buffer)
 759         InterlockedIncrement(&op->buffer->resource.bind_count);
 760     if (prev)
 761         InterlockedDecrement(&prev->resource.bind_count);
 762
 763     device_invalidate_state(cs->device, STATE_INDEXBUFFER);
 764 }
 765
 766 void wined3d_cs_emit_set_index_buffer(struct wined3d_cs *cs, struct wined3d_buffer *buffer,
 767         enum wined3d_format_id format_id, unsigned int offset)
 768 {
 769     struct wined3d_cs_set_index_buffer *op;
 770
 771     op = cs->ops->require_space(cs, sizeof(*op));
 772     op->opcode = WINED3D_CS_OP_SET_INDEX_BUFFER;
 773     op->buffer = buffer;
 774     op->format_id = format_id;
 775     op->offset = offset;
 776
 777     cs->ops->submit(cs);
 778 }
 779
 780 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs *cs, const void *data)
 781 {
 782     const struct wined3d_cs_set_constant_buffer *op = data;
 783     struct wined3d_buffer *prev;
 784
 785     prev = cs->state.cb[op->type][op->cb_idx];
 786     cs->state.cb[op->type][op->cb_idx] = op->buffer;
 787
 788     if (op->buffer)
 789         InterlockedIncrement(&op->buffer->resource.bind_count);
 790     if (prev)
 791         InterlockedDecrement(&prev->resource.bind_count);
 792
 793     device_invalidate_state(cs->device, STATE_CONSTANT_BUFFER(op->type));
 794 }
 795
 796 void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs *cs, enum wined3d_shader_type type,
 797         UINT cb_idx, struct wined3d_buffer *buffer)
 798 {
 799     struct wined3d_cs_set_constant_buffer *op;
 800
 801     op = cs->ops->require_space(cs, sizeof(*op));
 802     op->opcode = WINED3D_CS_OP_SET_CONSTANT_BUFFER;
 803     op->type = type;
 804     op->cb_idx = cb_idx;
 805     op->buffer = buffer;
 806
 807     cs->ops->submit(cs);
 808 }
 809
 810 static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
 811 {
 812     const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
 813     const struct wined3d_d3d_info *d3d_info = &cs->device->adapter->d3d_info;
 814     const struct wined3d_cs_set_texture *op = data;
 815     struct wined3d_texture *prev;
 816     BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
 817
 818     prev = cs->state.textures[op->stage];
 819     cs->state.textures[op->stage] = op->texture;
 820
 821     if (op->texture)
 822     {
 823         const struct wined3d_format *new_format = op->texture->resource.format;
 824         const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
 825         unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
 826         unsigned int new_fmt_flags = op->texture->resource.format_flags;
 827
 828         if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
 829             op->texture->sampler = op->stage;
 830
 831         if (!prev || op->texture->target != prev->target
 832                 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
 833                 && !(can_use_texture_swizzle(gl_info, new_format) && can_use_texture_swizzle(gl_info, old_format)))
 834                 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
 835             device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
 836
 837         if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
 838         {
 839             /* The source arguments for color and alpha ops have different
 840              * meanings when a NULL texture is bound, so the COLOR_OP and
 841              * ALPHA_OP have to be dirtified. */
 842             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
 843             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
 844         }
 845
 846         if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 847             new_use_color_key = TRUE;
 848     }
 849
 850     if (prev)
 851     {
 852         if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
 853         {
 854             unsigned int i;
 855
 856             /* Search for other stages the texture is bound to. Shouldn't
 857              * happen if applications bind textures to a single stage only. */
 858             TRACE("Searching for other stages the texture is bound to.\n");
 859             for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
 860             {
 861                 if (cs->state.textures[i] == prev)
 862                 {
 863                     TRACE("Texture is also bound to stage %u.\n", i);
 864                     prev->sampler = i;
 865                     break;
 866                 }
 867             }
 868         }
 869
 870         if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
 871         {
 872             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
 873             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
 874         }
 875
 876         if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 877             old_use_color_key = TRUE;
 878     }
 879
 880     device_invalidate_state(cs->device, STATE_SAMPLER(op->stage));
 881
 882     if (new_use_color_key != old_use_color_key)
 883         device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
 884
 885     if (new_use_color_key)
 886         device_invalidate_state(cs->device, STATE_COLOR_KEY);
 887 }
 888
 889 void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
 890 {
 891     struct wined3d_cs_set_texture *op;
 892
 893     op = cs->ops->require_space(cs, sizeof(*op));
 894     op->opcode = WINED3D_CS_OP_SET_TEXTURE;
 895     op->stage = stage;
 896     op->texture = texture;
 897
 898     cs->ops->submit(cs);
 899 }
 900
 901 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs *cs, const void *data)
 902 {
 903     const struct wined3d_cs_set_shader_resource_view *op = data;
 904
 905     cs->state.shader_resource_view[op->type][op->view_idx] = op->view;
 906     device_invalidate_state(cs->device, STATE_SHADER_RESOURCE_BINDING);
 907 }
 908
 909 void wined3d_cs_emit_set_shader_resource_view(struct wined3d_cs *cs, enum wined3d_shader_type type,
 910         UINT view_idx, struct wined3d_shader_resource_view *view)
 911 {
 912     struct wined3d_cs_set_shader_resource_view *op;
 913
 914     op = cs->ops->require_space(cs, sizeof(*op));
 915     op->opcode = WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW;
 916     op->type = type;
 917     op->view_idx = view_idx;
 918     op->view = view;
 919
 920     cs->ops->submit(cs);
 921 }
 922
 923 static void wined3d_cs_exec_set_sampler(struct wined3d_cs *cs, const void *data)
 924 {
 925     const struct wined3d_cs_set_sampler *op = data;
 926
 927     cs->state.sampler[op->type][op->sampler_idx] = op->sampler;
 928     device_invalidate_state(cs->device, STATE_SHADER_RESOURCE_BINDING);
 929 }
 930
 931 void wined3d_cs_emit_set_sampler(struct wined3d_cs *cs, enum wined3d_shader_type type,
 932         UINT sampler_idx, struct wined3d_sampler *sampler)
 933 {
 934     struct wined3d_cs_set_sampler *op;
 935
 936     op = cs->ops->require_space(cs, sizeof(*op));
 937     op->opcode = WINED3D_CS_OP_SET_SAMPLER;
 938     op->type = type;
 939     op->sampler_idx = sampler_idx;
 940     op->sampler = sampler;
 941
 942     cs->ops->submit(cs);
 943 }
 944
 945 static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
 946 {
 947     const struct wined3d_cs_set_shader *op = data;
 948
 949     cs->state.shader[op->type] = op->shader;
 950     device_invalidate_state(cs->device, STATE_SHADER(op->type));
 951     device_invalidate_state(cs->device, STATE_SHADER_RESOURCE_BINDING);
 952 }
 953
 954 void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
 955 {
 956     struct wined3d_cs_set_shader *op;
 957
 958     op = cs->ops->require_space(cs, sizeof(*op));
 959     op->opcode = WINED3D_CS_OP_SET_SHADER;
 960     op->type = type;
 961     op->shader = shader;
 962
 963     cs->ops->submit(cs);
 964 }
 965
 966 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs *cs, const void *data)
 967 {
 968     const struct wined3d_cs_set_rasterizer_state *op = data;
 969
 970     cs->state.rasterizer_state = op->state;
 971     device_invalidate_state(cs->device, STATE_FRONTFACE);
 972 }
 973
 974 void wined3d_cs_emit_set_rasterizer_state(struct wined3d_cs *cs,
 975         struct wined3d_rasterizer_state *rasterizer_state)
 976 {
 977     struct wined3d_cs_set_rasterizer_state *op;
 978
 979     op = cs->ops->require_space(cs, sizeof(*op));
 980     op->opcode = WINED3D_CS_OP_SET_RASTERIZER_STATE;
 981     op->state = rasterizer_state;
 982
 983     cs->ops->submit(cs);
 984 }
 985
 986 static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
 987 {
 988     const struct wined3d_cs_set_render_state *op = data;
 989
 990     cs->state.render_states[op->state] = op->value;
 991     device_invalidate_state(cs->device, STATE_RENDER(op->state));
 992 }
 993
 994 void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
 995 {
 996     struct wined3d_cs_set_render_state *op;
 997
 998     op = cs->ops->require_space(cs, sizeof(*op));
 999     op->opcode = WINED3D_CS_OP_SET_RENDER_STATE;
1000     op->state = state;
1001     op->value = value;
1002
1003     cs->ops->submit(cs);
1004 }
1005
1006 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
1007 {
1008     const struct wined3d_cs_set_texture_state *op = data;
1009
1010     cs->state.texture_states[op->stage][op->state] = op->value;
1011     device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, op->state));
1012 }
1013
1014 void wined3d_cs_emit_set_texture_state(struct wined3d_cs *cs, UINT stage,
1015         enum wined3d_texture_stage_state state, DWORD value)
1016 {
1017     struct wined3d_cs_set_texture_state *op;
1018
1019     op = cs->ops->require_space(cs, sizeof(*op));
1020     op->opcode = WINED3D_CS_OP_SET_TEXTURE_STATE;
1021     op->stage = stage;
1022     op->state = state;
1023     op->value = value;
1024
1025     cs->ops->submit(cs);
1026 }
1027
1028 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
1029 {
1030     const struct wined3d_cs_set_sampler_state *op = data;
1031
1032     cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
1033     device_invalidate_state(cs->device, STATE_SAMPLER(op->sampler_idx));
1034 }
1035
1036 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
1037         enum wined3d_sampler_state state, DWORD value)
1038 {
1039     struct wined3d_cs_set_sampler_state *op;
1040
1041     op = cs->ops->require_space(cs, sizeof(*op));
1042     op->opcode = WINED3D_CS_OP_SET_SAMPLER_STATE;
1043     op->sampler_idx = sampler_idx;
1044     op->state = state;
1045     op->value = value;
1046
1047     cs->ops->submit(cs);
1048 }
1049
1050 static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
1051 {
1052     const struct wined3d_cs_set_transform *op = data;
1053
1054     cs->state.transforms[op->state] = op->matrix;
1055     if (op->state < WINED3D_TS_WORLD_MATRIX(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
1056         device_invalidate_state(cs->device, STATE_TRANSFORM(op->state));
1057 }
1058
1059 void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform_state state,
1060         const struct wined3d_matrix *matrix)
1061 {
1062     struct wined3d_cs_set_transform *op;
1063
1064     op = cs->ops->require_space(cs, sizeof(*op));
1065     op->opcode = WINED3D_CS_OP_SET_TRANSFORM;
1066     op->state = state;
1067     op->matrix = *matrix;
1068
1069     cs->ops->submit(cs);
1070 }
1071
1072 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
1073 {
1074     const struct wined3d_cs_set_clip_plane *op = data;
1075
1076     cs->state.clip_planes[op->plane_idx] = op->plane;
1077     device_invalidate_state(cs->device, STATE_CLIPPLANE(op->plane_idx));
1078 }
1079
1080 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
1081 {
1082     struct wined3d_cs_set_clip_plane *op;
1083
1084     op = cs->ops->require_space(cs, sizeof(*op));
1085     op->opcode = WINED3D_CS_OP_SET_CLIP_PLANE;
1086     op->plane_idx = plane_idx;
1087     op->plane = *plane;
1088
1089     cs->ops->submit(cs);
1090 }
1091
1092 static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
1093 {
1094     const struct wined3d_cs_set_color_key *op = data;
1095     struct wined3d_texture *texture = op->texture;
1096
1097     if (op->set)
1098     {
1099         switch (op->flags)
1100         {
1101             case WINED3D_CKEY_DST_BLT:
1102                 texture->async.dst_blt_color_key = op->color_key;
1103                 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
1104                 break;
1105
1106             case WINED3D_CKEY_DST_OVERLAY:
1107                 texture->async.dst_overlay_color_key = op->color_key;
1108                 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
1109                 break;
1110
1111             case WINED3D_CKEY_SRC_BLT:
1112                 if (texture == cs->state.textures[0])
1113                 {
1114                     device_invalidate_state(cs->device, STATE_COLOR_KEY);
1115                     if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1116                         device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1117                 }
1118
1119                 texture->async.src_blt_color_key = op->color_key;
1120                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
1121                 break;
1122
1123             case WINED3D_CKEY_SRC_OVERLAY:
1124                 texture->async.src_overlay_color_key = op->color_key;
1125                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
1126                 break;
1127         }
1128     }
1129     else
1130     {
1131         switch (op->flags)
1132         {
1133             case WINED3D_CKEY_DST_BLT:
1134                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
1135                 break;
1136
1137             case WINED3D_CKEY_DST_OVERLAY:
1138                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
1139                 break;
1140
1141             case WINED3D_CKEY_SRC_BLT:
1142                 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1143                     device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1144
1145                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
1146                 break;
1147
1148             case WINED3D_CKEY_SRC_OVERLAY:
1149                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
1150                 break;
1151         }
1152     }
1153 }
1154
1155 void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
1156         WORD flags, const struct wined3d_color_key *color_key)
1157 {
1158     struct wined3d_cs_set_color_key *op;
1159
1160     op = cs->ops->require_space(cs, sizeof(*op));
1161     op->opcode = WINED3D_CS_OP_SET_COLOR_KEY;
1162     op->texture = texture;
1163     op->flags = flags;
1164     if (color_key)
1165     {
1166         op->color_key = *color_key;
1167         op->set = 1;
1168     }
1169     else
1170         op->set = 0;
1171
1172     cs->ops->submit(cs);
1173 }
1174
1175 static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
1176 {
1177     const struct wined3d_cs_set_material *op = data;
1178
1179     cs->state.material = op->material;
1180     device_invalidate_state(cs->device, STATE_MATERIAL);
1181 }
1182
1183 void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material)
1184 {
1185     struct wined3d_cs_set_material *op;
1186
1187     op = cs->ops->require_space(cs, sizeof(*op));
1188     op->opcode = WINED3D_CS_OP_SET_MATERIAL;
1189     op->material = *material;
1190
1191     cs->ops->submit(cs);
1192 }
1193
1194 static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
1195 {
1196     struct wined3d_adapter *adapter = cs->device->adapter;
1197
1198     state_cleanup(&cs->state);
1199     memset(&cs->state, 0, sizeof(cs->state));
1200     state_init(&cs->state, &cs->fb, &adapter->gl_info, &adapter->d3d_info,
1201             WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
1202 }
1203
1204 void wined3d_cs_emit_reset_state(struct wined3d_cs *cs)
1205 {
1206     struct wined3d_cs_reset_state *op;
1207
1208     op = cs->ops->require_space(cs, sizeof(*op));
1209     op->opcode = WINED3D_CS_OP_RESET_STATE;
1210
1211     cs->ops->submit(cs);
1212 }
1213
1214 static void wined3d_cs_exec_destroy_object(struct wined3d_cs *cs, const void *data)
1215 {
1216     const struct wined3d_cs_destroy_object *op = data;
1217
1218     op->callback(op->object);
1219 }
1220
1221 void wined3d_cs_emit_destroy_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1222 {
1223     struct wined3d_cs_destroy_object *op;
1224
1225     op = cs->ops->require_space(cs, sizeof(*op));
1226     op->opcode = WINED3D_CS_OP_DESTROY_OBJECT;
1227     op->callback = callback;
1228     op->object = object;
1229
1230     cs->ops->submit(cs);
1231 }
1232
1233 static void wined3d_cs_exec_query_issue(struct wined3d_cs *cs, const void *data)
1234 {
1235     const struct wined3d_cs_query_issue *op = data;
1236     struct wined3d_query *query = op->query;
1237
1238     query->query_ops->query_issue(query, op->flags);
1239 }
1240
1241 void wined3d_cs_emit_query_issue(struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags)
1242 {
1243     struct wined3d_cs_query_issue *op;
1244
1245     op = cs->ops->require_space(cs, sizeof(*op));
1246     op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
1247     op->query = query;
1248     op->flags = flags;
1249
1250     cs->ops->submit(cs);
1251 }
1252
1253 static void wined3d_cs_exec_unload_resource(struct wined3d_cs *cs, const void *data)
1254 {
1255     const struct wined3d_cs_unload_resource *op = data;
1256     struct wined3d_resource *resource = op->resource;
1257
1258     resource->resource_ops->resource_unload(resource);
1259     wined3d_resource_release(resource);
1260 }
1261
1262 void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
1263 {
1264     struct wined3d_cs_unload_resource *op;
1265
1266     op = cs->ops->require_space(cs, sizeof(*op));
1267     op->opcode = WINED3D_CS_OP_UNLOAD_RESOURCE;
1268     op->resource = resource;
1269
1270     wined3d_resource_acquire(resource);
1271
1272     cs->ops->submit(cs);
1273 }
1274
1275 static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data) =
1276 {
1277     /* WINED3D_CS_OP_PRESENT                    */ wined3d_cs_exec_present,
1278     /* WINED3D_CS_OP_CLEAR                      */ wined3d_cs_exec_clear,
1279     /* WINED3D_CS_OP_DRAW                       */ wined3d_cs_exec_draw,
1280     /* WINED3D_CS_OP_SET_PREDICATION            */ wined3d_cs_exec_set_predication,
1281     /* WINED3D_CS_OP_SET_VIEWPORT               */ wined3d_cs_exec_set_viewport,
1282     /* WINED3D_CS_OP_SET_SCISSOR_RECT           */ wined3d_cs_exec_set_scissor_rect,
1283     /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW      */ wined3d_cs_exec_set_rendertarget_view,
1284     /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW     */ wined3d_cs_exec_set_depth_stencil_view,
1285     /* WINED3D_CS_OP_SET_VERTEX_DECLARATION     */ wined3d_cs_exec_set_vertex_declaration,
1286     /* WINED3D_CS_OP_SET_STREAM_SOURCE          */ wined3d_cs_exec_set_stream_source,
1287     /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ     */ wined3d_cs_exec_set_stream_source_freq,
1288     /* WINED3D_CS_OP_SET_STREAM_OUTPUT          */ wined3d_cs_exec_set_stream_output,
1289     /* WINED3D_CS_OP_SET_INDEX_BUFFER           */ wined3d_cs_exec_set_index_buffer,
1290     /* WINED3D_CS_OP_SET_CONSTANT_BUFFER        */ wined3d_cs_exec_set_constant_buffer,
1291     /* WINED3D_CS_OP_SET_TEXTURE                */ wined3d_cs_exec_set_texture,
1292     /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW   */ wined3d_cs_exec_set_shader_resource_view,
1293     /* WINED3D_CS_OP_SET_SAMPLER                */ wined3d_cs_exec_set_sampler,
1294     /* WINED3D_CS_OP_SET_SHADER                 */ wined3d_cs_exec_set_shader,
1295     /* WINED3D_CS_OP_SET_RASTERIZER_STATE       */ wined3d_cs_exec_set_rasterizer_state,
1296     /* WINED3D_CS_OP_SET_RENDER_STATE           */ wined3d_cs_exec_set_render_state,
1297     /* WINED3D_CS_OP_SET_TEXTURE_STATE          */ wined3d_cs_exec_set_texture_state,
1298     /* WINED3D_CS_OP_SET_SAMPLER_STATE          */ wined3d_cs_exec_set_sampler_state,
1299     /* WINED3D_CS_OP_SET_TRANSFORM              */ wined3d_cs_exec_set_transform,
1300     /* WINED3D_CS_OP_SET_CLIP_PLANE             */ wined3d_cs_exec_set_clip_plane,
1301     /* WINED3D_CS_OP_SET_COLOR_KEY              */ wined3d_cs_exec_set_color_key,
1302     /* WINED3D_CS_OP_SET_MATERIAL               */ wined3d_cs_exec_set_material,
1303     /* WINED3D_CS_OP_RESET_STATE                */ wined3d_cs_exec_reset_state,
1304     /* WINED3D_CS_OP_DESTROY_OBJECT             */ wined3d_cs_exec_destroy_object,
1305     /* WINED3D_CS_OP_QUERY_ISSUE                */ wined3d_cs_exec_query_issue,
1306     /* WINED3D_CS_OP_UNLOAD_RESOURCE            */ wined3d_cs_exec_unload_resource,
1307 };
1308
1309 static void *wined3d_cs_st_require_space(struct wined3d_cs *cs, size_t size)
1310 {
1311     if (size > cs->data_size)
1312     {
1313         void *new_data;
1314
1315         size = max( size, cs->data_size * 2 );
1316         if (!(new_data = HeapReAlloc(GetProcessHeap(), 0, cs->data, size)))
1317             return NULL;
1318
1319         cs->data_size = size;
1320         cs->data = new_data;
1321     }
1322
1323     return cs->data;
1324 }
1325
1326 static void wined3d_cs_st_submit(struct wined3d_cs *cs)
1327 {
1328     enum wined3d_cs_op opcode = *(const enum wined3d_cs_op *)cs->data;
1329
1330     wined3d_cs_op_handlers[opcode](cs, cs->data);
1331 }
1332
1333 static void wined3d_cs_st_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p,
1334         unsigned int start_idx, unsigned int count, const void *constants)
1335 {
1336     struct wined3d_device *device = cs->device;
1337     unsigned int context_count;
1338     unsigned int i;
1339     size_t offset;
1340
1341     static const struct
1342     {
1343         size_t offset;
1344         size_t size;
1345         DWORD mask;
1346     }
1347     push_constant_info[] =
1348     {
1349         /* WINED3D_PUSH_CONSTANTS_VS_F */
1350         {FIELD_OFFSET(struct wined3d_state, vs_consts_f), sizeof(struct wined3d_vec4),  WINED3D_SHADER_CONST_VS_F},
1351         /* WINED3D_PUSH_CONSTANTS_PS_F */
1352         {FIELD_OFFSET(struct wined3d_state, ps_consts_f), sizeof(struct wined3d_vec4),  WINED3D_SHADER_CONST_PS_F},
1353         /* WINED3D_PUSH_CONSTANTS_VS_I */
1354         {FIELD_OFFSET(struct wined3d_state, vs_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_VS_I},
1355         /* WINED3D_PUSH_CONSTANTS_PS_I */
1356         {FIELD_OFFSET(struct wined3d_state, ps_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_PS_I},
1357         /* WINED3D_PUSH_CONSTANTS_VS_B */
1358         {FIELD_OFFSET(struct wined3d_state, vs_consts_b), sizeof(BOOL),                 WINED3D_SHADER_CONST_VS_B},
1359         /* WINED3D_PUSH_CONSTANTS_PS_B */
1360         {FIELD_OFFSET(struct wined3d_state, ps_consts_b), sizeof(BOOL),                 WINED3D_SHADER_CONST_PS_B},
1361     };
1362
1363     if (p == WINED3D_PUSH_CONSTANTS_VS_F)
1364         device->shader_backend->shader_update_float_vertex_constants(device, start_idx, count);
1365     else if (p == WINED3D_PUSH_CONSTANTS_PS_F)
1366         device->shader_backend->shader_update_float_pixel_constants(device, start_idx, count);
1367
1368     offset = push_constant_info[p].offset + start_idx * push_constant_info[p].size;
1369     memcpy((BYTE *)&cs->state + offset, constants, count * push_constant_info[p].size);
1370     for (i = 0, context_count = device->context_count; i < context_count; ++i)
1371     {
1372         device->contexts[i]->constant_update_mask |= push_constant_info[p].mask;
1373     }
1374 }
1375
1376 static const struct wined3d_cs_ops wined3d_cs_st_ops =
1377 {
1378     wined3d_cs_st_require_space,
1379     wined3d_cs_st_submit,
1380     wined3d_cs_st_push_constants,
1381 };
1382
1383 struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
1384 {
1385     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1386     struct wined3d_cs *cs;
1387
1388     if (!(cs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cs))))
1389         return NULL;
1390
1391     if (!(cs->fb.render_targets = wined3d_calloc(gl_info->limits.buffers, sizeof(*cs->fb.render_targets))))
1392     {
1393         HeapFree(GetProcessHeap(), 0, cs);
1394         return NULL;
1395     }
1396
1397     state_init(&cs->state, &cs->fb, gl_info, &device->adapter->d3d_info,
1398             WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
1399
1400     cs->ops = &wined3d_cs_st_ops;
1401     cs->device = device;
1402
1403     cs->data_size = WINED3D_INITIAL_CS_SIZE;
1404     if (!(cs->data = HeapAlloc(GetProcessHeap(), 0, cs->data_size)))
1405     {
1406         state_cleanup(&cs->state);
1407         HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
1408         HeapFree(GetProcessHeap(), 0, cs);
1409         return NULL;
1410     }
1411
1412     return cs;
1413 }
1414
1415 void wined3d_cs_destroy(struct wined3d_cs *cs)
1416 {
1417     state_cleanup(&cs->state);
1418     HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
1419     HeapFree(GetProcessHeap(), 0, cs->data);
1420     HeapFree(GetProcessHeap(), 0, cs);
1421 }