ReactOS 0.4.15-dev-7931-gfd331f1
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;
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{
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{
400};
401
403{
406 unsigned int sub_resource_idx;
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
447static void wined3d_cs_exec_nop(struct wined3d_cs *cs, const void *data)
448{
449}
450
451static 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
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 {
510 pending = InterlockedCompareExchange(&cs->pending_presents, 0, 0);
511 }
512}
513
514static 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
536void 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
606
607 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
608}
609
610static 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
639 }
640 }
641}
642
643static 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
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
716static 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
770
771 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
772}
773
774static 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;
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
873void 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
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
916
917 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
918}
919
920static 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
941static 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
961static 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{
972
973 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
975 op->viewport = *viewport;
976
977 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
978}
979
980static 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
1000{
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{
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{
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
1087static 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;
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{
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
1147static 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;
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
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
1180static 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
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
1242static 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
1400static 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
1425static 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
1449static 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
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
1488static 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
1508static 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
1530static 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
1552static 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{
1565
1566 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1568 op->state = state;
1569 op->matrix = *matrix;
1570
1571 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1572}
1573
1574static 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{
1585
1586 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1588 op->plane_idx = plane_idx;
1589 op->plane = *plane;
1590
1591 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1592}
1593
1594static 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 {
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
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 {
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
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{
1661
1662 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
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
1677static 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{
1688
1689 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1691 op->material = *material;
1692
1693 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1694}
1695
1696static 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
1744static 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
1778static 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},
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
1821static 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{
1832 size_t size;
1833
1835 op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_push_constants, constants[size]),
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
1846static 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
1866static 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
1873static 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
1885void wined3d_cs_destroy_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1886{
1888}
1889
1890void wined3d_cs_init_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1891{
1893}
1894
1895static 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
1947static 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
1969static 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
1991static 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
2000HRESULT 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
2025static 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
2033HRESULT 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
2052static 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
2166error:
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
2194 wined3d_resource_acquire(dst_resource);
2195 if (src_resource)
2196 wined3d_resource_acquire(src_resource);
2197
2198 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2200 cs->ops->finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2201}
2202
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
2254done:
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;
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
2309no_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 {
2343 if (wined3d_texture_load_location(texture, sub_resource_idx, context, texture->resource.map_binding))
2344 wined3d_texture_invalidate_location(texture, sub_resource_idx, ~texture->resource.map_binding);
2345 else
2346 ERR("Failed to load location %s.\n", wined3d_debug_location(texture->resource.map_binding));
2347 }
2349
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
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
2396static 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
2427static 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
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
2460static 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)
2512static 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 */
2518static 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
2543static 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
2565static void wined3d_cs_st_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
2566{
2567}
2568
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
2599static 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)
2611static 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)
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)
2687static 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 */
2696static 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
2704static 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
2717{
2718#if defined(STAGING_CSMT)
2719 wined3d_cs_mt_check_space,
2720#endif /* STAGING_CSMT */
2725};
2726
2727static void poll_queries(struct wined3d_cs *cs)
2728{
2729 struct wined3d_query *query, *cursor;
2730
2731 LIST_FOR_EACH_ENTRY_SAFE(query, cursor, &cs->query_poll_list, struct wined3d_query, poll_list_entry)
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
2759}
2760
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;
2768 HMODULE wined3d_module;
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 {
2785 poll = 0;
2786 }
2787
2788 queue = &cs->queue[WINED3D_CS_QUEUE_MAP];
2790 {
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
2817 tail += FIELD_OFFSET(struct wined3d_cs_packet, data[packet->size]);
2818 tail &= (WINED3D_CS_QUEUE_SIZE - 1);
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
2879fail:
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 outqueuenode * tail
Definition: adnsresfilter.c:66
struct outqueuenode * head
Definition: adnsresfilter.c:66
static int state
Definition: maze.c:121
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:71
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedExchange
Definition: armddk.h:54
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define ARRAY_SIZE(A)
Definition: main.h:33
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static int list_empty(struct list_entry *head)
Definition: list.h:58
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
static void list_init(struct list_entry *head)
Definition: list.h:51
#define FIXME(fmt,...)
Definition: debug.h:111
#define ERR(fmt,...)
Definition: debug.h:110
Definition: _queue.h:67
static void wined3d_cs_exec_unload_resource(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1969
void wined3d_cs_emit_set_light(struct wined3d_cs *cs, const struct wined3d_light_info *light)
Definition: cs.c:1733
static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1212
void wined3d_cs_destroy(struct wined3d_cs *cs)
Definition: cs.c:2885
void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
Definition: cs.c:1496
void wined3d_cs_emit_set_light_enable(struct wined3d_cs *cs, unsigned int idx, BOOL enable)
Definition: cs.c:1766
void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
Definition: cs.c:1437
static BOOL wined3d_cs_queue_is_empty(const struct wined3d_cs *cs, const struct wined3d_cs_queue *queue)
Definition: cs.c:2580
static DWORD WINAPI wined3d_cs_run(void *ctx)
Definition: cs.c:2761
void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material)
Definition: cs.c:1685
void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs *cs, const RECT *rect)
Definition: cs.c:988
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 wined3d_cs_st_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
Definition: cs.c:2565
static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1508
static void poll_queries(struct wined3d_cs *cs)
Definition: cs.c:2727
static void wined3d_cs_exec_push_constants(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1821
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 void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1068
static void wined3d_cs_exec_preload_resource(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1947
void wined3d_cs_emit_query_issue(struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags)
Definition: cs.c:1934
void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs, struct wined3d_vertex_declaration *declaration)
Definition: cs.c:1076
static void wined3d_cs_st_submit(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
Definition: cs.c:2543
static void wined3d_cs_queue_submit(struct wined3d_cs_queue *queue, struct wined3d_cs *cs)
Definition: cs.c:2586
wined3d_cs_op
Definition: cs.c:28
@ WINED3D_CS_OP_MAP
Definition: cs.c:68
@ WINED3D_CS_OP_SET_SCISSOR_RECT
Definition: cs.c:37
@ WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
Definition: cs.c:73
@ WINED3D_CS_OP_COPY_UAV_COUNTER
Definition: cs.c:74
@ WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
Definition: cs.c:47
@ WINED3D_CS_OP_SET_TEXTURE_STATE
Definition: cs.c:54
@ WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
Definition: cs.c:72
@ WINED3D_CS_OP_SET_LIGHT
Definition: cs.c:60
@ WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
Definition: cs.c:39
@ WINED3D_CS_OP_STOP
Definition: cs.c:76
@ WINED3D_CS_OP_SET_INDEX_BUFFER
Definition: cs.c:44
@ WINED3D_CS_OP_SET_VERTEX_DECLARATION
Definition: cs.c:40
@ WINED3D_CS_OP_SET_STREAM_OUTPUT
Definition: cs.c:43
@ WINED3D_CS_OP_CLEAR
Definition: cs.c:31
@ WINED3D_CS_OP_NOP
Definition: cs.c:29
@ WINED3D_CS_OP_QUERY_ISSUE
Definition: cs.c:65
@ WINED3D_CS_OP_SET_LIGHT_ENABLE
Definition: cs.c:61
@ WINED3D_CS_OP_SET_TEXTURE
Definition: cs.c:46
@ WINED3D_CS_OP_PUSH_CONSTANTS
Definition: cs.c:62
@ WINED3D_CS_OP_UPDATE_SUB_RESOURCE
Definition: cs.c:71
@ WINED3D_CS_OP_RESET_STATE
Definition: cs.c:63
@ WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
Definition: cs.c:48
@ WINED3D_CS_OP_SET_VIEWPORT
Definition: cs.c:36
@ WINED3D_CS_OP_UNMAP
Definition: cs.c:69
@ WINED3D_CS_OP_PRELOAD_RESOURCE
Definition: cs.c:66
@ WINED3D_CS_OP_SET_RENDER_STATE
Definition: cs.c:53
@ WINED3D_CS_OP_SET_RASTERIZER_STATE
Definition: cs.c:52
@ WINED3D_CS_OP_SET_SAMPLER
Definition: cs.c:49
@ WINED3D_CS_OP_SET_STREAM_SOURCE
Definition: cs.c:41
@ WINED3D_CS_OP_BLT_SUB_RESOURCE
Definition: cs.c:70
@ WINED3D_CS_OP_DRAW
Definition: cs.c:33
@ WINED3D_CS_OP_SET_RENDERTARGET_VIEW
Definition: cs.c:38
@ WINED3D_CS_OP_SET_BLEND_STATE
Definition: cs.c:51
@ WINED3D_CS_OP_SET_CONSTANT_BUFFER
Definition: cs.c:45
@ WINED3D_CS_OP_SET_MATERIAL
Definition: cs.c:59
@ WINED3D_CS_OP_FLUSH
Definition: cs.c:34
@ WINED3D_CS_OP_SET_CLIP_PLANE
Definition: cs.c:57
@ WINED3D_CS_OP_SET_SAMPLER_STATE
Definition: cs.c:55
@ WINED3D_CS_OP_PRESENT
Definition: cs.c:30
@ WINED3D_CS_OP_SET_PREDICATION
Definition: cs.c:35
@ WINED3D_CS_OP_GENERATE_MIPMAPS
Definition: cs.c:75
@ WINED3D_CS_OP_SET_SHADER
Definition: cs.c:50
@ WINED3D_CS_OP_DISPATCH
Definition: cs.c:32
@ WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
Definition: cs.c:42
@ WINED3D_CS_OP_UNLOAD_RESOURCE
Definition: cs.c:67
@ WINED3D_CS_OP_SET_COLOR_KEY
Definition: cs.c:58
@ WINED3D_CS_OP_SET_TRANSFORM
Definition: cs.c:56
@ WINED3D_CS_OP_CALLBACK
Definition: cs.c:64
static void wined3d_cs_emit_stop(struct wined3d_cs *cs)
Definition: cs.c:2449
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_map(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1991
static void wined3d_cs_exec_set_scissor_rect(struct wined3d_cs *cs, const void *data)
Definition: cs.c:980
static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1488
static void * wined3d_cs_queue_require_space(struct wined3d_cs_queue *queue, size_t size, struct wined3d_cs *cs)
Definition: cs.c:2625
static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
Definition: cs.c:941
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_wait_event(struct wined3d_cs *cs)
Definition: cs.c:2742
static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1020
static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1594
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
static void wined3d_cs_exec_set_stream_source(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1087
static void acquire_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
Definition: cs.c:610
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
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
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
void wined3d_cs_emit_set_rasterizer_state(struct wined3d_cs *cs, struct wined3d_rasterizer_state *rasterizer_state)
Definition: cs.c:1476
static void wined3d_cs_exec_flush(struct wined3d_cs *cs, const void *data)
Definition: cs.c:920
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
static void wined3d_cs_exec_set_light_enable(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1744
static void wined3d_cs_exec_nop(struct wined3d_cs *cs, const void *data)
Definition: cs.c:447
static void wined3d_cs_mt_submit(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
Definition: cs.c:2599
static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
Definition: cs.c:774
static const struct wined3d_cs_ops wined3d_cs_st_ops
Definition: cs.c:2569
void wined3d_cs_emit_preload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
Definition: cs.c:1956
static void wined3d_cs_exec_add_dirty_texture_region(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2332
static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1180
void wined3d_cs_emit_add_dirty_texture_region(struct wined3d_cs *cs, struct wined3d_texture *texture, unsigned int layer)
Definition: cs.c:2353
void wined3d_cs_emit_update_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch, unsigned int slice_pitch)
Definition: cs.c:2260
#define WINED3D_INITIAL_CS_SIZE
Definition: cs.c:25
static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1425
void wined3d_cs_emit_set_viewport(struct wined3d_cs *cs, const struct wined3d_viewport *viewport)
Definition: cs.c:969
static void wined3d_cs_exec_blt_sub_resource(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2052
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_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
static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1530
static void wined3d_cs_exec_clear_unordered_access_view(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2368
static void wined3d_cs_exec_copy_uav_counter(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2396
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
static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1846
void wined3d_cs_emit_reset_state(struct wined3d_cs *cs)
Definition: cs.c:1856
static void wined3d_cs_emit_callback(struct wined3d_cs *cs, void(*callback)(void *object), void *object)
Definition: cs.c:1873
size_t size
Definition: cs.c:1781
static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1333
static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1574
void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
Definition: cs.c:1978
static void wined3d_cs_exec_set_viewport(struct wined3d_cs *cs, const void *data)
Definition: cs.c:961
void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
Definition: cs.c:1321
static const struct @272 wined3d_cs_push_constant_info[]
static void wined3d_cs_exec_unmap(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2025
void wined3d_cs_emit_dispatch_indirect(struct wined3d_cs *cs, struct wined3d_buffer *buffer, unsigned int offset)
Definition: cs.c:756
static void wined3d_cs_exec_set_stream_output(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1147
static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1468
static void wined3d_cs_mt_finish(struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
Definition: cs.c:2704
static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1242
void wined3d_cs_emit_set_blend_state(struct wined3d_cs *cs, struct wined3d_blend_state *state)
Definition: cs.c:1457
void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *dst_resource, unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box, struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
Definition: cs.c:2172
static void wined3d_cs_exec_callback(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1866
static void wined3d_cs_exec_set_sampler(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1400
void wined3d_cs_destroy_object(struct wined3d_cs *cs, void(*callback)(void *object), void *object)
Definition: cs.c:1885
size_t offset
Definition: cs.c:1780
void wined3d_cs_emit_flush(struct wined3d_cs *cs)
Definition: cs.c:930
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
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
static void * wined3d_cs_st_require_space(struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
Definition: cs.c:2518
static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
Definition: cs.c:514
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
void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view, const RECT *rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
Definition: cs.c:574
void wined3d_cs_emit_set_stream_output(struct wined3d_cs *cs, UINT stream_idx, struct wined3d_buffer *buffer, UINT offset)
Definition: cs.c:1166
static const struct wined3d_cs_ops wined3d_cs_mt_ops
Definition: cs.c:2716
static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2203
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
void wined3d_cs_emit_generate_mipmaps(struct wined3d_cs *cs, struct wined3d_shader_resource_view *view)
Definition: cs.c:2436
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
static void acquire_unordered_access_resources(const struct wined3d_shader *shader, struct wined3d_unordered_access_view *const *views)
Definition: cs.c:676
DWORD mask
Definition: cs.c:1782
static void wined3d_cs_exec_dispatch(struct wined3d_cs *cs, const void *data)
Definition: cs.c:716
static void acquire_graphics_pipeline_resources(const struct wined3d_state *state, BOOL indexed, const struct wined3d_gl_info *gl_info)
Definition: cs.c:839
void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx, struct wined3d_rendertarget_view *view)
Definition: cs.c:1007
void wined3d_cs_init_object(struct wined3d_cs *cs, void(*callback)(void *object), void *object)
Definition: cs.c:1890
static void wined3d_cs_st_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p, unsigned int start_idx, unsigned int count, const void *constants)
Definition: cs.c:1800
static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1122
static void acquire_compute_pipeline_resources(const struct wined3d_state *state)
Definition: cs.c:731
void wined3d_cs_emit_set_predication(struct wined3d_cs *cs, struct wined3d_query *predicate, BOOL value)
Definition: cs.c:949
static void release_unordered_access_resources(const struct wined3d_shader *shader, struct wined3d_unordered_access_view *const *views)
Definition: cs.c:696
static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data)
Definition: cs.c:999
static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1677
static void wined3d_cs_exec_generate_mipmaps(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2427
static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1552
static void release_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
Definition: cs.c:643
void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
Definition: cs.c:1057
struct wined3d_cs * wined3d_cs_create(struct wined3d_device *device)
Definition: cs.c:2828
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(*const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data)
Definition: cs.c:2460
static void wined3d_cs_exec_set_light(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1696
static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
Definition: cs.c:451
void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
Definition: cs.c:1582
static void wined3d_cs_exec_set_blend_state(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1449
static void wined3d_cs_exec_query_issue(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1895
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
static void wined3d_cs_exec_set_unordered_access_view(struct wined3d_cs *cs, const void *data)
Definition: cs.c:1366
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
void state_init(void *ipp)
Definition: dhclient.c:210
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
UINT op
Definition: effect.c:236
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
void wined3d_buffer_copy(struct wined3d_buffer *dst_buffer, unsigned int dst_offset, struct wined3d_buffer *src_buffer, unsigned int src_offset, unsigned int size)
Definition: buffer.c:1195
BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer, struct wined3d_context *context, DWORD location)
Definition: buffer.c:641
void wined3d_buffer_invalidate_location(struct wined3d_buffer *buffer, DWORD location)
Definition: buffer.c:130
struct wined3d_context * context_acquire(const struct wined3d_device *device, struct wined3d_texture *texture, unsigned int sub_resource_idx)
Definition: context.c:4242
void dispatch_compute(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_dispatch_parameters *parameters)
Definition: context.c:4327
void context_release(struct wined3d_context *context)
Definition: context.c:1571
void draw_primitive(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters)
Definition: context.c:4924
void device_invalidate_state(const struct wined3d_device *device, DWORD state)
Definition: device.c:5263
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
void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
Definition: texture.c:1546
BOOL wined3d_texture_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
Definition: texture.c:229
void wined3d_texture_invalidate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:159
void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
Definition: texture.c:868
void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, const struct wined3d_context *context, const struct wined3d_box *box, const struct wined3d_const_bo_address *data, unsigned int row_pitch, unsigned int slice_pitch)
Definition: texture.c:1696
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
void wined3d_texture_validate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:135
const char * debug_box(const struct wined3d_box *box)
Definition: utils.c:3939
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
unsigned int idx
Definition: utils.c:41
const char * wined3d_debug_location(DWORD location)
Definition: utils.c:6396
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
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
void shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view)
Definition: view.c:851
void wined3d_unordered_access_view_set_counter(struct wined3d_unordered_access_view *view, unsigned int value)
Definition: view.c:1046
#define CloseHandle
Definition: compat.h:739
#define FreeLibrary(x)
Definition: compat.h:748
PPEB Peb
Definition: dllmain.c:27
BOOL WINAPI GetModuleHandleExW(IN DWORD dwFlags, IN LPCWSTR lpwModuleName OPTIONAL, OUT HMODULE *phModule)
Definition: loader.c:866
VOID WINAPI FreeLibraryAndExitThread(HMODULE hLibModule, DWORD dwExitCode)
Definition: loader.c:507
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:137
#define assert(x)
Definition: debug.h:53
#define INFINITE
Definition: serial.h:102
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
return adapter
GLuint start
Definition: gl.h:1545
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
GLint level
Definition: gl.h:1546
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
unsigned int GLenum
Definition: gl.h:150
#define GL_POINTS
Definition: gl.h:190
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
int GLint
Definition: gl.h:156
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint texture
Definition: glext.h:6295
GLsizei stride
Definition: glext.h:5848
GLuint buffer
Definition: glext.h:5915
GLuint color
Definition: glext.h:6243
GLuint sampler
Definition: glext.h:7283
GLuint shader
Definition: glext.h:6030
GLuint GLenum matrix
Definition: glext.h:9407
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
GLbitfield flags
Definition: glext.h:7161
GLenum const GLvoid * addr
Definition: glext.h:9621
GLfloat GLfloat p
Definition: glext.h:8902
GLboolean enable
Definition: glext.h:11120
GLenum GLuint GLint GLint layer
Definition: glext.h:7007
GLint GLfloat GLint stencil
Definition: glext.h:6260
GLintptr offset
Definition: glext.h:5920
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
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
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
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
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
#define cs
Definition: i386-dis.c:442
const char cursor[]
Definition: icontest.c:13
#define InterlockedCompareExchange
Definition: interlocked.h:104
#define FAILED(hr)
Definition: intsafe.h:51
#define NtCurrentTeb
uint32_t entry
Definition: isohybrid.c:63
#define resource
Definition: kernel32.h:9
if(dx< 0)
Definition: linetemp.h:194
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static IPrintDialogCallback callback
Definition: printdlg.c:326
constants
Definition: resource.c:29
static LARGE_INTEGER * frequency
Definition: time.c:106
static UINT format_id
Definition: clipboard.c:1343
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI ULONG NTAPI RtlIsCriticalSectionLockedByThread(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define BOOL
Definition: nt_native.h:43
long LONG
Definition: pedump.c:60
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
& rect
Definition: startmenu.cpp:1413
PVOID LoaderLock
Definition: ntddk_ex.h:295
Definition: palette.c:468
Definition: http.c:7252
Definition: devices.h:37
Definition: dhcpd.h:135
Definition: parse.h:23
struct wined3d_resource resource
enum wined3d_cs_op opcode
Definition: cs.c:416
struct wined3d_texture * texture
Definition: cs.c:417
struct wined3d_resource * dst_resource
Definition: cs.c:391
struct wined3d_blt_fx fx
Definition: cs.c:398
enum wined3d_cs_op opcode
Definition: cs.c:390
struct wined3d_box src_box
Definition: cs.c:396
struct wined3d_resource * src_resource
Definition: cs.c:394
unsigned int src_sub_resource_idx
Definition: cs.c:395
struct wined3d_box dst_box
Definition: cs.c:393
enum wined3d_texture_filter_type filter
Definition: cs.c:399
unsigned int dst_sub_resource_idx
Definition: cs.c:392
void * object
Definition: cs.c:347
enum wined3d_cs_op opcode
Definition: cs.c:345
void(* callback)(void *object)
Definition: cs.c:346
struct wined3d_unordered_access_view * view
Definition: cs.c:424
enum wined3d_cs_op opcode
Definition: cs.c:423
struct wined3d_uvec4 clear_value
Definition: cs.c:425
float depth
Definition: cs.c:109
unsigned int rt_count
Definition: cs.c:105
RECT rects[1]
Definition: cs.c:112
unsigned int rect_count
Definition: cs.c:111
DWORD stencil
Definition: cs.c:110
RECT draw_rect
Definition: cs.c:107
struct wined3d_fb_state * fb
Definition: cs.c:106
DWORD flags
Definition: cs.c:104