1 /**************************************************************************
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "util/u_memory.h"
29 #include "util/u_simple_list.h"
30 #include "util/u_format.h"
32 #include "pipe/p_format.h"
33 #include "pipe/p_screen.h"
36 #include "tr_dump_state.h"
38 #include "tr_buffer.h"
39 #include "tr_screen.h"
40 #include "tr_texture.h"
43 static INLINE
struct pipe_buffer
*
44 trace_buffer_unwrap(struct trace_context
*tr_ctx
,
45 struct pipe_buffer
*buffer
)
47 struct trace_screen
*tr_scr
= trace_screen(tr_ctx
->base
.screen
);
48 struct trace_buffer
*tr_buf
;
53 tr_buf
= trace_buffer(buffer
);
55 assert(tr_buf
->buffer
);
56 assert(tr_buf
->buffer
->screen
== tr_scr
->screen
);
58 return tr_buf
->buffer
;
62 static INLINE
struct pipe_texture
*
63 trace_texture_unwrap(struct trace_context
*tr_ctx
,
64 struct pipe_texture
*texture
)
66 struct trace_texture
*tr_tex
;
71 tr_tex
= trace_texture(texture
);
73 assert(tr_tex
->texture
);
74 return tr_tex
->texture
;
78 static INLINE
struct pipe_surface
*
79 trace_surface_unwrap(struct trace_context
*tr_ctx
,
80 struct pipe_surface
*surface
)
82 struct trace_screen
*tr_scr
= trace_screen(tr_ctx
->base
.screen
);
83 struct trace_surface
*tr_surf
;
88 assert(surface
->texture
);
92 tr_surf
= trace_surface(surface
);
94 assert(tr_surf
->surface
);
95 assert(tr_surf
->surface
->texture
->screen
== tr_scr
->screen
);
97 return tr_surf
->surface
;
102 trace_context_draw_block(struct trace_context
*tr_ctx
, int flag
)
106 pipe_mutex_lock(tr_ctx
->draw_mutex
);
108 if (tr_ctx
->draw_blocker
& flag
) {
109 tr_ctx
->draw_blocked
|= flag
;
110 } else if ((tr_ctx
->draw_rule
.blocker
& flag
) &&
111 (tr_ctx
->draw_blocker
& 4)) {
112 boolean block
= FALSE
;
113 debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__
,
114 (void *) tr_ctx
->draw_rule
.fs
, (void *) tr_ctx
->curr
.fs
,
115 (void *) tr_ctx
->draw_rule
.vs
, (void *) tr_ctx
->curr
.vs
,
116 (void *) tr_ctx
->draw_rule
.surf
, 0,
117 (void *) tr_ctx
->draw_rule
.tex
, 0);
118 if (tr_ctx
->draw_rule
.fs
&&
119 tr_ctx
->draw_rule
.fs
== tr_ctx
->curr
.fs
)
121 if (tr_ctx
->draw_rule
.vs
&&
122 tr_ctx
->draw_rule
.vs
== tr_ctx
->curr
.vs
)
124 if (tr_ctx
->draw_rule
.surf
&&
125 tr_ctx
->draw_rule
.surf
== tr_ctx
->curr
.zsbuf
)
127 if (tr_ctx
->draw_rule
.surf
)
128 for (k
= 0; k
< tr_ctx
->curr
.nr_cbufs
; k
++)
129 if (tr_ctx
->draw_rule
.surf
== tr_ctx
->curr
.cbufs
[k
])
131 if (tr_ctx
->draw_rule
.tex
) {
132 for (k
= 0; k
< tr_ctx
->curr
.num_texs
; k
++)
133 if (tr_ctx
->draw_rule
.tex
== tr_ctx
->curr
.tex
[k
])
135 for (k
= 0; k
< tr_ctx
->curr
.num_vert_texs
; k
++) {
136 if (tr_ctx
->draw_rule
.tex
== tr_ctx
->curr
.vert_tex
[k
]) {
143 tr_ctx
->draw_blocked
|= (flag
| 4);
146 if (tr_ctx
->draw_blocked
)
147 trace_rbug_notify_draw_blocked(tr_ctx
);
149 /* wait for rbug to clear the blocked flag */
150 while (tr_ctx
->draw_blocked
& flag
) {
151 tr_ctx
->draw_blocked
|= flag
;
152 #ifdef PIPE_THREAD_HAVE_CONDVAR
153 pipe_condvar_wait(tr_ctx
->draw_cond
, tr_ctx
->draw_mutex
);
155 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
156 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
159 pipe_mutex_lock(tr_ctx
->draw_mutex
);
163 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
167 trace_context_draw_arrays(struct pipe_context
*_pipe
,
168 unsigned mode
, unsigned start
, unsigned count
)
170 struct trace_context
*tr_ctx
= trace_context(_pipe
);
171 struct pipe_context
*pipe
= tr_ctx
->pipe
;
173 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
176 trace_context_draw_block(tr_ctx
, 1);
178 trace_dump_call_begin("pipe_context", "draw_arrays");
180 trace_dump_arg(ptr
, pipe
);
181 trace_dump_arg(uint
, mode
);
182 trace_dump_arg(uint
, start
);
183 trace_dump_arg(uint
, count
);
185 pipe
->draw_arrays(pipe
, mode
, start
, count
);
187 trace_dump_call_end();
189 trace_context_draw_block(tr_ctx
, 2);
194 trace_context_draw_elements(struct pipe_context
*_pipe
,
195 struct pipe_buffer
*_indexBuffer
,
197 unsigned mode
, unsigned start
, unsigned count
)
199 struct trace_context
*tr_ctx
= trace_context(_pipe
);
200 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
201 struct pipe_context
*pipe
= tr_ctx
->pipe
;
202 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
204 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
207 trace_context_draw_block(tr_ctx
, 1);
209 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
211 trace_dump_call_begin("pipe_context", "draw_elements");
213 trace_dump_arg(ptr
, pipe
);
214 trace_dump_arg(ptr
, indexBuffer
);
215 trace_dump_arg(uint
, indexSize
);
216 trace_dump_arg(uint
, mode
);
217 trace_dump_arg(uint
, start
);
218 trace_dump_arg(uint
, count
);
220 pipe
->draw_elements(pipe
, indexBuffer
, indexSize
, mode
, start
, count
);
222 trace_dump_call_end();
224 trace_context_draw_block(tr_ctx
, 2);
229 trace_context_draw_range_elements(struct pipe_context
*_pipe
,
230 struct pipe_buffer
*_indexBuffer
,
238 struct trace_context
*tr_ctx
= trace_context(_pipe
);
239 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
240 struct pipe_context
*pipe
= tr_ctx
->pipe
;
241 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
243 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
246 trace_context_draw_block(tr_ctx
, 1);
248 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
250 trace_dump_call_begin("pipe_context", "draw_range_elements");
252 trace_dump_arg(ptr
, pipe
);
253 trace_dump_arg(ptr
, indexBuffer
);
254 trace_dump_arg(uint
, indexSize
);
255 trace_dump_arg(uint
, minIndex
);
256 trace_dump_arg(uint
, maxIndex
);
257 trace_dump_arg(uint
, mode
);
258 trace_dump_arg(uint
, start
);
259 trace_dump_arg(uint
, count
);
261 pipe
->draw_range_elements(pipe
,
263 indexSize
, minIndex
, maxIndex
,
266 trace_dump_call_end();
268 trace_context_draw_block(tr_ctx
, 2);
272 static INLINE
struct pipe_query
*
273 trace_context_create_query(struct pipe_context
*_pipe
,
276 struct trace_context
*tr_ctx
= trace_context(_pipe
);
277 struct pipe_context
*pipe
= tr_ctx
->pipe
;
278 struct pipe_query
*result
;
280 trace_dump_call_begin("pipe_context", "create_query");
282 trace_dump_arg(ptr
, pipe
);
283 trace_dump_arg(uint
, query_type
);
285 result
= pipe
->create_query(pipe
, query_type
);
287 trace_dump_ret(ptr
, result
);
289 trace_dump_call_end();
296 trace_context_destroy_query(struct pipe_context
*_pipe
,
297 struct pipe_query
*query
)
299 struct trace_context
*tr_ctx
= trace_context(_pipe
);
300 struct pipe_context
*pipe
= tr_ctx
->pipe
;
302 trace_dump_call_begin("pipe_context", "destroy_query");
304 trace_dump_arg(ptr
, pipe
);
305 trace_dump_arg(ptr
, query
);
307 pipe
->destroy_query(pipe
, query
);
309 trace_dump_call_end();
314 trace_context_begin_query(struct pipe_context
*_pipe
,
315 struct pipe_query
*query
)
317 struct trace_context
*tr_ctx
= trace_context(_pipe
);
318 struct pipe_context
*pipe
= tr_ctx
->pipe
;
320 trace_dump_call_begin("pipe_context", "begin_query");
322 trace_dump_arg(ptr
, pipe
);
323 trace_dump_arg(ptr
, query
);
325 pipe
->begin_query(pipe
, query
);
327 trace_dump_call_end();
332 trace_context_end_query(struct pipe_context
*_pipe
,
333 struct pipe_query
*query
)
335 struct trace_context
*tr_ctx
= trace_context(_pipe
);
336 struct pipe_context
*pipe
= tr_ctx
->pipe
;
338 trace_dump_call_begin("pipe_context", "end_query");
340 trace_dump_arg(ptr
, pipe
);
341 trace_dump_arg(ptr
, query
);
343 pipe
->end_query(pipe
, query
);
345 trace_dump_call_end();
349 static INLINE boolean
350 trace_context_get_query_result(struct pipe_context
*_pipe
,
351 struct pipe_query
*query
,
355 struct trace_context
*tr_ctx
= trace_context(_pipe
);
356 struct pipe_context
*pipe
= tr_ctx
->pipe
;
360 trace_dump_call_begin("pipe_context", "get_query_result");
362 trace_dump_arg(ptr
, pipe
);
364 _result
= pipe
->get_query_result(pipe
, query
, wait
, presult
);
367 trace_dump_arg(uint
, result
);
368 trace_dump_ret(bool, _result
);
370 trace_dump_call_end();
377 trace_context_create_blend_state(struct pipe_context
*_pipe
,
378 const struct pipe_blend_state
*state
)
380 struct trace_context
*tr_ctx
= trace_context(_pipe
);
381 struct pipe_context
*pipe
= tr_ctx
->pipe
;
384 trace_dump_call_begin("pipe_context", "create_blend_state");
386 trace_dump_arg(ptr
, pipe
);
387 trace_dump_arg(blend_state
, state
);
389 result
= pipe
->create_blend_state(pipe
, state
);
391 trace_dump_ret(ptr
, result
);
393 trace_dump_call_end();
400 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
403 struct trace_context
*tr_ctx
= trace_context(_pipe
);
404 struct pipe_context
*pipe
= tr_ctx
->pipe
;
406 trace_dump_call_begin("pipe_context", "bind_blend_state");
408 trace_dump_arg(ptr
, pipe
);
409 trace_dump_arg(ptr
, state
);
411 pipe
->bind_blend_state(pipe
, state
);
413 trace_dump_call_end();
418 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
421 struct trace_context
*tr_ctx
= trace_context(_pipe
);
422 struct pipe_context
*pipe
= tr_ctx
->pipe
;
424 trace_dump_call_begin("pipe_context", "delete_blend_state");
426 trace_dump_arg(ptr
, pipe
);
427 trace_dump_arg(ptr
, state
);
429 pipe
->delete_blend_state(pipe
, state
);
431 trace_dump_call_end();
436 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
437 const struct pipe_sampler_state
*state
)
439 struct trace_context
*tr_ctx
= trace_context(_pipe
);
440 struct pipe_context
*pipe
= tr_ctx
->pipe
;
443 trace_dump_call_begin("pipe_context", "create_sampler_state");
445 trace_dump_arg(ptr
, pipe
);
446 trace_dump_arg(sampler_state
, state
);
448 result
= pipe
->create_sampler_state(pipe
, state
);
450 trace_dump_ret(ptr
, result
);
452 trace_dump_call_end();
459 trace_context_bind_fragment_sampler_states(struct pipe_context
*_pipe
,
463 struct trace_context
*tr_ctx
= trace_context(_pipe
);
464 struct pipe_context
*pipe
= tr_ctx
->pipe
;
466 trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
468 trace_dump_arg(ptr
, pipe
);
469 trace_dump_arg(uint
, num_states
);
470 trace_dump_arg_array(ptr
, states
, num_states
);
472 pipe
->bind_fragment_sampler_states(pipe
, num_states
, states
);
474 trace_dump_call_end();
479 trace_context_bind_vertex_sampler_states(struct pipe_context
*_pipe
,
483 struct trace_context
*tr_ctx
= trace_context(_pipe
);
484 struct pipe_context
*pipe
= tr_ctx
->pipe
;
486 trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
488 trace_dump_arg(ptr
, pipe
);
489 trace_dump_arg(uint
, num_states
);
490 trace_dump_arg_array(ptr
, states
, num_states
);
492 pipe
->bind_vertex_sampler_states(pipe
, num_states
, states
);
494 trace_dump_call_end();
499 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
502 struct trace_context
*tr_ctx
= trace_context(_pipe
);
503 struct pipe_context
*pipe
= tr_ctx
->pipe
;
505 trace_dump_call_begin("pipe_context", "delete_sampler_state");
507 trace_dump_arg(ptr
, pipe
);
508 trace_dump_arg(ptr
, state
);
510 pipe
->delete_sampler_state(pipe
, state
);
512 trace_dump_call_end();
517 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
518 const struct pipe_rasterizer_state
*state
)
520 struct trace_context
*tr_ctx
= trace_context(_pipe
);
521 struct pipe_context
*pipe
= tr_ctx
->pipe
;
524 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
526 trace_dump_arg(ptr
, pipe
);
527 trace_dump_arg(rasterizer_state
, state
);
529 result
= pipe
->create_rasterizer_state(pipe
, state
);
531 trace_dump_ret(ptr
, result
);
533 trace_dump_call_end();
540 trace_context_bind_rasterizer_state(struct pipe_context
*_pipe
,
543 struct trace_context
*tr_ctx
= trace_context(_pipe
);
544 struct pipe_context
*pipe
= tr_ctx
->pipe
;
546 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
548 trace_dump_arg(ptr
, pipe
);
549 trace_dump_arg(ptr
, state
);
551 pipe
->bind_rasterizer_state(pipe
, state
);
553 trace_dump_call_end();
558 trace_context_delete_rasterizer_state(struct pipe_context
*_pipe
,
561 struct trace_context
*tr_ctx
= trace_context(_pipe
);
562 struct pipe_context
*pipe
= tr_ctx
->pipe
;
564 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
566 trace_dump_arg(ptr
, pipe
);
567 trace_dump_arg(ptr
, state
);
569 pipe
->delete_rasterizer_state(pipe
, state
);
571 trace_dump_call_end();
576 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
577 const struct pipe_depth_stencil_alpha_state
*state
)
579 struct trace_context
*tr_ctx
= trace_context(_pipe
);
580 struct pipe_context
*pipe
= tr_ctx
->pipe
;
583 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
585 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);
587 trace_dump_arg(ptr
, pipe
);
588 trace_dump_arg(depth_stencil_alpha_state
, state
);
590 trace_dump_ret(ptr
, result
);
592 trace_dump_call_end();
599 trace_context_bind_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
602 struct trace_context
*tr_ctx
= trace_context(_pipe
);
603 struct pipe_context
*pipe
= tr_ctx
->pipe
;
605 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
607 trace_dump_arg(ptr
, pipe
);
608 trace_dump_arg(ptr
, state
);
610 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);
612 trace_dump_call_end();
617 trace_context_delete_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
620 struct trace_context
*tr_ctx
= trace_context(_pipe
);
621 struct pipe_context
*pipe
= tr_ctx
->pipe
;
623 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
625 trace_dump_arg(ptr
, pipe
);
626 trace_dump_arg(ptr
, state
);
628 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);
630 trace_dump_call_end();
635 trace_context_create_fs_state(struct pipe_context
*_pipe
,
636 const struct pipe_shader_state
*state
)
638 struct trace_context
*tr_ctx
= trace_context(_pipe
);
639 struct pipe_context
*pipe
= tr_ctx
->pipe
;
642 trace_dump_call_begin("pipe_context", "create_fs_state");
644 trace_dump_arg(ptr
, pipe
);
645 trace_dump_arg(shader_state
, state
);
647 result
= pipe
->create_fs_state(pipe
, state
);
649 trace_dump_ret(ptr
, result
);
651 trace_dump_call_end();
653 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_FRAGMENT
);
660 trace_context_bind_fs_state(struct pipe_context
*_pipe
,
663 struct trace_context
*tr_ctx
= trace_context(_pipe
);
664 struct trace_shader
*tr_shdr
= trace_shader(_state
);
665 struct pipe_context
*pipe
= tr_ctx
->pipe
;
666 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
668 trace_dump_call_begin("pipe_context", "bind_fs_state");
670 trace_dump_arg(ptr
, pipe
);
671 trace_dump_arg(ptr
, state
);
673 tr_ctx
->curr
.fs
= tr_shdr
;
675 if (tr_shdr
&& tr_shdr
->replaced
)
676 state
= tr_shdr
->replaced
;
678 pipe
->bind_fs_state(pipe
, state
);
680 trace_dump_call_end();
685 trace_context_delete_fs_state(struct pipe_context
*_pipe
,
688 struct trace_context
*tr_ctx
= trace_context(_pipe
);
689 struct trace_shader
*tr_shdr
= trace_shader(_state
);
690 struct pipe_context
*pipe
= tr_ctx
->pipe
;
691 void *state
= tr_shdr
->state
;
693 trace_dump_call_begin("pipe_context", "delete_fs_state");
695 trace_dump_arg(ptr
, pipe
);
696 trace_dump_arg(ptr
, state
);
698 pipe
->delete_fs_state(pipe
, state
);
700 trace_dump_call_end();
702 trace_shader_destroy(tr_ctx
, tr_shdr
);
707 trace_context_create_vs_state(struct pipe_context
*_pipe
,
708 const struct pipe_shader_state
*state
)
710 struct trace_context
*tr_ctx
= trace_context(_pipe
);
711 struct pipe_context
*pipe
= tr_ctx
->pipe
;
714 trace_dump_call_begin("pipe_context", "create_vs_state");
716 trace_dump_arg(ptr
, pipe
);
717 trace_dump_arg(shader_state
, state
);
719 result
= pipe
->create_vs_state(pipe
, state
);
721 trace_dump_ret(ptr
, result
);
723 trace_dump_call_end();
725 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_VERTEX
);
732 trace_context_bind_vs_state(struct pipe_context
*_pipe
,
735 struct trace_context
*tr_ctx
= trace_context(_pipe
);
736 struct trace_shader
*tr_shdr
= trace_shader(_state
);
737 struct pipe_context
*pipe
= tr_ctx
->pipe
;
738 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
740 trace_dump_call_begin("pipe_context", "bind_vs_state");
742 trace_dump_arg(ptr
, pipe
);
743 trace_dump_arg(ptr
, state
);
745 tr_ctx
->curr
.vs
= tr_shdr
;
747 if (tr_shdr
&& tr_shdr
->replaced
)
748 state
= tr_shdr
->replaced
;
750 pipe
->bind_vs_state(pipe
, state
);
752 trace_dump_call_end();
757 trace_context_delete_vs_state(struct pipe_context
*_pipe
,
760 struct trace_context
*tr_ctx
= trace_context(_pipe
);
761 struct trace_shader
*tr_shdr
= trace_shader(_state
);
762 struct pipe_context
*pipe
= tr_ctx
->pipe
;
763 void *state
= tr_shdr
->state
;
765 trace_dump_call_begin("pipe_context", "delete_vs_state");
767 trace_dump_arg(ptr
, pipe
);
768 trace_dump_arg(ptr
, state
);
770 pipe
->delete_vs_state(pipe
, state
);
772 trace_dump_call_end();
774 trace_shader_destroy(tr_ctx
, tr_shdr
);
779 trace_context_create_vertex_elements_state(struct pipe_context
*_pipe
,
780 unsigned num_elements
,
781 const struct pipe_vertex_element
*elements
)
783 struct trace_context
*tr_ctx
= trace_context(_pipe
);
784 struct pipe_context
*pipe
= tr_ctx
->pipe
;
787 trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
789 trace_dump_arg(ptr
, pipe
);
790 trace_dump_arg(uint
, num_elements
);
792 trace_dump_arg_begin("elements");
793 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
794 trace_dump_arg_end();
796 result
= pipe
->create_vertex_elements_state(pipe
, num_elements
, elements
);
798 trace_dump_ret(ptr
, result
);
800 trace_dump_call_end();
807 trace_context_bind_vertex_elements_state(struct pipe_context
*_pipe
,
810 struct trace_context
*tr_ctx
= trace_context(_pipe
);
811 struct pipe_context
*pipe
= tr_ctx
->pipe
;
813 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
815 trace_dump_arg(ptr
, pipe
);
816 trace_dump_arg(ptr
, state
);
818 pipe
->bind_vertex_elements_state(pipe
, state
);
820 trace_dump_call_end();
825 trace_context_delete_vertex_elements_state(struct pipe_context
*_pipe
,
828 struct trace_context
*tr_ctx
= trace_context(_pipe
);
829 struct pipe_context
*pipe
= tr_ctx
->pipe
;
831 trace_dump_call_begin("pipe_context", "delete_verte_elements_state");
833 trace_dump_arg(ptr
, pipe
);
834 trace_dump_arg(ptr
, state
);
836 pipe
->delete_vertex_elements_state(pipe
, state
);
838 trace_dump_call_end();
843 trace_context_set_blend_color(struct pipe_context
*_pipe
,
844 const struct pipe_blend_color
*state
)
846 struct trace_context
*tr_ctx
= trace_context(_pipe
);
847 struct pipe_context
*pipe
= tr_ctx
->pipe
;
849 trace_dump_call_begin("pipe_context", "set_blend_color");
851 trace_dump_arg(ptr
, pipe
);
852 trace_dump_arg(blend_color
, state
);
854 pipe
->set_blend_color(pipe
, state
);
856 trace_dump_call_end();
861 trace_context_set_stencil_ref(struct pipe_context
*_pipe
,
862 const struct pipe_stencil_ref
*state
)
864 struct trace_context
*tr_ctx
= trace_context(_pipe
);
865 struct pipe_context
*pipe
= tr_ctx
->pipe
;
867 trace_dump_call_begin("pipe_context", "set_stencil_ref");
869 trace_dump_arg(ptr
, pipe
);
870 trace_dump_arg(stencil_ref
, state
);
872 pipe
->set_stencil_ref(pipe
, state
);
874 trace_dump_call_end();
879 trace_context_set_clip_state(struct pipe_context
*_pipe
,
880 const struct pipe_clip_state
*state
)
882 struct trace_context
*tr_ctx
= trace_context(_pipe
);
883 struct pipe_context
*pipe
= tr_ctx
->pipe
;
885 trace_dump_call_begin("pipe_context", "set_clip_state");
887 trace_dump_arg(ptr
, pipe
);
888 trace_dump_arg(clip_state
, state
);
890 pipe
->set_clip_state(pipe
, state
);
892 trace_dump_call_end();
897 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
898 uint shader
, uint index
,
899 struct pipe_buffer
*buffer
)
901 struct trace_context
*tr_ctx
= trace_context(_pipe
);
902 struct pipe_context
*pipe
= tr_ctx
->pipe
;
905 trace_screen_user_buffer_update(_pipe
->screen
, buffer
);
906 buffer
= trace_buffer_unwrap(tr_ctx
, buffer
);
909 trace_dump_call_begin("pipe_context", "set_constant_buffer");
911 trace_dump_arg(ptr
, pipe
);
912 trace_dump_arg(uint
, shader
);
913 trace_dump_arg(uint
, index
);
914 trace_dump_arg(ptr
, buffer
);
916 pipe
->set_constant_buffer(pipe
, shader
, index
, buffer
);
918 trace_dump_call_end();
923 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
924 const struct pipe_framebuffer_state
*state
)
926 struct trace_context
*tr_ctx
= trace_context(_pipe
);
927 struct pipe_context
*pipe
= tr_ctx
->pipe
;
928 struct pipe_framebuffer_state unwrapped_state
;
932 tr_ctx
->curr
.nr_cbufs
= state
->nr_cbufs
;
933 for (i
= 0; i
< state
->nr_cbufs
; i
++)
935 tr_ctx
->curr
.cbufs
[i
] = trace_texture(state
->cbufs
[i
]->texture
);
937 tr_ctx
->curr
.cbufs
[i
] = NULL
;
939 tr_ctx
->curr
.zsbuf
= trace_texture(state
->zsbuf
->texture
);
941 tr_ctx
->curr
.zsbuf
= NULL
;
944 /* Unwrap the input state */
945 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
946 for(i
= 0; i
< state
->nr_cbufs
; ++i
)
947 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
948 for(i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
949 unwrapped_state
.cbufs
[i
] = NULL
;
950 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
951 state
= &unwrapped_state
;
953 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
955 trace_dump_arg(ptr
, pipe
);
956 trace_dump_arg(framebuffer_state
, state
);
958 pipe
->set_framebuffer_state(pipe
, state
);
960 trace_dump_call_end();
965 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
966 const struct pipe_poly_stipple
*state
)
968 struct trace_context
*tr_ctx
= trace_context(_pipe
);
969 struct pipe_context
*pipe
= tr_ctx
->pipe
;
971 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
973 trace_dump_arg(ptr
, pipe
);
974 trace_dump_arg(poly_stipple
, state
);
976 pipe
->set_polygon_stipple(pipe
, state
);
978 trace_dump_call_end();
983 trace_context_set_scissor_state(struct pipe_context
*_pipe
,
984 const struct pipe_scissor_state
*state
)
986 struct trace_context
*tr_ctx
= trace_context(_pipe
);
987 struct pipe_context
*pipe
= tr_ctx
->pipe
;
989 trace_dump_call_begin("pipe_context", "set_scissor_state");
991 trace_dump_arg(ptr
, pipe
);
992 trace_dump_arg(scissor_state
, state
);
994 pipe
->set_scissor_state(pipe
, state
);
996 trace_dump_call_end();
1001 trace_context_set_viewport_state(struct pipe_context
*_pipe
,
1002 const struct pipe_viewport_state
*state
)
1004 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1005 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1007 trace_dump_call_begin("pipe_context", "set_viewport_state");
1009 trace_dump_arg(ptr
, pipe
);
1010 trace_dump_arg(viewport_state
, state
);
1012 pipe
->set_viewport_state(pipe
, state
);
1014 trace_dump_call_end();
1019 trace_context_set_fragment_sampler_textures(struct pipe_context
*_pipe
,
1020 unsigned num_textures
,
1021 struct pipe_texture
**textures
)
1023 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1024 struct trace_texture
*tr_tex
;
1025 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1026 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_SAMPLERS
];
1029 tr_ctx
->curr
.num_texs
= num_textures
;
1030 for(i
= 0; i
< num_textures
; ++i
) {
1031 tr_tex
= trace_texture(textures
[i
]);
1032 tr_ctx
->curr
.tex
[i
] = tr_tex
;
1033 unwrapped_textures
[i
] = tr_tex
? tr_tex
->texture
: NULL
;
1035 textures
= unwrapped_textures
;
1037 trace_dump_call_begin("pipe_context", "set_fragment_sampler_textures");
1039 trace_dump_arg(ptr
, pipe
);
1040 trace_dump_arg(uint
, num_textures
);
1041 trace_dump_arg_array(ptr
, textures
, num_textures
);
1043 pipe
->set_fragment_sampler_textures(pipe
, num_textures
, textures
);
1045 trace_dump_call_end();
1050 trace_context_set_vertex_sampler_textures(struct pipe_context
*_pipe
,
1051 unsigned num_textures
,
1052 struct pipe_texture
**textures
)
1054 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1055 struct trace_texture
*tr_tex
;
1056 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1057 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_VERTEX_SAMPLERS
];
1060 tr_ctx
->curr
.num_vert_texs
= num_textures
;
1061 for(i
= 0; i
< num_textures
; ++i
) {
1062 tr_tex
= trace_texture(textures
[i
]);
1063 tr_ctx
->curr
.vert_tex
[i
] = tr_tex
;
1064 unwrapped_textures
[i
] = tr_tex
? tr_tex
->texture
: NULL
;
1066 textures
= unwrapped_textures
;
1068 trace_dump_call_begin("pipe_context", "set_vertex_sampler_textures");
1070 trace_dump_arg(ptr
, pipe
);
1071 trace_dump_arg(uint
, num_textures
);
1072 trace_dump_arg_array(ptr
, textures
, num_textures
);
1074 pipe
->set_vertex_sampler_textures(pipe
, num_textures
, textures
);
1076 trace_dump_call_end();
1081 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
1082 unsigned num_buffers
,
1083 const struct pipe_vertex_buffer
*buffers
)
1085 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1086 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1089 for(i
= 0; i
< num_buffers
; ++i
)
1090 trace_screen_user_buffer_update(_pipe
->screen
, buffers
[i
].buffer
);
1092 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1094 trace_dump_arg(ptr
, pipe
);
1095 trace_dump_arg(uint
, num_buffers
);
1097 trace_dump_arg_begin("buffers");
1098 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
1099 trace_dump_arg_end();
1102 struct pipe_vertex_buffer
*_buffers
= malloc(num_buffers
* sizeof(*_buffers
));
1103 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
1104 for (i
= 0; i
< num_buffers
; i
++)
1105 _buffers
[i
].buffer
= trace_buffer_unwrap(tr_ctx
, buffers
[i
].buffer
);
1106 pipe
->set_vertex_buffers(pipe
, num_buffers
, _buffers
);
1109 pipe
->set_vertex_buffers(pipe
, num_buffers
, NULL
);
1112 trace_dump_call_end();
1117 trace_context_surface_copy(struct pipe_context
*_pipe
,
1118 struct pipe_surface
*dest
,
1119 unsigned destx
, unsigned desty
,
1120 struct pipe_surface
*src
,
1121 unsigned srcx
, unsigned srcy
,
1122 unsigned width
, unsigned height
)
1124 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1125 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1127 dest
= trace_surface_unwrap(tr_ctx
, dest
);
1128 src
= trace_surface_unwrap(tr_ctx
, src
);
1130 trace_dump_call_begin("pipe_context", "surface_copy");
1132 trace_dump_arg(ptr
, pipe
);
1133 trace_dump_arg(ptr
, dest
);
1134 trace_dump_arg(uint
, destx
);
1135 trace_dump_arg(uint
, desty
);
1136 trace_dump_arg(ptr
, src
);
1137 trace_dump_arg(uint
, srcx
);
1138 trace_dump_arg(uint
, srcy
);
1139 trace_dump_arg(uint
, width
);
1140 trace_dump_arg(uint
, height
);
1142 pipe
->surface_copy(pipe
,
1144 src
, srcx
, srcy
, width
, height
);
1146 trace_dump_call_end();
1151 trace_context_surface_fill(struct pipe_context
*_pipe
,
1152 struct pipe_surface
*dst
,
1153 unsigned dstx
, unsigned dsty
,
1154 unsigned width
, unsigned height
,
1157 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1158 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1160 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1162 trace_dump_call_begin("pipe_context", "surface_fill");
1164 trace_dump_arg(ptr
, pipe
);
1165 trace_dump_arg(ptr
, dst
);
1166 trace_dump_arg(uint
, dstx
);
1167 trace_dump_arg(uint
, dsty
);
1168 trace_dump_arg(uint
, width
);
1169 trace_dump_arg(uint
, height
);
1171 pipe
->surface_fill(pipe
, dst
, dstx
, dsty
, width
, height
, value
);
1173 trace_dump_call_end();
1178 trace_context_clear(struct pipe_context
*_pipe
,
1184 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1185 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1187 trace_dump_call_begin("pipe_context", "clear");
1189 trace_dump_arg(ptr
, pipe
);
1190 trace_dump_arg(uint
, buffers
);
1191 trace_dump_arg_array(float, rgba
, 4);
1192 trace_dump_arg(float, depth
);
1193 trace_dump_arg(uint
, stencil
);
1195 pipe
->clear(pipe
, buffers
, rgba
, depth
, stencil
);
1197 trace_dump_call_end();
1202 trace_context_flush(struct pipe_context
*_pipe
,
1204 struct pipe_fence_handle
**fence
)
1206 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1207 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1209 trace_dump_call_begin("pipe_context", "flush");
1211 trace_dump_arg(ptr
, pipe
);
1212 trace_dump_arg(uint
, flags
);
1214 pipe
->flush(pipe
, flags
, fence
);
1217 trace_dump_ret(ptr
, *fence
);
1219 trace_dump_call_end();
1224 trace_context_destroy(struct pipe_context
*_pipe
)
1226 struct trace_screen
*tr_scr
= trace_screen(_pipe
->screen
);
1227 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1228 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1230 trace_dump_call_begin("pipe_context", "destroy");
1231 trace_dump_arg(ptr
, pipe
);
1232 trace_dump_call_end();
1234 trace_screen_remove_from_list(tr_scr
, contexts
, tr_ctx
);
1236 pipe
->destroy(pipe
);
1242 trace_is_texture_referenced( struct pipe_context
*_pipe
,
1243 struct pipe_texture
*_texture
,
1244 unsigned face
, unsigned level
)
1246 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1247 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1248 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1249 struct pipe_texture
*texture
= tr_tex
->texture
;
1250 unsigned int referenced
;
1252 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1253 trace_dump_arg(ptr
, pipe
);
1254 trace_dump_arg(ptr
, texture
);
1255 trace_dump_arg(uint
, face
);
1256 trace_dump_arg(uint
, level
);
1258 referenced
= pipe
->is_texture_referenced(pipe
, texture
, face
, level
);
1260 trace_dump_ret(uint
, referenced
);
1261 trace_dump_call_end();
1267 trace_is_buffer_referenced( struct pipe_context
*_pipe
,
1268 struct pipe_buffer
*_buf
)
1270 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1271 struct trace_buffer
*tr_buf
= trace_buffer(_buf
);
1272 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1273 struct pipe_buffer
*buf
= tr_buf
->buffer
;
1274 unsigned int referenced
;
1276 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1277 trace_dump_arg(ptr
, pipe
);
1278 trace_dump_arg(ptr
, buf
);
1280 referenced
= pipe
->is_buffer_referenced(pipe
, buf
);
1282 trace_dump_ret(uint
, referenced
);
1283 trace_dump_call_end();
1289 /********************************************************************
1294 static struct pipe_transfer
*
1295 trace_context_get_tex_transfer(struct pipe_context
*_context
,
1296 struct pipe_texture
*_texture
,
1297 unsigned face
, unsigned level
,
1299 enum pipe_transfer_usage usage
,
1300 unsigned x
, unsigned y
, unsigned w
, unsigned h
)
1302 struct trace_context
*tr_context
= trace_context(_context
);
1303 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1304 struct pipe_context
*context
= tr_context
->pipe
;
1305 struct pipe_texture
*texture
= tr_tex
->texture
;
1306 struct pipe_transfer
*result
= NULL
;
1308 assert(texture
->screen
== context
->screen
);
1310 trace_dump_call_begin("pipe_context", "get_tex_transfer");
1312 trace_dump_arg(ptr
, context
);
1313 trace_dump_arg(ptr
, texture
);
1314 trace_dump_arg(uint
, face
);
1315 trace_dump_arg(uint
, level
);
1316 trace_dump_arg(uint
, zslice
);
1317 trace_dump_arg(uint
, usage
);
1319 trace_dump_arg(uint
, x
);
1320 trace_dump_arg(uint
, y
);
1321 trace_dump_arg(uint
, w
);
1322 trace_dump_arg(uint
, h
);
1324 result
= context
->get_tex_transfer(context
, texture
, face
, level
, zslice
, usage
,
1327 trace_dump_ret(ptr
, result
);
1329 trace_dump_call_end();
1332 result
= trace_transfer_create(tr_context
, tr_tex
, result
);
1339 trace_context_tex_transfer_destroy(struct pipe_transfer
*_transfer
)
1341 struct trace_context
*tr_ctx
= trace_context(_transfer
->pipe
);
1342 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
1343 struct pipe_context
*context
= tr_ctx
->pipe
;
1344 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
1346 trace_dump_call_begin("pipe_context", "tex_transfer_destroy");
1348 trace_dump_arg(ptr
, context
);
1349 trace_dump_arg(ptr
, transfer
);
1351 trace_dump_call_end();
1353 trace_transfer_destroy(tr_trans
);
1358 trace_context_transfer_map(struct pipe_context
*_context
,
1359 struct pipe_transfer
*_transfer
)
1361 struct trace_context
*tr_context
= trace_context(_context
);
1362 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
1363 struct pipe_context
*context
= tr_context
->pipe
;
1364 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
1367 map
= context
->transfer_map(context
, transfer
);
1369 if(transfer
->usage
& PIPE_TRANSFER_WRITE
) {
1370 assert(!tr_trans
->map
);
1371 tr_trans
->map
= map
;
1380 trace_context_transfer_unmap(struct pipe_context
*_context
,
1381 struct pipe_transfer
*_transfer
)
1383 struct trace_context
*tr_ctx
= trace_context(_context
);
1384 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
1385 struct pipe_context
*context
= tr_ctx
->pipe
;
1386 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
1389 size_t size
= util_format_get_nblocksy(transfer
->texture
->format
, transfer
->height
) * transfer
->stride
;
1391 trace_dump_call_begin("pipe_context", "transfer_write");
1393 trace_dump_arg(ptr
, context
);
1395 trace_dump_arg(ptr
, transfer
);
1397 trace_dump_arg_begin("stride");
1398 trace_dump_uint(transfer
->stride
);
1399 trace_dump_arg_end();
1401 trace_dump_arg_begin("data");
1402 trace_dump_bytes(tr_trans
->map
, size
);
1403 trace_dump_arg_end();
1405 trace_dump_arg_begin("size");
1406 trace_dump_uint(size
);
1407 trace_dump_arg_end();
1409 trace_dump_call_end();
1411 tr_trans
->map
= NULL
;
1414 context
->transfer_unmap(context
, transfer
);
1417 static const struct debug_named_value rbug_blocker_flags
[] = {
1423 struct pipe_context
*
1424 trace_context_create(struct trace_screen
*tr_scr
,
1425 struct pipe_context
*pipe
)
1427 struct trace_context
*tr_ctx
;
1432 if(!trace_enabled())
1435 tr_ctx
= CALLOC_STRUCT(trace_context
);
1439 tr_ctx
->base
.winsys
= NULL
;
1440 tr_ctx
->base
.priv
= pipe
->priv
; /* expose wrapped priv data */
1441 tr_ctx
->base
.screen
= &tr_scr
->base
;
1442 tr_ctx
->draw_blocker
= debug_get_flags_option("RBUG_BLOCK",
1445 pipe_mutex_init(tr_ctx
->draw_mutex
);
1446 pipe_condvar_init(tr_ctx
->draw_cond
);
1447 pipe_mutex_init(tr_ctx
->list_mutex
);
1448 make_empty_list(&tr_ctx
->shaders
);
1450 tr_ctx
->base
.destroy
= trace_context_destroy
;
1451 tr_ctx
->base
.draw_arrays
= trace_context_draw_arrays
;
1452 tr_ctx
->base
.draw_elements
= trace_context_draw_elements
;
1453 tr_ctx
->base
.draw_range_elements
= trace_context_draw_range_elements
;
1454 tr_ctx
->base
.create_query
= trace_context_create_query
;
1455 tr_ctx
->base
.destroy_query
= trace_context_destroy_query
;
1456 tr_ctx
->base
.begin_query
= trace_context_begin_query
;
1457 tr_ctx
->base
.end_query
= trace_context_end_query
;
1458 tr_ctx
->base
.get_query_result
= trace_context_get_query_result
;
1459 tr_ctx
->base
.create_blend_state
= trace_context_create_blend_state
;
1460 tr_ctx
->base
.bind_blend_state
= trace_context_bind_blend_state
;
1461 tr_ctx
->base
.delete_blend_state
= trace_context_delete_blend_state
;
1462 tr_ctx
->base
.create_sampler_state
= trace_context_create_sampler_state
;
1463 tr_ctx
->base
.bind_fragment_sampler_states
= trace_context_bind_fragment_sampler_states
;
1464 tr_ctx
->base
.bind_vertex_sampler_states
= trace_context_bind_vertex_sampler_states
;
1465 tr_ctx
->base
.delete_sampler_state
= trace_context_delete_sampler_state
;
1466 tr_ctx
->base
.create_rasterizer_state
= trace_context_create_rasterizer_state
;
1467 tr_ctx
->base
.bind_rasterizer_state
= trace_context_bind_rasterizer_state
;
1468 tr_ctx
->base
.delete_rasterizer_state
= trace_context_delete_rasterizer_state
;
1469 tr_ctx
->base
.create_depth_stencil_alpha_state
= trace_context_create_depth_stencil_alpha_state
;
1470 tr_ctx
->base
.bind_depth_stencil_alpha_state
= trace_context_bind_depth_stencil_alpha_state
;
1471 tr_ctx
->base
.delete_depth_stencil_alpha_state
= trace_context_delete_depth_stencil_alpha_state
;
1472 tr_ctx
->base
.create_fs_state
= trace_context_create_fs_state
;
1473 tr_ctx
->base
.bind_fs_state
= trace_context_bind_fs_state
;
1474 tr_ctx
->base
.delete_fs_state
= trace_context_delete_fs_state
;
1475 tr_ctx
->base
.create_vs_state
= trace_context_create_vs_state
;
1476 tr_ctx
->base
.bind_vs_state
= trace_context_bind_vs_state
;
1477 tr_ctx
->base
.delete_vs_state
= trace_context_delete_vs_state
;
1478 tr_ctx
->base
.create_vertex_elements_state
= trace_context_create_vertex_elements_state
;
1479 tr_ctx
->base
.bind_vertex_elements_state
= trace_context_bind_vertex_elements_state
;
1480 tr_ctx
->base
.delete_vertex_elements_state
= trace_context_delete_vertex_elements_state
;
1481 tr_ctx
->base
.set_blend_color
= trace_context_set_blend_color
;
1482 tr_ctx
->base
.set_stencil_ref
= trace_context_set_stencil_ref
;
1483 tr_ctx
->base
.set_clip_state
= trace_context_set_clip_state
;
1484 tr_ctx
->base
.set_constant_buffer
= trace_context_set_constant_buffer
;
1485 tr_ctx
->base
.set_framebuffer_state
= trace_context_set_framebuffer_state
;
1486 tr_ctx
->base
.set_polygon_stipple
= trace_context_set_polygon_stipple
;
1487 tr_ctx
->base
.set_scissor_state
= trace_context_set_scissor_state
;
1488 tr_ctx
->base
.set_viewport_state
= trace_context_set_viewport_state
;
1489 tr_ctx
->base
.set_fragment_sampler_textures
= trace_context_set_fragment_sampler_textures
;
1490 tr_ctx
->base
.set_vertex_sampler_textures
= trace_context_set_vertex_sampler_textures
;
1491 tr_ctx
->base
.set_vertex_buffers
= trace_context_set_vertex_buffers
;
1492 if (pipe
->surface_copy
)
1493 tr_ctx
->base
.surface_copy
= trace_context_surface_copy
;
1494 if (pipe
->surface_fill
)
1495 tr_ctx
->base
.surface_fill
= trace_context_surface_fill
;
1496 tr_ctx
->base
.clear
= trace_context_clear
;
1497 tr_ctx
->base
.flush
= trace_context_flush
;
1498 tr_ctx
->base
.is_texture_referenced
= trace_is_texture_referenced
;
1499 tr_ctx
->base
.is_buffer_referenced
= trace_is_buffer_referenced
;
1501 tr_ctx
->base
.get_tex_transfer
= trace_context_get_tex_transfer
;
1502 tr_ctx
->base
.tex_transfer_destroy
= trace_context_tex_transfer_destroy
;
1503 tr_ctx
->base
.transfer_map
= trace_context_transfer_map
;
1504 tr_ctx
->base
.transfer_unmap
= trace_context_transfer_unmap
;
1506 tr_ctx
->pipe
= pipe
;
1508 trace_screen_add_to_list(tr_scr
, contexts
, tr_ctx
);
1510 return &tr_ctx
->base
;