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