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