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.
38 #include "hud/hud_context.h"
39 #include "hud/hud_private.h"
42 #include "cso_cache/cso_context.h"
43 #include "util/u_draw_quad.h"
44 #include "util/u_inlines.h"
45 #include "util/u_memory.h"
46 #include "util/u_math.h"
47 #include "util/u_sampler.h"
48 #include "util/u_simple_shaders.h"
49 #include "util/u_string.h"
50 #include "util/u_upload_mgr.h"
51 #include "tgsi/tgsi_text.h"
52 #include "tgsi/tgsi_dump.h"
56 struct pipe_context
*pipe
;
57 struct cso_context
*cso
;
58 struct u_upload_mgr
*uploader
;
60 struct list_head pane_list
;
63 struct pipe_blend_state alpha_blend
;
64 struct pipe_depth_stencil_alpha_state dsa
;
65 void *fs_color
, *fs_text
;
66 struct pipe_rasterizer_state rasterizer
;
68 struct pipe_vertex_element velems
[2];
71 struct util_font font
;
72 struct pipe_sampler_view
*font_sampler_view
;
73 struct pipe_sampler_state font_sampler_state
;
75 /* VS constant buffer */
78 float two_div_fb_width
;
79 float two_div_fb_height
;
84 struct pipe_constant_buffer constbuf
;
86 unsigned fb_width
, fb_height
;
88 /* vertices for text and background drawing are accumulated here and then
89 * drawn all at once */
92 struct pipe_vertex_buffer vbuf
;
93 unsigned max_num_vertices
;
94 unsigned num_vertices
;
95 } text
, bg
, whitelines
;
100 hud_draw_colored_prims(struct hud_context
*hud
, unsigned prim
,
101 float *buffer
, unsigned num_vertices
,
102 float r
, float g
, float b
, float a
,
103 int xoffset
, int yoffset
, float yscale
)
105 struct cso_context
*cso
= hud
->cso
;
106 struct pipe_vertex_buffer vbuffer
= {0};
108 hud
->constants
.color
[0] = r
;
109 hud
->constants
.color
[1] = g
;
110 hud
->constants
.color
[2] = b
;
111 hud
->constants
.color
[3] = a
;
112 hud
->constants
.translate
[0] = (float) xoffset
;
113 hud
->constants
.translate
[1] = (float) yoffset
;
114 hud
->constants
.scale
[0] = 1;
115 hud
->constants
.scale
[1] = yscale
;
116 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
118 vbuffer
.user_buffer
= buffer
;
119 vbuffer
.stride
= 2 * sizeof(float);
121 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
),
123 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
124 cso_draw_arrays(cso
, prim
, 0, num_vertices
);
128 hud_draw_colored_quad(struct hud_context
*hud
, unsigned prim
,
129 unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
,
130 float r
, float g
, float b
, float a
)
133 (float) x1
, (float) y1
,
134 (float) x1
, (float) y2
,
135 (float) x2
, (float) y2
,
136 (float) x2
, (float) y1
,
139 hud_draw_colored_prims(hud
, prim
, buffer
, 4, r
, g
, b
, a
, 0, 0, 1);
143 hud_draw_background_quad(struct hud_context
*hud
,
144 unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
)
146 float *vertices
= hud
->bg
.vertices
+ hud
->bg
.num_vertices
*2;
149 assert(hud
->bg
.num_vertices
+ 4 <= hud
->bg
.max_num_vertices
);
151 vertices
[num
++] = (float) x1
;
152 vertices
[num
++] = (float) y1
;
154 vertices
[num
++] = (float) x1
;
155 vertices
[num
++] = (float) y2
;
157 vertices
[num
++] = (float) x2
;
158 vertices
[num
++] = (float) y2
;
160 vertices
[num
++] = (float) x2
;
161 vertices
[num
++] = (float) y1
;
163 hud
->bg
.num_vertices
+= num
/2;
167 hud_draw_string(struct hud_context
*hud
, unsigned x
, unsigned y
,
168 const char *str
, ...)
172 float *vertices
= hud
->text
.vertices
+ hud
->text
.num_vertices
*4;
177 util_vsnprintf(buf
, sizeof(buf
), str
, ap
);
183 hud_draw_background_quad(hud
,
185 x
+ strlen(buf
)*hud
->font
.glyph_width
,
186 y
+ hud
->font
.glyph_height
);
191 unsigned x2
= x
+ hud
->font
.glyph_width
;
192 unsigned y2
= y
+ hud
->font
.glyph_height
;
193 unsigned tx1
= (*s
% 16) * hud
->font
.glyph_width
;
194 unsigned ty1
= (*s
/ 16) * hud
->font
.glyph_height
;
195 unsigned tx2
= tx1
+ hud
->font
.glyph_width
;
196 unsigned ty2
= ty1
+ hud
->font
.glyph_height
;
199 x
+= hud
->font
.glyph_width
;
204 assert(hud
->text
.num_vertices
+ num
/4 + 4 <= hud
->text
.max_num_vertices
);
206 vertices
[num
++] = (float) x1
;
207 vertices
[num
++] = (float) y1
;
208 vertices
[num
++] = (float) tx1
;
209 vertices
[num
++] = (float) ty1
;
211 vertices
[num
++] = (float) x1
;
212 vertices
[num
++] = (float) y2
;
213 vertices
[num
++] = (float) tx1
;
214 vertices
[num
++] = (float) ty2
;
216 vertices
[num
++] = (float) x2
;
217 vertices
[num
++] = (float) y2
;
218 vertices
[num
++] = (float) tx2
;
219 vertices
[num
++] = (float) ty2
;
221 vertices
[num
++] = (float) x2
;
222 vertices
[num
++] = (float) y1
;
223 vertices
[num
++] = (float) tx2
;
224 vertices
[num
++] = (float) ty1
;
226 x
+= hud
->font
.glyph_width
;
230 hud
->text
.num_vertices
+= num
/4;
234 number_to_human_readable(uint64_t num
, uint64_t max_value
,
235 enum pipe_driver_query_type type
, char *out
)
237 static const char *byte_units
[] =
238 {" B", " KB", " MB", " GB", " TB", " PB", " EB"};
239 static const char *metric_units
[] =
240 {"", " k", " M", " G", " T", " P", " E"};
241 static const char *time_units
[] =
242 {" us", " ms", " s"}; /* based on microseconds */
243 static const char *hz_units
[] =
244 {" Hz", " KHz", " MHz", " GHz"};
245 static const char *percent_units
[] = {"%"};
249 double divisor
= (type
== PIPE_DRIVER_QUERY_TYPE_BYTES
) ? 1024 : 1000;
254 case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS
:
255 max_unit
= ARRAY_SIZE(time_units
)-1;
258 case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE
:
259 max_unit
= ARRAY_SIZE(percent_units
)-1;
260 units
= percent_units
;
262 case PIPE_DRIVER_QUERY_TYPE_BYTES
:
263 max_unit
= ARRAY_SIZE(byte_units
)-1;
266 case PIPE_DRIVER_QUERY_TYPE_HZ
:
267 max_unit
= ARRAY_SIZE(hz_units
)-1;
271 if (max_value
== 100) {
272 max_unit
= ARRAY_SIZE(percent_units
)-1;
273 units
= percent_units
;
275 max_unit
= ARRAY_SIZE(metric_units
)-1;
276 units
= metric_units
;
280 while (d
> divisor
&& unit
< max_unit
) {
285 if (d
>= 100 || d
== (int)d
)
286 sprintf(out
, "%.0f%s", d
, units
[unit
]);
287 else if (d
>= 10 || d
*10 == (int)(d
*10))
288 sprintf(out
, "%.1f%s", d
, units
[unit
]);
290 sprintf(out
, "%.2f%s", d
, units
[unit
]);
294 hud_draw_graph_line_strip(struct hud_context
*hud
, const struct hud_graph
*gr
,
295 unsigned xoffset
, unsigned yoffset
, float yscale
)
297 if (gr
->num_vertices
<= 1)
300 assert(gr
->index
<= gr
->num_vertices
);
302 hud_draw_colored_prims(hud
, PIPE_PRIM_LINE_STRIP
,
303 gr
->vertices
, gr
->index
,
304 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1,
305 xoffset
+ (gr
->pane
->max_num_vertices
- gr
->index
- 1) * 2 - 1,
308 if (gr
->num_vertices
<= gr
->index
)
311 hud_draw_colored_prims(hud
, PIPE_PRIM_LINE_STRIP
,
312 gr
->vertices
+ gr
->index
*2,
313 gr
->num_vertices
- gr
->index
,
314 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1,
315 xoffset
- gr
->index
*2 - 1, yoffset
, yscale
);
319 hud_pane_accumulate_vertices(struct hud_context
*hud
,
320 const struct hud_pane
*pane
)
322 struct hud_graph
*gr
;
323 float *line_verts
= hud
->whitelines
.vertices
+ hud
->whitelines
.num_vertices
*2;
327 /* draw background */
328 hud_draw_background_quad(hud
,
332 /* draw numbers on the right-hand side */
333 for (i
= 0; i
< 6; i
++) {
334 unsigned x
= pane
->x2
+ 2;
335 unsigned y
= pane
->inner_y1
+ pane
->inner_height
* (5 - i
) / 5 -
336 hud
->font
.glyph_height
/ 2;
338 number_to_human_readable(pane
->max_value
* i
/ 5, pane
->max_value
,
340 hud_draw_string(hud
, x
, y
, "%s", str
);
343 /* draw info below the pane */
345 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
346 unsigned x
= pane
->x1
+ 2;
347 unsigned y
= pane
->y2
+ 2 + i
*hud
->font
.glyph_height
;
349 number_to_human_readable(gr
->current_value
, pane
->max_value
,
351 hud_draw_string(hud
, x
, y
, " %s: %s", gr
->name
, str
);
356 assert(hud
->whitelines
.num_vertices
+ num
/2 + 8 <= hud
->whitelines
.max_num_vertices
);
357 line_verts
[num
++] = (float) pane
->x1
;
358 line_verts
[num
++] = (float) pane
->y1
;
359 line_verts
[num
++] = (float) pane
->x2
;
360 line_verts
[num
++] = (float) pane
->y1
;
362 line_verts
[num
++] = (float) pane
->x2
;
363 line_verts
[num
++] = (float) pane
->y1
;
364 line_verts
[num
++] = (float) pane
->x2
;
365 line_verts
[num
++] = (float) pane
->y2
;
367 line_verts
[num
++] = (float) pane
->x1
;
368 line_verts
[num
++] = (float) pane
->y2
;
369 line_verts
[num
++] = (float) pane
->x2
;
370 line_verts
[num
++] = (float) pane
->y2
;
372 line_verts
[num
++] = (float) pane
->x1
;
373 line_verts
[num
++] = (float) pane
->y1
;
374 line_verts
[num
++] = (float) pane
->x1
;
375 line_verts
[num
++] = (float) pane
->y2
;
377 /* draw horizontal lines inside the graph */
378 for (i
= 0; i
<= 5; i
++) {
379 float y
= round((pane
->max_value
* i
/ 5.0) * pane
->yscale
+ pane
->inner_y2
);
381 assert(hud
->whitelines
.num_vertices
+ num
/2 + 2 <= hud
->whitelines
.max_num_vertices
);
382 line_verts
[num
++] = pane
->x1
;
383 line_verts
[num
++] = y
;
384 line_verts
[num
++] = pane
->x2
;
385 line_verts
[num
++] = y
;
388 hud
->whitelines
.num_vertices
+= num
/2;
392 hud_pane_draw_colored_objects(struct hud_context
*hud
,
393 const struct hud_pane
*pane
)
395 struct hud_graph
*gr
;
398 /* draw colored quads below the pane */
400 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
401 unsigned x
= pane
->x1
+ 2;
402 unsigned y
= pane
->y2
+ 2 + i
*hud
->font
.glyph_height
;
404 hud_draw_colored_quad(hud
, PIPE_PRIM_QUADS
, x
+ 1, y
+ 1, x
+ 12, y
+ 13,
405 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1);
409 /* draw the line strips */
410 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
411 hud_draw_graph_line_strip(hud
, gr
, pane
->inner_x1
, pane
->inner_y2
, pane
->yscale
);
416 hud_alloc_vertices(struct hud_context
*hud
, struct vertex_queue
*v
,
417 unsigned num_vertices
, unsigned stride
)
420 v
->max_num_vertices
= num_vertices
;
421 v
->vbuf
.stride
= stride
;
422 u_upload_alloc(hud
->uploader
, 0, v
->vbuf
.stride
* v
->max_num_vertices
,
423 &v
->vbuf
.buffer_offset
, &v
->vbuf
.buffer
,
424 (void**)&v
->vertices
);
428 * Draw the HUD to the texture \p tex.
429 * The texture is usually the back buffer being displayed.
432 hud_draw(struct hud_context
*hud
, struct pipe_resource
*tex
)
434 struct cso_context
*cso
= hud
->cso
;
435 struct pipe_context
*pipe
= hud
->pipe
;
436 struct pipe_framebuffer_state fb
;
437 struct pipe_surface surf_templ
, *surf
;
438 struct pipe_viewport_state viewport
;
439 const struct pipe_sampler_state
*sampler_states
[] =
440 { &hud
->font_sampler_state
};
441 struct hud_pane
*pane
;
442 struct hud_graph
*gr
;
444 hud
->fb_width
= tex
->width0
;
445 hud
->fb_height
= tex
->height0
;
446 hud
->constants
.two_div_fb_width
= 2.0f
/ hud
->fb_width
;
447 hud
->constants
.two_div_fb_height
= 2.0f
/ hud
->fb_height
;
449 cso_save_framebuffer(cso
);
450 cso_save_sample_mask(cso
);
451 cso_save_min_samples(cso
);
453 cso_save_depth_stencil_alpha(cso
);
454 cso_save_fragment_shader(cso
);
455 cso_save_fragment_sampler_views(cso
);
456 cso_save_fragment_samplers(cso
);
457 cso_save_rasterizer(cso
);
458 cso_save_viewport(cso
);
459 cso_save_stream_outputs(cso
);
460 cso_save_geometry_shader(cso
);
461 cso_save_tessctrl_shader(cso
);
462 cso_save_tesseval_shader(cso
);
463 cso_save_vertex_shader(cso
);
464 cso_save_vertex_elements(cso
);
465 cso_save_aux_vertex_buffer_slot(cso
);
466 cso_save_constant_buffer_slot0(cso
, PIPE_SHADER_VERTEX
);
467 cso_save_render_condition(cso
);
470 memset(&surf_templ
, 0, sizeof(surf_templ
));
471 surf_templ
.format
= tex
->format
;
472 surf
= pipe
->create_surface(pipe
, tex
, &surf_templ
);
474 memset(&fb
, 0, sizeof(fb
));
478 fb
.width
= hud
->fb_width
;
479 fb
.height
= hud
->fb_height
;
481 viewport
.scale
[0] = 0.5f
* hud
->fb_width
;
482 viewport
.scale
[1] = 0.5f
* hud
->fb_height
;
483 viewport
.scale
[2] = 1.0f
;
484 viewport
.translate
[0] = 0.5f
* hud
->fb_width
;
485 viewport
.translate
[1] = 0.5f
* hud
->fb_height
;
486 viewport
.translate
[2] = 0.0f
;
488 cso_set_framebuffer(cso
, &fb
);
489 cso_set_sample_mask(cso
, ~0);
490 cso_set_min_samples(cso
, 1);
491 cso_set_blend(cso
, &hud
->alpha_blend
);
492 cso_set_depth_stencil_alpha(cso
, &hud
->dsa
);
493 cso_set_rasterizer(cso
, &hud
->rasterizer
);
494 cso_set_viewport(cso
, &viewport
);
495 cso_set_stream_outputs(cso
, 0, NULL
, NULL
);
496 cso_set_tessctrl_shader_handle(cso
, NULL
);
497 cso_set_tesseval_shader_handle(cso
, NULL
);
498 cso_set_geometry_shader_handle(cso
, NULL
);
499 cso_set_vertex_shader_handle(cso
, hud
->vs
);
500 cso_set_vertex_elements(cso
, 2, hud
->velems
);
501 cso_set_render_condition(cso
, NULL
, FALSE
, 0);
502 cso_set_sampler_views(cso
, PIPE_SHADER_FRAGMENT
, 1,
503 &hud
->font_sampler_view
);
504 cso_set_samplers(cso
, PIPE_SHADER_FRAGMENT
, 1, sampler_states
);
505 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
507 /* prepare vertex buffers */
508 hud_alloc_vertices(hud
, &hud
->bg
, 4 * 128, 2 * sizeof(float));
509 hud_alloc_vertices(hud
, &hud
->whitelines
, 4 * 256, 2 * sizeof(float));
510 hud_alloc_vertices(hud
, &hud
->text
, 4 * 512, 4 * sizeof(float));
512 /* prepare all graphs */
513 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
514 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
515 gr
->query_new_value(gr
);
518 hud_pane_accumulate_vertices(hud
, pane
);
521 /* unmap the uploader's vertex buffer before drawing */
522 u_upload_unmap(hud
->uploader
);
524 /* draw accumulated vertices for background quads */
525 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
527 if (hud
->bg
.num_vertices
) {
528 hud
->constants
.color
[0] = 0;
529 hud
->constants
.color
[1] = 0;
530 hud
->constants
.color
[2] = 0;
531 hud
->constants
.color
[3] = 0.666f
;
532 hud
->constants
.translate
[0] = 0;
533 hud
->constants
.translate
[1] = 0;
534 hud
->constants
.scale
[0] = 1;
535 hud
->constants
.scale
[1] = 1;
537 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
538 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
540 cso_draw_arrays(cso
, PIPE_PRIM_QUADS
, 0, hud
->bg
.num_vertices
);
542 pipe_resource_reference(&hud
->bg
.vbuf
.buffer
, NULL
);
544 /* draw accumulated vertices for white lines */
545 hud
->constants
.color
[0] = 1;
546 hud
->constants
.color
[1] = 1;
547 hud
->constants
.color
[2] = 1;
548 hud
->constants
.color
[3] = 1;
549 hud
->constants
.translate
[0] = 0;
550 hud
->constants
.translate
[1] = 0;
551 hud
->constants
.scale
[0] = 1;
552 hud
->constants
.scale
[1] = 1;
553 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
555 if (hud
->whitelines
.num_vertices
) {
556 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
557 &hud
->whitelines
.vbuf
);
558 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
559 cso_draw_arrays(cso
, PIPE_PRIM_LINES
, 0, hud
->whitelines
.num_vertices
);
561 pipe_resource_reference(&hud
->whitelines
.vbuf
.buffer
, NULL
);
563 /* draw accumulated vertices for text */
564 if (hud
->text
.num_vertices
) {
565 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
567 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_text
);
568 cso_draw_arrays(cso
, PIPE_PRIM_QUADS
, 0, hud
->text
.num_vertices
);
570 pipe_resource_reference(&hud
->text
.vbuf
.buffer
, NULL
);
573 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
575 hud_pane_draw_colored_objects(hud
, pane
);
579 cso_restore_framebuffer(cso
);
580 cso_restore_sample_mask(cso
);
581 cso_restore_min_samples(cso
);
582 cso_restore_blend(cso
);
583 cso_restore_depth_stencil_alpha(cso
);
584 cso_restore_fragment_shader(cso
);
585 cso_restore_fragment_sampler_views(cso
);
586 cso_restore_fragment_samplers(cso
);
587 cso_restore_rasterizer(cso
);
588 cso_restore_viewport(cso
);
589 cso_restore_stream_outputs(cso
);
590 cso_restore_tessctrl_shader(cso
);
591 cso_restore_tesseval_shader(cso
);
592 cso_restore_geometry_shader(cso
);
593 cso_restore_vertex_shader(cso
);
594 cso_restore_vertex_elements(cso
);
595 cso_restore_aux_vertex_buffer_slot(cso
);
596 cso_restore_constant_buffer_slot0(cso
, PIPE_SHADER_VERTEX
);
597 cso_restore_render_condition(cso
);
599 pipe_surface_reference(&surf
, NULL
);
603 * Set the maximum value for the Y axis of the graph.
604 * This scales the graph accordingly.
607 hud_pane_set_max_value(struct hud_pane
*pane
, uint64_t value
)
609 pane
->max_value
= value
;
610 pane
->yscale
= -(int)pane
->inner_height
/ (float)pane
->max_value
;
614 hud_pane_update_dyn_ceiling(struct hud_graph
*gr
, struct hud_pane
*pane
)
619 if (pane
->dyn_ceil_last_ran
!= gr
->index
) {
620 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
621 for (i
= 0; i
< gr
->num_vertices
; ++i
) {
622 tmp
= gr
->vertices
[i
* 2 + 1] > tmp
?
623 gr
->vertices
[i
* 2 + 1] : tmp
;
627 /* Avoid setting it lower than the initial starting height. */
628 tmp
= tmp
> pane
->initial_max_value
? tmp
: pane
->initial_max_value
;
629 hud_pane_set_max_value(pane
, tmp
);
633 * Mark this adjustment run so we could avoid repeating a full update
634 * again needlessly in case the pane has more than one graph.
636 pane
->dyn_ceil_last_ran
= gr
->index
;
639 static struct hud_pane
*
640 hud_pane_create(unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
,
641 unsigned period
, uint64_t max_value
, uint64_t ceiling
,
644 struct hud_pane
*pane
= CALLOC_STRUCT(hud_pane
);
653 pane
->inner_x1
= x1
+ 1;
654 pane
->inner_x2
= x2
- 1;
655 pane
->inner_y1
= y1
+ 1;
656 pane
->inner_y2
= y2
- 1;
657 pane
->inner_width
= pane
->inner_x2
- pane
->inner_x1
;
658 pane
->inner_height
= pane
->inner_y2
- pane
->inner_y1
;
659 pane
->period
= period
;
660 pane
->max_num_vertices
= (x2
- x1
+ 2) / 2;
661 pane
->ceiling
= ceiling
;
662 pane
->dyn_ceiling
= dyn_ceiling
;
663 pane
->dyn_ceil_last_ran
= 0;
664 pane
->initial_max_value
= max_value
;
665 hud_pane_set_max_value(pane
, max_value
);
666 LIST_INITHEAD(&pane
->graph_list
);
671 * Add a graph to an existing pane.
672 * One pane can contain multiple graphs over each other.
675 hud_pane_add_graph(struct hud_pane
*pane
, struct hud_graph
*gr
)
677 static const float colors
[][3] = {
686 char *name
= gr
->name
;
688 /* replace '-' with a space */
695 assert(pane
->num_graphs
< Elements(colors
));
696 gr
->vertices
= MALLOC(pane
->max_num_vertices
* sizeof(float) * 2);
697 gr
->color
[0] = colors
[pane
->num_graphs
][0];
698 gr
->color
[1] = colors
[pane
->num_graphs
][1];
699 gr
->color
[2] = colors
[pane
->num_graphs
][2];
701 LIST_ADDTAIL(&gr
->head
, &pane
->graph_list
);
706 hud_graph_add_value(struct hud_graph
*gr
, uint64_t value
)
708 gr
->current_value
= value
;
709 value
= value
> gr
->pane
->ceiling
? gr
->pane
->ceiling
: value
;
711 if (gr
->index
== gr
->pane
->max_num_vertices
) {
713 gr
->vertices
[1] = gr
->vertices
[(gr
->index
-1)*2+1];
716 gr
->vertices
[(gr
->index
)*2+0] = (float) (gr
->index
* 2);
717 gr
->vertices
[(gr
->index
)*2+1] = (float) value
;
720 if (gr
->num_vertices
< gr
->pane
->max_num_vertices
) {
724 if (gr
->pane
->dyn_ceiling
== true) {
725 hud_pane_update_dyn_ceiling(gr
, gr
->pane
);
727 if (value
> gr
->pane
->max_value
) {
728 hud_pane_set_max_value(gr
->pane
, value
);
733 hud_graph_destroy(struct hud_graph
*graph
)
735 FREE(graph
->vertices
);
736 if (graph
->free_query_data
)
737 graph
->free_query_data(graph
->query_data
);
742 * Read a string from the environment variable.
743 * The separators "+", ",", ":", and ";" terminate the string.
744 * Return the number of read characters.
747 parse_string(const char *s
, char *out
)
751 for (i
= 0; *s
&& *s
!= '+' && *s
!= ',' && *s
!= ':' && *s
!= ';';
758 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c' (%i) while "
759 "parsing a string\n", *s
, *s
);
764 read_pane_settings(char *str
, unsigned * const x
, unsigned * const y
,
765 unsigned * const width
, unsigned * const height
,
766 uint64_t * const ceiling
, boolean
* const dyn_ceiling
)
771 while (*str
== '.') {
776 *x
= strtoul(str
, &ret
, 10);
782 *y
= strtoul(str
, &ret
, 10);
788 tmp
= strtoul(str
, &ret
, 10);
789 *width
= tmp
> 80 ? tmp
: 80; /* 80 is chosen arbitrarily */
794 * Prevent setting height to less than 50. If the height is set to less,
795 * the text of the Y axis labels on the graph will start overlapping.
799 tmp
= strtoul(str
, &ret
, 10);
800 *height
= tmp
> 50 ? tmp
: 50;
806 tmp
= strtoul(str
, &ret
, 10);
807 *ceiling
= tmp
> 10 ? tmp
: 10;
818 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c'\n", *str
);
827 has_occlusion_query(struct pipe_screen
*screen
)
829 return screen
->get_param(screen
, PIPE_CAP_OCCLUSION_QUERY
) != 0;
833 has_streamout(struct pipe_screen
*screen
)
835 return screen
->get_param(screen
, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS
) != 0;
839 has_pipeline_stats_query(struct pipe_screen
*screen
)
841 return screen
->get_param(screen
, PIPE_CAP_QUERY_PIPELINE_STATISTICS
) != 0;
845 hud_parse_env_var(struct hud_context
*hud
, const char *env
)
848 char name_a
[256], s
[256];
850 struct hud_pane
*pane
= NULL
;
851 unsigned x
= 10, y
= 10;
852 unsigned width
= 251, height
= 100;
853 unsigned period
= 500 * 1000; /* default period (1/2 second) */
854 uint64_t ceiling
= UINT64_MAX
;
855 unsigned column_width
= 251;
856 boolean dyn_ceiling
= false;
857 const char *period_env
;
860 * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
861 * The env var is in seconds (a float).
862 * Zero means update after every frame.
864 period_env
= getenv("GALLIUM_HUD_PERIOD");
866 float p
= (float) atof(period_env
);
868 period
= (unsigned) (p
* 1000 * 1000);
872 while ((num
= parse_string(env
, name_a
)) != 0) {
875 /* check for explicit location, size and etc. settings */
876 name
= read_pane_settings(name_a
, &x
, &y
, &width
, &height
, &ceiling
,
880 * Keep track of overall column width to avoid pane overlapping in case
881 * later we create a new column while the bottom pane in the current
882 * column is less wide than the rest of the panes in it.
884 column_width
= width
> column_width
? width
: column_width
;
887 pane
= hud_pane_create(x
, y
, x
+ width
, y
+ height
, period
, 10,
888 ceiling
, dyn_ceiling
);
894 /* IF YOU CHANGE THIS, UPDATE print_help! */
895 if (strcmp(name
, "fps") == 0) {
896 hud_fps_graph_install(pane
);
898 else if (strcmp(name
, "cpu") == 0) {
899 hud_cpu_graph_install(pane
, ALL_CPUS
);
901 else if (sscanf(name
, "cpu%u%s", &i
, s
) == 1) {
902 hud_cpu_graph_install(pane
, i
);
904 else if (strcmp(name
, "samples-passed") == 0 &&
905 has_occlusion_query(hud
->pipe
->screen
)) {
906 hud_pipe_query_install(pane
, hud
->pipe
, "samples-passed",
907 PIPE_QUERY_OCCLUSION_COUNTER
, 0, 0,
908 PIPE_DRIVER_QUERY_TYPE_UINT64
,
909 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE
);
911 else if (strcmp(name
, "primitives-generated") == 0 &&
912 has_streamout(hud
->pipe
->screen
)) {
913 hud_pipe_query_install(pane
, hud
->pipe
, "primitives-generated",
914 PIPE_QUERY_PRIMITIVES_GENERATED
, 0, 0,
915 PIPE_DRIVER_QUERY_TYPE_UINT64
,
916 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE
);
919 boolean processed
= FALSE
;
921 /* pipeline statistics queries */
922 if (has_pipeline_stats_query(hud
->pipe
->screen
)) {
923 static const char *pipeline_statistics_names
[] =
930 "clipper-invocations",
931 "clipper-primitives-generated",
937 for (i
= 0; i
< Elements(pipeline_statistics_names
); ++i
)
938 if (strcmp(name
, pipeline_statistics_names
[i
]) == 0)
940 if (i
< Elements(pipeline_statistics_names
)) {
941 hud_pipe_query_install(pane
, hud
->pipe
, name
,
942 PIPE_QUERY_PIPELINE_STATISTICS
, i
,
943 0, PIPE_DRIVER_QUERY_TYPE_UINT64
,
944 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE
);
951 if (!hud_driver_query_install(pane
, hud
->pipe
, name
)){
952 fprintf(stderr
, "gallium_hud: unknown driver query '%s'\n", name
);
961 fprintf(stderr
, "gallium_hud: syntax error: unexpected ':', "
962 "expected a name\n");
966 num
= parse_string(env
, s
);
969 if (num
&& sscanf(s
, "%u", &i
) == 1) {
970 hud_pane_set_max_value(pane
, i
);
971 pane
->initial_max_value
= i
;
974 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c' (%i) "
975 "after ':'\n", *env
, *env
);
982 /* parse a separator */
990 y
+= height
+ hud
->font
.glyph_height
* (pane
->num_graphs
+ 2);
993 if (pane
&& pane
->num_graphs
) {
994 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
1002 x
+= column_width
+ hud
->font
.glyph_width
* 7;
1005 if (pane
&& pane
->num_graphs
) {
1006 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
1010 /* Starting a new column; reset column width. */
1015 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c'\n", *env
);
1018 /* Reset to defaults for the next pane in case these were modified. */
1020 ceiling
= UINT64_MAX
;
1021 dyn_ceiling
= false;
1026 if (pane
->num_graphs
) {
1027 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
1036 print_help(struct pipe_screen
*screen
)
1038 int i
, num_queries
, num_cpus
= hud_get_num_cpus();
1040 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
1042 puts(" Names are identifiers of data sources which will be drawn as graphs");
1043 puts(" in panes. Multiple graphs can be drawn in the same pane.");
1044 puts(" There can be multiple panes placed in rows and columns.");
1046 puts(" '+' separates names which will share a pane.");
1047 puts(" ':[value]' specifies the initial maximum value of the Y axis");
1048 puts(" for the given pane.");
1049 puts(" ',' creates a new pane below the last one.");
1050 puts(" ';' creates a new pane at the top of the next column.");
1052 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
1054 puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
1055 puts(" a name, it is possible to explicitly set the location and size");
1056 puts(" of a pane, along with limiting overall maximum value of the");
1057 puts(" Y axis and activating dynamic readjustment of the Y axis.");
1058 puts(" Several modifiers may be applied to the same pane simultaneously.");
1060 puts(" 'x[value]' sets the location of the pane on the x axis relative");
1061 puts(" to the upper-left corner of the viewport, in pixels.");
1062 puts(" 'y[value]' sets the location of the pane on the y axis relative");
1063 puts(" to the upper-left corner of the viewport, in pixels.");
1064 puts(" 'w[value]' sets width of the graph pixels.");
1065 puts(" 'h[value]' sets height of the graph in pixels.");
1066 puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
1067 puts(" If the graph needs to draw values higher than");
1068 puts(" the ceiling allows, the value is clamped.");
1069 puts(" 'd' activates dynamic Y axis readjustment to set the value of");
1070 puts(" the Y axis to match the highest value still visible in the graph.");
1072 puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
1073 puts(" the Y axis does not go above the restriction imposed by 'c' while");
1074 puts(" still adjusting the value of the Y axis down when appropriate.");
1076 puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
1078 puts(" Available names:");
1082 for (i
= 0; i
< num_cpus
; i
++)
1083 printf(" cpu%i\n", i
);
1085 if (has_occlusion_query(screen
))
1086 puts(" samples-passed");
1087 if (has_streamout(screen
))
1088 puts(" primitives-generated");
1090 if (has_pipeline_stats_query(screen
)) {
1091 puts(" ia-vertices");
1092 puts(" ia-primitives");
1093 puts(" vs-invocations");
1094 puts(" gs-invocations");
1095 puts(" gs-primitives");
1096 puts(" clipper-invocations");
1097 puts(" clipper-primitives-generated");
1098 puts(" ps-invocations");
1099 puts(" hs-invocations");
1100 puts(" ds-invocations");
1101 puts(" cs-invocations");
1104 if (screen
->get_driver_query_info
){
1105 struct pipe_driver_query_info info
;
1106 num_queries
= screen
->get_driver_query_info(screen
, 0, NULL
);
1108 for (i
= 0; i
< num_queries
; i
++){
1109 screen
->get_driver_query_info(screen
, i
, &info
);
1110 printf(" %s\n", info
.name
);
1118 struct hud_context
*
1119 hud_create(struct pipe_context
*pipe
, struct cso_context
*cso
)
1121 struct hud_context
*hud
;
1122 struct pipe_sampler_view view_templ
;
1124 const char *env
= debug_get_option("GALLIUM_HUD", NULL
);
1129 if (strcmp(env
, "help") == 0) {
1130 print_help(pipe
->screen
);
1134 hud
= CALLOC_STRUCT(hud_context
);
1140 hud
->uploader
= u_upload_create(pipe
, 256 * 1024, 16,
1141 PIPE_BIND_VERTEX_BUFFER
);
1144 if (!util_font_create(pipe
, UTIL_FONT_FIXED_8X13
, &hud
->font
)) {
1145 u_upload_destroy(hud
->uploader
);
1151 hud
->alpha_blend
.rt
[0].colormask
= PIPE_MASK_RGBA
;
1152 hud
->alpha_blend
.rt
[0].blend_enable
= 1;
1153 hud
->alpha_blend
.rt
[0].rgb_func
= PIPE_BLEND_ADD
;
1154 hud
->alpha_blend
.rt
[0].rgb_src_factor
= PIPE_BLENDFACTOR_SRC_ALPHA
;
1155 hud
->alpha_blend
.rt
[0].rgb_dst_factor
= PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
1156 hud
->alpha_blend
.rt
[0].alpha_func
= PIPE_BLEND_ADD
;
1157 hud
->alpha_blend
.rt
[0].alpha_src_factor
= PIPE_BLENDFACTOR_ZERO
;
1158 hud
->alpha_blend
.rt
[0].alpha_dst_factor
= PIPE_BLENDFACTOR_ONE
;
1160 /* fragment shader */
1162 util_make_fragment_passthrough_shader(pipe
,
1163 TGSI_SEMANTIC_COLOR
,
1164 TGSI_INTERPOLATE_CONSTANT
,
1168 /* Read a texture and do .xxxx swizzling. */
1169 static const char *fragment_shader_text
= {
1171 "DCL IN[0], GENERIC[0], LINEAR\n"
1173 "DCL OUT[0], COLOR[0]\n"
1176 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
1177 "MOV OUT[0], TEMP[0].xxxx\n"
1181 struct tgsi_token tokens
[1000];
1182 struct pipe_shader_state state
= {tokens
};
1184 if (!tgsi_text_translate(fragment_shader_text
, tokens
, Elements(tokens
))) {
1186 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1187 u_upload_destroy(hud
->uploader
);
1192 hud
->fs_text
= pipe
->create_fs_state(pipe
, &state
);
1196 hud
->rasterizer
.half_pixel_center
= 1;
1197 hud
->rasterizer
.bottom_edge_rule
= 1;
1198 hud
->rasterizer
.depth_clip
= 1;
1199 hud
->rasterizer
.line_width
= 1;
1200 hud
->rasterizer
.line_last_pixel
= 1;
1204 static const char *vertex_shader_text
= {
1207 "DCL OUT[0], POSITION\n"
1208 "DCL OUT[1], COLOR[0]\n" /* color */
1209 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
1211 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
1212 * [2] = (xscale, yscale, 0, 0) */
1215 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
1217 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
1218 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
1219 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
1220 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
1221 "MOV OUT[0].zw, IMM[0]\n"
1223 "MOV OUT[1], CONST[0]\n"
1224 "MOV OUT[2], IN[1]\n"
1228 struct tgsi_token tokens
[1000];
1229 struct pipe_shader_state state
= {tokens
};
1231 if (!tgsi_text_translate(vertex_shader_text
, tokens
, Elements(tokens
))) {
1233 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1234 u_upload_destroy(hud
->uploader
);
1239 hud
->vs
= pipe
->create_vs_state(pipe
, &state
);
1242 /* vertex elements */
1243 for (i
= 0; i
< 2; i
++) {
1244 hud
->velems
[i
].src_offset
= i
* 2 * sizeof(float);
1245 hud
->velems
[i
].src_format
= PIPE_FORMAT_R32G32_FLOAT
;
1246 hud
->velems
[i
].vertex_buffer_index
= cso_get_aux_vertex_buffer_slot(cso
);
1250 u_sampler_view_default_template(
1251 &view_templ
, hud
->font
.texture
, hud
->font
.texture
->format
);
1252 hud
->font_sampler_view
= pipe
->create_sampler_view(pipe
, hud
->font
.texture
,
1255 /* sampler state (for font drawing) */
1256 hud
->font_sampler_state
.wrap_s
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
1257 hud
->font_sampler_state
.wrap_t
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
1258 hud
->font_sampler_state
.wrap_r
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
1259 hud
->font_sampler_state
.normalized_coords
= 0;
1262 hud
->constbuf
.buffer_size
= sizeof(hud
->constants
);
1263 hud
->constbuf
.user_buffer
= &hud
->constants
;
1265 LIST_INITHEAD(&hud
->pane_list
);
1267 hud_parse_env_var(hud
, env
);
1272 hud_destroy(struct hud_context
*hud
)
1274 struct pipe_context
*pipe
= hud
->pipe
;
1275 struct hud_pane
*pane
, *pane_tmp
;
1276 struct hud_graph
*graph
, *graph_tmp
;
1278 LIST_FOR_EACH_ENTRY_SAFE(pane
, pane_tmp
, &hud
->pane_list
, head
) {
1279 LIST_FOR_EACH_ENTRY_SAFE(graph
, graph_tmp
, &pane
->graph_list
, head
) {
1280 LIST_DEL(&graph
->head
);
1281 hud_graph_destroy(graph
);
1283 LIST_DEL(&pane
->head
);
1287 pipe
->delete_fs_state(pipe
, hud
->fs_color
);
1288 pipe
->delete_fs_state(pipe
, hud
->fs_text
);
1289 pipe
->delete_vs_state(pipe
, hud
->vs
);
1290 pipe_sampler_view_reference(&hud
->font_sampler_view
, NULL
);
1291 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1292 u_upload_destroy(hud
->uploader
);