?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
reg/tests: Test import with non-standard registry file headers.
[wine.git] / dlls / wined3d / cs.c
blob763fda7153274f4d9d36405cc7f3e58806ded2a8
1 /*
2 * Copyright 2013 Henri Verbeet for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21 #include "wined3d_private.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
24
25 #define WINED3D_INITIAL_CS_SIZE 4096
26
27 enum wined3d_cs_op
28 {
29 WINED3D_CS_OP_PRESENT,
30 WINED3D_CS_OP_CLEAR,
31 WINED3D_CS_OP_DISPATCH,
32 WINED3D_CS_OP_DRAW,
33 WINED3D_CS_OP_SET_PREDICATION,
34 WINED3D_CS_OP_SET_VIEWPORT,
35 WINED3D_CS_OP_SET_SCISSOR_RECT,
36 WINED3D_CS_OP_SET_RENDERTARGET_VIEW,
37 WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW,
38 WINED3D_CS_OP_SET_VERTEX_DECLARATION,
39 WINED3D_CS_OP_SET_STREAM_SOURCE,
40 WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ,
41 WINED3D_CS_OP_SET_STREAM_OUTPUT,
42 WINED3D_CS_OP_SET_INDEX_BUFFER,
43 WINED3D_CS_OP_SET_CONSTANT_BUFFER,
44 WINED3D_CS_OP_SET_TEXTURE,
45 WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW,
46 WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW,
47 WINED3D_CS_OP_SET_SAMPLER,
48 WINED3D_CS_OP_SET_SHADER,
49 WINED3D_CS_OP_SET_RASTERIZER_STATE,
50 WINED3D_CS_OP_SET_RENDER_STATE,
51 WINED3D_CS_OP_SET_TEXTURE_STATE,
52 WINED3D_CS_OP_SET_SAMPLER_STATE,
53 WINED3D_CS_OP_SET_TRANSFORM,
54 WINED3D_CS_OP_SET_CLIP_PLANE,
55 WINED3D_CS_OP_SET_COLOR_KEY,
56 WINED3D_CS_OP_SET_MATERIAL,
57 WINED3D_CS_OP_SET_LIGHT,
58 WINED3D_CS_OP_SET_LIGHT_ENABLE,
59 WINED3D_CS_OP_RESET_STATE,
60 WINED3D_CS_OP_CALLBACK,
61 WINED3D_CS_OP_QUERY_ISSUE,
62 WINED3D_CS_OP_PRELOAD_RESOURCE,
63 WINED3D_CS_OP_UNLOAD_RESOURCE,
64 WINED3D_CS_OP_MAP,
65 WINED3D_CS_OP_UNMAP,
66 };
67
68 struct wined3d_cs_present
69 {
70 enum wined3d_cs_op opcode;
71 HWND dst_window_override;
72 struct wined3d_swapchain *swapchain;
73 RECT src_rect;
74 RECT dst_rect;
75 DWORD flags;
76 };
77
78 struct wined3d_cs_clear
79 {
80 enum wined3d_cs_op opcode;
81 DWORD flags;
82 struct wined3d_color color;
83 float depth;
84 DWORD stencil;
85 unsigned int rect_count;
86 RECT rects[1];
87 };
88
89 struct wined3d_cs_dispatch
90 {
91 enum wined3d_cs_op opcode;
92 unsigned int group_count_x;
93 unsigned int group_count_y;
94 unsigned int group_count_z;
95 };
96
97 struct wined3d_cs_draw
98 {
99 enum wined3d_cs_op opcode;
100 int base_vertex_idx;
101 unsigned int start_idx;
102 unsigned int index_count;
103 unsigned int start_instance;
104 unsigned int instance_count;
105 BOOL indexed;
106 };
107
108 struct wined3d_cs_set_predication
109 {
110 enum wined3d_cs_op opcode;
111 struct wined3d_query *predicate;
112 BOOL value;
113 };
114
115 struct wined3d_cs_set_viewport
116 {
117 enum wined3d_cs_op opcode;
118 struct wined3d_viewport viewport;
119 };
120
121 struct wined3d_cs_set_scissor_rect
122 {
123 enum wined3d_cs_op opcode;
124 RECT rect;
125 };
126
127 struct wined3d_cs_set_rendertarget_view
128 {
129 enum wined3d_cs_op opcode;
130 unsigned int view_idx;
131 struct wined3d_rendertarget_view *view;
132 };
133
134 struct wined3d_cs_set_depth_stencil_view
135 {
136 enum wined3d_cs_op opcode;
137 struct wined3d_rendertarget_view *view;
138 };
139
140 struct wined3d_cs_set_vertex_declaration
141 {
142 enum wined3d_cs_op opcode;
143 struct wined3d_vertex_declaration *declaration;
144 };
145
146 struct wined3d_cs_set_stream_source
147 {
148 enum wined3d_cs_op opcode;
149 UINT stream_idx;
150 struct wined3d_buffer *buffer;
151 UINT offset;
152 UINT stride;
153 };
154
155 struct wined3d_cs_set_stream_source_freq
156 {
157 enum wined3d_cs_op opcode;
158 UINT stream_idx;
159 UINT frequency;
160 UINT flags;
161 };
162
163 struct wined3d_cs_set_stream_output
164 {
165 enum wined3d_cs_op opcode;
166 UINT stream_idx;
167 struct wined3d_buffer *buffer;
168 UINT offset;
169 };
170
171 struct wined3d_cs_set_index_buffer
172 {
173 enum wined3d_cs_op opcode;
174 struct wined3d_buffer *buffer;
175 enum wined3d_format_id format_id;
176 unsigned int offset;
177 };
178
179 struct wined3d_cs_set_constant_buffer
180 {
181 enum wined3d_cs_op opcode;
182 enum wined3d_shader_type type;
183 UINT cb_idx;
184 struct wined3d_buffer *buffer;
185 };
186
187 struct wined3d_cs_set_texture
188 {
189 enum wined3d_cs_op opcode;
190 UINT stage;
191 struct wined3d_texture *texture;
192 };
193
194 struct wined3d_cs_set_color_key
195 {
196 enum wined3d_cs_op opcode;
197 struct wined3d_texture *texture;
198 WORD flags;
199 WORD set;
200 struct wined3d_color_key color_key;
201 };
202
203 struct wined3d_cs_set_shader_resource_view
204 {
205 enum wined3d_cs_op opcode;
206 enum wined3d_shader_type type;
207 UINT view_idx;
208 struct wined3d_shader_resource_view *view;
209 };
210
211 struct wined3d_cs_set_unordered_access_view
212 {
213 enum wined3d_cs_op opcode;
214 enum wined3d_pipeline pipeline;
215 unsigned int view_idx;
216 struct wined3d_unordered_access_view *view;
217 };
218
219 struct wined3d_cs_set_sampler
220 {
221 enum wined3d_cs_op opcode;
222 enum wined3d_shader_type type;
223 UINT sampler_idx;
224 struct wined3d_sampler *sampler;
225 };
226
227 struct wined3d_cs_set_shader
228 {
229 enum wined3d_cs_op opcode;
230 enum wined3d_shader_type type;
231 struct wined3d_shader *shader;
232 };
233
234 struct wined3d_cs_set_rasterizer_state
235 {
236 enum wined3d_cs_op opcode;
237 struct wined3d_rasterizer_state *state;
238 };
239
240 struct wined3d_cs_set_render_state
241 {
242 enum wined3d_cs_op opcode;
243 enum wined3d_render_state state;
244 DWORD value;
245 };
246
247 struct wined3d_cs_set_texture_state
248 {
249 enum wined3d_cs_op opcode;
250 UINT stage;
251 enum wined3d_texture_stage_state state;
252 DWORD value;
253 };
254
255 struct wined3d_cs_set_sampler_state
256 {
257 enum wined3d_cs_op opcode;
258 UINT sampler_idx;
259 enum wined3d_sampler_state state;
260 DWORD value;
261 };
262
263 struct wined3d_cs_set_transform
264 {
265 enum wined3d_cs_op opcode;
266 enum wined3d_transform_state state;
267 struct wined3d_matrix matrix;
268 };
269
270 struct wined3d_cs_set_clip_plane
271 {
272 enum wined3d_cs_op opcode;
273 UINT plane_idx;
274 struct wined3d_vec4 plane;
275 };
276
277 struct wined3d_cs_set_material
278 {
279 enum wined3d_cs_op opcode;
280 struct wined3d_material material;
281 };
282
283 struct wined3d_cs_set_light
284 {
285 enum wined3d_cs_op opcode;
286 struct wined3d_light_info light;
287 };
288
289 struct wined3d_cs_set_light_enable
290 {
291 enum wined3d_cs_op opcode;
292 unsigned int idx;
293 BOOL enable;
294 };
295
296 struct wined3d_cs_reset_state
297 {
298 enum wined3d_cs_op opcode;
299 };
300
301 struct wined3d_cs_callback
302 {
303 enum wined3d_cs_op opcode;
304 void (*callback)(void *object);
305 void *object;
306 };
307
308 struct wined3d_cs_query_issue
309 {
310 enum wined3d_cs_op opcode;
311 struct wined3d_query *query;
312 DWORD flags;
313 };
314
315 struct wined3d_cs_preload_resource
316 {
317 enum wined3d_cs_op opcode;
318 struct wined3d_resource *resource;
319 };
320
321 struct wined3d_cs_unload_resource
322 {
323 enum wined3d_cs_op opcode;
324 struct wined3d_resource *resource;
325 };
326
327 struct wined3d_cs_map
328 {
329 enum wined3d_cs_op opcode;
330 struct wined3d_resource *resource;
331 unsigned int sub_resource_idx;
332 struct wined3d_map_desc *map_desc;
333 const struct wined3d_box *box;
334 DWORD flags;
335 HRESULT *hr;
336 };
337
338 struct wined3d_cs_unmap
339 {
340 enum wined3d_cs_op opcode;
341 struct wined3d_resource *resource;
342 unsigned int sub_resource_idx;
343 HRESULT *hr;
344 };
345
346 static void wined3d_cs_exec_present(struct wined3d_cs *cs, const void *data)
347 {
348 const struct wined3d_cs_present *op = data;
349 struct wined3d_swapchain *swapchain;
350 unsigned int i;
351
352 swapchain = op->swapchain;
353 wined3d_swapchain_set_window(swapchain, op->dst_window_override);
354
355 swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->flags);
356
357 wined3d_resource_release(&swapchain->front_buffer->resource);
358 for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
359 {
360 wined3d_resource_release(&swapchain->back_buffers[i]->resource);
361 }
362 }
363
364 void wined3d_cs_emit_present(struct wined3d_cs *cs, struct wined3d_swapchain *swapchain,
365 const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, DWORD flags)
366 {
367 struct wined3d_cs_present *op;
368 unsigned int i;
369
370 op = cs->ops->require_space(cs, sizeof(*op));
371 op->opcode = WINED3D_CS_OP_PRESENT;
372 op->dst_window_override = dst_window_override;
373 op->swapchain = swapchain;
374 op->src_rect = *src_rect;
375 op->dst_rect = *dst_rect;
376 op->flags = flags;
377
378 wined3d_resource_acquire(&swapchain->front_buffer->resource);
379 for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
380 {
381 wined3d_resource_acquire(&swapchain->back_buffers[i]->resource);
382 }
383
384 cs->ops->submit(cs);
385 }
386
387 static void wined3d_cs_exec_clear(struct wined3d_cs *cs, const void *data)
388 {
389 const struct wined3d_cs_clear *op = data;
390 const struct wined3d_state *state;
391 struct wined3d_device *device;
392 unsigned int i;
393 RECT draw_rect;
394
395 device = cs->device;
396 state = &device->state;
397 wined3d_get_draw_rect(state, &draw_rect);
398 device_clear_render_targets(device, device->adapter->gl_info.limits.buffers,
399 &device->fb, op->rect_count, op->rects, &draw_rect, op->flags,
400 &op->color, op->depth, op->stencil);
401
402 if (op->flags & WINED3DCLEAR_TARGET)
403 {
404 for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
405 {
406 if (state->fb->render_targets[i])
407 wined3d_resource_release(state->fb->render_targets[i]->resource);
408 }
409 }
410 if (op->flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
411 wined3d_resource_release(state->fb->depth_stencil->resource);
412 }
413
414 void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects,
415 DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
416 {
417 const struct wined3d_state *state = &cs->device->state;
418 struct wined3d_cs_clear *op;
419 unsigned int i;
420
421 op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]));
422 op->opcode = WINED3D_CS_OP_CLEAR;
423 op->flags = flags;
424 op->color = *color;
425 op->depth = depth;
426 op->stencil = stencil;
427 op->rect_count = rect_count;
428 memcpy(op->rects, rects, sizeof(*rects) * rect_count);
429
430 if (flags & WINED3DCLEAR_TARGET)
431 {
432 for (i = 0; i < cs->device->adapter->gl_info.limits.buffers; ++i)
433 {
434 if (state->fb->render_targets[i])
435 wined3d_resource_acquire(state->fb->render_targets[i]->resource);
436 }
437 }
438 if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
439 wined3d_resource_acquire(state->fb->depth_stencil->resource);
440
441 cs->ops->submit(cs);
442 }
443
444 static void acquire_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
445 {
446 struct wined3d_shader_sampler_map_entry *entry;
447 struct wined3d_shader_resource_view *view;
448 struct wined3d_shader *shader;
449 unsigned int i, j;
450
451 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
452 {
453 if (!(shader_mask & (1u << i)))
454 continue;
455
456 if (!(shader = state->shader[i]))
457 continue;
458
459 for (j = 0; j < WINED3D_MAX_CBS; ++j)
460 {
461 if (state->cb[i][j])
462 wined3d_resource_acquire(&state->cb[i][j]->resource);
463 }
464
465 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
466 {
467 entry = &shader->reg_maps.sampler_map.entries[j];
468
469 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
470 continue;
471
472 wined3d_resource_acquire(view->resource);
473 }
474 }
475 }
476
477 static void release_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
478 {
479 struct wined3d_shader_sampler_map_entry *entry;
480 struct wined3d_shader_resource_view *view;
481 struct wined3d_shader *shader;
482 unsigned int i, j;
483
484 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
485 {
486 if (!(shader_mask & (1u << i)))
487 continue;
488
489 if (!(shader = state->shader[i]))
490 continue;
491
492 for (j = 0; j < WINED3D_MAX_CBS; ++j)
493 {
494 if (state->cb[i][j])
495 wined3d_resource_release(&state->cb[i][j]->resource);
496 }
497
498 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
499 {
500 entry = &shader->reg_maps.sampler_map.entries[j];
501
502 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
503 continue;
504
505 wined3d_resource_release(view->resource);
506 }
507 }
508 }
509
510 static void acquire_unordered_access_resources(const struct wined3d_shader *shader,
511 struct wined3d_unordered_access_view * const *views)
512 {
513 unsigned int i;
514
515 if (!shader)
516 return;
517
518 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
519 {
520 if (!shader->reg_maps.uav_resource_info[i].type)
521 continue;
522
523 if (!views[i])
524 continue;
525
526 wined3d_resource_acquire(views[i]->resource);
527 }
528 }
529
530 static void release_unordered_access_resources(const struct wined3d_shader *shader,
531 struct wined3d_unordered_access_view * const *views)
532 {
533 unsigned int i;
534
535 if (!shader)
536 return;
537
538 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
539 {
540 if (!shader->reg_maps.uav_resource_info[i].type)
541 continue;
542
543 if (!views[i])
544 continue;
545
546 wined3d_resource_release(views[i]->resource);
547 }
548 }
549
550 static void wined3d_cs_exec_dispatch(struct wined3d_cs *cs, const void *data)
551 {
552 struct wined3d_state *state = &cs->device->state;
553 const struct wined3d_cs_dispatch *op = data;
554
555 dispatch_compute(cs->device, state,
556 op->group_count_x, op->group_count_y, op->group_count_z);
557
558 release_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
559 release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
560 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
561 }
562
563 void wined3d_cs_emit_dispatch(struct wined3d_cs *cs,
564 unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
565 {
566 const struct wined3d_state *state = &cs->device->state;
567 struct wined3d_cs_dispatch *op;
568
569 op = cs->ops->require_space(cs, sizeof(*op));
570 op->opcode = WINED3D_CS_OP_DISPATCH;
571 op->group_count_x = group_count_x;
572 op->group_count_y = group_count_y;
573 op->group_count_z = group_count_z;
574
575 acquire_shader_resources(state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
576 acquire_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_COMPUTE],
577 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
578
579 cs->ops->submit(cs);
580 }
581
582 static void wined3d_cs_exec_draw(struct wined3d_cs *cs, const void *data)
583 {
584 struct wined3d_state *state = &cs->device->state;
585 const struct wined3d_cs_draw *op = data;
586 unsigned int i;
587
588 if (!cs->device->adapter->gl_info.supported[ARB_DRAW_ELEMENTS_BASE_VERTEX]
589 && state->load_base_vertex_index != op->base_vertex_idx)
590 {
591 state->load_base_vertex_index = op->base_vertex_idx;
592 device_invalidate_state(cs->device, STATE_BASEVERTEXINDEX);
593 }
594
595 draw_primitive(cs->device, state, op->base_vertex_idx, op->start_idx,
596 op->index_count, op->start_instance, op->instance_count, op->indexed);
597
598 if (op->indexed)
599 wined3d_resource_release(&state->index_buffer->resource);
600 for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
601 {
602 if (state->streams[i].buffer)
603 wined3d_resource_release(&state->streams[i].buffer->resource);
604 }
605 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
606 {
607 if (state->textures[i])
608 wined3d_resource_release(&state->textures[i]->resource);
609 }
610 for (i = 0; i < cs->device->adapter->gl_info.limits.buffers; ++i)
611 {
612 if (state->fb->render_targets[i])
613 wined3d_resource_release(state->fb->render_targets[i]->resource);
614 }
615 if (state->fb->depth_stencil)
616 wined3d_resource_release(state->fb->depth_stencil->resource);
617 release_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
618 release_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
619 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
620 }
621
622 void wined3d_cs_emit_draw(struct wined3d_cs *cs, int base_vertex_idx, unsigned int start_idx,
623 unsigned int index_count, unsigned int start_instance, unsigned int instance_count, BOOL indexed)
624 {
625 const struct wined3d_state *state = &cs->device->state;
626 struct wined3d_cs_draw *op;
627 unsigned int i;
628
629 op = cs->ops->require_space(cs, sizeof(*op));
630 op->opcode = WINED3D_CS_OP_DRAW;
631 op->base_vertex_idx = base_vertex_idx;
632 op->start_idx = start_idx;
633 op->index_count = index_count;
634 op->start_instance = start_instance;
635 op->instance_count = instance_count;
636 op->indexed = indexed;
637
638 if (indexed)
639 wined3d_resource_acquire(&state->index_buffer->resource);
640 for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
641 {
642 if (state->streams[i].buffer)
643 wined3d_resource_acquire(&state->streams[i].buffer->resource);
644 }
645 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
646 {
647 if (state->textures[i])
648 wined3d_resource_acquire(&state->textures[i]->resource);
649 }
650 for (i = 0; i < cs->device->adapter->gl_info.limits.buffers; ++i)
651 {
652 if (state->fb->render_targets[i])
653 wined3d_resource_acquire(state->fb->render_targets[i]->resource);
654 }
655 if (state->fb->depth_stencil)
656 wined3d_resource_acquire(state->fb->depth_stencil->resource);
657 acquire_shader_resources(state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
658 acquire_unordered_access_resources(state->shader[WINED3D_SHADER_TYPE_PIXEL],
659 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
660
661 cs->ops->submit(cs);
662 }
663
664 static void wined3d_cs_exec_set_predication(struct wined3d_cs *cs, const void *data)
665 {
666 const struct wined3d_cs_set_predication *op = data;
667
668 cs->state.predicate = op->predicate;
669 cs->state.predicate_value = op->value;
670 }
671
672 void wined3d_cs_emit_set_predication(struct wined3d_cs *cs, struct wined3d_query *predicate, BOOL value)
673 {
674 struct wined3d_cs_set_predication *op;
675
676 op = cs->ops->require_space(cs, sizeof(*op));
677 op->opcode = WINED3D_CS_OP_SET_PREDICATION;
678 op->predicate = predicate;
679 op->value = value;
680
681 cs->ops->submit(cs);
682 }
683
684 static void wined3d_cs_exec_set_viewport(struct wined3d_cs *cs, const void *data)
685 {
686 const struct wined3d_cs_set_viewport *op = data;
687
688 cs->state.viewport = op->viewport;
689 device_invalidate_state(cs->device, STATE_VIEWPORT);
690 }
691
692 void wined3d_cs_emit_set_viewport(struct wined3d_cs *cs, const struct wined3d_viewport *viewport)
693 {
694 struct wined3d_cs_set_viewport *op;
695
696 op = cs->ops->require_space(cs, sizeof(*op));
697 op->opcode = WINED3D_CS_OP_SET_VIEWPORT;
698 op->viewport = *viewport;
699
700 cs->ops->submit(cs);
701 }
702
703 static void wined3d_cs_exec_set_scissor_rect(struct wined3d_cs *cs, const void *data)
704 {
705 const struct wined3d_cs_set_scissor_rect *op = data;
706
707 cs->state.scissor_rect = op->rect;
708 device_invalidate_state(cs->device, STATE_SCISSORRECT);
709 }
710
711 void wined3d_cs_emit_set_scissor_rect(struct wined3d_cs *cs, const RECT *rect)
712 {
713 struct wined3d_cs_set_scissor_rect *op;
714
715 op = cs->ops->require_space(cs, sizeof(*op));
716 op->opcode = WINED3D_CS_OP_SET_SCISSOR_RECT;
717 op->rect = *rect;
718
719 cs->ops->submit(cs);
720 }
721
722 static void wined3d_cs_exec_set_rendertarget_view(struct wined3d_cs *cs, const void *data)
723 {
724 const struct wined3d_cs_set_rendertarget_view *op = data;
725
726 cs->state.fb->render_targets[op->view_idx] = op->view;
727 device_invalidate_state(cs->device, STATE_FRAMEBUFFER);
728 }
729
730 void wined3d_cs_emit_set_rendertarget_view(struct wined3d_cs *cs, unsigned int view_idx,
731 struct wined3d_rendertarget_view *view)
732 {
733 struct wined3d_cs_set_rendertarget_view *op;
734
735 op = cs->ops->require_space(cs, sizeof(*op));
736 op->opcode = WINED3D_CS_OP_SET_RENDERTARGET_VIEW;
737 op->view_idx = view_idx;
738 op->view = view;
739
740 cs->ops->submit(cs);
741 }
742
743 static void wined3d_cs_exec_set_depth_stencil_view(struct wined3d_cs *cs, const void *data)
744 {
745 const struct wined3d_cs_set_depth_stencil_view *op = data;
746 struct wined3d_device *device = cs->device;
747 struct wined3d_rendertarget_view *prev;
748
749 if ((prev = cs->state.fb->depth_stencil))
750 {
751 struct wined3d_surface *prev_surface = wined3d_rendertarget_view_get_surface(prev);
752
753 if (prev_surface && (device->swapchains[0]->desc.flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
754 || prev_surface->container->flags & WINED3D_TEXTURE_DISCARD))
755 {
756 wined3d_texture_validate_location(prev_surface->container,
757 prev->sub_resource_idx, WINED3D_LOCATION_DISCARDED);
758 }
759 }
760
761 cs->fb.depth_stencil = op->view;
762
763 if (!prev != !op->view)
764 {
765 /* Swapping NULL / non NULL depth stencil affects the depth and tests */
766 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_ZENABLE));
767 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILENABLE));
768 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
769 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
770 }
771 else if (prev && (prev->format_flags & WINED3DFMT_FLAG_FLOAT)
772 != (op->view->format_flags & WINED3DFMT_FLAG_FLOAT))
773 {
774 device_invalidate_state(device, STATE_RENDER(WINED3D_RS_DEPTHBIAS));
775 }
776
777 device_invalidate_state(device, STATE_FRAMEBUFFER);
778 }
779
780 void wined3d_cs_emit_set_depth_stencil_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
781 {
782 struct wined3d_cs_set_depth_stencil_view *op;
783
784 op = cs->ops->require_space(cs, sizeof(*op));
785 op->opcode = WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW;
786 op->view = view;
787
788 cs->ops->submit(cs);
789 }
790
791 static void wined3d_cs_exec_set_vertex_declaration(struct wined3d_cs *cs, const void *data)
792 {
793 const struct wined3d_cs_set_vertex_declaration *op = data;
794
795 cs->state.vertex_declaration = op->declaration;
796 device_invalidate_state(cs->device, STATE_VDECL);
797 }
798
799 void wined3d_cs_emit_set_vertex_declaration(struct wined3d_cs *cs, struct wined3d_vertex_declaration *declaration)
800 {
801 struct wined3d_cs_set_vertex_declaration *op;
802
803 op = cs->ops->require_space(cs, sizeof(*op));
804 op->opcode = WINED3D_CS_OP_SET_VERTEX_DECLARATION;
805 op->declaration = declaration;
806
807 cs->ops->submit(cs);
808 }
809
810 static void wined3d_cs_exec_set_stream_source(struct wined3d_cs *cs, const void *data)
811 {
812 const struct wined3d_cs_set_stream_source *op = data;
813 struct wined3d_stream_state *stream;
814 struct wined3d_buffer *prev;
815
816 stream = &cs->state.streams[op->stream_idx];
817 prev = stream->buffer;
818 stream->buffer = op->buffer;
819 stream->offset = op->offset;
820 stream->stride = op->stride;
821
822 if (op->buffer)
823 InterlockedIncrement(&op->buffer->resource.bind_count);
824 if (prev)
825 InterlockedDecrement(&prev->resource.bind_count);
826
827 device_invalidate_state(cs->device, STATE_STREAMSRC);
828 }
829
830 void wined3d_cs_emit_set_stream_source(struct wined3d_cs *cs, UINT stream_idx,
831 struct wined3d_buffer *buffer, UINT offset, UINT stride)
832 {
833 struct wined3d_cs_set_stream_source *op;
834
835 op = cs->ops->require_space(cs, sizeof(*op));
836 op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE;
837 op->stream_idx = stream_idx;
838 op->buffer = buffer;
839 op->offset = offset;
840 op->stride = stride;
841
842 cs->ops->submit(cs);
843 }
844
845 static void wined3d_cs_exec_set_stream_source_freq(struct wined3d_cs *cs, const void *data)
846 {
847 const struct wined3d_cs_set_stream_source_freq *op = data;
848 struct wined3d_stream_state *stream;
849
850 stream = &cs->state.streams[op->stream_idx];
851 stream->frequency = op->frequency;
852 stream->flags = op->flags;
853
854 device_invalidate_state(cs->device, STATE_STREAMSRC);
855 }
856
857 void wined3d_cs_emit_set_stream_source_freq(struct wined3d_cs *cs, UINT stream_idx, UINT frequency, UINT flags)
858 {
859 struct wined3d_cs_set_stream_source_freq *op;
860
861 op = cs->ops->require_space(cs, sizeof(*op));
862 op->opcode = WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ;
863 op->stream_idx = stream_idx;
864 op->frequency = frequency;
865 op->flags = flags;
866
867 cs->ops->submit(cs);
868 }
869
870 static void wined3d_cs_exec_set_stream_output(struct wined3d_cs *cs, const void *data)
871 {
872 const struct wined3d_cs_set_stream_output *op = data;
873 struct wined3d_stream_output *stream;
874 struct wined3d_buffer *prev;
875
876 stream = &cs->state.stream_output[op->stream_idx];
877 prev = stream->buffer;
878 stream->buffer = op->buffer;
879 stream->offset = op->offset;
880
881 if (op->buffer)
882 InterlockedIncrement(&op->buffer->resource.bind_count);
883 if (prev)
884 InterlockedDecrement(&prev->resource.bind_count);
885 }
886
887 void wined3d_cs_emit_set_stream_output(struct wined3d_cs *cs, UINT stream_idx,
888 struct wined3d_buffer *buffer, UINT offset)
889 {
890 struct wined3d_cs_set_stream_output *op;
891
892 op = cs->ops->require_space(cs, sizeof(*op));
893 op->opcode = WINED3D_CS_OP_SET_STREAM_OUTPUT;
894 op->stream_idx = stream_idx;
895 op->buffer = buffer;
896 op->offset = offset;
897
898 cs->ops->submit(cs);
899 }
900
901 static void wined3d_cs_exec_set_index_buffer(struct wined3d_cs *cs, const void *data)
902 {
903 const struct wined3d_cs_set_index_buffer *op = data;
904 struct wined3d_buffer *prev;
905
906 prev = cs->state.index_buffer;
907 cs->state.index_buffer = op->buffer;
908 cs->state.index_format = op->format_id;
909 cs->state.index_offset = op->offset;
910
911 if (op->buffer)
912 InterlockedIncrement(&op->buffer->resource.bind_count);
913 if (prev)
914 InterlockedDecrement(&prev->resource.bind_count);
915
916 device_invalidate_state(cs->device, STATE_INDEXBUFFER);
917 }
918
919 void wined3d_cs_emit_set_index_buffer(struct wined3d_cs *cs, struct wined3d_buffer *buffer,
920 enum wined3d_format_id format_id, unsigned int offset)
921 {
922 struct wined3d_cs_set_index_buffer *op;
923
924 op = cs->ops->require_space(cs, sizeof(*op));
925 op->opcode = WINED3D_CS_OP_SET_INDEX_BUFFER;
926 op->buffer = buffer;
927 op->format_id = format_id;
928 op->offset = offset;
929
930 cs->ops->submit(cs);
931 }
932
933 static void wined3d_cs_exec_set_constant_buffer(struct wined3d_cs *cs, const void *data)
934 {
935 const struct wined3d_cs_set_constant_buffer *op = data;
936 struct wined3d_buffer *prev;
937
938 prev = cs->state.cb[op->type][op->cb_idx];
939 cs->state.cb[op->type][op->cb_idx] = op->buffer;
940
941 if (op->buffer)
942 InterlockedIncrement(&op->buffer->resource.bind_count);
943 if (prev)
944 InterlockedDecrement(&prev->resource.bind_count);
945
946 device_invalidate_state(cs->device, STATE_CONSTANT_BUFFER(op->type));
947 }
948
949 void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs *cs, enum wined3d_shader_type type,
950 UINT cb_idx, struct wined3d_buffer *buffer)
951 {
952 struct wined3d_cs_set_constant_buffer *op;
953
954 op = cs->ops->require_space(cs, sizeof(*op));
955 op->opcode = WINED3D_CS_OP_SET_CONSTANT_BUFFER;
956 op->type = type;
957 op->cb_idx = cb_idx;
958 op->buffer = buffer;
959
960 cs->ops->submit(cs);
961 }
962
963 static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data)
964 {
965 const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
966 const struct wined3d_d3d_info *d3d_info = &cs->device->adapter->d3d_info;
967 const struct wined3d_cs_set_texture *op = data;
968 struct wined3d_texture *prev;
969 BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
970
971 prev = cs->state.textures[op->stage];
972 cs->state.textures[op->stage] = op->texture;
973
974 if (op->texture)
975 {
976 const struct wined3d_format *new_format = op->texture->resource.format;
977 const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
978 unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
979 unsigned int new_fmt_flags = op->texture->resource.format_flags;
980
981 if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
982 op->texture->sampler = op->stage;
983
984 if (!prev || op->texture->target != prev->target
985 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
986 && !(can_use_texture_swizzle(gl_info, new_format) && can_use_texture_swizzle(gl_info, old_format)))
987 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
988 device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
989
990 if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
991 {
992 /* The source arguments for color and alpha ops have different
993 * meanings when a NULL texture is bound, so the COLOR_OP and
994 * ALPHA_OP have to be dirtified. */
995 device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
996 device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
997 }
998
999 if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1000 new_use_color_key = TRUE;
1001 }
1002
1003 if (prev)
1004 {
1005 if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
1006 {
1007 unsigned int i;
1008
1009 /* Search for other stages the texture is bound to. Shouldn't
1010 * happen if applications bind textures to a single stage only. */
1011 TRACE("Searching for other stages the texture is bound to.\n");
1012 for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
1013 {
1014 if (cs->state.textures[i] == prev)
1015 {
1016 TRACE("Texture is also bound to stage %u.\n", i);
1017 prev->sampler = i;
1018 break;
1019 }
1020 }
1021 }
1022
1023 if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
1024 {
1025 device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_COLOR_OP));
1026 device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, WINED3D_TSS_ALPHA_OP));
1027 }
1028
1029 if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1030 old_use_color_key = TRUE;
1031 }
1032
1033 device_invalidate_state(cs->device, STATE_SAMPLER(op->stage));
1034
1035 if (new_use_color_key != old_use_color_key)
1036 device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1037
1038 if (new_use_color_key)
1039 device_invalidate_state(cs->device, STATE_COLOR_KEY);
1040 }
1041
1042 void wined3d_cs_emit_set_texture(struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
1043 {
1044 struct wined3d_cs_set_texture *op;
1045
1046 op = cs->ops->require_space(cs, sizeof(*op));
1047 op->opcode = WINED3D_CS_OP_SET_TEXTURE;
1048 op->stage = stage;
1049 op->texture = texture;
1050
1051 cs->ops->submit(cs);
1052 }
1053
1054 static void wined3d_cs_exec_set_shader_resource_view(struct wined3d_cs *cs, const void *data)
1055 {
1056 const struct wined3d_cs_set_shader_resource_view *op = data;
1057 struct wined3d_shader_resource_view *prev;
1058
1059 prev = cs->state.shader_resource_view[op->type][op->view_idx];
1060 cs->state.shader_resource_view[op->type][op->view_idx] = op->view;
1061
1062 if (op->view)
1063 InterlockedIncrement(&op->view->resource->bind_count);
1064 if (prev)
1065 InterlockedDecrement(&prev->resource->bind_count);
1066
1067 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1068 device_invalidate_state(cs->device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1069 else
1070 device_invalidate_state(cs->device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1071 }
1072
1073 void wined3d_cs_emit_set_shader_resource_view(struct wined3d_cs *cs, enum wined3d_shader_type type,
1074 UINT view_idx, struct wined3d_shader_resource_view *view)
1075 {
1076 struct wined3d_cs_set_shader_resource_view *op;
1077
1078 op = cs->ops->require_space(cs, sizeof(*op));
1079 op->opcode = WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW;
1080 op->type = type;
1081 op->view_idx = view_idx;
1082 op->view = view;
1083
1084 cs->ops->submit(cs);
1085 }
1086
1087 static void wined3d_cs_exec_set_unordered_access_view(struct wined3d_cs *cs, const void *data)
1088 {
1089 const struct wined3d_cs_set_unordered_access_view *op = data;
1090 struct wined3d_unordered_access_view *prev;
1091
1092 prev = cs->state.unordered_access_view[op->pipeline][op->view_idx];
1093 cs->state.unordered_access_view[op->pipeline][op->view_idx] = op->view;
1094
1095 if (op->view)
1096 InterlockedIncrement(&op->view->resource->bind_count);
1097 if (prev)
1098 InterlockedDecrement(&prev->resource->bind_count);
1099
1100 device_invalidate_state(cs->device, STATE_UNORDERED_ACCESS_VIEW_BINDING(op->pipeline));
1101 }
1102
1103 void wined3d_cs_emit_set_unordered_access_view(struct wined3d_cs *cs, enum wined3d_pipeline pipeline,
1104 unsigned int view_idx, struct wined3d_unordered_access_view *view)
1105 {
1106 struct wined3d_cs_set_unordered_access_view *op;
1107
1108 op = cs->ops->require_space(cs, sizeof(*op));
1109 op->opcode = WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW;
1110 op->pipeline = pipeline;
1111 op->view_idx = view_idx;
1112 op->view = view;
1113
1114 cs->ops->submit(cs);
1115 }
1116
1117 static void wined3d_cs_exec_set_sampler(struct wined3d_cs *cs, const void *data)
1118 {
1119 const struct wined3d_cs_set_sampler *op = data;
1120
1121 cs->state.sampler[op->type][op->sampler_idx] = op->sampler;
1122 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1123 device_invalidate_state(cs->device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1124 else
1125 device_invalidate_state(cs->device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1126 }
1127
1128 void wined3d_cs_emit_set_sampler(struct wined3d_cs *cs, enum wined3d_shader_type type,
1129 UINT sampler_idx, struct wined3d_sampler *sampler)
1130 {
1131 struct wined3d_cs_set_sampler *op;
1132
1133 op = cs->ops->require_space(cs, sizeof(*op));
1134 op->opcode = WINED3D_CS_OP_SET_SAMPLER;
1135 op->type = type;
1136 op->sampler_idx = sampler_idx;
1137 op->sampler = sampler;
1138
1139 cs->ops->submit(cs);
1140 }
1141
1142 static void wined3d_cs_exec_set_shader(struct wined3d_cs *cs, const void *data)
1143 {
1144 const struct wined3d_cs_set_shader *op = data;
1145
1146 cs->state.shader[op->type] = op->shader;
1147 device_invalidate_state(cs->device, STATE_SHADER(op->type));
1148 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1149 device_invalidate_state(cs->device, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
1150 else
1151 device_invalidate_state(cs->device, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
1152 }
1153
1154 void wined3d_cs_emit_set_shader(struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
1155 {
1156 struct wined3d_cs_set_shader *op;
1157
1158 op = cs->ops->require_space(cs, sizeof(*op));
1159 op->opcode = WINED3D_CS_OP_SET_SHADER;
1160 op->type = type;
1161 op->shader = shader;
1162
1163 cs->ops->submit(cs);
1164 }
1165
1166 static void wined3d_cs_exec_set_rasterizer_state(struct wined3d_cs *cs, const void *data)
1167 {
1168 const struct wined3d_cs_set_rasterizer_state *op = data;
1169
1170 cs->state.rasterizer_state = op->state;
1171 device_invalidate_state(cs->device, STATE_FRONTFACE);
1172 }
1173
1174 void wined3d_cs_emit_set_rasterizer_state(struct wined3d_cs *cs,
1175 struct wined3d_rasterizer_state *rasterizer_state)
1176 {
1177 struct wined3d_cs_set_rasterizer_state *op;
1178
1179 op = cs->ops->require_space(cs, sizeof(*op));
1180 op->opcode = WINED3D_CS_OP_SET_RASTERIZER_STATE;
1181 op->state = rasterizer_state;
1182
1183 cs->ops->submit(cs);
1184 }
1185
1186 static void wined3d_cs_exec_set_render_state(struct wined3d_cs *cs, const void *data)
1187 {
1188 const struct wined3d_cs_set_render_state *op = data;
1189
1190 cs->state.render_states[op->state] = op->value;
1191 device_invalidate_state(cs->device, STATE_RENDER(op->state));
1192 }
1193
1194 void wined3d_cs_emit_set_render_state(struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
1195 {
1196 struct wined3d_cs_set_render_state *op;
1197
1198 op = cs->ops->require_space(cs, sizeof(*op));
1199 op->opcode = WINED3D_CS_OP_SET_RENDER_STATE;
1200 op->state = state;
1201 op->value = value;
1202
1203 cs->ops->submit(cs);
1204 }
1205
1206 static void wined3d_cs_exec_set_texture_state(struct wined3d_cs *cs, const void *data)
1207 {
1208 const struct wined3d_cs_set_texture_state *op = data;
1209
1210 cs->state.texture_states[op->stage][op->state] = op->value;
1211 device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, op->state));
1212 }
1213
1214 void wined3d_cs_emit_set_texture_state(struct wined3d_cs *cs, UINT stage,
1215 enum wined3d_texture_stage_state state, DWORD value)
1216 {
1217 struct wined3d_cs_set_texture_state *op;
1218
1219 op = cs->ops->require_space(cs, sizeof(*op));
1220 op->opcode = WINED3D_CS_OP_SET_TEXTURE_STATE;
1221 op->stage = stage;
1222 op->state = state;
1223 op->value = value;
1224
1225 cs->ops->submit(cs);
1226 }
1227
1228 static void wined3d_cs_exec_set_sampler_state(struct wined3d_cs *cs, const void *data)
1229 {
1230 const struct wined3d_cs_set_sampler_state *op = data;
1231
1232 cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
1233 device_invalidate_state(cs->device, STATE_SAMPLER(op->sampler_idx));
1234 }
1235
1236 void wined3d_cs_emit_set_sampler_state(struct wined3d_cs *cs, UINT sampler_idx,
1237 enum wined3d_sampler_state state, DWORD value)
1238 {
1239 struct wined3d_cs_set_sampler_state *op;
1240
1241 op = cs->ops->require_space(cs, sizeof(*op));
1242 op->opcode = WINED3D_CS_OP_SET_SAMPLER_STATE;
1243 op->sampler_idx = sampler_idx;
1244 op->state = state;
1245 op->value = value;
1246
1247 cs->ops->submit(cs);
1248 }
1249
1250 static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *data)
1251 {
1252 const struct wined3d_cs_set_transform *op = data;
1253
1254 cs->state.transforms[op->state] = op->matrix;
1255 if (op->state < WINED3D_TS_WORLD_MATRIX(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
1256 device_invalidate_state(cs->device, STATE_TRANSFORM(op->state));
1257 }
1258
1259 void wined3d_cs_emit_set_transform(struct wined3d_cs *cs, enum wined3d_transform_state state,
1260 const struct wined3d_matrix *matrix)
1261 {
1262 struct wined3d_cs_set_transform *op;
1263
1264 op = cs->ops->require_space(cs, sizeof(*op));
1265 op->opcode = WINED3D_CS_OP_SET_TRANSFORM;
1266 op->state = state;
1267 op->matrix = *matrix;
1268
1269 cs->ops->submit(cs);
1270 }
1271
1272 static void wined3d_cs_exec_set_clip_plane(struct wined3d_cs *cs, const void *data)
1273 {
1274 const struct wined3d_cs_set_clip_plane *op = data;
1275
1276 cs->state.clip_planes[op->plane_idx] = op->plane;
1277 device_invalidate_state(cs->device, STATE_CLIPPLANE(op->plane_idx));
1278 }
1279
1280 void wined3d_cs_emit_set_clip_plane(struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
1281 {
1282 struct wined3d_cs_set_clip_plane *op;
1283
1284 op = cs->ops->require_space(cs, sizeof(*op));
1285 op->opcode = WINED3D_CS_OP_SET_CLIP_PLANE;
1286 op->plane_idx = plane_idx;
1287 op->plane = *plane;
1288
1289 cs->ops->submit(cs);
1290 }
1291
1292 static void wined3d_cs_exec_set_color_key(struct wined3d_cs *cs, const void *data)
1293 {
1294 const struct wined3d_cs_set_color_key *op = data;
1295 struct wined3d_texture *texture = op->texture;
1296
1297 if (op->set)
1298 {
1299 switch (op->flags)
1300 {
1301 case WINED3D_CKEY_DST_BLT:
1302 texture->async.dst_blt_color_key = op->color_key;
1303 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
1304 break;
1305
1306 case WINED3D_CKEY_DST_OVERLAY:
1307 texture->async.dst_overlay_color_key = op->color_key;
1308 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
1309 break;
1310
1311 case WINED3D_CKEY_SRC_BLT:
1312 if (texture == cs->state.textures[0])
1313 {
1314 device_invalidate_state(cs->device, STATE_COLOR_KEY);
1315 if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1316 device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1317 }
1318
1319 texture->async.src_blt_color_key = op->color_key;
1320 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
1321 break;
1322
1323 case WINED3D_CKEY_SRC_OVERLAY:
1324 texture->async.src_overlay_color_key = op->color_key;
1325 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
1326 break;
1327 }
1328 }
1329 else
1330 {
1331 switch (op->flags)
1332 {
1333 case WINED3D_CKEY_DST_BLT:
1334 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
1335 break;
1336
1337 case WINED3D_CKEY_DST_OVERLAY:
1338 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
1339 break;
1340
1341 case WINED3D_CKEY_SRC_BLT:
1342 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1343 device_invalidate_state(cs->device, STATE_RENDER(WINED3D_RS_COLORKEYENABLE));
1344
1345 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
1346 break;
1347
1348 case WINED3D_CKEY_SRC_OVERLAY:
1349 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
1350 break;
1351 }
1352 }
1353 }
1354
1355 void wined3d_cs_emit_set_color_key(struct wined3d_cs *cs, struct wined3d_texture *texture,
1356 WORD flags, const struct wined3d_color_key *color_key)
1357 {
1358 struct wined3d_cs_set_color_key *op;
1359
1360 op = cs->ops->require_space(cs, sizeof(*op));
1361 op->opcode = WINED3D_CS_OP_SET_COLOR_KEY;
1362 op->texture = texture;
1363 op->flags = flags;
1364 if (color_key)
1365 {
1366 op->color_key = *color_key;
1367 op->set = 1;
1368 }
1369 else
1370 op->set = 0;
1371
1372 cs->ops->submit(cs);
1373 }
1374
1375 static void wined3d_cs_exec_set_material(struct wined3d_cs *cs, const void *data)
1376 {
1377 const struct wined3d_cs_set_material *op = data;
1378
1379 cs->state.material = op->material;
1380 device_invalidate_state(cs->device, STATE_MATERIAL);
1381 }
1382
1383 void wined3d_cs_emit_set_material(struct wined3d_cs *cs, const struct wined3d_material *material)
1384 {
1385 struct wined3d_cs_set_material *op;
1386
1387 op = cs->ops->require_space(cs, sizeof(*op));
1388 op->opcode = WINED3D_CS_OP_SET_MATERIAL;
1389 op->material = *material;
1390
1391 cs->ops->submit(cs);
1392 }
1393
1394 static void wined3d_cs_exec_set_light(struct wined3d_cs *cs, const void *data)
1395 {
1396 const struct wined3d_cs_set_light *op = data;
1397 struct wined3d_light_info *light_info;
1398 unsigned int light_idx, hash_idx;
1399
1400 light_idx = op->light.OriginalIndex;
1401
1402 if (!(light_info = wined3d_state_get_light(&cs->state, light_idx)))
1403 {
1404 TRACE("Adding new light.\n");
1405 if (!(light_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*light_info))))
1406 {
1407 ERR("Failed to allocate light info.\n");
1408 return;
1409 }
1410
1411 hash_idx = LIGHTMAP_HASHFUNC(light_idx);
1412 list_add_head(&cs->state.light_map[hash_idx], &light_info->entry);
1413 light_info->glIndex = -1;
1414 light_info->OriginalIndex = light_idx;
1415 }
1416
1417 if (light_info->glIndex != -1)
1418 {
1419 if (light_info->OriginalParms.type != op->light.OriginalParms.type)
1420 device_invalidate_state(cs->device, STATE_LIGHT_TYPE);
1421 device_invalidate_state(cs->device, STATE_ACTIVELIGHT(light_info->glIndex));
1422 }
1423
1424 light_info->OriginalParms = op->light.OriginalParms;
1425 light_info->position = op->light.position;
1426 light_info->direction = op->light.direction;
1427 light_info->exponent = op->light.exponent;
1428 light_info->cutoff = op->light.cutoff;
1429 }
1430
1431 void wined3d_cs_emit_set_light(struct wined3d_cs *cs, const struct wined3d_light_info *light)
1432 {
1433 struct wined3d_cs_set_light *op;
1434
1435 op = cs->ops->require_space(cs, sizeof(*op));
1436 op->opcode = WINED3D_CS_OP_SET_LIGHT;
1437 op->light = *light;
1438
1439 cs->ops->submit(cs);
1440 }
1441
1442 static void wined3d_cs_exec_set_light_enable(struct wined3d_cs *cs, const void *data)
1443 {
1444 const struct wined3d_cs_set_light_enable *op = data;
1445 struct wined3d_device *device = cs->device;
1446 struct wined3d_light_info *light_info;
1447 int prev_idx;
1448
1449 if (!(light_info = wined3d_state_get_light(&cs->state, op->idx)))
1450 {
1451 ERR("Light doesn't exist.\n");
1452 return;
1453 }
1454
1455 prev_idx = light_info->glIndex;
1456 wined3d_state_enable_light(&cs->state, &device->adapter->d3d_info, light_info, op->enable);
1457 if (light_info->glIndex != prev_idx)
1458 {
1459 device_invalidate_state(device, STATE_LIGHT_TYPE);
1460 device_invalidate_state(device, STATE_ACTIVELIGHT(op->enable ? light_info->glIndex : prev_idx));
1461 }
1462 }
1463
1464 void wined3d_cs_emit_set_light_enable(struct wined3d_cs *cs, unsigned int idx, BOOL enable)
1465 {
1466 struct wined3d_cs_set_light_enable *op;
1467
1468 op = cs->ops->require_space(cs, sizeof(*op));
1469 op->opcode = WINED3D_CS_OP_SET_LIGHT_ENABLE;
1470 op->idx = idx;
1471 op->enable = enable;
1472
1473 cs->ops->submit(cs);
1474 }
1475
1476 static void wined3d_cs_exec_reset_state(struct wined3d_cs *cs, const void *data)
1477 {
1478 struct wined3d_adapter *adapter = cs->device->adapter;
1479
1480 state_cleanup(&cs->state);
1481 memset(&cs->state, 0, sizeof(cs->state));
1482 state_init(&cs->state, &cs->fb, &adapter->gl_info, &adapter->d3d_info,
1483 WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
1484 }
1485
1486 void wined3d_cs_emit_reset_state(struct wined3d_cs *cs)
1487 {
1488 struct wined3d_cs_reset_state *op;
1489
1490 op = cs->ops->require_space(cs, sizeof(*op));
1491 op->opcode = WINED3D_CS_OP_RESET_STATE;
1492
1493 cs->ops->submit(cs);
1494 }
1495
1496 static void wined3d_cs_exec_callback(struct wined3d_cs *cs, const void *data)
1497 {
1498 const struct wined3d_cs_callback *op = data;
1499
1500 op->callback(op->object);
1501 }
1502
1503 static void wined3d_cs_emit_callback(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1504 {
1505 struct wined3d_cs_callback *op;
1506
1507 op = cs->ops->require_space(cs, sizeof(*op));
1508 op->opcode = WINED3D_CS_OP_CALLBACK;
1509 op->callback = callback;
1510 op->object = object;
1511
1512 cs->ops->submit(cs);
1513 }
1514
1515 void wined3d_cs_destroy_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1516 {
1517 wined3d_cs_emit_callback(cs, callback, object);
1518 }
1519
1520 void wined3d_cs_init_object(struct wined3d_cs *cs, void (*callback)(void *object), void *object)
1521 {
1522 wined3d_cs_emit_callback(cs, callback, object);
1523 }
1524
1525 static void wined3d_cs_exec_query_issue(struct wined3d_cs *cs, const void *data)
1526 {
1527 const struct wined3d_cs_query_issue *op = data;
1528 struct wined3d_query *query = op->query;
1529
1530 query->query_ops->query_issue(query, op->flags);
1531 }
1532
1533 void wined3d_cs_emit_query_issue(struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags)
1534 {
1535 struct wined3d_cs_query_issue *op;
1536
1537 op = cs->ops->require_space(cs, sizeof(*op));
1538 op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
1539 op->query = query;
1540 op->flags = flags;
1541
1542 cs->ops->submit(cs);
1543 }
1544
1545 static void wined3d_cs_exec_preload_resource(struct wined3d_cs *cs, const void *data)
1546 {
1547 const struct wined3d_cs_preload_resource *op = data;
1548 struct wined3d_resource *resource = op->resource;
1549
1550 resource->resource_ops->resource_preload(resource);
1551 wined3d_resource_release(resource);
1552 }
1553
1554 void wined3d_cs_emit_preload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
1555 {
1556 struct wined3d_cs_preload_resource *op;
1557
1558 op = cs->ops->require_space(cs, sizeof(*op));
1559 op->opcode = WINED3D_CS_OP_PRELOAD_RESOURCE;
1560 op->resource = resource;
1561
1562 wined3d_resource_acquire(resource);
1563
1564 cs->ops->submit(cs);
1565 }
1566
1567 static void wined3d_cs_exec_unload_resource(struct wined3d_cs *cs, const void *data)
1568 {
1569 const struct wined3d_cs_unload_resource *op = data;
1570 struct wined3d_resource *resource = op->resource;
1571
1572 resource->resource_ops->resource_unload(resource);
1573 wined3d_resource_release(resource);
1574 }
1575
1576 void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
1577 {
1578 struct wined3d_cs_unload_resource *op;
1579
1580 op = cs->ops->require_space(cs, sizeof(*op));
1581 op->opcode = WINED3D_CS_OP_UNLOAD_RESOURCE;
1582 op->resource = resource;
1583
1584 wined3d_resource_acquire(resource);
1585
1586 cs->ops->submit(cs);
1587 }
1588
1589 static void wined3d_cs_exec_map(struct wined3d_cs *cs, const void *data)
1590 {
1591 const struct wined3d_cs_map *op = data;
1592 struct wined3d_resource *resource = op->resource;
1593
1594 *op->hr = resource->resource_ops->resource_sub_resource_map(resource,
1595 op->sub_resource_idx, op->map_desc, op->box, op->flags);
1596 }
1597
1598 HRESULT wined3d_cs_map(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx,
1599 struct wined3d_map_desc *map_desc, const struct wined3d_box *box, unsigned int flags)
1600 {
1601 struct wined3d_cs_map *op;
1602 HRESULT hr;
1603
1604 op = cs->ops->require_space(cs, sizeof(*op));
1605 op->opcode = WINED3D_CS_OP_MAP;
1606 op->resource = resource;
1607 op->sub_resource_idx = sub_resource_idx;
1608 op->map_desc = map_desc;
1609 op->box = box;
1610 op->flags = flags;
1611 op->hr = &hr;
1612
1613 cs->ops->submit(cs);
1614
1615 return hr;
1616 }
1617
1618 static void wined3d_cs_exec_unmap(struct wined3d_cs *cs, const void *data)
1619 {
1620 const struct wined3d_cs_unmap *op = data;
1621 struct wined3d_resource *resource = op->resource;
1622
1623 *op->hr = resource->resource_ops->resource_sub_resource_unmap(resource, op->sub_resource_idx);
1624 }
1625
1626 HRESULT wined3d_cs_unmap(struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx)
1627 {
1628 struct wined3d_cs_unmap *op;
1629 HRESULT hr;
1630
1631 op = cs->ops->require_space(cs, sizeof(*op));
1632 op->opcode = WINED3D_CS_OP_UNMAP;
1633 op->resource = resource;
1634 op->sub_resource_idx = sub_resource_idx;
1635 op->hr = &hr;
1636
1637 cs->ops->submit(cs);
1638
1639 return hr;
1640 }
1641
1642 static void (* const wined3d_cs_op_handlers[])(struct wined3d_cs *cs, const void *data) =
1643 {
1644 /* WINED3D_CS_OP_PRESENT */ wined3d_cs_exec_present,
1645 /* WINED3D_CS_OP_CLEAR */ wined3d_cs_exec_clear,
1646 /* WINED3D_CS_OP_DISPATCH */ wined3d_cs_exec_dispatch,
1647 /* WINED3D_CS_OP_DRAW */ wined3d_cs_exec_draw,
1648 /* WINED3D_CS_OP_SET_PREDICATION */ wined3d_cs_exec_set_predication,
1649 /* WINED3D_CS_OP_SET_VIEWPORT */ wined3d_cs_exec_set_viewport,
1650 /* WINED3D_CS_OP_SET_SCISSOR_RECT */ wined3d_cs_exec_set_scissor_rect,
1651 /* WINED3D_CS_OP_SET_RENDERTARGET_VIEW */ wined3d_cs_exec_set_rendertarget_view,
1652 /* WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW */ wined3d_cs_exec_set_depth_stencil_view,
1653 /* WINED3D_CS_OP_SET_VERTEX_DECLARATION */ wined3d_cs_exec_set_vertex_declaration,
1654 /* WINED3D_CS_OP_SET_STREAM_SOURCE */ wined3d_cs_exec_set_stream_source,
1655 /* WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ */ wined3d_cs_exec_set_stream_source_freq,
1656 /* WINED3D_CS_OP_SET_STREAM_OUTPUT */ wined3d_cs_exec_set_stream_output,
1657 /* WINED3D_CS_OP_SET_INDEX_BUFFER */ wined3d_cs_exec_set_index_buffer,
1658 /* WINED3D_CS_OP_SET_CONSTANT_BUFFER */ wined3d_cs_exec_set_constant_buffer,
1659 /* WINED3D_CS_OP_SET_TEXTURE */ wined3d_cs_exec_set_texture,
1660 /* WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW */ wined3d_cs_exec_set_shader_resource_view,
1661 /* WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW */ wined3d_cs_exec_set_unordered_access_view,
1662 /* WINED3D_CS_OP_SET_SAMPLER */ wined3d_cs_exec_set_sampler,
1663 /* WINED3D_CS_OP_SET_SHADER */ wined3d_cs_exec_set_shader,
1664 /* WINED3D_CS_OP_SET_RASTERIZER_STATE */ wined3d_cs_exec_set_rasterizer_state,
1665 /* WINED3D_CS_OP_SET_RENDER_STATE */ wined3d_cs_exec_set_render_state,
1666 /* WINED3D_CS_OP_SET_TEXTURE_STATE */ wined3d_cs_exec_set_texture_state,
1667 /* WINED3D_CS_OP_SET_SAMPLER_STATE */ wined3d_cs_exec_set_sampler_state,
1668 /* WINED3D_CS_OP_SET_TRANSFORM */ wined3d_cs_exec_set_transform,
1669 /* WINED3D_CS_OP_SET_CLIP_PLANE */ wined3d_cs_exec_set_clip_plane,
1670 /* WINED3D_CS_OP_SET_COLOR_KEY */ wined3d_cs_exec_set_color_key,
1671 /* WINED3D_CS_OP_SET_MATERIAL */ wined3d_cs_exec_set_material,
1672 /* WINED3D_CS_OP_SET_LIGHT */ wined3d_cs_exec_set_light,
1673 /* WINED3D_CS_OP_SET_LIGHT_ENABLE */ wined3d_cs_exec_set_light_enable,
1674 /* WINED3D_CS_OP_RESET_STATE */ wined3d_cs_exec_reset_state,
1675 /* WINED3D_CS_OP_CALLBACK */ wined3d_cs_exec_callback,
1676 /* WINED3D_CS_OP_QUERY_ISSUE */ wined3d_cs_exec_query_issue,
1677 /* WINED3D_CS_OP_PRELOAD_RESOURCE */ wined3d_cs_exec_preload_resource,
1678 /* WINED3D_CS_OP_UNLOAD_RESOURCE */ wined3d_cs_exec_unload_resource,
1679 /* WINED3D_CS_OP_MAP */ wined3d_cs_exec_map,
1680 /* WINED3D_CS_OP_UNMAP */ wined3d_cs_exec_unmap,
1681 };
1682
1683 static void *wined3d_cs_st_require_space(struct wined3d_cs *cs, size_t size)
1684 {
1685 if (size > (cs->data_size - cs->end))
1686 {
1687 size_t new_size;
1688 void *new_data;
1689
1690 new_size = max(size, cs->data_size * 2);
1691 if (!cs->end)
1692 new_data = HeapReAlloc(GetProcessHeap(), 0, cs->data, new_size);
1693 else
1694 new_data = HeapAlloc(GetProcessHeap(), 0, new_size);
1695 if (!new_data)
1696 return NULL;
1697
1698 cs->data_size = new_size;
1699 cs->start = cs->end = 0;
1700 cs->data = new_data;
1701 }
1702
1703 cs->end += size;
1704
1705 return (BYTE *)cs->data + cs->start;
1706 }
1707
1708 static void wined3d_cs_st_submit(struct wined3d_cs *cs)
1709 {
1710 enum wined3d_cs_op opcode;
1711 size_t start;
1712 BYTE *data;
1713
1714 data = cs->data;
1715 start = cs->start;
1716 cs->start = cs->end;
1717
1718 opcode = *(const enum wined3d_cs_op *)&data[start];
1719 wined3d_cs_op_handlers[opcode](cs, &data[start]);
1720
1721 if (cs->data == data)
1722 cs->start = cs->end = start;
1723 else if (!start)
1724 HeapFree(GetProcessHeap(), 0, data);
1725 }
1726
1727 static void wined3d_cs_st_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p,
1728 unsigned int start_idx, unsigned int count, const void *constants)
1729 {
1730 struct wined3d_device *device = cs->device;
1731 unsigned int context_count;
1732 unsigned int i;
1733 size_t offset;
1734
1735 static const struct
1736 {
1737 size_t offset;
1738 size_t size;
1739 DWORD mask;
1740 }
1741 push_constant_info[] =
1742 {
1743 /* WINED3D_PUSH_CONSTANTS_VS_F */
1744 {FIELD_OFFSET(struct wined3d_state, vs_consts_f), sizeof(struct wined3d_vec4), WINED3D_SHADER_CONST_VS_F},
1745 /* WINED3D_PUSH_CONSTANTS_PS_F */
1746 {FIELD_OFFSET(struct wined3d_state, ps_consts_f), sizeof(struct wined3d_vec4), WINED3D_SHADER_CONST_PS_F},
1747 /* WINED3D_PUSH_CONSTANTS_VS_I */
1748 {FIELD_OFFSET(struct wined3d_state, vs_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_VS_I},
1749 /* WINED3D_PUSH_CONSTANTS_PS_I */
1750 {FIELD_OFFSET(struct wined3d_state, ps_consts_i), sizeof(struct wined3d_ivec4), WINED3D_SHADER_CONST_PS_I},
1751 /* WINED3D_PUSH_CONSTANTS_VS_B */
1752 {FIELD_OFFSET(struct wined3d_state, vs_consts_b), sizeof(BOOL), WINED3D_SHADER_CONST_VS_B},
1753 /* WINED3D_PUSH_CONSTANTS_PS_B */
1754 {FIELD_OFFSET(struct wined3d_state, ps_consts_b), sizeof(BOOL), WINED3D_SHADER_CONST_PS_B},
1755 };
1756
1757 if (p == WINED3D_PUSH_CONSTANTS_VS_F)
1758 device->shader_backend->shader_update_float_vertex_constants(device, start_idx, count);
1759 else if (p == WINED3D_PUSH_CONSTANTS_PS_F)
1760 device->shader_backend->shader_update_float_pixel_constants(device, start_idx, count);
1761
1762 offset = push_constant_info[p].offset + start_idx * push_constant_info[p].size;
1763 memcpy((BYTE *)&cs->state + offset, constants, count * push_constant_info[p].size);
1764 for (i = 0, context_count = device->context_count; i < context_count; ++i)
1765 {
1766 device->contexts[i]->constant_update_mask |= push_constant_info[p].mask;
1767 }
1768 }
1769
1770 static const struct wined3d_cs_ops wined3d_cs_st_ops =
1771 {
1772 wined3d_cs_st_require_space,
1773 wined3d_cs_st_submit,
1774 wined3d_cs_st_push_constants,
1775 };
1776
1777 struct wined3d_cs *wined3d_cs_create(struct wined3d_device *device)
1778 {
1779 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1780 struct wined3d_cs *cs;
1781
1782 if (!(cs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cs))))
1783 return NULL;
1784
1785 if (!(cs->fb.render_targets = wined3d_calloc(gl_info->limits.buffers, sizeof(*cs->fb.render_targets))))
1786 {
1787 HeapFree(GetProcessHeap(), 0, cs);
1788 return NULL;
1789 }
1790
1791 state_init(&cs->state, &cs->fb, gl_info, &device->adapter->d3d_info,
1792 WINED3D_STATE_NO_REF | WINED3D_STATE_INIT_DEFAULT);
1793
1794 cs->ops = &wined3d_cs_st_ops;
1795 cs->device = device;
1796
1797 cs->data_size = WINED3D_INITIAL_CS_SIZE;
1798 if (!(cs->data = HeapAlloc(GetProcessHeap(), 0, cs->data_size)))
1799 {
1800 state_cleanup(&cs->state);
1801 HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
1802 HeapFree(GetProcessHeap(), 0, cs);
1803 return NULL;
1804 }
1805
1806 return cs;
1807 }
1808
1809 void wined3d_cs_destroy(struct wined3d_cs *cs)
1810 {
1811 state_cleanup(&cs->state);
1812 HeapFree(GetProcessHeap(), 0, cs->fb.render_targets);
1813 HeapFree(GetProcessHeap(), 0, cs->data);
1814 HeapFree(GetProcessHeap(), 0, cs);
1815 }
Windows API implementation