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_RENDER_STATE,
  48     WINED3D_CS_OP_SET_TEXTURE_STATE,
  49     WINED3D_CS_OP_SET_SAMPLER_STATE,
  50     WINED3D_CS_OP_SET_TRANSFORM,
  51     WINED3D_CS_OP_SET_CLIP_PLANE,
  52     WINED3D_CS_OP_SET_COLOR_KEY,
  53     WINED3D_CS_OP_SET_MATERIAL,
  54     WINED3D_CS_OP_RESET_STATE,
  55 };
  56
  57 struct wined3d_cs_present
  58 {
  59     enum wined3d_cs_op opcode;
  60     HWND dst_window_override;
  61     struct wined3d_swapchain *swapchain;
  62     RECT src_rect;
  63     RECT dst_rect;
  64     DWORD flags;
  65 };
  66
  67 struct wined3d_cs_clear
  68 {
  69     enum wined3d_cs_op opcode;
  70     DWORD flags;
  71     struct wined3d_color color;
  72     float depth;
  73     DWORD stencil;
  74     unsigned int rect_count;
  75     RECT rects[1];
  76 };
  77
  78 struct wined3d_cs_draw
  79 {
  80     enum wined3d_cs_op opcode;
  81     UINT start_idx;
  82     UINT index_count;
  83     UINT start_instance;
  84     UINT instance_count;
  85     BOOL indexed;
  86 };
  87
  88 struct wined3d_cs_set_predication
  89 {
  90     enum wined3d_cs_op opcode;
  91     struct wined3d_query *predicate;
  92     BOOL value;
  93 };
  94
  95 struct wined3d_cs_set_viewport
  96 {
  97     enum wined3d_cs_op opcode;
  98     struct wined3d_viewport viewport;
  99 };
 100
 101 struct wined3d_cs_set_scissor_rect
 102 {
 103     enum wined3d_cs_op opcode;
 104     RECT rect;
 105 };
 106
 107 struct wined3d_cs_set_rendertarget_view
 108 {
 109     enum wined3d_cs_op opcode;
 110     unsigned int view_idx;
 111     struct wined3d_rendertarget_view *view;
 112 };
 113
 114 struct wined3d_cs_set_depth_stencil_view
 115 {
 116     enum wined3d_cs_op opcode;
 117     struct wined3d_rendertarget_view *view;
 118 };
 119
 120 struct wined3d_cs_set_vertex_declaration
 121 {
 122     enum wined3d_cs_op opcode;
 123     struct wined3d_vertex_declaration *declaration;
 124 };
 125
 126 struct wined3d_cs_set_stream_source
 127 {
 128     enum wined3d_cs_op opcode;
 129     UINT stream_idx;
 130     struct wined3d_buffer *buffer;
 131     UINT offset;
 132     UINT stride;
 133 };
 134
 135 struct wined3d_cs_set_stream_source_freq
 136 {
 137     enum wined3d_cs_op opcode;
 138     UINT stream_idx;
 139     UINT frequency;
 140     UINT flags;
 141 };
 142
 143 struct wined3d_cs_set_stream_output
 144 {
 145     enum wined3d_cs_op opcode;
 146     UINT stream_idx;
 147     struct wined3d_buffer *buffer;
 148     UINT offset;
 149 };
 150
 151 struct wined3d_cs_set_index_buffer
 152 {
 153     enum wined3d_cs_op opcode;
 154     struct wined3d_buffer *buffer;
 155     enum wined3d_format_id format_id;
 156 };
 157
 158 struct wined3d_cs_set_constant_buffer
 159 {
 160     enum wined3d_cs_op opcode;
 161     enum wined3d_shader_type type;
 162     UINT cb_idx;
 163     struct wined3d_buffer *buffer;
 164 };
 165
 166 struct wined3d_cs_set_texture
 167 {
 168     enum wined3d_cs_op opcode;
 169     UINT stage;
 170     struct wined3d_texture *texture;
 171 };
 172
 173 struct wined3d_cs_set_color_key
 174 {
 175     enum wined3d_cs_op opcode;
 176     struct wined3d_texture *texture;
 177     WORD flags;
 178     WORD set;
 179     struct wined3d_color_key color_key;
 180 };
 181
 182 struct wined3d_cs_set_shader_resource_view
 183 {
 184     enum wined3d_cs_op opcode;
 185     enum wined3d_shader_type type;
 186     UINT view_idx;
 187     struct wined3d_shader_resource_view *view;
 188 };
 189
 190 struct wined3d_cs_set_sampler
 191 {
 192     enum wined3d_cs_op opcode;
 193     enum wined3d_shader_type type;
 194     UINT sampler_idx;
 195     struct wined3d_sampler *sampler;
 196 };
 197
 198 struct wined3d_cs_set_shader
 199 {
 200     enum wined3d_cs_op opcode;
 201     enum wined3d_shader_type type;
 202     struct wined3d_shader *shader;
 203 };
 204
 205 struct wined3d_cs_set_render_state
 206 {
 207     enum wined3d_cs_op opcode;
 208     enum wined3d_render_state state;
 209     DWORD value;
 210 };
 211
 212 struct wined3d_cs_set_texture_state
 213 {
 214     enum wined3d_cs_op opcode;
 215     UINT stage;
 216     enum wined3d_texture_stage_state state;
 217     DWORD value;
 218 };
 219
 220 struct wined3d_cs_set_sampler_state
 221 {
 222     enum wined3d_cs_op opcode;
 223     UINT sampler_idx;
 224     enum wined3d_sampler_state state;
 225     DWORD value;
 226 };
 227
 228 struct wined3d_cs_set_transform
 229 {
 230     enum wined3d_cs_op opcode;
 231     enum wined3d_transform_state state;
 232     struct wined3d_matrix matrix;
 233 };
 234
 235 struct wined3d_cs_set_clip_plane
 236 {
 237     enum wined3d_cs_op opcode;
 238     UINT plane_idx;
 239     struct wined3d_vec4 plane;
 240 };
 241
 242 struct wined3d_cs_set_material
 243 {
 244     enum wined3d_cs_op opcode;
 245     struct wined3d_material material;
 246 };
 247
 248 struct wined3d_cs_reset_state
 249 {
 250     enum wined3d_cs_op opcode;
 251 };
 252
 253 static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
 254 {
 255     const struct wined3d_cs_present *op = data;
 256     struct wined3d_swapchain *swapchain;
 257
 258     swapchain = op->swapchain;
 259     wined3d_swapchain_set_window(swapchain, op->dst_window_override);
 260
 261     swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->flags);
 262 }
 263
 264 void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain,
 265         const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, DWORD flags)
 266 {
 267     struct wined3d_cs_present *op;
 268
 269     op = cs->ops->require_space(cs, sizeof(*op));
 270     op->opcode = WINED3D_CS_OP_PRESENT;
 271     op->dst_window_override = dst_window_override;
 272     op->swapchain = swapchain;
 273     op->src_rect = *src_rect;
 274     op->dst_rect = *dst_rect;
 275     op->flags = flags;
 276
 277     cs->ops->submit(cs);
 278 }
 279
 280 static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
 281 {
 282     const struct wined3d_cs_clear *op = data;
 283     struct wined3d_device *device;
 284     RECT draw_rect;
 285
 286     device = cs->device;
 287     wined3d_get_draw_rect(&device->state, &draw_rect);
 288     device_clear_render_targets(device, device->adapter->gl_info.limits.buffers,
 289             &device->fb, op->rect_count, op->rects, &draw_rect, op->flags,
 290             &op->color, op->depth, op->stencil);
 291 }
 292
 293 void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
 294         DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 295 {
 296     struct wined3d_cs_clear *op;
 297
 298     op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]));
 299     op->opcode = WINED3D_CS_OP_CLEAR;
 300     op->flags = flags;
 301     op->color = *color;
 302     op->depth = depth;
 303     op->stencil = stencil;
 304     op->rect_count = rect_count;
 305     memcpy(op->rects, rects, sizeof(*rects) * rect_count);
 306
 307     cs->ops->submit(cs);
 308 }
 309
 310 static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
 311 {
 312     const struct wined3d_cs_draw *op = data;
 313
 314     draw_primitive(cs->device, &cs->device->state, op->start_idx, op->index_count,
 315             op->start_instance, op->instance_count, op->indexed);
 316 }
 317
 318 void wined3d_cs_emit_draw(struct wined3d_cs *cs, UINT start_idx, UINT index_count,
 319         UINT start_instance, UINT instance_count, BOOL indexed)
 320 {
 321     struct wined3d_cs_draw *op;
 322
 323     op = cs->ops->require_space(cs, sizeof(*op));
 324     op->opcode = WINED3D_CS_OP_DRAW;
 325     op->start_idx = start_idx;
 326     op->index_count = index_count;
 327     op->start_instance = start_instance;
 328     op->instance_count = instance_count;
 329     op->indexed = indexed;
 330
 331     cs->ops->submit(cs);
 332 }
 333
 334 static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
 335 {
 336     const struct wined3d_cs_set_predication *op = data;
 337
 338     cs->state.predicate = op->predicate;
 339     cs->state.predicate_value = op->value;
 340 }
 341
 342 void wined3d_cs_emit_set_predication(struct wined3d_cs *cs, struct wined3d_query *predicate, BOOL value)
 343 {
 344     struct wined3d_cs_set_predication *op;
 345
 346     op = cs->ops->require_space(cs, sizeof(*op));
 347     op->opcode = WINED3D_CS_OP_SET_PREDICATION;
 348     op->predicate = predicate;
 349     op->value = value;
 350
 351     cs->ops->submit(cs);
 352 }
 353
 354 static void wined3d_cs_exec_set_viewport(struct wined3d_cs *cs, const void *data)
 355 {
 356     const struct wined3d_cs_set_viewport *op = data;
 357
 358     cs->state.viewport = op->viewport;
 359     device_invalidate_state(cs->device, STATE_VIEWPORT);
 360 }
 361
 362 void wined3d_cs_emit_set_viewport(struct wined3d_cs *cs, const struct wined3d_viewport *viewport)
 363 {
 364     struct wined3d_cs_set_viewport *op;
 365
 366     op = cs->ops->require_space(cs, sizeof(*op));
 367     op->opcode = WINED3D_CS_OP_SET_VIEWPORT;
 368     op->viewport = *viewport;
 369
 370     cs->ops->submit(cs);
 371 }
 372
 373 static void wined3d_cs_exec_set_scissor_rect(struct wined3d_cs *cs, const void *data)
 374 {
 375     const struct wined3d_cs_set_scissor_rect *op = data;
 376
 377     cs->state.scissor_rect = op->rect;
 378     device_invalidate_state(cs->device, STATE_SCISSORRECT);
 379 }
 380
 381 void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs *cs, const RECT *rect)
 382 {
 383     struct wined3d_cs_set_scissor_rect *op;
 384
 385     op = cs->ops->require_space(cs, sizeof(*op));
 386     op->opcode = WINED3D_CS_OP_SET_SCISSOR_RECT;
 387     op->rect = *rect;
 388
 389     cs->ops->submit(cs);
 390 }
 391
 392 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data)
 393 {
 394     const struct wined3d_cs_set_rendertarget_view *op = data;
 395
 396     cs->state.fb->render_targets[op->view_idx] = op->view;
 397     device_invalidate_state(cs->device, STATE_FRAMEBUFFER);
 398 }
 399
 400 void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx,
 401         struct wined3d_rendertarget_view *view)
 402 {
 403     struct wined3d_cs_set_rendertarget_view *op;
 404
 405     op = cs->ops->require_space(cs, sizeof(*op));
 406     op->opcode = WINED3D_CS_OP_SET_RENDERTARGET_VIEW;
 407     op->view_idx = view_idx;
 408     op->view = view;
 409
 410     cs->ops->submit(cs);
 411 }
 412
 413 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
 414 {
 415     const struct wined3d_cs_set_depth_stencil_view *op = data;
 416     struct wined3d_device *device = cs->device;
 417     struct wined3d_rendertarget_view *prev;
 418
 419     if ((prev = cs->state.fb->depth_stencil))
 420     {
 421         struct wined3d_surface *prev_surface = wined3d_rendertarget_view_get_surface(prev);
 422
 423         if (prev_surface && (device->swapchains[0]->desc.flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
 424                 || prev_surface->container->flags & WINED3D_TEXTURE_DISCARD))
 425         {
 426             surface_modify_ds_location(prev_surface, WINED3D_LOCATION_DISCARDED, prev->width, prev->height);
 427             if (prev_surface == device->onscreen_depth_stencil)
 428             {
 429                 wined3d_texture_decref(device->onscreen_depth_stencil->container);
 430                 device->onscreen_depth_stencil = NULL;
 431             }
 432         }
 433     }
 434
 435     cs->fb.depth_stencil = op->view;
 436
 437     if (!prev != !op->view)
 438     {
 439         /* Swapping NULL / non NULL depth stencil affects the depth and tests */
 440         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
 441         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILENABLE));
 442         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
 443         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
 444     }
 445     else if (prev && (prev->format_flags & WINED3DFMT_FLAG_FLOAT)
 446             != (op->view->format_flags & WINED3DFMT_FLAG_FLOAT))
 447     {
 448         device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
 449     }
 450
 451     device_invalidate_state(device, STATE_FRAMEBUFFER);
 452 }
 453
 454 void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
 455 {
 456     struct wined3d_cs_set_depth_stencil_view *op;
 457
 458     op = cs->ops->require_space(cs, sizeof(*op));
 459     op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
 460     op->view = view;
 461
 462     cs->ops->submit(cs);
 463 }
 464
 465 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
 466 {
 467     const struct wined3d_cs_set_vertex_declaration *op = data;
 468
 469     cs->state.vertex_declaration = op->declaration;
 470     device_invalidate_state(cs->device, STATE_VDECL);
 471 }
 472
 473 void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs, struct wined3d_vertex_declaration *declaration)
 474 {
 475     struct wined3d_cs_set_vertex_declaration *op;
 476
 477     op = cs->ops->require_space(cs, sizeof(*op));
 478     op->opcode = WINED3D_CS_OP_SET_VERTEX_DECLARATION;
 479     op->declaration = declaration;
 480
 481     cs->ops->submit(cs);
 482 }
 483
 484 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs *cs, const void *data)
 485 {
 486     const struct wined3d_cs_set_stream_source *op = data;
 487     struct wined3d_stream_state *stream;
 488     struct wined3d_buffer *prev;
 489
 490     stream = &cs->state.streams[op->stream_idx];
 491     prev = stream->buffer;
 492     stream->buffer = op->buffer;
 493     stream->offset = op->offset;
 494     stream->stride = op->stride;
 495
 496     if (op->buffer)
 497         InterlockedIncrement(&op->buffer->resource.bind_count);
 498     if (prev)
 499         InterlockedDecrement(&prev->resource.bind_count);
 500
 501     device_invalidate_state(cs->device, STATE_STREAMSRC);
 502 }
 503
 504 void wined3d_cs_emit_set_stream_source(struct wined3d_cs *cs, UINT stream_idx,
 505         struct wined3d_buffer *buffer, UINT offset, UINT stride)
 506 {
 507     struct wined3d_cs_set_stream_source *op;
 508
 509     op = cs->ops->require_space(cs, sizeof(*op));
 510     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE;
 511     op->stream_idx = stream_idx;
 512     op->buffer = buffer;
 513     op->offset = offset;
 514     op->stride = stride;
 515
 516     cs->ops->submit(cs);
 517 }
 518
 519 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs *cs, const void *data)
 520 {
 521     const struct wined3d_cs_set_stream_source_freq *op = data;
 522     struct wined3d_stream_state *stream;
 523
 524     stream = &cs->state.streams[op->stream_idx];
 525     stream->frequency = op->frequency;
 526     stream->flags = op->flags;
 527
 528     device_invalidate_state(cs->device, STATE_STREAMSRC);
 529 }
 530
 531 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx, UINT frequency, UINT flags)
 532 {
 533     struct wined3d_cs_set_stream_source_freq *op;
 534
 535     op = cs->ops->require_space(cs, sizeof(*op));
 536     op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ;
 537     op->stream_idx = stream_idx;
 538     op->frequency = frequency;
 539     op->flags = flags;
 540
 541     cs->ops->submit(cs);
 542 }
 543
 544 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs *cs, const void *data)
 545 {
 546     const struct wined3d_cs_set_stream_output *op = data;
 547     struct wined3d_stream_output *stream;
 548     struct wined3d_buffer *prev;
 549
 550     stream = &cs->state.stream_output[op->stream_idx];
 551     prev = stream->buffer;
 552     stream->buffer = op->buffer;
 553     stream->offset = op->offset;
 554
 555     if (op->buffer)
 556         InterlockedIncrement(&op->buffer->resource.bind_count);
 557     if (prev)
 558         InterlockedDecrement(&prev->resource.bind_count);
 559 }
 560
 561 void wined3d_cs_emit_set_stream_output(struct wined3d_cs *cs, UINT stream_idx,
 562         struct wined3d_buffer *buffer, UINT offset)
 563 {
 564     struct wined3d_cs_set_stream_output *op;
 565
 566     op = cs->ops->require_space(cs, sizeof(*op));
 567     op->opcode = WINED3D_CS_OP_SET_STREAM_OUTPUT;
 568     op->stream_idx = stream_idx;
 569     op->buffer = buffer;
 570     op->offset = offset;
 571
 572     cs->ops->submit(cs);
 573 }
 574
 575 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
 576 {
 577     const struct wined3d_cs_set_index_buffer *op = data;
 578     struct wined3d_buffer *prev;
 579
 580     prev = cs->state.index_buffer;
 581     cs->state.index_buffer = op->buffer;
 582     cs->state.index_format = op->format_id;
 583
 584     if (op->buffer)
 585         InterlockedIncrement(&op->buffer->resource.bind_count);
 586     if (prev)
 587         InterlockedDecrement(&prev->resource.bind_count);
 588
 589     device_invalidate_state(cs->device, STATE_INDEXBUFFER);
 590 }
 591
 592 void wined3d_cs_emit_set_index_buffer(struct wined3d_cs *cs, struct wined3d_buffer *buffer,
 593         enum wined3d_format_id format_id)
 594 {
 595     struct wined3d_cs_set_index_buffer *op;
 596
 597     op = cs->ops->require_space(cs, sizeof(*op));
 598     op->opcode = WINED3D_CS_OP_SET_INDEX_BUFFER;
 599     op->buffer = buffer;
 600     op->format_id = format_id;
 601
 602     cs->ops->submit(cs);
 603 }
 604
 605 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs *cs, const void *data)
 606 {
 607     const struct wined3d_cs_set_constant_buffer *op = data;
 608     struct wined3d_buffer *prev;
 609
 610     prev = cs->state.cb[op->type][op->cb_idx];
 611     cs->state.cb[op->type][op->cb_idx] = op->buffer;
 612
 613     if (op->buffer)
 614         InterlockedIncrement(&op->buffer->resource.bind_count);
 615     if (prev)
 616         InterlockedDecrement(&prev->resource.bind_count);
 617
 618     device_invalidate_state(cs->device, STATE_CONSTANT_BUFFER(op->type));
 619 }
 620
 621 void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs *cs, enum wined3d_shader_type type,
 622         UINT cb_idx, struct wined3d_buffer *buffer)
 623 {
 624     struct wined3d_cs_set_constant_buffer *op;
 625
 626     op = cs->ops->require_space(cs, sizeof(*op));
 627     op->opcode = WINED3D_CS_OP_SET_CONSTANT_BUFFER;
 628     op->type = type;
 629     op->cb_idx = cb_idx;
 630     op->buffer = buffer;
 631
 632     cs->ops->submit(cs);
 633 }
 634
 635 static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
 636 {
 637     const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
 638     const struct wined3d_d3d_info *d3d_info = &cs->device->adapter->d3d_info;
 639     const struct wined3d_cs_set_texture *op = data;
 640     struct wined3d_texture *prev;
 641     BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
 642
 643     prev = cs->state.textures[op->stage];
 644     cs->state.textures[op->stage] = op->texture;
 645
 646     if (op->texture)
 647     {
 648         const struct wined3d_format *new_format = op->texture->resource.format;
 649         const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
 650         unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
 651         unsigned int new_fmt_flags = op->texture->resource.format_flags;
 652
 653         if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
 654             op->texture->sampler = op->stage;
 655
 656         if (!prev || op->texture->target != prev->target
 657                 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
 658                 && !(can_use_texture_swizzle(gl_info, new_format) && can_use_texture_swizzle(gl_info, old_format)))
 659                 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
 660             device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
 661
 662         if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
 663         {
 664             /* The source arguments for color and alpha ops have different
 665              * meanings when a NULL texture is bound, so the COLOR_OP and
 666              * ALPHA_OP have to be dirtified. */
 667             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
 668             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
 669         }
 670
 671         if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 672             new_use_color_key = TRUE;
 673     }
 674
 675     if (prev)
 676     {
 677         if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
 678         {
 679             unsigned int i;
 680
 681             /* Search for other stages the texture is bound to. Shouldn't
 682              * happen if applications bind textures to a single stage only. */
 683             TRACE("Searching for other stages the texture is bound to.\n");
 684             for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
 685             {
 686                 if (cs->state.textures[i] == prev)
 687                 {
 688                     TRACE("Texture is also bound to stage %u.\n", i);
 689                     prev->sampler = i;
 690                     break;
 691                 }
 692             }
 693         }
 694
 695         if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
 696         {
 697             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
 698             device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
 699         }
 700
 701         if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 702             old_use_color_key = TRUE;
 703     }
 704
 705     device_invalidate_state(cs->device, STATE_SAMPLER(op->stage));
 706
 707     if (new_use_color_key != old_use_color_key)
 708         device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
 709
 710     if (new_use_color_key)
 711         device_invalidate_state(cs->device, STATE_COLOR_KEY);
 712 }
 713
 714 void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
 715 {
 716     struct wined3d_cs_set_texture *op;
 717
 718     op = cs->ops->require_space(cs, sizeof(*op));
 719     op->opcode = WINED3D_CS_OP_SET_TEXTURE;
 720     op->stage = stage;
 721     op->texture = texture;
 722
 723     cs->ops->submit(cs);
 724 }
 725
 726 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs *cs, const void *data)
 727 {
 728     const struct wined3d_cs_set_shader_resource_view *op = data;
 729
 730     cs->state.shader_resource_view[op->type][op->view_idx] = op->view;
 731     device_invalidate_state(cs->device, STATE_SHADER_RESOURCE_BINDING);
 732 }
 733
 734 void wined3d_cs_emit_set_shader_resource_view(struct wined3d_cs *cs, enum wined3d_shader_type type,
 735         UINT view_idx, struct wined3d_shader_resource_view *view)
 736 {
 737     struct wined3d_cs_set_shader_resource_view *op;
 738
 739     op = cs->ops->require_space(cs, sizeof(*op));
 740     op->opcode = WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW;
 741     op->type = type;
 742     op->view_idx = view_idx;
 743     op->view = view;
 744
 745     cs->ops->submit(cs);
 746 }
 747
 748 static void wined3d_cs_exec_set_sampler(struct wined3d_cs *cs, const void *data)
 749 {
 750     const struct wined3d_cs_set_sampler *op = data;
 751
 752     cs->state.sampler[op->type][op->sampler_idx] = op->sampler;
 753     device_invalidate_state(cs->device, STATE_SHADER_RESOURCE_BINDING);
 754 }
 755
 756 void wined3d_cs_emit_set_sampler(struct wined3d_cs *cs, enum wined3d_shader_type type,
 757         UINT sampler_idx, struct wined3d_sampler *sampler)
 758 {
 759     struct wined3d_cs_set_sampler *op;
 760
 761     op = cs->ops->require_space(cs, sizeof(*op));
 762     op->opcode = WINED3D_CS_OP_SET_SAMPLER;
 763     op->type = type;
 764     op->sampler_idx = sampler_idx;
 765     op->sampler = sampler;
 766
 767     cs->ops->submit(cs);
 768 }
 769
 770 static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
 771 {
 772     const struct wined3d_cs_set_shader *op = data;
 773
 774     cs->state.shader[op->type] = op->shader;
 775     device_invalidate_state(cs->device, STATE_SHADER(op->type));
 776     device_invalidate_state(cs->device, STATE_SHADER_RESOURCE_BINDING);
 777 }
 778
 779 void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
 780 {
 781     struct wined3d_cs_set_shader *op;
 782
 783     op = cs->ops->require_space(cs, sizeof(*op));
 784     op->opcode = WINED3D_CS_OP_SET_SHADER;
 785     op->type = type;
 786     op->shader = shader;
 787
 788     cs->ops->submit(cs);
 789 }
 790
 791 static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
 792 {
 793     const struct wined3d_cs_set_render_state *op = data;
 794
 795     cs->state.render_states[op->state] = op->value;
 796     device_invalidate_state(cs->device, STATE_RENDER(op->state));
 797 }
 798
 799 void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
 800 {
 801     struct wined3d_cs_set_render_state *op;
 802
 803     op = cs->ops->require_space(cs, sizeof(*op));
 804     op->opcode = WINED3D_CS_OP_SET_RENDER_STATE;
 805     op->state = state;
 806     op->value = value;
 807
 808     cs->ops->submit(cs);
 809 }
 810
 811 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
 812 {
 813     const struct wined3d_cs_set_texture_state *op = data;
 814
 815     cs->state.texture_states[op->stage][op->state] = op->value;
 816     device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, op->state));
 817 }
 818
 819 void wined3d_cs_emit_set_texture_state(struct wined3d_cs *cs, UINT stage,
 820         enum wined3d_texture_stage_state state, DWORD value)
 821 {
 822     struct wined3d_cs_set_texture_state *op;
 823
 824     op = cs->ops->require_space(cs, sizeof(*op));
 825     op->opcode = WINED3D_CS_OP_SET_TEXTURE_STATE;
 826     op->stage = stage;
 827     op->state = state;
 828     op->value = value;
 829
 830     cs->ops->submit(cs);
 831 }
 832
 833 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
 834 {
 835     const struct wined3d_cs_set_sampler_state *op = data;
 836
 837     cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
 838     device_invalidate_state(cs->device, STATE_SAMPLER(op->sampler_idx));
 839 }
 840
 841 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
 842         enum wined3d_sampler_state state, DWORD value)
 843 {
 844     struct wined3d_cs_set_sampler_state *op;
 845
 846     op = cs->ops->require_space(cs, sizeof(*op));
 847     op->opcode = WINED3D_CS_OP_SET_SAMPLER_STATE;
 848     op->sampler_idx = sampler_idx;
 849     op->state = state;
 850     op->value = value;
 851
 852     cs->ops->submit(cs);
 853 }
 854
 855 static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
 856 {
 857     const struct wined3d_cs_set_transform *op = data;
 858
 859     cs->state.transforms[op->state] = op->matrix;
 860     if (op->state < WINED3D_TS_WORLD_MATRIX(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
 861         device_invalidate_state(cs->device, STATE_TRANSFORM(op->state));
 862 }
 863
 864 void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform_state state,
 865         const struct wined3d_matrix *matrix)
 866 {
 867     struct wined3d_cs_set_transform *op;
 868
 869     op = cs->ops->require_space(cs, sizeof(*op));
 870     op->opcode = WINED3D_CS_OP_SET_TRANSFORM;
 871     op->state = state;
 872     op->matrix = *matrix;
 873
 874     cs->ops->submit(cs);
 875 }
 876
 877 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
 878 {
 879     const struct wined3d_cs_set_clip_plane *op = data;
 880
 881     cs->state.clip_planes[op->plane_idx] = op->plane;
 882     device_invalidate_state(cs->device, STATE_CLIPPLANE(op->plane_idx));
 883 }
 884
 885 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
 886 {
 887     struct wined3d_cs_set_clip_plane *op;
 888
 889     op = cs->ops->require_space(cs, sizeof(*op));
 890     op->opcode = WINED3D_CS_OP_SET_CLIP_PLANE;
 891     op->plane_idx = plane_idx;
 892     op->plane = *plane;
 893
 894     cs->ops->submit(cs);
 895 }
 896
 897 static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
 898 {
 899     const struct wined3d_cs_set_color_key *op = data;
 900     struct wined3d_texture *texture = op->texture;
 901
 902     if (op->set)
 903     {
 904         switch (op->flags)
 905         {
 906             case WINED3D_CKEY_DST_BLT:
 907                 texture->async.dst_blt_color_key = op->color_key;
 908                 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
 909                 break;
 910
 911             case WINED3D_CKEY_DST_OVERLAY:
 912                 texture->async.dst_overlay_color_key = op->color_key;
 913                 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
 914                 break;
 915
 916             case WINED3D_CKEY_SRC_BLT:
 917                 if (texture == cs->state.textures[0])
 918                 {
 919                     device_invalidate_state(cs->device, STATE_COLOR_KEY);
 920                     if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
 921                         device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
 922                 }
 923
 924                 texture->async.src_blt_color_key = op->color_key;
 925                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
 926                 break;
 927
 928             case WINED3D_CKEY_SRC_OVERLAY:
 929                 texture->async.src_overlay_color_key = op->color_key;
 930                 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
 931                 break;
 932         }
 933     }
 934     else
 935     {
 936         switch (op->flags)
 937         {
 938             case WINED3D_CKEY_DST_BLT:
 939                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
 940                 break;
 941
 942             case WINED3D_CKEY_DST_OVERLAY:
 943                 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
 944                 break;
 945
 946             case WINED3D_CKEY_SRC_BLT:
 947                 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
 948                     device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
 949
 950                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
 951                 break;
 952
 953             case WINED3D_CKEY_SRC_OVERLAY:
 954                 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
 955                 break;
 956         }
 957     }
 958 }
 959
 960 void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
 961         WORD flags, const struct wined3d_color_key *color_key)
 962 {
 963     struct wined3d_cs_set_color_key *op;
 964
 965     op = cs->ops->require_space(cs, sizeof(*op));
 966     op->opcode = WINED3D_CS_OP_SET_COLOR_KEY;
 967     op->texture = texture;
 968     op->flags = flags;
 969     if (color_key)
 970     {
 971         op->color_key = *color_key;
 972         op->set = 1;
 973     }
 974     else
 975         op->set = 0;
 976
 977     cs->ops->submit(cs);
 978 }
 979
 980 static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
 981 {
 982     const struct wined3d_cs_set_material *op = data;
 983
 984     cs->state.material = op->material;
 985     device_invalidate_state(cs->device, STATE_MATERIAL);
 986 }
 987
 988 void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material)
 989 {
 990     struct wined3d_cs_set_material *op;
 991
 992     op = cs->ops->require_space(cs, sizeof(*op));
 993     op->opcode = WINED3D_CS_OP_SET_MATERIAL;
 994     op->material = *material;
 995
 996     cs->ops->submit(cs);
 997 }
 998
 999 static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
1000 {
1001     struct wined3d_adapter *adapter = cs->device->adapter;
1002     HRESULT hr;
1003
1004     state_cleanup(&cs->state);
1005     memset(&cs->state, 0, sizeof(cs->state));
1006     if (FAILED(hr = state_init(&cs->state, &cs->fb, &adapter->gl_info, &adapter->d3d_info,
1007             WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT)))
1008         ERR("Failed to initialize CS state, hr %#x.\n", hr);
1009 }
1010
1011 void wined3d_cs_emit_reset_state(struct wined3d_cs *cs)
1012 {
1013     struct wined3d_cs_reset_state *op;
1014
1015     op = cs->ops->require_space(cs, sizeof(*op));
1016     op->opcode = WINED3D_CS_OP_RESET_STATE;
1017
1018     cs->ops->submit(cs);
1019 }
1020
1021 static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data) =
1022 {
1023     /* WINED3D_CS_OP_PRESENT                    */ wined3d_cs_exec_present,
1024     /* WINED3D_CS_OP_CLEAR                      */ wined3d_cs_exec_clear,
1025     /* WINED3D_CS_OP_DRAW                       */ wined3d_cs_exec_draw,
1026     /* WINED3D_CS_OP_SET_PREDICATION            */ wined3d_cs_exec_set_predication,
1027     /* WINED3D_CS_OP_SET_VIEWPORT               */ wined3d_cs_exec_set_viewport,
1028     /* WINED3D_CS_OP_SET_SCISSOR_RECT           */ wined3d_cs_exec_set_scissor_rect,
1029     /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW      */ wined3d_cs_exec_set_rendertarget_view,
1030     /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW     */ wined3d_cs_exec_set_depth_stencil_view,
1031     /* WINED3D_CS_OP_SET_VERTEX_DECLARATION     */ wined3d_cs_exec_set_vertex_declaration,
1032     /* WINED3D_CS_OP_SET_STREAM_SOURCE          */ wined3d_cs_exec_set_stream_source,
1033     /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ     */ wined3d_cs_exec_set_stream_source_freq,
1034     /* WINED3D_CS_OP_SET_STREAM_OUTPUT          */ wined3d_cs_exec_set_stream_output,
1035     /* WINED3D_CS_OP_SET_INDEX_BUFFER           */ wined3d_cs_exec_set_index_buffer,
1036     /* WINED3D_CS_OP_SET_CONSTANT_BUFFER        */ wined3d_cs_exec_set_constant_buffer,
1037     /* WINED3D_CS_OP_SET_TEXTURE                */ wined3d_cs_exec_set_texture,
1038     /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW   */ wined3d_cs_exec_set_shader_resource_view,
1039     /* WINED3D_CS_OP_SET_SAMPLER                */ wined3d_cs_exec_set_sampler,
1040     /* WINED3D_CS_OP_SET_SHADER                 */ wined3d_cs_exec_set_shader,
1041     /* WINED3D_CS_OP_SET_RENDER_STATE           */ wined3d_cs_exec_set_render_state,
1042     /* WINED3D_CS_OP_SET_TEXTURE_STATE          */ wined3d_cs_exec_set_texture_state,
1043     /* WINED3D_CS_OP_SET_SAMPLER_STATE          */ wined3d_cs_exec_set_sampler_state,
1044     /* WINED3D_CS_OP_SET_TRANSFORM              */ wined3d_cs_exec_set_transform,
1045     /* WINED3D_CS_OP_SET_CLIP_PLANE             */ wined3d_cs_exec_set_clip_plane,
1046     /* WINED3D_CS_OP_SET_COLOR_KEY              */ wined3d_cs_exec_set_color_key,
1047     /* WINED3D_CS_OP_SET_MATERIAL               */ wined3d_cs_exec_set_material,
1048     /* WINED3D_CS_OP_RESET_STATE                */ wined3d_cs_exec_reset_state,
1049 };
1050
1051 static void *wined3d_cs_st_require_space(struct wined3d_cs *cs, size_t size)
1052 {
1053     if (size > cs->data_size)
1054     {
1055         void *new_data;
1056
1057         size = max( size, cs->data_size * 2 );
1058         if (!(new_data = HeapReAlloc(GetProcessHeap(), 0, cs->data, size)))
1059             return NULL;
1060
1061         cs->data_size = size;
1062         cs->data = new_data;
1063     }
1064
1065     return cs->data;
1066 }
1067
1068 static void wined3d_cs_st_submit(struct wined3d_cs *cs)
1069 {
1070     enum wined3d_cs_op opcode = *(const enum wined3d_cs_op *)cs->data;
1071
1072     wined3d_cs_op_handlers[opcode](cs, cs->data);
1073 }
1074
1075 static const struct wined3d_cs_ops wined3d_cs_st_ops =
1076 {
1077     wined3d_cs_st_require_space,
1078     wined3d_cs_st_submit,
1079 };
1080
1081 struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
1082 {
1083     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1084     struct wined3d_cs *cs;
1085
1086     if (!(cs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cs))))
1087         return NULL;
1088
1089     if (!(cs->fb.render_targets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1090             sizeof(*cs->fb.render_targets) * gl_info->limits.buffers)))
1091     {
1092         HeapFree(GetProcessHeap(), 0, cs);
1093         return NULL;
1094     }
1095
1096     if (FAILED(state_init(&cs->state, &cs->fb, gl_info, &device->adapter->d3d_info,
1097             WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT)))
1098     {
1099         HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
1100         HeapFree(GetProcessHeap(), 0, cs);
1101         return NULL;
1102     }
1103
1104     cs->ops = &wined3d_cs_st_ops;
1105     cs->device = device;
1106
1107     cs->data_size = WINED3D_INITIAL_CS_SIZE;
1108     if (!(cs->data = HeapAlloc(GetProcessHeap(), 0, cs->data_size)))
1109     {
1110         HeapFree(GetProcessHeap(), 0, cs);
1111         return NULL;
1112     }
1113
1114     return cs;
1115 }
1116
1117 void wined3d_cs_destroy(struct wined3d_cs *cs)
1118 {
1119     state_cleanup(&cs->state);
1120     HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
1121     HeapFree(GetProcessHeap(), 0, cs->data);
1122     HeapFree(GetProcessHeap(), 0, cs);
1123 }