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.
40 #include "hud/hud_context.h"
41 #include "hud/hud_private.h"
44 #include "cso_cache/cso_context.h"
45 #include "util/u_draw_quad.h"
46 #include "util/u_format.h"
47 #include "util/u_inlines.h"
48 #include "util/u_memory.h"
49 #include "util/u_math.h"
50 #include "util/u_sampler.h"
51 #include "util/u_simple_shaders.h"
52 #include "util/u_string.h"
53 #include "util/u_upload_mgr.h"
54 #include "tgsi/tgsi_text.h"
55 #include "tgsi/tgsi_dump.h"
57 /* Control the visibility of all HUD contexts */
58 static boolean huds_visible
= TRUE
;
61 struct pipe_context
*pipe
;
62 struct cso_context
*cso
;
63 struct u_upload_mgr
*uploader
;
65 struct hud_batch_query_context
*batch_query
;
66 struct list_head pane_list
;
69 struct pipe_blend_state no_blend
, alpha_blend
;
70 struct pipe_depth_stencil_alpha_state dsa
;
71 void *fs_color
, *fs_text
;
72 struct pipe_rasterizer_state rasterizer
, rasterizer_aa_lines
;
74 struct pipe_vertex_element velems
[2];
77 struct util_font font
;
78 struct pipe_sampler_view
*font_sampler_view
;
79 struct pipe_sampler_state font_sampler_state
;
81 /* VS constant buffer */
84 float two_div_fb_width
;
85 float two_div_fb_height
;
90 struct pipe_constant_buffer constbuf
;
92 unsigned fb_width
, fb_height
;
94 /* vertices for text and background drawing are accumulated here and then
95 * drawn all at once */
98 struct pipe_vertex_buffer vbuf
;
99 unsigned max_num_vertices
;
100 unsigned num_vertices
;
101 } text
, bg
, whitelines
;
108 signal_visible_handler(int sig
, siginfo_t
*siginfo
, void *context
)
110 huds_visible
= !huds_visible
;
115 hud_draw_colored_prims(struct hud_context
*hud
, unsigned prim
,
116 float *buffer
, unsigned num_vertices
,
117 float r
, float g
, float b
, float a
,
118 int xoffset
, int yoffset
, float yscale
)
120 struct cso_context
*cso
= hud
->cso
;
121 struct pipe_vertex_buffer vbuffer
= {0};
123 hud
->constants
.color
[0] = r
;
124 hud
->constants
.color
[1] = g
;
125 hud
->constants
.color
[2] = b
;
126 hud
->constants
.color
[3] = a
;
127 hud
->constants
.translate
[0] = (float) xoffset
;
128 hud
->constants
.translate
[1] = (float) yoffset
;
129 hud
->constants
.scale
[0] = 1;
130 hud
->constants
.scale
[1] = yscale
;
131 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
133 vbuffer
.user_buffer
= buffer
;
134 vbuffer
.stride
= 2 * sizeof(float);
136 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
),
138 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
139 cso_draw_arrays(cso
, prim
, 0, num_vertices
);
143 hud_draw_colored_quad(struct hud_context
*hud
, unsigned prim
,
144 unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
,
145 float r
, float g
, float b
, float a
)
148 (float) x1
, (float) y1
,
149 (float) x1
, (float) y2
,
150 (float) x2
, (float) y2
,
151 (float) x2
, (float) y1
,
154 hud_draw_colored_prims(hud
, prim
, buffer
, 4, r
, g
, b
, a
, 0, 0, 1);
158 hud_draw_background_quad(struct hud_context
*hud
,
159 unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
)
161 float *vertices
= hud
->bg
.vertices
+ hud
->bg
.num_vertices
*2;
164 assert(hud
->bg
.num_vertices
+ 4 <= hud
->bg
.max_num_vertices
);
166 vertices
[num
++] = (float) x1
;
167 vertices
[num
++] = (float) y1
;
169 vertices
[num
++] = (float) x1
;
170 vertices
[num
++] = (float) y2
;
172 vertices
[num
++] = (float) x2
;
173 vertices
[num
++] = (float) y2
;
175 vertices
[num
++] = (float) x2
;
176 vertices
[num
++] = (float) y1
;
178 hud
->bg
.num_vertices
+= num
/2;
182 hud_draw_string(struct hud_context
*hud
, unsigned x
, unsigned y
,
183 const char *str
, ...)
187 float *vertices
= hud
->text
.vertices
+ hud
->text
.num_vertices
*4;
192 util_vsnprintf(buf
, sizeof(buf
), str
, ap
);
198 hud_draw_background_quad(hud
,
200 x
+ strlen(buf
)*hud
->font
.glyph_width
,
201 y
+ hud
->font
.glyph_height
);
206 unsigned x2
= x
+ hud
->font
.glyph_width
;
207 unsigned y2
= y
+ hud
->font
.glyph_height
;
208 unsigned tx1
= (*s
% 16) * hud
->font
.glyph_width
;
209 unsigned ty1
= (*s
/ 16) * hud
->font
.glyph_height
;
210 unsigned tx2
= tx1
+ hud
->font
.glyph_width
;
211 unsigned ty2
= ty1
+ hud
->font
.glyph_height
;
214 x
+= hud
->font
.glyph_width
;
219 assert(hud
->text
.num_vertices
+ num
/4 + 4 <= hud
->text
.max_num_vertices
);
221 vertices
[num
++] = (float) x1
;
222 vertices
[num
++] = (float) y1
;
223 vertices
[num
++] = (float) tx1
;
224 vertices
[num
++] = (float) ty1
;
226 vertices
[num
++] = (float) x1
;
227 vertices
[num
++] = (float) y2
;
228 vertices
[num
++] = (float) tx1
;
229 vertices
[num
++] = (float) ty2
;
231 vertices
[num
++] = (float) x2
;
232 vertices
[num
++] = (float) y2
;
233 vertices
[num
++] = (float) tx2
;
234 vertices
[num
++] = (float) ty2
;
236 vertices
[num
++] = (float) x2
;
237 vertices
[num
++] = (float) y1
;
238 vertices
[num
++] = (float) tx2
;
239 vertices
[num
++] = (float) ty1
;
241 x
+= hud
->font
.glyph_width
;
245 hud
->text
.num_vertices
+= num
/4;
249 number_to_human_readable(uint64_t num
, enum pipe_driver_query_type type
,
252 static const char *byte_units
[] =
253 {" B", " KB", " MB", " GB", " TB", " PB", " EB"};
254 static const char *metric_units
[] =
255 {"", " k", " M", " G", " T", " P", " E"};
256 static const char *time_units
[] =
257 {" us", " ms", " s"}; /* based on microseconds */
258 static const char *hz_units
[] =
259 {" Hz", " KHz", " MHz", " GHz"};
260 static const char *percent_units
[] = {"%"};
261 static const char *dbm_units
[] = {" (-dBm)"};
262 static const char *temperature_units
[] = {" C"};
263 static const char *volt_units
[] = {" mV", " V"};
264 static const char *amp_units
[] = {" mA", " A"};
265 static const char *watt_units
[] = {" mW", " W"};
269 double divisor
= (type
== PIPE_DRIVER_QUERY_TYPE_BYTES
) ? 1024 : 1000;
274 case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS
:
275 max_unit
= ARRAY_SIZE(time_units
)-1;
278 case PIPE_DRIVER_QUERY_TYPE_VOLTS
:
279 max_unit
= ARRAY_SIZE(volt_units
)-1;
282 case PIPE_DRIVER_QUERY_TYPE_AMPS
:
283 max_unit
= ARRAY_SIZE(amp_units
)-1;
286 case PIPE_DRIVER_QUERY_TYPE_DBM
:
287 max_unit
= ARRAY_SIZE(dbm_units
)-1;
290 case PIPE_DRIVER_QUERY_TYPE_TEMPERATURE
:
291 max_unit
= ARRAY_SIZE(temperature_units
)-1;
292 units
= temperature_units
;
294 case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE
:
295 max_unit
= ARRAY_SIZE(percent_units
)-1;
296 units
= percent_units
;
298 case PIPE_DRIVER_QUERY_TYPE_BYTES
:
299 max_unit
= ARRAY_SIZE(byte_units
)-1;
302 case PIPE_DRIVER_QUERY_TYPE_HZ
:
303 max_unit
= ARRAY_SIZE(hz_units
)-1;
306 case PIPE_DRIVER_QUERY_TYPE_WATTS
:
307 max_unit
= ARRAY_SIZE(watt_units
)-1;
311 max_unit
= ARRAY_SIZE(metric_units
)-1;
312 units
= metric_units
;
315 while (d
> divisor
&& unit
< max_unit
) {
320 /* Round to 3 decimal places so as not to print trailing zeros. */
321 if (d
*1000 != (int)(d
*1000))
322 d
= round(d
* 1000) / 1000;
324 /* Show at least 4 digits with at most 3 decimal places, but not zeros. */
325 if (d
>= 1000 || d
== (int)d
)
326 sprintf(out
, "%.0f%s", d
, units
[unit
]);
327 else if (d
>= 100 || d
*10 == (int)(d
*10))
328 sprintf(out
, "%.1f%s", d
, units
[unit
]);
329 else if (d
>= 10 || d
*100 == (int)(d
*100))
330 sprintf(out
, "%.2f%s", d
, units
[unit
]);
332 sprintf(out
, "%.3f%s", d
, units
[unit
]);
336 hud_draw_graph_line_strip(struct hud_context
*hud
, const struct hud_graph
*gr
,
337 unsigned xoffset
, unsigned yoffset
, float yscale
)
339 if (gr
->num_vertices
<= 1)
342 assert(gr
->index
<= gr
->num_vertices
);
344 hud_draw_colored_prims(hud
, PIPE_PRIM_LINE_STRIP
,
345 gr
->vertices
, gr
->index
,
346 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1,
347 xoffset
+ (gr
->pane
->max_num_vertices
- gr
->index
- 1) * 2 - 1,
350 if (gr
->num_vertices
<= gr
->index
)
353 hud_draw_colored_prims(hud
, PIPE_PRIM_LINE_STRIP
,
354 gr
->vertices
+ gr
->index
*2,
355 gr
->num_vertices
- gr
->index
,
356 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1,
357 xoffset
- gr
->index
*2 - 1, yoffset
, yscale
);
361 hud_pane_accumulate_vertices(struct hud_context
*hud
,
362 const struct hud_pane
*pane
)
364 struct hud_graph
*gr
;
365 float *line_verts
= hud
->whitelines
.vertices
+ hud
->whitelines
.num_vertices
*2;
368 const unsigned last_line
= pane
->last_line
;
370 /* draw background */
371 hud_draw_background_quad(hud
,
375 /* draw numbers on the right-hand side */
376 for (i
= 0; i
<= last_line
; i
++) {
377 unsigned x
= pane
->x2
+ 2;
378 unsigned y
= pane
->inner_y1
+
379 pane
->inner_height
* (last_line
- i
) / last_line
-
380 hud
->font
.glyph_height
/ 2;
382 number_to_human_readable(pane
->max_value
* i
/ last_line
,
384 hud_draw_string(hud
, x
, y
, "%s", str
);
387 /* draw info below the pane */
389 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
390 unsigned x
= pane
->x1
+ 2;
391 unsigned y
= pane
->y2
+ 2 + i
*hud
->font
.glyph_height
;
393 number_to_human_readable(gr
->current_value
, pane
->type
, str
);
394 hud_draw_string(hud
, x
, y
, " %s: %s", gr
->name
, str
);
399 assert(hud
->whitelines
.num_vertices
+ num
/2 + 8 <= hud
->whitelines
.max_num_vertices
);
400 line_verts
[num
++] = (float) pane
->x1
;
401 line_verts
[num
++] = (float) pane
->y1
;
402 line_verts
[num
++] = (float) pane
->x2
;
403 line_verts
[num
++] = (float) pane
->y1
;
405 line_verts
[num
++] = (float) pane
->x2
;
406 line_verts
[num
++] = (float) pane
->y1
;
407 line_verts
[num
++] = (float) pane
->x2
;
408 line_verts
[num
++] = (float) pane
->y2
;
410 line_verts
[num
++] = (float) pane
->x1
;
411 line_verts
[num
++] = (float) pane
->y2
;
412 line_verts
[num
++] = (float) pane
->x2
;
413 line_verts
[num
++] = (float) pane
->y2
;
415 line_verts
[num
++] = (float) pane
->x1
;
416 line_verts
[num
++] = (float) pane
->y1
;
417 line_verts
[num
++] = (float) pane
->x1
;
418 line_verts
[num
++] = (float) pane
->y2
;
420 /* draw horizontal lines inside the graph */
421 for (i
= 0; i
<= last_line
; i
++) {
422 float y
= round((pane
->max_value
* i
/ (double)last_line
) *
423 pane
->yscale
+ pane
->inner_y2
);
425 assert(hud
->whitelines
.num_vertices
+ num
/2 + 2 <= hud
->whitelines
.max_num_vertices
);
426 line_verts
[num
++] = pane
->x1
;
427 line_verts
[num
++] = y
;
428 line_verts
[num
++] = pane
->x2
;
429 line_verts
[num
++] = y
;
432 hud
->whitelines
.num_vertices
+= num
/2;
436 hud_pane_draw_colored_objects(struct hud_context
*hud
,
437 const struct hud_pane
*pane
)
439 struct hud_graph
*gr
;
442 /* draw colored quads below the pane */
444 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
445 unsigned x
= pane
->x1
+ 2;
446 unsigned y
= pane
->y2
+ 2 + i
*hud
->font
.glyph_height
;
448 hud_draw_colored_quad(hud
, PIPE_PRIM_QUADS
, x
+ 1, y
+ 1, x
+ 12, y
+ 13,
449 gr
->color
[0], gr
->color
[1], gr
->color
[2], 1);
453 /* draw the line strips */
454 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
455 hud_draw_graph_line_strip(hud
, gr
, pane
->inner_x1
, pane
->inner_y2
, pane
->yscale
);
460 hud_alloc_vertices(struct hud_context
*hud
, struct vertex_queue
*v
,
461 unsigned num_vertices
, unsigned stride
)
464 v
->max_num_vertices
= num_vertices
;
465 v
->vbuf
.stride
= stride
;
466 u_upload_alloc(hud
->uploader
, 0, v
->vbuf
.stride
* v
->max_num_vertices
,
467 16, &v
->vbuf
.buffer_offset
, &v
->vbuf
.buffer
,
468 (void**)&v
->vertices
);
472 * Draw the HUD to the texture \p tex.
473 * The texture is usually the back buffer being displayed.
476 hud_draw(struct hud_context
*hud
, struct pipe_resource
*tex
)
478 struct cso_context
*cso
= hud
->cso
;
479 struct pipe_context
*pipe
= hud
->pipe
;
480 struct pipe_framebuffer_state fb
;
481 struct pipe_surface surf_templ
, *surf
;
482 struct pipe_viewport_state viewport
;
483 const struct pipe_sampler_state
*sampler_states
[] =
484 { &hud
->font_sampler_state
};
485 struct hud_pane
*pane
;
486 struct hud_graph
*gr
, *next
;
491 hud
->fb_width
= tex
->width0
;
492 hud
->fb_height
= tex
->height0
;
493 hud
->constants
.two_div_fb_width
= 2.0f
/ hud
->fb_width
;
494 hud
->constants
.two_div_fb_height
= 2.0f
/ hud
->fb_height
;
496 cso_save_state(cso
, (CSO_BIT_FRAMEBUFFER
|
497 CSO_BIT_SAMPLE_MASK
|
498 CSO_BIT_MIN_SAMPLES
|
500 CSO_BIT_DEPTH_STENCIL_ALPHA
|
501 CSO_BIT_FRAGMENT_SHADER
|
502 CSO_BIT_FRAGMENT_SAMPLER_VIEWS
|
503 CSO_BIT_FRAGMENT_SAMPLERS
|
506 CSO_BIT_STREAM_OUTPUTS
|
507 CSO_BIT_GEOMETRY_SHADER
|
508 CSO_BIT_TESSCTRL_SHADER
|
509 CSO_BIT_TESSEVAL_SHADER
|
510 CSO_BIT_VERTEX_SHADER
|
511 CSO_BIT_VERTEX_ELEMENTS
|
512 CSO_BIT_AUX_VERTEX_BUFFER_SLOT
|
513 CSO_BIT_PAUSE_QUERIES
|
514 CSO_BIT_RENDER_CONDITION
));
515 cso_save_constant_buffer_slot0(cso
, PIPE_SHADER_VERTEX
);
518 memset(&surf_templ
, 0, sizeof(surf_templ
));
519 surf_templ
.format
= tex
->format
;
521 /* Without this, AA lines look thinner if they are between 2 pixels
522 * because the alpha is 0.5 on both pixels. (it's ugly)
524 * sRGB makes the width of all AA lines look the same.
527 enum pipe_format srgb_format
= util_format_srgb(tex
->format
);
529 if (srgb_format
!= PIPE_FORMAT_NONE
)
530 surf_templ
.format
= srgb_format
;
532 surf
= pipe
->create_surface(pipe
, tex
, &surf_templ
);
534 memset(&fb
, 0, sizeof(fb
));
538 fb
.width
= hud
->fb_width
;
539 fb
.height
= hud
->fb_height
;
541 viewport
.scale
[0] = 0.5f
* hud
->fb_width
;
542 viewport
.scale
[1] = 0.5f
* hud
->fb_height
;
543 viewport
.scale
[2] = 1.0f
;
544 viewport
.translate
[0] = 0.5f
* hud
->fb_width
;
545 viewport
.translate
[1] = 0.5f
* hud
->fb_height
;
546 viewport
.translate
[2] = 0.0f
;
548 cso_set_framebuffer(cso
, &fb
);
549 cso_set_sample_mask(cso
, ~0);
550 cso_set_min_samples(cso
, 1);
551 cso_set_depth_stencil_alpha(cso
, &hud
->dsa
);
552 cso_set_rasterizer(cso
, &hud
->rasterizer
);
553 cso_set_viewport(cso
, &viewport
);
554 cso_set_stream_outputs(cso
, 0, NULL
, NULL
);
555 cso_set_tessctrl_shader_handle(cso
, NULL
);
556 cso_set_tesseval_shader_handle(cso
, NULL
);
557 cso_set_geometry_shader_handle(cso
, NULL
);
558 cso_set_vertex_shader_handle(cso
, hud
->vs
);
559 cso_set_vertex_elements(cso
, 2, hud
->velems
);
560 cso_set_render_condition(cso
, NULL
, FALSE
, 0);
561 cso_set_sampler_views(cso
, PIPE_SHADER_FRAGMENT
, 1,
562 &hud
->font_sampler_view
);
563 cso_set_samplers(cso
, PIPE_SHADER_FRAGMENT
, 1, sampler_states
);
564 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
566 /* prepare vertex buffers */
567 hud_alloc_vertices(hud
, &hud
->bg
, 16 * 256, 2 * sizeof(float));
568 hud_alloc_vertices(hud
, &hud
->whitelines
, 4 * 256, 2 * sizeof(float));
569 hud_alloc_vertices(hud
, &hud
->text
, 16 * 1024, 4 * sizeof(float));
571 /* prepare all graphs */
572 hud_batch_query_update(hud
->batch_query
);
574 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
575 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
576 gr
->query_new_value(gr
);
579 if (pane
->sort_items
) {
580 LIST_FOR_EACH_ENTRY_SAFE(gr
, next
, &pane
->graph_list
, head
) {
581 /* ignore the last one */
582 if (&gr
->head
== pane
->graph_list
.prev
)
585 /* This is an incremental bubble sort, because we only do one pass
586 * per frame. It will eventually reach an equilibrium.
588 if (gr
->current_value
<
589 LIST_ENTRY(struct hud_graph
, next
, head
)->current_value
) {
591 LIST_ADD(&gr
->head
, &next
->head
);
596 hud_pane_accumulate_vertices(hud
, pane
);
599 /* unmap the uploader's vertex buffer before drawing */
600 u_upload_unmap(hud
->uploader
);
602 /* draw accumulated vertices for background quads */
603 cso_set_blend(cso
, &hud
->alpha_blend
);
604 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
606 if (hud
->bg
.num_vertices
) {
607 hud
->constants
.color
[0] = 0;
608 hud
->constants
.color
[1] = 0;
609 hud
->constants
.color
[2] = 0;
610 hud
->constants
.color
[3] = 0.666f
;
611 hud
->constants
.translate
[0] = 0;
612 hud
->constants
.translate
[1] = 0;
613 hud
->constants
.scale
[0] = 1;
614 hud
->constants
.scale
[1] = 1;
616 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
617 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
619 cso_draw_arrays(cso
, PIPE_PRIM_QUADS
, 0, hud
->bg
.num_vertices
);
621 pipe_resource_reference(&hud
->bg
.vbuf
.buffer
, NULL
);
623 /* draw accumulated vertices for white lines */
624 cso_set_blend(cso
, &hud
->no_blend
);
626 hud
->constants
.color
[0] = 1;
627 hud
->constants
.color
[1] = 1;
628 hud
->constants
.color
[2] = 1;
629 hud
->constants
.color
[3] = 1;
630 hud
->constants
.translate
[0] = 0;
631 hud
->constants
.translate
[1] = 0;
632 hud
->constants
.scale
[0] = 1;
633 hud
->constants
.scale
[1] = 1;
634 cso_set_constant_buffer(cso
, PIPE_SHADER_VERTEX
, 0, &hud
->constbuf
);
636 if (hud
->whitelines
.num_vertices
) {
637 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
638 &hud
->whitelines
.vbuf
);
639 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_color
);
640 cso_draw_arrays(cso
, PIPE_PRIM_LINES
, 0, hud
->whitelines
.num_vertices
);
642 pipe_resource_reference(&hud
->whitelines
.vbuf
.buffer
, NULL
);
644 /* draw accumulated vertices for text */
645 cso_set_blend(cso
, &hud
->alpha_blend
);
646 if (hud
->text
.num_vertices
) {
647 cso_set_vertex_buffers(cso
, cso_get_aux_vertex_buffer_slot(cso
), 1,
649 cso_set_fragment_shader_handle(hud
->cso
, hud
->fs_text
);
650 cso_draw_arrays(cso
, PIPE_PRIM_QUADS
, 0, hud
->text
.num_vertices
);
652 pipe_resource_reference(&hud
->text
.vbuf
.buffer
, NULL
);
655 cso_set_rasterizer(cso
, &hud
->rasterizer_aa_lines
);
656 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
658 hud_pane_draw_colored_objects(hud
, pane
);
661 cso_restore_state(cso
);
662 cso_restore_constant_buffer_slot0(cso
, PIPE_SHADER_VERTEX
);
664 pipe_surface_reference(&surf
, NULL
);
667 hud_batch_query_begin(hud
->batch_query
);
669 LIST_FOR_EACH_ENTRY(pane
, &hud
->pane_list
, head
) {
670 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
678 fixup_bytes(enum pipe_driver_query_type type
, int position
, uint64_t *exp10
)
680 if (type
== PIPE_DRIVER_QUERY_TYPE_BYTES
&& position
% 3 == 0)
681 *exp10
= (*exp10
/ 1000) * 1024;
685 * Set the maximum value for the Y axis of the graph.
686 * This scales the graph accordingly.
689 hud_pane_set_max_value(struct hud_pane
*pane
, uint64_t value
)
691 double leftmost_digit
;
695 /* The following code determines the max_value in the graph as well as
696 * how many describing lines are drawn. The max_value is rounded up,
697 * so that all drawn numbers are rounded for readability.
698 * We want to print multiples of a simple number instead of multiples of
699 * hard-to-read numbers like 1.753.
702 /* Find the left-most digit. */
704 for (i
= 0; value
> 9 * exp10
; i
++) {
706 fixup_bytes(pane
->type
, i
+ 1, &exp10
);
709 leftmost_digit
= DIV_ROUND_UP(value
, exp10
);
712 if (leftmost_digit
== 9) {
715 fixup_bytes(pane
->type
, i
+ 1, &exp10
);
718 switch ((unsigned)leftmost_digit
) {
720 pane
->last_line
= 5; /* lines in +1/5 increments */
723 pane
->last_line
= 8; /* lines in +1/4 increments. */
727 pane
->last_line
= leftmost_digit
* 2; /* lines in +1/2 increments */
733 pane
->last_line
= leftmost_digit
; /* lines in +1 increments */
739 /* Truncate {3,4} to {2.5, 3.5} if possible. */
740 for (i
= 3; i
<= 4; i
++) {
741 if (leftmost_digit
== i
&& value
<= (i
- 0.5) * exp10
) {
742 leftmost_digit
= i
- 0.5;
743 pane
->last_line
= leftmost_digit
* 2; /* lines in +1/2 increments. */
747 /* Truncate 2 to a multiple of 0.2 in (1, 1.6] if possible. */
748 if (leftmost_digit
== 2) {
749 for (i
= 1; i
<= 3; i
++) {
750 if (value
<= (1 + i
*0.2) * exp10
) {
751 leftmost_digit
= 1 + i
*0.2;
752 pane
->last_line
= 5 + i
; /* lines in +1/5 increments. */
758 pane
->max_value
= leftmost_digit
* exp10
;
759 pane
->yscale
= -(int)pane
->inner_height
/ (float)pane
->max_value
;
763 hud_pane_update_dyn_ceiling(struct hud_graph
*gr
, struct hud_pane
*pane
)
768 if (pane
->dyn_ceil_last_ran
!= gr
->index
) {
769 LIST_FOR_EACH_ENTRY(gr
, &pane
->graph_list
, head
) {
770 for (i
= 0; i
< gr
->num_vertices
; ++i
) {
771 tmp
= gr
->vertices
[i
* 2 + 1] > tmp
?
772 gr
->vertices
[i
* 2 + 1] : tmp
;
776 /* Avoid setting it lower than the initial starting height. */
777 tmp
= tmp
> pane
->initial_max_value
? tmp
: pane
->initial_max_value
;
778 hud_pane_set_max_value(pane
, tmp
);
782 * Mark this adjustment run so we could avoid repeating a full update
783 * again needlessly in case the pane has more than one graph.
785 pane
->dyn_ceil_last_ran
= gr
->index
;
788 static struct hud_pane
*
789 hud_pane_create(unsigned x1
, unsigned y1
, unsigned x2
, unsigned y2
,
790 unsigned period
, uint64_t max_value
, uint64_t ceiling
,
791 boolean dyn_ceiling
, boolean sort_items
)
793 struct hud_pane
*pane
= CALLOC_STRUCT(hud_pane
);
802 pane
->inner_x1
= x1
+ 1;
803 pane
->inner_x2
= x2
- 1;
804 pane
->inner_y1
= y1
+ 1;
805 pane
->inner_y2
= y2
- 1;
806 pane
->inner_width
= pane
->inner_x2
- pane
->inner_x1
;
807 pane
->inner_height
= pane
->inner_y2
- pane
->inner_y1
;
808 pane
->period
= period
;
809 pane
->max_num_vertices
= (x2
- x1
+ 2) / 2;
810 pane
->ceiling
= ceiling
;
811 pane
->dyn_ceiling
= dyn_ceiling
;
812 pane
->dyn_ceil_last_ran
= 0;
813 pane
->sort_items
= sort_items
;
814 pane
->initial_max_value
= max_value
;
815 hud_pane_set_max_value(pane
, max_value
);
816 LIST_INITHEAD(&pane
->graph_list
);
820 /* replace '-' with a space */
822 strip_hyphens(char *s
)
832 * Add a graph to an existing pane.
833 * One pane can contain multiple graphs over each other.
836 hud_pane_add_graph(struct hud_pane
*pane
, struct hud_graph
*gr
)
838 static const float colors
[][3] = {
855 unsigned color
= pane
->next_color
% ARRAY_SIZE(colors
);
857 strip_hyphens(gr
->name
);
859 gr
->vertices
= MALLOC(pane
->max_num_vertices
* sizeof(float) * 2);
860 gr
->color
[0] = colors
[color
][0];
861 gr
->color
[1] = colors
[color
][1];
862 gr
->color
[2] = colors
[color
][2];
864 LIST_ADDTAIL(&gr
->head
, &pane
->graph_list
);
870 hud_graph_add_value(struct hud_graph
*gr
, uint64_t value
)
872 gr
->current_value
= value
;
873 value
= value
> gr
->pane
->ceiling
? gr
->pane
->ceiling
: value
;
876 fprintf(gr
->fd
, "%" PRIu64
"\n", value
);
878 if (gr
->index
== gr
->pane
->max_num_vertices
) {
880 gr
->vertices
[1] = gr
->vertices
[(gr
->index
-1)*2+1];
883 gr
->vertices
[(gr
->index
)*2+0] = (float) (gr
->index
* 2);
884 gr
->vertices
[(gr
->index
)*2+1] = (float) value
;
887 if (gr
->num_vertices
< gr
->pane
->max_num_vertices
) {
891 if (gr
->pane
->dyn_ceiling
== true) {
892 hud_pane_update_dyn_ceiling(gr
, gr
->pane
);
894 if (value
> gr
->pane
->max_value
) {
895 hud_pane_set_max_value(gr
->pane
, value
);
900 hud_graph_destroy(struct hud_graph
*graph
)
902 FREE(graph
->vertices
);
903 if (graph
->free_query_data
)
904 graph
->free_query_data(graph
->query_data
);
911 hud_graph_set_dump_file(struct hud_graph
*gr
)
913 #ifndef PIPE_OS_WINDOWS
914 const char *hud_dump_dir
= getenv("GALLIUM_HUD_DUMP_DIR");
917 if (hud_dump_dir
&& access(hud_dump_dir
, W_OK
) == 0) {
918 dump_file
= malloc(strlen(hud_dump_dir
) + sizeof("/") + sizeof(gr
->name
));
920 strcpy(dump_file
, hud_dump_dir
);
921 strcat(dump_file
, "/");
922 strcat(dump_file
, gr
->name
);
923 gr
->fd
= fopen(dump_file
, "w+");
931 * Read a string from the environment variable.
932 * The separators "+", ",", ":", and ";" terminate the string.
933 * Return the number of read characters.
936 parse_string(const char *s
, char *out
)
940 for (i
= 0; *s
&& *s
!= '+' && *s
!= ',' && *s
!= ':' && *s
!= ';' && *s
!= '=';
947 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c' (%i) while "
948 "parsing a string\n", *s
, *s
);
956 read_pane_settings(char *str
, unsigned * const x
, unsigned * const y
,
957 unsigned * const width
, unsigned * const height
,
958 uint64_t * const ceiling
, boolean
* const dyn_ceiling
,
959 boolean
*reset_colors
, boolean
*sort_items
)
964 while (*str
== '.') {
969 *x
= strtoul(str
, &ret
, 10);
975 *y
= strtoul(str
, &ret
, 10);
981 tmp
= strtoul(str
, &ret
, 10);
982 *width
= tmp
> 80 ? tmp
: 80; /* 80 is chosen arbitrarily */
987 * Prevent setting height to less than 50. If the height is set to less,
988 * the text of the Y axis labels on the graph will start overlapping.
992 tmp
= strtoul(str
, &ret
, 10);
993 *height
= tmp
> 50 ? tmp
: 50;
999 tmp
= strtoul(str
, &ret
, 10);
1000 *ceiling
= tmp
> 10 ? tmp
: 10;
1007 *dyn_ceiling
= true;
1013 *reset_colors
= true;
1023 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c'\n", *str
);
1033 has_occlusion_query(struct pipe_screen
*screen
)
1035 return screen
->get_param(screen
, PIPE_CAP_OCCLUSION_QUERY
) != 0;
1039 has_streamout(struct pipe_screen
*screen
)
1041 return screen
->get_param(screen
, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS
) != 0;
1045 has_pipeline_stats_query(struct pipe_screen
*screen
)
1047 return screen
->get_param(screen
, PIPE_CAP_QUERY_PIPELINE_STATISTICS
) != 0;
1051 hud_parse_env_var(struct hud_context
*hud
, const char *env
)
1054 char name_a
[256], s
[256];
1056 struct hud_pane
*pane
= NULL
;
1057 unsigned x
= 10, y
= 10;
1058 unsigned width
= 251, height
= 100;
1059 unsigned period
= 500 * 1000; /* default period (1/2 second) */
1060 uint64_t ceiling
= UINT64_MAX
;
1061 unsigned column_width
= 251;
1062 boolean dyn_ceiling
= false;
1063 boolean reset_colors
= false;
1064 boolean sort_items
= false;
1065 const char *period_env
;
1068 * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
1069 * The env var is in seconds (a float).
1070 * Zero means update after every frame.
1072 period_env
= getenv("GALLIUM_HUD_PERIOD");
1074 float p
= (float) atof(period_env
);
1076 period
= (unsigned) (p
* 1000 * 1000);
1080 while ((num
= parse_string(env
, name_a
)) != 0) {
1083 /* check for explicit location, size and etc. settings */
1084 name
= read_pane_settings(name_a
, &x
, &y
, &width
, &height
, &ceiling
,
1085 &dyn_ceiling
, &reset_colors
, &sort_items
);
1088 * Keep track of overall column width to avoid pane overlapping in case
1089 * later we create a new column while the bottom pane in the current
1090 * column is less wide than the rest of the panes in it.
1092 column_width
= width
> column_width
? width
: column_width
;
1095 pane
= hud_pane_create(x
, y
, x
+ width
, y
+ height
, period
, 10,
1096 ceiling
, dyn_ceiling
, sort_items
);
1102 pane
->next_color
= 0;
1103 reset_colors
= false;
1107 #if HAVE_GALLIUM_EXTRA_HUD || HAVE_LIBSENSORS
1110 /* IF YOU CHANGE THIS, UPDATE print_help! */
1111 if (strcmp(name
, "fps") == 0) {
1112 hud_fps_graph_install(pane
);
1114 else if (strcmp(name
, "cpu") == 0) {
1115 hud_cpu_graph_install(pane
, ALL_CPUS
);
1117 else if (sscanf(name
, "cpu%u%s", &i
, s
) == 1) {
1118 hud_cpu_graph_install(pane
, i
);
1120 #if HAVE_GALLIUM_EXTRA_HUD
1121 else if (sscanf(name
, "nic-rx-%s", arg_name
) == 1) {
1122 hud_nic_graph_install(pane
, arg_name
, NIC_DIRECTION_RX
);
1124 else if (sscanf(name
, "nic-tx-%s", arg_name
) == 1) {
1125 hud_nic_graph_install(pane
, arg_name
, NIC_DIRECTION_TX
);
1127 else if (sscanf(name
, "nic-rssi-%s", arg_name
) == 1) {
1128 hud_nic_graph_install(pane
, arg_name
, NIC_RSSI_DBM
);
1129 pane
->type
= PIPE_DRIVER_QUERY_TYPE_DBM
;
1131 else if (sscanf(name
, "diskstat-rd-%s", arg_name
) == 1) {
1132 hud_diskstat_graph_install(pane
, arg_name
, DISKSTAT_RD
);
1133 pane
->type
= PIPE_DRIVER_QUERY_TYPE_BYTES
;
1135 else if (sscanf(name
, "diskstat-wr-%s", arg_name
) == 1) {
1136 hud_diskstat_graph_install(pane
, arg_name
, DISKSTAT_WR
);
1137 pane
->type
= PIPE_DRIVER_QUERY_TYPE_BYTES
;
1139 else if (sscanf(name
, "cpufreq-min-cpu%u", &i
) == 1) {
1140 hud_cpufreq_graph_install(pane
, i
, CPUFREQ_MINIMUM
);
1141 pane
->type
= PIPE_DRIVER_QUERY_TYPE_HZ
;
1143 else if (sscanf(name
, "cpufreq-cur-cpu%u", &i
) == 1) {
1144 hud_cpufreq_graph_install(pane
, i
, CPUFREQ_CURRENT
);
1145 pane
->type
= PIPE_DRIVER_QUERY_TYPE_HZ
;
1147 else if (sscanf(name
, "cpufreq-max-cpu%u", &i
) == 1) {
1148 hud_cpufreq_graph_install(pane
, i
, CPUFREQ_MAXIMUM
);
1149 pane
->type
= PIPE_DRIVER_QUERY_TYPE_HZ
;
1153 else if (sscanf(name
, "sensors_temp_cu-%s", arg_name
) == 1) {
1154 hud_sensors_temp_graph_install(pane
, arg_name
,
1155 SENSORS_TEMP_CURRENT
);
1156 pane
->type
= PIPE_DRIVER_QUERY_TYPE_TEMPERATURE
;
1158 else if (sscanf(name
, "sensors_temp_cr-%s", arg_name
) == 1) {
1159 hud_sensors_temp_graph_install(pane
, arg_name
,
1160 SENSORS_TEMP_CRITICAL
);
1161 pane
->type
= PIPE_DRIVER_QUERY_TYPE_TEMPERATURE
;
1163 else if (sscanf(name
, "sensors_volt_cu-%s", arg_name
) == 1) {
1164 hud_sensors_temp_graph_install(pane
, arg_name
,
1165 SENSORS_VOLTAGE_CURRENT
);
1166 pane
->type
= PIPE_DRIVER_QUERY_TYPE_VOLTS
;
1168 else if (sscanf(name
, "sensors_curr_cu-%s", arg_name
) == 1) {
1169 hud_sensors_temp_graph_install(pane
, arg_name
,
1170 SENSORS_CURRENT_CURRENT
);
1171 pane
->type
= PIPE_DRIVER_QUERY_TYPE_AMPS
;
1173 else if (sscanf(name
, "sensors_pow_cu-%s", arg_name
) == 1) {
1174 hud_sensors_temp_graph_install(pane
, arg_name
,
1175 SENSORS_POWER_CURRENT
);
1176 pane
->type
= PIPE_DRIVER_QUERY_TYPE_WATTS
;
1179 else if (strcmp(name
, "samples-passed") == 0 &&
1180 has_occlusion_query(hud
->pipe
->screen
)) {
1181 hud_pipe_query_install(&hud
->batch_query
, pane
, hud
->pipe
,
1183 PIPE_QUERY_OCCLUSION_COUNTER
, 0, 0,
1184 PIPE_DRIVER_QUERY_TYPE_UINT64
,
1185 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE
,
1188 else if (strcmp(name
, "primitives-generated") == 0 &&
1189 has_streamout(hud
->pipe
->screen
)) {
1190 hud_pipe_query_install(&hud
->batch_query
, pane
, hud
->pipe
,
1191 "primitives-generated",
1192 PIPE_QUERY_PRIMITIVES_GENERATED
, 0, 0,
1193 PIPE_DRIVER_QUERY_TYPE_UINT64
,
1194 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE
,
1198 boolean processed
= FALSE
;
1200 /* pipeline statistics queries */
1201 if (has_pipeline_stats_query(hud
->pipe
->screen
)) {
1202 static const char *pipeline_statistics_names
[] =
1209 "clipper-invocations",
1210 "clipper-primitives-generated",
1216 for (i
= 0; i
< ARRAY_SIZE(pipeline_statistics_names
); ++i
)
1217 if (strcmp(name
, pipeline_statistics_names
[i
]) == 0)
1219 if (i
< ARRAY_SIZE(pipeline_statistics_names
)) {
1220 hud_pipe_query_install(&hud
->batch_query
, pane
, hud
->pipe
, name
,
1221 PIPE_QUERY_PIPELINE_STATISTICS
, i
,
1222 0, PIPE_DRIVER_QUERY_TYPE_UINT64
,
1223 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE
,
1229 /* driver queries */
1231 if (!hud_driver_query_install(&hud
->batch_query
, pane
, hud
->pipe
,
1233 fprintf(stderr
, "gallium_hud: unknown driver query '%s'\n", name
);
1243 fprintf(stderr
, "gallium_hud: syntax error: unexpected ':', "
1244 "expected a name\n");
1249 num
= parse_string(env
, s
);
1252 if (num
&& sscanf(s
, "%u", &i
) == 1) {
1253 hud_pane_set_max_value(pane
, i
);
1254 pane
->initial_max_value
= i
;
1257 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c' (%i) "
1258 "after ':'\n", *env
, *env
);
1267 fprintf(stderr
, "gallium_hud: syntax error: unexpected '=', "
1268 "expected a name\n");
1273 num
= parse_string(env
, s
);
1277 if (!LIST_IS_EMPTY(&pane
->graph_list
)) {
1278 strcpy(LIST_ENTRY(struct hud_graph
,
1279 pane
->graph_list
.prev
, head
)->name
, s
);
1286 /* parse a separator */
1297 y
+= height
+ hud
->font
.glyph_height
* (pane
->num_graphs
+ 2);
1300 if (pane
&& pane
->num_graphs
) {
1301 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
1309 x
+= column_width
+ hud
->font
.glyph_width
* 9;
1312 if (pane
&& pane
->num_graphs
) {
1313 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
1317 /* Starting a new column; reset column width. */
1322 fprintf(stderr
, "gallium_hud: syntax error: unexpected '%c'\n", *env
);
1326 /* Reset to defaults for the next pane in case these were modified. */
1328 ceiling
= UINT64_MAX
;
1329 dyn_ceiling
= false;
1335 if (pane
->num_graphs
) {
1336 LIST_ADDTAIL(&pane
->head
, &hud
->pane_list
);
1345 print_help(struct pipe_screen
*screen
)
1347 int i
, num_queries
, num_cpus
= hud_get_num_cpus();
1349 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
1351 puts(" Names are identifiers of data sources which will be drawn as graphs");
1352 puts(" in panes. Multiple graphs can be drawn in the same pane.");
1353 puts(" There can be multiple panes placed in rows and columns.");
1355 puts(" '+' separates names which will share a pane.");
1356 puts(" ':[value]' specifies the initial maximum value of the Y axis");
1357 puts(" for the given pane.");
1358 puts(" ',' creates a new pane below the last one.");
1359 puts(" ';' creates a new pane at the top of the next column.");
1360 puts(" '=' followed by a string, changes the name of the last data source");
1361 puts(" to that string");
1363 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
1365 puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
1366 puts(" a name, it is possible to explicitly set the location and size");
1367 puts(" of a pane, along with limiting overall maximum value of the");
1368 puts(" Y axis and activating dynamic readjustment of the Y axis.");
1369 puts(" Several modifiers may be applied to the same pane simultaneously.");
1371 puts(" 'x[value]' sets the location of the pane on the x axis relative");
1372 puts(" to the upper-left corner of the viewport, in pixels.");
1373 puts(" 'y[value]' sets the location of the pane on the y axis relative");
1374 puts(" to the upper-left corner of the viewport, in pixels.");
1375 puts(" 'w[value]' sets width of the graph pixels.");
1376 puts(" 'h[value]' sets height of the graph in pixels.");
1377 puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
1378 puts(" If the graph needs to draw values higher than");
1379 puts(" the ceiling allows, the value is clamped.");
1380 puts(" 'd' activates dynamic Y axis readjustment to set the value of");
1381 puts(" the Y axis to match the highest value still visible in the graph.");
1382 puts(" 'r' resets the color counter (the next color will be green)");
1383 puts(" 's' sort items below graphs in descending order");
1385 puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
1386 puts(" the Y axis does not go above the restriction imposed by 'c' while");
1387 puts(" still adjusting the value of the Y axis down when appropriate.");
1389 puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
1391 puts(" Available names:");
1395 for (i
= 0; i
< num_cpus
; i
++)
1396 printf(" cpu%i\n", i
);
1398 if (has_occlusion_query(screen
))
1399 puts(" samples-passed");
1400 if (has_streamout(screen
))
1401 puts(" primitives-generated");
1403 if (has_pipeline_stats_query(screen
)) {
1404 puts(" ia-vertices");
1405 puts(" ia-primitives");
1406 puts(" vs-invocations");
1407 puts(" gs-invocations");
1408 puts(" gs-primitives");
1409 puts(" clipper-invocations");
1410 puts(" clipper-primitives-generated");
1411 puts(" ps-invocations");
1412 puts(" hs-invocations");
1413 puts(" ds-invocations");
1414 puts(" cs-invocations");
1417 #if HAVE_GALLIUM_EXTRA_HUD
1418 hud_get_num_disks(1);
1419 hud_get_num_nics(1);
1420 hud_get_num_cpufreq(1);
1423 hud_get_num_sensors(1);
1426 if (screen
->get_driver_query_info
){
1427 boolean skipping
= false;
1428 struct pipe_driver_query_info info
;
1429 num_queries
= screen
->get_driver_query_info(screen
, 0, NULL
);
1431 for (i
= 0; i
< num_queries
; i
++){
1432 screen
->get_driver_query_info(screen
, i
, &info
);
1433 if (info
.flags
& PIPE_DRIVER_QUERY_FLAG_DONT_LIST
) {
1438 printf(" %s\n", info
.name
);
1448 struct hud_context
*
1449 hud_create(struct pipe_context
*pipe
, struct cso_context
*cso
)
1451 struct pipe_screen
*screen
= pipe
->screen
;
1452 struct hud_context
*hud
;
1453 struct pipe_sampler_view view_templ
;
1455 const char *env
= debug_get_option("GALLIUM_HUD", NULL
);
1457 unsigned signo
= debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0);
1458 static boolean sig_handled
= FALSE
;
1459 struct sigaction action
= {};
1461 huds_visible
= debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE
);
1466 if (strcmp(env
, "help") == 0) {
1467 print_help(pipe
->screen
);
1471 hud
= CALLOC_STRUCT(hud_context
);
1477 hud
->uploader
= u_upload_create(pipe
, 256 * 1024,
1478 PIPE_BIND_VERTEX_BUFFER
, PIPE_USAGE_STREAM
);
1481 if (!util_font_create(pipe
, UTIL_FONT_FIXED_8X13
, &hud
->font
)) {
1482 u_upload_destroy(hud
->uploader
);
1487 hud
->has_srgb
= screen
->is_format_supported(screen
,
1488 PIPE_FORMAT_B8G8R8A8_SRGB
,
1490 PIPE_BIND_RENDER_TARGET
) != 0;
1493 hud
->no_blend
.rt
[0].colormask
= PIPE_MASK_RGBA
;
1495 hud
->alpha_blend
.rt
[0].colormask
= PIPE_MASK_RGBA
;
1496 hud
->alpha_blend
.rt
[0].blend_enable
= 1;
1497 hud
->alpha_blend
.rt
[0].rgb_func
= PIPE_BLEND_ADD
;
1498 hud
->alpha_blend
.rt
[0].rgb_src_factor
= PIPE_BLENDFACTOR_SRC_ALPHA
;
1499 hud
->alpha_blend
.rt
[0].rgb_dst_factor
= PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
1500 hud
->alpha_blend
.rt
[0].alpha_func
= PIPE_BLEND_ADD
;
1501 hud
->alpha_blend
.rt
[0].alpha_src_factor
= PIPE_BLENDFACTOR_ZERO
;
1502 hud
->alpha_blend
.rt
[0].alpha_dst_factor
= PIPE_BLENDFACTOR_ONE
;
1504 /* fragment shader */
1506 util_make_fragment_passthrough_shader(pipe
,
1507 TGSI_SEMANTIC_COLOR
,
1508 TGSI_INTERPOLATE_CONSTANT
,
1512 /* Read a texture and do .xxxx swizzling. */
1513 static const char *fragment_shader_text
= {
1515 "DCL IN[0], GENERIC[0], LINEAR\n"
1517 "DCL SVIEW[0], RECT, FLOAT\n"
1518 "DCL OUT[0], COLOR[0]\n"
1521 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
1522 "MOV OUT[0], TEMP[0].xxxx\n"
1526 struct tgsi_token tokens
[1000];
1527 struct pipe_shader_state state
;
1529 if (!tgsi_text_translate(fragment_shader_text
, tokens
, ARRAY_SIZE(tokens
))) {
1531 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1532 u_upload_destroy(hud
->uploader
);
1536 pipe_shader_state_from_tgsi(&state
, tokens
);
1537 hud
->fs_text
= pipe
->create_fs_state(pipe
, &state
);
1541 hud
->rasterizer
.half_pixel_center
= 1;
1542 hud
->rasterizer
.bottom_edge_rule
= 1;
1543 hud
->rasterizer
.depth_clip
= 1;
1544 hud
->rasterizer
.line_width
= 1;
1545 hud
->rasterizer
.line_last_pixel
= 1;
1547 hud
->rasterizer_aa_lines
= hud
->rasterizer
;
1548 hud
->rasterizer_aa_lines
.line_smooth
= 1;
1552 static const char *vertex_shader_text
= {
1555 "DCL OUT[0], POSITION\n"
1556 "DCL OUT[1], COLOR[0]\n" /* color */
1557 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
1559 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
1560 * [2] = (xscale, yscale, 0, 0) */
1563 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
1565 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
1566 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
1567 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
1568 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
1569 "MOV OUT[0].zw, IMM[0]\n"
1571 "MOV OUT[1], CONST[0]\n"
1572 "MOV OUT[2], IN[1]\n"
1576 struct tgsi_token tokens
[1000];
1577 struct pipe_shader_state state
;
1578 if (!tgsi_text_translate(vertex_shader_text
, tokens
, ARRAY_SIZE(tokens
))) {
1580 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1581 u_upload_destroy(hud
->uploader
);
1585 pipe_shader_state_from_tgsi(&state
, tokens
);
1586 hud
->vs
= pipe
->create_vs_state(pipe
, &state
);
1589 /* vertex elements */
1590 for (i
= 0; i
< 2; i
++) {
1591 hud
->velems
[i
].src_offset
= i
* 2 * sizeof(float);
1592 hud
->velems
[i
].src_format
= PIPE_FORMAT_R32G32_FLOAT
;
1593 hud
->velems
[i
].vertex_buffer_index
= cso_get_aux_vertex_buffer_slot(cso
);
1597 u_sampler_view_default_template(
1598 &view_templ
, hud
->font
.texture
, hud
->font
.texture
->format
);
1599 hud
->font_sampler_view
= pipe
->create_sampler_view(pipe
, hud
->font
.texture
,
1602 /* sampler state (for font drawing) */
1603 hud
->font_sampler_state
.wrap_s
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
1604 hud
->font_sampler_state
.wrap_t
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
1605 hud
->font_sampler_state
.wrap_r
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
1606 hud
->font_sampler_state
.normalized_coords
= 0;
1609 hud
->constbuf
.buffer_size
= sizeof(hud
->constants
);
1610 hud
->constbuf
.user_buffer
= &hud
->constants
;
1612 LIST_INITHEAD(&hud
->pane_list
);
1614 /* setup sig handler once for all hud contexts */
1616 if (!sig_handled
&& signo
!= 0) {
1617 action
.sa_sigaction
= &signal_visible_handler
;
1618 action
.sa_flags
= SA_SIGINFO
;
1621 fprintf(stderr
, "gallium_hud: invalid signal %u\n", signo
);
1622 else if (sigaction(signo
, &action
, NULL
) < 0)
1623 fprintf(stderr
, "gallium_hud: unable to set handler for signal %u\n", signo
);
1630 hud_parse_env_var(hud
, env
);
1635 hud_destroy(struct hud_context
*hud
)
1637 struct pipe_context
*pipe
= hud
->pipe
;
1638 struct hud_pane
*pane
, *pane_tmp
;
1639 struct hud_graph
*graph
, *graph_tmp
;
1641 LIST_FOR_EACH_ENTRY_SAFE(pane
, pane_tmp
, &hud
->pane_list
, head
) {
1642 LIST_FOR_EACH_ENTRY_SAFE(graph
, graph_tmp
, &pane
->graph_list
, head
) {
1643 LIST_DEL(&graph
->head
);
1644 hud_graph_destroy(graph
);
1646 LIST_DEL(&pane
->head
);
1650 hud_batch_query_cleanup(&hud
->batch_query
);
1651 pipe
->delete_fs_state(pipe
, hud
->fs_color
);
1652 pipe
->delete_fs_state(pipe
, hud
->fs_text
);
1653 pipe
->delete_vs_state(pipe
, hud
->vs
);
1654 pipe_sampler_view_reference(&hud
->font_sampler_view
, NULL
);
1655 pipe_resource_reference(&hud
->font
.texture
, NULL
);
1656 u_upload_destroy(hud
->uploader
);