1 /**************************************************************************
3 * Copyright 2013 Marek Olšák <maraeo@gmail.com>
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 THE AUTHORS 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 /* This head-up display module can draw transparent graphs on top of what
29 * the app is rendering, visualizing various data like framerate, cpu load,
30 * performance counters, etc. It can be hook up into any state tracker.
32 * The HUD is controlled with the GALLIUM_HUD environment variable.
33 * Set GALLIUM_HUD=help for more info.
36 #include "hud/hud_context.h"
37 #include "hud/hud_private.h"
40 #include "cso_cache/cso_context.h"
41 #include "util/u_draw_quad.h"
42 #include "util/u_inlines.h"
43 #include "util/u_memory.h"
44 #include "util/u_math.h"
45 #include "util/u_simple_shaders.h"
46 #include "util/u_string.h"
47 #include "util/u_upload_mgr.h"
48 #include "tgsi/tgsi_text.h"
49 #include "tgsi/tgsi_dump.h"
53 struct pipe_context
*pipe
;
54 struct cso_context
*cso
;
55 struct u_upload_mgr
*uploader
;
57 struct list_head pane_list
;
60 struct pipe_blend_state alpha_blend
;
61 struct pipe_depth_stencil_alpha_state dsa
;
62 void *fs_color
, *fs_text
;
63 struct pipe_rasterizer_state rasterizer
;
65 struct pipe_vertex_element velems
[2];
68 struct util_font font
;
69 struct pipe_sampler_view
*font_sampler_view
;
70 struct pipe_sampler_state font_sampler_state
;
72 /* VS constant buffer */
75 float two_div_fb_width
;
76 float two_div_fb_height
;
81 struct pipe_constant_buffer constbuf
;
83 unsigned fb_width
, fb_height
;
85 /* vertices for text and background drawing are accumulated here and then
86 * drawn all at once */
89 struct pipe_vertex_buffer vbuf
;
90 unsigned max_num_vertices
;
91 unsigned num_vertices
;
92 } text
, bg
, whitelines
;
95 boolean query_pipeline_statistics
;
101 hud_draw_colored_prims(struct hud_context
*hud
, unsigned prim
,
102 float *buffer
, unsigned num_vertices
,
103 float r
, float g
, float b
, float a
,
104 int xoffset
, int yoffset
, float yscale
)
106 struct cso_context
*cso
= hud
->cso
;
107 struct pipe_vertex_buffer vbuffer
= {0};
109 hud
->constants
.color
[0] = r
;
110 hud
->constants
.color
[1] = g
;
111 hud
->constants
.color
[2] = b
;
112 hud
->constants
.color
[3] = a
;
113 hud
->constants
.translate
[0] = xoffset
;
114 hud
->constants
.translate
[1] = yoffset
;
115 hud
->constants
.scale
[0] = 1;
116 hud
->constants
.scale
[1] = yscale
;
117 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
119 vbuffer
.user_buffer
= buffer
;
120 vbuffer
.stride
= 2 * sizeof(float);
122 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
),
124 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
125 cso_draw_arrays(cso
, prim
, 0, num_vertices
);
129 hud_draw_colored_quad(struct hud_context
*hud
, unsigned prim
,
130 unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
,
131 float r
, float g
, float b
, float a
)
140 hud_draw_colored_prims(hud
, prim
, buffer
, 4, r
, g
, b
, a
, 0, 0, 1);
144 hud_draw_background_quad(struct hud_context
*hud
,
145 unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
)
147 float *vertices
= hud
->bg
.vertices
+ hud
->bg
.num_vertices
*2;
150 assert(hud
->bg
.num_vertices
+ 4 <= hud
->bg
.max_num_vertices
);
152 vertices
[num
++] = x1
;
153 vertices
[num
++] = y1
;
155 vertices
[num
++] = x1
;
156 vertices
[num
++] = y2
;
158 vertices
[num
++] = x2
;
159 vertices
[num
++] = y2
;
161 vertices
[num
++] = x2
;
162 vertices
[num
++] = y1
;
164 hud
->bg
.num_vertices
+= num
/2;
168 hud_draw_string(struct hud_context
*hud
, unsigned x
, unsigned y
,
169 const char *str
, ...)
173 float *vertices
= hud
->text
.vertices
+ hud
->text
.num_vertices
*4;
178 util_vsnprintf(buf
, sizeof(buf
), str
, ap
);
184 hud_draw_background_quad(hud
,
186 x
+ strlen(buf
)*hud
->font
.glyph_width
,
187 y
+ hud
->font
.glyph_height
);
192 unsigned x2
= x
+ hud
->font
.glyph_width
;
193 unsigned y2
= y
+ hud
->font
.glyph_height
;
194 unsigned tx1
= (*s
% 16) * hud
->font
.glyph_width
;
195 unsigned ty1
= (*s
/ 16) * hud
->font
.glyph_height
;
196 unsigned tx2
= tx1
+ hud
->font
.glyph_width
;
197 unsigned ty2
= ty1
+ hud
->font
.glyph_height
;
200 x
+= hud
->font
.glyph_width
;
205 assert(hud
->text
.num_vertices
+ num
/4 + 4 <= hud
->text
.max_num_vertices
);
207 vertices
[num
++] = x1
;
208 vertices
[num
++] = y1
;
209 vertices
[num
++] = tx1
;
210 vertices
[num
++] = ty1
;
212 vertices
[num
++] = x1
;
213 vertices
[num
++] = y2
;
214 vertices
[num
++] = tx1
;
215 vertices
[num
++] = ty2
;
217 vertices
[num
++] = x2
;
218 vertices
[num
++] = y2
;
219 vertices
[num
++] = tx2
;
220 vertices
[num
++] = ty2
;
222 vertices
[num
++] = x2
;
223 vertices
[num
++] = y1
;
224 vertices
[num
++] = tx2
;
225 vertices
[num
++] = ty1
;
227 x
+= hud
->font
.glyph_width
;
231 hud
->text
.num_vertices
+= num
/4;
235 number_to_human_readable(uint64_t num
, boolean is_in_bytes
, char *out
)
237 static const char *byte_units
[] =
238 {"", " KB", " MB", " GB", " TB", " PB", " EB"};
239 static const char *metric_units
[] =
240 {"", " k", " M", " G", " T", " P", " E"};
241 const char **units
= is_in_bytes
? byte_units
: metric_units
;
242 double divisor
= is_in_bytes
? 1024 : 1000;
246 while (d
> divisor
) {
251 if (d
>= 100 || d
== (int)d
)
252 sprintf(out
, "%.0f%s", d
, units
[unit
]);
253 else if (d
>= 10 || d
*10 == (int)(d
*10))
254 sprintf(out
, "%.1f%s", d
, units
[unit
]);
256 sprintf(out
, "%.2f%s", d
, units
[unit
]);
260 hud_draw_graph_line_strip(struct hud_context
*hud
, const struct hud_graph
*gr
,
261 unsigned xoffset
, unsigned yoffset
, float yscale
)
263 if (gr
->num_vertices
<= 1)
266 assert(gr
->index
<= gr
->num_vertices
);
268 hud_draw_colored_prims(hud
, PIPE_PRIM_LINE_STRIP
,
269 gr
->vertices
, gr
->index
,
270 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1,
271 xoffset
+ (gr
->pane
->max_num_vertices
- gr
->index
- 1) * 2 - 1,
274 if (gr
->num_vertices
<= gr
->index
)
277 hud_draw_colored_prims(hud
, PIPE_PRIM_LINE_STRIP
,
278 gr
->vertices
+ gr
->index
*2,
279 gr
->num_vertices
- gr
->index
,
280 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1,
281 xoffset
- gr
->index
*2 - 1, yoffset
, yscale
);
285 hud_pane_accumulate_vertices(struct hud_context
*hud
,
286 const struct hud_pane
*pane
)
288 struct hud_graph
*gr
;
289 float *line_verts
= hud
->whitelines
.vertices
+ hud
->whitelines
.num_vertices
*2;
293 /* draw background */
294 hud_draw_background_quad(hud
,
298 /* draw numbers on the right-hand side */
299 for (i
= 0; i
< 6; i
++) {
300 unsigned x
= pane
->x2
+ 2;
301 unsigned y
= pane
->inner_y1
+ pane
->inner_height
* (5 - i
) / 5 -
302 hud
->font
.glyph_height
/ 2;
304 number_to_human_readable(pane
->max_value
* i
/ 5,
305 pane
->uses_byte_units
, str
);
306 hud_draw_string(hud
, x
, y
, str
);
309 /* draw info below the pane */
311 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
312 unsigned x
= pane
->x1
+ 2;
313 unsigned y
= pane
->y2
+ 2 + i
*hud
->font
.glyph_height
;
315 number_to_human_readable(gr
->current_value
,
316 pane
->uses_byte_units
, str
);
317 hud_draw_string(hud
, x
, y
, " %s: %s", gr
->name
, str
);
322 assert(hud
->whitelines
.num_vertices
+ num
/2 + 8 <= hud
->whitelines
.max_num_vertices
);
323 line_verts
[num
++] = pane
->x1
;
324 line_verts
[num
++] = pane
->y1
;
325 line_verts
[num
++] = pane
->x2
;
326 line_verts
[num
++] = pane
->y1
;
328 line_verts
[num
++] = pane
->x2
;
329 line_verts
[num
++] = pane
->y1
;
330 line_verts
[num
++] = pane
->x2
;
331 line_verts
[num
++] = pane
->y2
;
333 line_verts
[num
++] = pane
->x1
;
334 line_verts
[num
++] = pane
->y2
;
335 line_verts
[num
++] = pane
->x2
;
336 line_verts
[num
++] = pane
->y2
;
338 line_verts
[num
++] = pane
->x1
;
339 line_verts
[num
++] = pane
->y1
;
340 line_verts
[num
++] = pane
->x1
;
341 line_verts
[num
++] = pane
->y2
;
343 /* draw horizontal lines inside the graph */
344 for (i
= 0; i
<= 5; i
++) {
345 float y
= round((pane
->max_value
* i
/ 5.0) * pane
->yscale
+ pane
->inner_y2
);
347 assert(hud
->whitelines
.num_vertices
+ num
/2 + 2 <= hud
->whitelines
.max_num_vertices
);
348 line_verts
[num
++] = pane
->x1
;
349 line_verts
[num
++] = y
;
350 line_verts
[num
++] = pane
->x2
;
351 line_verts
[num
++] = y
;
354 hud
->whitelines
.num_vertices
+= num
/2;
358 hud_pane_draw_colored_objects(struct hud_context
*hud
,
359 const struct hud_pane
*pane
)
361 struct hud_graph
*gr
;
364 /* draw colored quads below the pane */
366 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
367 unsigned x
= pane
->x1
+ 2;
368 unsigned y
= pane
->y2
+ 2 + i
*hud
->font
.glyph_height
;
370 hud_draw_colored_quad(hud
, PIPE_PRIM_QUADS
, x
+ 1, y
+ 1, x
+ 12, y
+ 13,
371 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1);
375 /* draw the line strips */
376 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
377 hud_draw_graph_line_strip(hud
, gr
, pane
->inner_x1
, pane
->inner_y2
, pane
->yscale
);
382 hud_alloc_vertices(struct hud_context
*hud
, struct vertex_queue
*v
,
383 unsigned num_vertices
, unsigned stride
)
386 v
->max_num_vertices
= num_vertices
;
387 v
->vbuf
.stride
= stride
;
388 u_upload_alloc(hud
->uploader
, 0, v
->vbuf
.stride
* v
->max_num_vertices
,
389 &v
->vbuf
.buffer_offset
, &v
->vbuf
.buffer
,
390 (void**)&v
->vertices
);
394 * Draw the HUD to the texture \p tex.
395 * The texture is usually the back buffer being displayed.
398 hud_draw(struct hud_context
*hud
, struct pipe_resource
*tex
)
400 struct cso_context
*cso
= hud
->cso
;
401 struct pipe_context
*pipe
= hud
->pipe
;
402 struct pipe_framebuffer_state fb
;
403 struct pipe_surface surf_templ
, *surf
;
404 struct pipe_viewport_state viewport
;
405 const struct pipe_sampler_state
*sampler_states
[] =
406 { &hud
->font_sampler_state
};
407 struct hud_pane
*pane
;
408 struct hud_graph
*gr
;
410 hud
->fb_width
= tex
->width0
;
411 hud
->fb_height
= tex
->height0
;
412 hud
->constants
.two_div_fb_width
= 2.0 / hud
->fb_width
;
413 hud
->constants
.two_div_fb_height
= 2.0 / hud
->fb_height
;
415 cso_save_framebuffer(cso
);
416 cso_save_sample_mask(cso
);
418 cso_save_depth_stencil_alpha(cso
);
419 cso_save_fragment_shader(cso
);
420 cso_save_sampler_views(cso
, PIPE_SHADER_FRAGMENT
);
421 cso_save_samplers(cso
, PIPE_SHADER_FRAGMENT
);
422 cso_save_rasterizer(cso
);
423 cso_save_viewport(cso
);
424 cso_save_stream_outputs(cso
);
425 cso_save_geometry_shader(cso
);
426 cso_save_vertex_shader(cso
);
427 cso_save_vertex_elements(cso
);
428 cso_save_aux_vertex_buffer_slot(cso
);
429 cso_save_constant_buffer_slot0(cso
, PIPE_SHADER_VERTEX
);
430 cso_save_render_condition(cso
);
433 memset(&surf_templ
, 0, sizeof(surf_templ
));
434 surf_templ
.format
= tex
->format
;
435 surf
= pipe
->create_surface(pipe
, tex
, &surf_templ
);
437 memset(&fb
, 0, sizeof(fb
));
441 fb
.width
= hud
->fb_width
;
442 fb
.height
= hud
->fb_height
;
444 viewport
.scale
[0] = 0.5f
* hud
->fb_width
;
445 viewport
.scale
[1] = 0.5f
* hud
->fb_height
;
446 viewport
.scale
[2] = 1.0f
;
447 viewport
.scale
[3] = 1.0f
;
448 viewport
.translate
[0] = 0.5f
* hud
->fb_width
;
449 viewport
.translate
[1] = 0.5f
* hud
->fb_height
;
450 viewport
.translate
[2] = 0.0f
;
451 viewport
.translate
[3] = 0.0f
;
453 cso_set_framebuffer(cso
, &fb
);
454 cso_set_sample_mask(cso
, ~0);
455 cso_set_blend(cso
, &hud
->alpha_blend
);
456 cso_set_depth_stencil_alpha(cso
, &hud
->dsa
);
457 cso_set_rasterizer(cso
, &hud
->rasterizer
);
458 cso_set_viewport(cso
, &viewport
);
459 cso_set_stream_outputs(cso
, 0, NULL
, 0);
460 cso_set_geometry_shader_handle(cso
, NULL
);
461 cso_set_vertex_shader_handle(cso
, hud
->vs
);
462 cso_set_vertex_elements(cso
, 2, hud
->velems
);
463 cso_set_render_condition(cso
, NULL
, 0);
464 cso_set_sampler_views(cso
, PIPE_SHADER_FRAGMENT
, 1,
465 &hud
->font_sampler_view
);
466 cso_set_samplers(cso
, PIPE_SHADER_FRAGMENT
, 1, sampler_states
);
467 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
469 /* prepare vertex buffers */
470 hud_alloc_vertices(hud
, &hud
->bg
, 4 * 64, 2 * sizeof(float));
471 hud_alloc_vertices(hud
, &hud
->whitelines
, 4 * 256, 2 * sizeof(float));
472 hud_alloc_vertices(hud
, &hud
->text
, 4 * 512, 4 * sizeof(float));
474 /* prepare all graphs */
475 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
476 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
477 gr
->query_new_value(gr
);
480 hud_pane_accumulate_vertices(hud
, pane
);
483 /* unmap the uploader's vertex buffer before drawing */
484 u_upload_flush(hud
->uploader
);
486 /* draw accumulated vertices for background quads */
487 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
489 if (hud
->bg
.num_vertices
) {
490 hud
->constants
.color
[0] = 0;
491 hud
->constants
.color
[1] = 0;
492 hud
->constants
.color
[2] = 0;
493 hud
->constants
.color
[3] = 0.666;
494 hud
->constants
.translate
[0] = 0;
495 hud
->constants
.translate
[1] = 0;
496 hud
->constants
.scale
[0] = 1;
497 hud
->constants
.scale
[1] = 1;
499 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
500 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
502 cso_draw_arrays(cso
, PIPE_PRIM_QUADS
, 0, hud
->bg
.num_vertices
);
504 pipe_resource_reference(&hud
->bg
.vbuf
.buffer
, NULL
);
506 /* draw accumulated vertices for white lines */
507 hud
->constants
.color
[0] = 1;
508 hud
->constants
.color
[1] = 1;
509 hud
->constants
.color
[2] = 1;
510 hud
->constants
.color
[3] = 1;
511 hud
->constants
.translate
[0] = 0;
512 hud
->constants
.translate
[1] = 0;
513 hud
->constants
.scale
[0] = 1;
514 hud
->constants
.scale
[1] = 1;
515 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
517 if (hud
->whitelines
.num_vertices
) {
518 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
519 &hud
->whitelines
.vbuf
);
520 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
521 cso_draw_arrays(cso
, PIPE_PRIM_LINES
, 0, hud
->whitelines
.num_vertices
);
523 pipe_resource_reference(&hud
->whitelines
.vbuf
.buffer
, NULL
);
525 /* draw accumulated vertices for text */
526 if (hud
->text
.num_vertices
) {
527 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
529 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_text
);
530 cso_draw_arrays(cso
, PIPE_PRIM_QUADS
, 0, hud
->text
.num_vertices
);
532 pipe_resource_reference(&hud
->text
.vbuf
.buffer
, NULL
);
535 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
537 hud_pane_draw_colored_objects(hud
, pane
);
541 cso_restore_framebuffer(cso
);
542 cso_restore_sample_mask(cso
);
543 cso_restore_blend(cso
);
544 cso_restore_depth_stencil_alpha(cso
);
545 cso_restore_fragment_shader(cso
);
546 cso_restore_sampler_views(cso
, PIPE_SHADER_FRAGMENT
);
547 cso_restore_samplers(cso
, PIPE_SHADER_FRAGMENT
);
548 cso_restore_rasterizer(cso
);
549 cso_restore_viewport(cso
);
550 cso_restore_stream_outputs(cso
);
551 cso_restore_geometry_shader(cso
);
552 cso_restore_vertex_shader(cso
);
553 cso_restore_vertex_elements(cso
);
554 cso_restore_aux_vertex_buffer_slot(cso
);
555 cso_restore_constant_buffer_slot0(cso
, PIPE_SHADER_VERTEX
);
556 cso_restore_render_condition(cso
);
558 pipe_surface_reference(&surf
, NULL
);
562 * Set the maximum value for the Y axis of the graph.
563 * This scales the graph accordingly.
566 hud_pane_set_max_value(struct hud_pane
*pane
, uint64_t value
)
568 pane
->max_value
= value
;
569 pane
->yscale
= -(int)pane
->inner_height
/ (double)pane
->max_value
;
572 static struct hud_pane
*
573 hud_pane_create(unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
,
574 unsigned period
, uint64_t max_value
)
576 struct hud_pane
*pane
= CALLOC_STRUCT(hud_pane
);
585 pane
->inner_x1
= x1
+ 1;
586 pane
->inner_x2
= x2
- 1;
587 pane
->inner_y1
= y1
+ 1;
588 pane
->inner_y2
= y2
- 1;
589 pane
->inner_width
= pane
->inner_x2
- pane
->inner_x1
;
590 pane
->inner_height
= pane
->inner_y2
- pane
->inner_y1
;
591 pane
->period
= period
;
592 pane
->max_num_vertices
= (x2
- x1
+ 2) / 2;
593 hud_pane_set_max_value(pane
, max_value
);
594 LIST_INITHEAD(&pane
->graph_list
);
599 * Add a graph to an existing pane.
600 * One pane can contain multiple graphs over each other.
603 hud_pane_add_graph(struct hud_pane
*pane
, struct hud_graph
*gr
)
605 static const float colors
[][3] = {
614 char *name
= gr
->name
;
616 /* replace '-' with a space */
623 assert(pane
->num_graphs
< Elements(colors
));
624 gr
->vertices
= malloc(pane
->max_num_vertices
* sizeof(float) * 2);
625 gr
->color
[0] = colors
[pane
->num_graphs
][0];
626 gr
->color
[1] = colors
[pane
->num_graphs
][1];
627 gr
->color
[2] = colors
[pane
->num_graphs
][2];
629 LIST_ADDTAIL(&gr
->head
, &pane
->graph_list
);
634 hud_graph_add_value(struct hud_graph
*gr
, uint64_t value
)
636 if (gr
->index
== gr
->pane
->max_num_vertices
) {
638 gr
->vertices
[1] = gr
->vertices
[(gr
->index
-1)*2+1];
641 gr
->vertices
[(gr
->index
)*2+0] = gr
->index
*2;
642 gr
->vertices
[(gr
->index
)*2+1] = value
;
645 if (gr
->num_vertices
< gr
->pane
->max_num_vertices
) {
649 gr
->current_value
= value
;
650 if (value
> gr
->pane
->max_value
) {
651 hud_pane_set_max_value(gr
->pane
, value
);
656 hud_graph_destroy(struct hud_graph
*graph
)
658 FREE(graph
->vertices
);
659 if (graph
->free_query_data
)
660 graph
->free_query_data(graph
->query_data
);
665 * Read a string from the environment variable.
666 * The separators "+", ",", ":", and ";" terminate the string.
667 * Return the number of read characters.
670 parse_string(const char *s
, char *out
)
674 for (i
= 0; *s
&& *s
!= '+' && *s
!= ',' && *s
!= ':' && *s
!= ';';
681 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c' (%i) while "
682 "parsing a string\n", *s
, *s
);
687 has_occlusion_query(struct pipe_screen
*screen
)
689 return screen
->get_param(screen
, PIPE_CAP_OCCLUSION_QUERY
) != 0;
693 has_streamout(struct pipe_screen
*screen
)
695 return screen
->get_param(screen
, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS
) != 0;
699 hud_parse_env_var(struct hud_context
*hud
, const char *env
)
702 char name
[256], s
[256];
703 struct hud_pane
*pane
= NULL
;
704 unsigned x
= 10, y
= 10;
705 unsigned width
= 251, height
= 100;
707 while ((num
= parse_string(env
, name
)) != 0) {
711 pane
= hud_pane_create(x
, y
, x
+ width
, y
+ height
, 40000, 10);
717 if (strcmp(name
, "fps") == 0) {
718 hud_fps_graph_install(pane
);
720 else if (strcmp(name
, "cpu") == 0) {
721 hud_cpu_graph_install(pane
, ALL_CPUS
);
723 else if (sscanf(name
, "cpu%u%s", &i
, s
) == 1) {
724 hud_cpu_graph_install(pane
, i
);
726 else if (strcmp(name
, "samples-passed") == 0 &&
727 has_occlusion_query(hud
->pipe
->screen
)) {
728 hud_pipe_query_install(pane
, hud
->pipe
, "samples-passed",
729 PIPE_QUERY_OCCLUSION_COUNTER
, 0, 0, FALSE
);
731 else if (strcmp(name
, "primitives-generated") == 0 &&
732 has_streamout(hud
->pipe
->screen
)) {
733 hud_pipe_query_install(pane
, hud
->pipe
, "primitives-generated",
734 PIPE_QUERY_PRIMITIVES_GENERATED
, 0, 0, FALSE
);
736 else if (strncmp(name
, "pipeline-statistics-", 20) == 0) {
737 if (hud
->cap
.query_pipeline_statistics
) {
738 static const char *pipeline_statistics_names
[] =
745 "clipper-invocations",
746 "clipper-primitives-generated",
752 for (i
= 0; i
< Elements(pipeline_statistics_names
); ++i
)
753 if (strcmp(&name
[20], pipeline_statistics_names
[i
]) == 0)
755 if (i
< Elements(pipeline_statistics_names
))
756 hud_pipe_query_install(pane
, hud
->pipe
, &name
[20],
757 PIPE_QUERY_PIPELINE_STATISTICS
, i
,
760 fprintf(stderr
, "gallium_hud: invalid pipeline-statistics-*\n");
762 fprintf(stderr
, "gallium_hud: PIPE_QUERY_PIPELINE_STATISTICS "
763 "not supported by the driver\n");
767 if (!hud_driver_query_install(pane
, hud
->pipe
, name
)){
768 fprintf(stderr
, "gallium_hud: unknown driver query '%s'\n", name
);
776 fprintf(stderr
, "gallium_hud: syntax error: unexpected ':', "
777 "expected a name\n");
781 num
= parse_string(env
, s
);
784 if (num
&& sscanf(s
, "%u", &i
) == 1) {
785 hud_pane_set_max_value(pane
, i
);
788 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c' (%i) "
789 "after ':'\n", *env
, *env
);
796 /* parse a separator */
804 y
+= height
+ hud
->font
.glyph_height
* (pane
->num_graphs
+ 2);
806 if (pane
&& pane
->num_graphs
) {
807 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
815 x
+= width
+ hud
->font
.glyph_width
* 7;
817 if (pane
&& pane
->num_graphs
) {
818 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
824 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c'\n", *env
);
829 if (pane
->num_graphs
) {
830 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
839 print_help(struct pipe_screen
*screen
)
841 int i
, num_queries
, num_cpus
= hud_get_num_cpus();
843 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
845 puts(" Names are identifiers of data sources which will be drawn as graphs");
846 puts(" in panes. Multiple graphs can be drawn in the same pane.");
847 puts(" There can be multiple panes placed in rows and columns.");
849 puts(" '+' separates names which will share a pane.");
850 puts(" ':[value]' specifies the initial maximum value of the Y axis");
851 puts(" for the given pane.");
852 puts(" ',' creates a new pane below the last one.");
853 puts(" ';' creates a new pane at the top of the next column.");
855 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
857 puts(" Available names:");
861 for (i
= 0; i
< num_cpus
; i
++)
862 printf(" cpu%i\n", i
);
864 if (has_occlusion_query(screen
))
865 puts(" pixels-rendered");
866 if (has_streamout(screen
))
867 puts(" primitives-generated");
869 if (screen
->get_driver_query_info
){
870 struct pipe_driver_query_info info
;
871 num_queries
= screen
->get_driver_query_info(screen
, 0, NULL
);
873 for (i
= 0; i
< num_queries
; i
++){
874 screen
->get_driver_query_info(screen
, i
, &info
);
875 printf(" %s\n", info
.name
);
883 hud_create(struct pipe_context
*pipe
, struct cso_context
*cso
)
885 struct hud_context
*hud
;
886 struct pipe_sampler_view view_templ
;
888 const char *env
= debug_get_option("GALLIUM_HUD", NULL
);
893 if (strcmp(env
, "help") == 0) {
894 print_help(pipe
->screen
);
898 hud
= CALLOC_STRUCT(hud_context
);
904 hud
->uploader
= u_upload_create(pipe
, 256 * 1024, 16,
905 PIPE_BIND_VERTEX_BUFFER
);
908 if (!util_font_create(pipe
, UTIL_FONT_FIXED_8X13
, &hud
->font
)) {
909 u_upload_destroy(hud
->uploader
);
915 hud
->alpha_blend
.rt
[0].colormask
= PIPE_MASK_RGBA
;
916 hud
->alpha_blend
.rt
[0].blend_enable
= 1;
917 hud
->alpha_blend
.rt
[0].rgb_func
= PIPE_BLEND_ADD
;
918 hud
->alpha_blend
.rt
[0].rgb_src_factor
= PIPE_BLENDFACTOR_SRC_ALPHA
;
919 hud
->alpha_blend
.rt
[0].rgb_dst_factor
= PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
920 hud
->alpha_blend
.rt
[0].alpha_func
= PIPE_BLEND_ADD
;
921 hud
->alpha_blend
.rt
[0].alpha_src_factor
= PIPE_BLENDFACTOR_ZERO
;
922 hud
->alpha_blend
.rt
[0].alpha_dst_factor
= PIPE_BLENDFACTOR_ONE
;
924 /* fragment shader */
926 util_make_fragment_passthrough_shader(pipe
,
928 TGSI_INTERPOLATE_CONSTANT
);
931 /* Read a texture and do .xxxx swizzling. */
932 static const char *fragment_shader_text
= {
934 "DCL IN[0], GENERIC[0], LINEAR\n"
936 "DCL OUT[0], COLOR[0]\n"
939 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
940 "MOV OUT[0], TEMP[0].xxxx\n"
944 struct tgsi_token tokens
[1000];
945 struct pipe_shader_state state
= {tokens
};
947 if (!tgsi_text_translate(fragment_shader_text
, tokens
, Elements(tokens
))) {
949 pipe_resource_reference(&hud
->font
.texture
, NULL
);
950 u_upload_destroy(hud
->uploader
);
955 hud
->fs_text
= pipe
->create_fs_state(pipe
, &state
);
959 hud
->rasterizer
.gl_rasterization_rules
= 1;
960 hud
->rasterizer
.depth_clip
= 1;
961 hud
->rasterizer
.line_width
= 1;
962 hud
->rasterizer
.line_last_pixel
= 1;
966 static const char *vertex_shader_text
= {
969 "DCL OUT[0], POSITION\n"
970 "DCL OUT[1], COLOR[0]\n" /* color */
971 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
973 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
974 * [2] = (xscale, yscale, 0, 0) */
977 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
979 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
980 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
981 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
982 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
983 "MOV OUT[0].zw, IMM[0]\n"
985 "MOV OUT[1], CONST[0]\n"
986 "MOV OUT[2], IN[1]\n"
990 struct tgsi_token tokens
[1000];
991 struct pipe_shader_state state
= {tokens
};
993 if (!tgsi_text_translate(vertex_shader_text
, tokens
, Elements(tokens
))) {
995 pipe_resource_reference(&hud
->font
.texture
, NULL
);
996 u_upload_destroy(hud
->uploader
);
1001 hud
->vs
= pipe
->create_vs_state(pipe
, &state
);
1004 /* vertex elements */
1005 for (i
= 0; i
< 2; i
++) {
1006 hud
->velems
[i
].src_offset
= i
* 2 * sizeof(float);
1007 hud
->velems
[i
].src_format
= PIPE_FORMAT_R32G32_FLOAT
;
1008 hud
->velems
[i
].vertex_buffer_index
= cso_get_aux_vertex_buffer_slot(cso
);
1012 memset(&view_templ
, 0, sizeof(view_templ
));
1013 view_templ
.format
= hud
->font
.texture
->format
;
1014 view_templ
.swizzle_r
= PIPE_SWIZZLE_RED
;
1015 view_templ
.swizzle_g
= PIPE_SWIZZLE_GREEN
;
1016 view_templ
.swizzle_b
= PIPE_SWIZZLE_BLUE
;
1017 view_templ
.swizzle_a
= PIPE_SWIZZLE_ALPHA
;
1018 hud
->font_sampler_view
= pipe
->create_sampler_view(pipe
, hud
->font
.texture
,
1022 hud
->constbuf
.buffer_size
= sizeof(hud
->constants
);
1023 hud
->constbuf
.user_buffer
= &hud
->constants
;
1025 LIST_INITHEAD(&hud
->pane_list
);
1027 hud
->cap
.query_pipeline_statistics
=
1028 pipe
->screen
->get_param(pipe
->screen
, PIPE_CAP_QUERY_PIPELINE_STATISTICS
);
1030 hud_parse_env_var(hud
, env
);
1035 hud_destroy(struct hud_context
*hud
)
1037 struct pipe_context
*pipe
= hud
->pipe
;
1038 struct hud_pane
*pane
, *pane_tmp
;
1039 struct hud_graph
*graph
, *graph_tmp
;
1041 LIST_FOR_EACH_ENTRY_SAFE(pane
, pane_tmp
, &hud
->pane_list
, head
) {
1042 LIST_FOR_EACH_ENTRY_SAFE(graph
, graph_tmp
, &pane
->graph_list
, head
) {
1043 LIST_DEL(&graph
->head
);
1044 hud_graph_destroy(graph
);
1046 LIST_DEL(&pane
->head
);
1050 pipe
->delete_fs_state(pipe
, hud
->fs_color
);
1051 pipe
->delete_fs_state(pipe
, hud
->fs_text
);
1052 pipe
->delete_vs_state(pipe
, hud
->vs
);
1053 pipe_sampler_view_reference(&hud
->font_sampler_view
, NULL
);
1054 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1055 u_upload_destroy(hud
->uploader
);