gallium/hud: draw numbers with 3 decimal places if those aren't 0
[mesa.git] / src / gallium / auxiliary / hud / hud_context.c
1 /**************************************************************************
2 *
3 * Copyright 2013 Marek Olšák <maraeo@gmail.com>
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
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.
31 *
32 * The HUD is controlled with the GALLIUM_HUD environment variable.
33 * Set GALLIUM_HUD=help for more info.
34 */
35
36 #include <signal.h>
37 #include <stdio.h>
38
39 #include "hud/hud_context.h"
40 #include "hud/hud_private.h"
41 #include "hud/font.h"
42
43 #include "cso_cache/cso_context.h"
44 #include "util/u_draw_quad.h"
45 #include "util/u_format.h"
46 #include "util/u_inlines.h"
47 #include "util/u_memory.h"
48 #include "util/u_math.h"
49 #include "util/u_sampler.h"
50 #include "util/u_simple_shaders.h"
51 #include "util/u_string.h"
52 #include "util/u_upload_mgr.h"
53 #include "tgsi/tgsi_text.h"
54 #include "tgsi/tgsi_dump.h"
55
56 /* Control the visibility of all HUD contexts */
57 static boolean huds_visible = TRUE;
58
59 struct hud_context {
60 struct pipe_context *pipe;
61 struct cso_context *cso;
62 struct u_upload_mgr *uploader;
63
64 struct hud_batch_query_context *batch_query;
65 struct list_head pane_list;
66
67 /* states */
68 struct pipe_blend_state no_blend, alpha_blend;
69 struct pipe_depth_stencil_alpha_state dsa;
70 void *fs_color, *fs_text;
71 struct pipe_rasterizer_state rasterizer, rasterizer_aa_lines;
72 void *vs;
73 struct pipe_vertex_element velems[2];
74
75 /* font */
76 struct util_font font;
77 struct pipe_sampler_view *font_sampler_view;
78 struct pipe_sampler_state font_sampler_state;
79
80 /* VS constant buffer */
81 struct {
82 float color[4];
83 float two_div_fb_width;
84 float two_div_fb_height;
85 float translate[2];
86 float scale[2];
87 float padding[2];
88 } constants;
89 struct pipe_constant_buffer constbuf;
90
91 unsigned fb_width, fb_height;
92
93 /* vertices for text and background drawing are accumulated here and then
94 * drawn all at once */
95 struct vertex_queue {
96 float *vertices;
97 struct pipe_vertex_buffer vbuf;
98 unsigned max_num_vertices;
99 unsigned num_vertices;
100 } text, bg, whitelines;
101
102 bool has_srgb;
103 };
104
105 #ifdef PIPE_OS_UNIX
106 static void
107 signal_visible_handler(int sig, siginfo_t *siginfo, void *context)
108 {
109 huds_visible = !huds_visible;
110 }
111 #endif
112
113 static void
114 hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
115 float *buffer, unsigned num_vertices,
116 float r, float g, float b, float a,
117 int xoffset, int yoffset, float yscale)
118 {
119 struct cso_context *cso = hud->cso;
120 struct pipe_vertex_buffer vbuffer = {0};
121
122 hud->constants.color[0] = r;
123 hud->constants.color[1] = g;
124 hud->constants.color[2] = b;
125 hud->constants.color[3] = a;
126 hud->constants.translate[0] = (float) xoffset;
127 hud->constants.translate[1] = (float) yoffset;
128 hud->constants.scale[0] = 1;
129 hud->constants.scale[1] = yscale;
130 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
131
132 vbuffer.user_buffer = buffer;
133 vbuffer.stride = 2 * sizeof(float);
134
135 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso),
136 1, &vbuffer);
137 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
138 cso_draw_arrays(cso, prim, 0, num_vertices);
139 }
140
141 static void
142 hud_draw_colored_quad(struct hud_context *hud, unsigned prim,
143 unsigned x1, unsigned y1, unsigned x2, unsigned y2,
144 float r, float g, float b, float a)
145 {
146 float buffer[] = {
147 (float) x1, (float) y1,
148 (float) x1, (float) y2,
149 (float) x2, (float) y2,
150 (float) x2, (float) y1,
151 };
152
153 hud_draw_colored_prims(hud, prim, buffer, 4, r, g, b, a, 0, 0, 1);
154 }
155
156 static void
157 hud_draw_background_quad(struct hud_context *hud,
158 unsigned x1, unsigned y1, unsigned x2, unsigned y2)
159 {
160 float *vertices = hud->bg.vertices + hud->bg.num_vertices*2;
161 unsigned num = 0;
162
163 assert(hud->bg.num_vertices + 4 <= hud->bg.max_num_vertices);
164
165 vertices[num++] = (float) x1;
166 vertices[num++] = (float) y1;
167
168 vertices[num++] = (float) x1;
169 vertices[num++] = (float) y2;
170
171 vertices[num++] = (float) x2;
172 vertices[num++] = (float) y2;
173
174 vertices[num++] = (float) x2;
175 vertices[num++] = (float) y1;
176
177 hud->bg.num_vertices += num/2;
178 }
179
180 static void
181 hud_draw_string(struct hud_context *hud, unsigned x, unsigned y,
182 const char *str, ...)
183 {
184 char buf[256];
185 char *s = buf;
186 float *vertices = hud->text.vertices + hud->text.num_vertices*4;
187 unsigned num = 0;
188
189 va_list ap;
190 va_start(ap, str);
191 util_vsnprintf(buf, sizeof(buf), str, ap);
192 va_end(ap);
193
194 if (!*s)
195 return;
196
197 hud_draw_background_quad(hud,
198 x, y,
199 x + strlen(buf)*hud->font.glyph_width,
200 y + hud->font.glyph_height);
201
202 while (*s) {
203 unsigned x1 = x;
204 unsigned y1 = y;
205 unsigned x2 = x + hud->font.glyph_width;
206 unsigned y2 = y + hud->font.glyph_height;
207 unsigned tx1 = (*s % 16) * hud->font.glyph_width;
208 unsigned ty1 = (*s / 16) * hud->font.glyph_height;
209 unsigned tx2 = tx1 + hud->font.glyph_width;
210 unsigned ty2 = ty1 + hud->font.glyph_height;
211
212 if (*s == ' ') {
213 x += hud->font.glyph_width;
214 s++;
215 continue;
216 }
217
218 assert(hud->text.num_vertices + num/4 + 4 <= hud->text.max_num_vertices);
219
220 vertices[num++] = (float) x1;
221 vertices[num++] = (float) y1;
222 vertices[num++] = (float) tx1;
223 vertices[num++] = (float) ty1;
224
225 vertices[num++] = (float) x1;
226 vertices[num++] = (float) y2;
227 vertices[num++] = (float) tx1;
228 vertices[num++] = (float) ty2;
229
230 vertices[num++] = (float) x2;
231 vertices[num++] = (float) y2;
232 vertices[num++] = (float) tx2;
233 vertices[num++] = (float) ty2;
234
235 vertices[num++] = (float) x2;
236 vertices[num++] = (float) y1;
237 vertices[num++] = (float) tx2;
238 vertices[num++] = (float) ty1;
239
240 x += hud->font.glyph_width;
241 s++;
242 }
243
244 hud->text.num_vertices += num/4;
245 }
246
247 static void
248 number_to_human_readable(uint64_t num, uint64_t max_value,
249 enum pipe_driver_query_type type, char *out)
250 {
251 static const char *byte_units[] =
252 {" B", " KB", " MB", " GB", " TB", " PB", " EB"};
253 static const char *metric_units[] =
254 {"", " k", " M", " G", " T", " P", " E"};
255 static const char *time_units[] =
256 {" us", " ms", " s"}; /* based on microseconds */
257 static const char *hz_units[] =
258 {" Hz", " KHz", " MHz", " GHz"};
259 static const char *percent_units[] = {"%"};
260
261 const char **units;
262 unsigned max_unit;
263 double divisor = (type == PIPE_DRIVER_QUERY_TYPE_BYTES) ? 1024 : 1000;
264 unsigned unit = 0;
265 double d = num;
266
267 switch (type) {
268 case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS:
269 max_unit = ARRAY_SIZE(time_units)-1;
270 units = time_units;
271 break;
272 case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE:
273 max_unit = ARRAY_SIZE(percent_units)-1;
274 units = percent_units;
275 break;
276 case PIPE_DRIVER_QUERY_TYPE_BYTES:
277 max_unit = ARRAY_SIZE(byte_units)-1;
278 units = byte_units;
279 break;
280 case PIPE_DRIVER_QUERY_TYPE_HZ:
281 max_unit = ARRAY_SIZE(hz_units)-1;
282 units = hz_units;
283 break;
284 default:
285 if (max_value == 100) {
286 max_unit = ARRAY_SIZE(percent_units)-1;
287 units = percent_units;
288 } else {
289 max_unit = ARRAY_SIZE(metric_units)-1;
290 units = metric_units;
291 }
292 }
293
294 while (d > divisor && unit < max_unit) {
295 d /= divisor;
296 unit++;
297 }
298
299 /* Round to 3 decimal places so as not to print trailing zeros. */
300 if (d*1000 != (int)(d*1000))
301 d = round(d * 1000) / 1000;
302
303 /* Show at least 4 digits with at most 3 decimal places, but not zeros. */
304 if (d >= 1000 || d == (int)d)
305 sprintf(out, "%.0f%s", d, units[unit]);
306 else if (d >= 100 || d*10 == (int)(d*10))
307 sprintf(out, "%.1f%s", d, units[unit]);
308 else if (d >= 10 || d*100 == (int)(d*100))
309 sprintf(out, "%.2f%s", d, units[unit]);
310 else
311 sprintf(out, "%.3f%s", d, units[unit]);
312 }
313
314 static void
315 hud_draw_graph_line_strip(struct hud_context *hud, const struct hud_graph *gr,
316 unsigned xoffset, unsigned yoffset, float yscale)
317 {
318 if (gr->num_vertices <= 1)
319 return;
320
321 assert(gr->index <= gr->num_vertices);
322
323 hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
324 gr->vertices, gr->index,
325 gr->color[0], gr->color[1], gr->color[2], 1,
326 xoffset + (gr->pane->max_num_vertices - gr->index - 1) * 2 - 1,
327 yoffset, yscale);
328
329 if (gr->num_vertices <= gr->index)
330 return;
331
332 hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
333 gr->vertices + gr->index*2,
334 gr->num_vertices - gr->index,
335 gr->color[0], gr->color[1], gr->color[2], 1,
336 xoffset - gr->index*2 - 1, yoffset, yscale);
337 }
338
339 static void
340 hud_pane_accumulate_vertices(struct hud_context *hud,
341 const struct hud_pane *pane)
342 {
343 struct hud_graph *gr;
344 float *line_verts = hud->whitelines.vertices + hud->whitelines.num_vertices*2;
345 unsigned i, num = 0;
346 char str[32];
347
348 /* draw background */
349 hud_draw_background_quad(hud,
350 pane->x1, pane->y1,
351 pane->x2, pane->y2);
352
353 /* draw numbers on the right-hand side */
354 for (i = 0; i < 6; i++) {
355 unsigned x = pane->x2 + 2;
356 unsigned y = pane->inner_y1 + pane->inner_height * (5 - i) / 5 -
357 hud->font.glyph_height / 2;
358
359 number_to_human_readable(pane->max_value * i / 5, pane->max_value,
360 pane->type, str);
361 hud_draw_string(hud, x, y, "%s", str);
362 }
363
364 /* draw info below the pane */
365 i = 0;
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;
369
370 number_to_human_readable(gr->current_value, pane->max_value,
371 pane->type, str);
372 hud_draw_string(hud, x, y, " %s: %s", gr->name, str);
373 i++;
374 }
375
376 /* draw border */
377 assert(hud->whitelines.num_vertices + num/2 + 8 <= hud->whitelines.max_num_vertices);
378 line_verts[num++] = (float) pane->x1;
379 line_verts[num++] = (float) pane->y1;
380 line_verts[num++] = (float) pane->x2;
381 line_verts[num++] = (float) pane->y1;
382
383 line_verts[num++] = (float) pane->x2;
384 line_verts[num++] = (float) pane->y1;
385 line_verts[num++] = (float) pane->x2;
386 line_verts[num++] = (float) pane->y2;
387
388 line_verts[num++] = (float) pane->x1;
389 line_verts[num++] = (float) pane->y2;
390 line_verts[num++] = (float) pane->x2;
391 line_verts[num++] = (float) pane->y2;
392
393 line_verts[num++] = (float) pane->x1;
394 line_verts[num++] = (float) pane->y1;
395 line_verts[num++] = (float) pane->x1;
396 line_verts[num++] = (float) pane->y2;
397
398 /* draw horizontal lines inside the graph */
399 for (i = 0; i <= 5; i++) {
400 float y = round((pane->max_value * i / 5.0) * pane->yscale + pane->inner_y2);
401
402 assert(hud->whitelines.num_vertices + num/2 + 2 <= hud->whitelines.max_num_vertices);
403 line_verts[num++] = pane->x1;
404 line_verts[num++] = y;
405 line_verts[num++] = pane->x2;
406 line_verts[num++] = y;
407 }
408
409 hud->whitelines.num_vertices += num/2;
410 }
411
412 static void
413 hud_pane_draw_colored_objects(struct hud_context *hud,
414 const struct hud_pane *pane)
415 {
416 struct hud_graph *gr;
417 unsigned i;
418
419 /* draw colored quads below the pane */
420 i = 0;
421 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
422 unsigned x = pane->x1 + 2;
423 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
424
425 hud_draw_colored_quad(hud, PIPE_PRIM_QUADS, x + 1, y + 1, x + 12, y + 13,
426 gr->color[0], gr->color[1], gr->color[2], 1);
427 i++;
428 }
429
430 /* draw the line strips */
431 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
432 hud_draw_graph_line_strip(hud, gr, pane->inner_x1, pane->inner_y2, pane->yscale);
433 }
434 }
435
436 static void
437 hud_alloc_vertices(struct hud_context *hud, struct vertex_queue *v,
438 unsigned num_vertices, unsigned stride)
439 {
440 v->num_vertices = 0;
441 v->max_num_vertices = num_vertices;
442 v->vbuf.stride = stride;
443 u_upload_alloc(hud->uploader, 0, v->vbuf.stride * v->max_num_vertices,
444 16, &v->vbuf.buffer_offset, &v->vbuf.buffer,
445 (void**)&v->vertices);
446 }
447
448 /**
449 * Draw the HUD to the texture \p tex.
450 * The texture is usually the back buffer being displayed.
451 */
452 void
453 hud_draw(struct hud_context *hud, struct pipe_resource *tex)
454 {
455 struct cso_context *cso = hud->cso;
456 struct pipe_context *pipe = hud->pipe;
457 struct pipe_framebuffer_state fb;
458 struct pipe_surface surf_templ, *surf;
459 struct pipe_viewport_state viewport;
460 const struct pipe_sampler_state *sampler_states[] =
461 { &hud->font_sampler_state };
462 struct hud_pane *pane;
463 struct hud_graph *gr;
464
465 if (!huds_visible)
466 return;
467
468 hud->fb_width = tex->width0;
469 hud->fb_height = tex->height0;
470 hud->constants.two_div_fb_width = 2.0f / hud->fb_width;
471 hud->constants.two_div_fb_height = 2.0f / hud->fb_height;
472
473 cso_save_state(cso, (CSO_BIT_FRAMEBUFFER |
474 CSO_BIT_SAMPLE_MASK |
475 CSO_BIT_MIN_SAMPLES |
476 CSO_BIT_BLEND |
477 CSO_BIT_DEPTH_STENCIL_ALPHA |
478 CSO_BIT_FRAGMENT_SHADER |
479 CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
480 CSO_BIT_FRAGMENT_SAMPLERS |
481 CSO_BIT_RASTERIZER |
482 CSO_BIT_VIEWPORT |
483 CSO_BIT_STREAM_OUTPUTS |
484 CSO_BIT_GEOMETRY_SHADER |
485 CSO_BIT_TESSCTRL_SHADER |
486 CSO_BIT_TESSEVAL_SHADER |
487 CSO_BIT_VERTEX_SHADER |
488 CSO_BIT_VERTEX_ELEMENTS |
489 CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
490 CSO_BIT_PAUSE_QUERIES |
491 CSO_BIT_RENDER_CONDITION));
492 cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
493
494 /* set states */
495 memset(&surf_templ, 0, sizeof(surf_templ));
496 surf_templ.format = tex->format;
497
498 /* Without this, AA lines look thinner if they are between 2 pixels
499 * because the alpha is 0.5 on both pixels. (it's ugly)
500 *
501 * sRGB makes the width of all AA lines look the same.
502 */
503 if (hud->has_srgb) {
504 enum pipe_format srgb_format = util_format_srgb(tex->format);
505
506 if (srgb_format != PIPE_FORMAT_NONE)
507 surf_templ.format = srgb_format;
508 }
509 surf = pipe->create_surface(pipe, tex, &surf_templ);
510
511 memset(&fb, 0, sizeof(fb));
512 fb.nr_cbufs = 1;
513 fb.cbufs[0] = surf;
514 fb.zsbuf = NULL;
515 fb.width = hud->fb_width;
516 fb.height = hud->fb_height;
517
518 viewport.scale[0] = 0.5f * hud->fb_width;
519 viewport.scale[1] = 0.5f * hud->fb_height;
520 viewport.scale[2] = 1.0f;
521 viewport.translate[0] = 0.5f * hud->fb_width;
522 viewport.translate[1] = 0.5f * hud->fb_height;
523 viewport.translate[2] = 0.0f;
524
525 cso_set_framebuffer(cso, &fb);
526 cso_set_sample_mask(cso, ~0);
527 cso_set_min_samples(cso, 1);
528 cso_set_depth_stencil_alpha(cso, &hud->dsa);
529 cso_set_rasterizer(cso, &hud->rasterizer);
530 cso_set_viewport(cso, &viewport);
531 cso_set_stream_outputs(cso, 0, NULL, NULL);
532 cso_set_tessctrl_shader_handle(cso, NULL);
533 cso_set_tesseval_shader_handle(cso, NULL);
534 cso_set_geometry_shader_handle(cso, NULL);
535 cso_set_vertex_shader_handle(cso, hud->vs);
536 cso_set_vertex_elements(cso, 2, hud->velems);
537 cso_set_render_condition(cso, NULL, FALSE, 0);
538 cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1,
539 &hud->font_sampler_view);
540 cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states);
541 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
542
543 /* prepare vertex buffers */
544 hud_alloc_vertices(hud, &hud->bg, 4 * 128, 2 * sizeof(float));
545 hud_alloc_vertices(hud, &hud->whitelines, 4 * 256, 2 * sizeof(float));
546 hud_alloc_vertices(hud, &hud->text, 4 * 1024, 4 * sizeof(float));
547
548 /* prepare all graphs */
549 hud_batch_query_update(hud->batch_query);
550
551 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
552 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
553 gr->query_new_value(gr);
554 }
555
556 hud_pane_accumulate_vertices(hud, pane);
557 }
558
559 /* unmap the uploader's vertex buffer before drawing */
560 u_upload_unmap(hud->uploader);
561
562 /* draw accumulated vertices for background quads */
563 cso_set_blend(cso, &hud->alpha_blend);
564 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
565
566 if (hud->bg.num_vertices) {
567 hud->constants.color[0] = 0;
568 hud->constants.color[1] = 0;
569 hud->constants.color[2] = 0;
570 hud->constants.color[3] = 0.666f;
571 hud->constants.translate[0] = 0;
572 hud->constants.translate[1] = 0;
573 hud->constants.scale[0] = 1;
574 hud->constants.scale[1] = 1;
575
576 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
577 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
578 &hud->bg.vbuf);
579 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->bg.num_vertices);
580 }
581 pipe_resource_reference(&hud->bg.vbuf.buffer, NULL);
582
583 /* draw accumulated vertices for white lines */
584 cso_set_blend(cso, &hud->no_blend);
585
586 hud->constants.color[0] = 1;
587 hud->constants.color[1] = 1;
588 hud->constants.color[2] = 1;
589 hud->constants.color[3] = 1;
590 hud->constants.translate[0] = 0;
591 hud->constants.translate[1] = 0;
592 hud->constants.scale[0] = 1;
593 hud->constants.scale[1] = 1;
594 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
595
596 if (hud->whitelines.num_vertices) {
597 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
598 &hud->whitelines.vbuf);
599 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
600 cso_draw_arrays(cso, PIPE_PRIM_LINES, 0, hud->whitelines.num_vertices);
601 }
602 pipe_resource_reference(&hud->whitelines.vbuf.buffer, NULL);
603
604 /* draw accumulated vertices for text */
605 cso_set_blend(cso, &hud->alpha_blend);
606 if (hud->text.num_vertices) {
607 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
608 &hud->text.vbuf);
609 cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
610 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->text.num_vertices);
611 }
612 pipe_resource_reference(&hud->text.vbuf.buffer, NULL);
613
614 /* draw the rest */
615 cso_set_rasterizer(cso, &hud->rasterizer_aa_lines);
616 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
617 if (pane)
618 hud_pane_draw_colored_objects(hud, pane);
619 }
620
621 cso_restore_state(cso);
622 cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
623
624 pipe_surface_reference(&surf, NULL);
625 }
626
627 /**
628 * Set the maximum value for the Y axis of the graph.
629 * This scales the graph accordingly.
630 */
631 void
632 hud_pane_set_max_value(struct hud_pane *pane, uint64_t value)
633 {
634 pane->max_value = value;
635 pane->yscale = -(int)pane->inner_height / (float)pane->max_value;
636 }
637
638 static void
639 hud_pane_update_dyn_ceiling(struct hud_graph *gr, struct hud_pane *pane)
640 {
641 unsigned i;
642 float tmp = 0.0f;
643
644 if (pane->dyn_ceil_last_ran != gr->index) {
645 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
646 for (i = 0; i < gr->num_vertices; ++i) {
647 tmp = gr->vertices[i * 2 + 1] > tmp ?
648 gr->vertices[i * 2 + 1] : tmp;
649 }
650 }
651
652 /* Avoid setting it lower than the initial starting height. */
653 tmp = tmp > pane->initial_max_value ? tmp : pane->initial_max_value;
654 hud_pane_set_max_value(pane, tmp);
655 }
656
657 /*
658 * Mark this adjustment run so we could avoid repeating a full update
659 * again needlessly in case the pane has more than one graph.
660 */
661 pane->dyn_ceil_last_ran = gr->index;
662 }
663
664 static struct hud_pane *
665 hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
666 unsigned period, uint64_t max_value, uint64_t ceiling,
667 boolean dyn_ceiling)
668 {
669 struct hud_pane *pane = CALLOC_STRUCT(hud_pane);
670
671 if (!pane)
672 return NULL;
673
674 pane->x1 = x1;
675 pane->y1 = y1;
676 pane->x2 = x2;
677 pane->y2 = y2;
678 pane->inner_x1 = x1 + 1;
679 pane->inner_x2 = x2 - 1;
680 pane->inner_y1 = y1 + 1;
681 pane->inner_y2 = y2 - 1;
682 pane->inner_width = pane->inner_x2 - pane->inner_x1;
683 pane->inner_height = pane->inner_y2 - pane->inner_y1;
684 pane->period = period;
685 pane->max_num_vertices = (x2 - x1 + 2) / 2;
686 pane->ceiling = ceiling;
687 pane->dyn_ceiling = dyn_ceiling;
688 pane->dyn_ceil_last_ran = 0;
689 pane->initial_max_value = max_value;
690 hud_pane_set_max_value(pane, max_value);
691 LIST_INITHEAD(&pane->graph_list);
692 return pane;
693 }
694
695 /**
696 * Add a graph to an existing pane.
697 * One pane can contain multiple graphs over each other.
698 */
699 void
700 hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr)
701 {
702 static const float colors[][3] = {
703 {0, 1, 0},
704 {1, 0, 0},
705 {0, 1, 1},
706 {1, 0, 1},
707 {1, 1, 0},
708 {0.5, 0.5, 1},
709 {0.5, 0.5, 0.5},
710 };
711 char *name = gr->name;
712
713 /* replace '-' with a space */
714 while (*name) {
715 if (*name == '-')
716 *name = ' ';
717 name++;
718 }
719
720 assert(pane->num_graphs < ARRAY_SIZE(colors));
721 gr->vertices = MALLOC(pane->max_num_vertices * sizeof(float) * 2);
722 gr->color[0] = colors[pane->num_graphs][0];
723 gr->color[1] = colors[pane->num_graphs][1];
724 gr->color[2] = colors[pane->num_graphs][2];
725 gr->pane = pane;
726 LIST_ADDTAIL(&gr->head, &pane->graph_list);
727 pane->num_graphs++;
728 }
729
730 void
731 hud_graph_add_value(struct hud_graph *gr, uint64_t value)
732 {
733 gr->current_value = value;
734 value = value > gr->pane->ceiling ? gr->pane->ceiling : value;
735
736 if (gr->index == gr->pane->max_num_vertices) {
737 gr->vertices[0] = 0;
738 gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
739 gr->index = 1;
740 }
741 gr->vertices[(gr->index)*2+0] = (float) (gr->index * 2);
742 gr->vertices[(gr->index)*2+1] = (float) value;
743 gr->index++;
744
745 if (gr->num_vertices < gr->pane->max_num_vertices) {
746 gr->num_vertices++;
747 }
748
749 if (gr->pane->dyn_ceiling == true) {
750 hud_pane_update_dyn_ceiling(gr, gr->pane);
751 }
752 if (value > gr->pane->max_value) {
753 hud_pane_set_max_value(gr->pane, value);
754 }
755 }
756
757 static void
758 hud_graph_destroy(struct hud_graph *graph)
759 {
760 FREE(graph->vertices);
761 if (graph->free_query_data)
762 graph->free_query_data(graph->query_data);
763 FREE(graph);
764 }
765
766 /**
767 * Read a string from the environment variable.
768 * The separators "+", ",", ":", and ";" terminate the string.
769 * Return the number of read characters.
770 */
771 static int
772 parse_string(const char *s, char *out)
773 {
774 int i;
775
776 for (i = 0; *s && *s != '+' && *s != ',' && *s != ':' && *s != ';';
777 s++, out++, i++)
778 *out = *s;
779
780 *out = 0;
781
782 if (*s && !i)
783 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) while "
784 "parsing a string\n", *s, *s);
785 return i;
786 }
787
788 static char *
789 read_pane_settings(char *str, unsigned * const x, unsigned * const y,
790 unsigned * const width, unsigned * const height,
791 uint64_t * const ceiling, boolean * const dyn_ceiling)
792 {
793 char *ret = str;
794 unsigned tmp;
795
796 while (*str == '.') {
797 ++str;
798 switch (*str) {
799 case 'x':
800 ++str;
801 *x = strtoul(str, &ret, 10);
802 str = ret;
803 break;
804
805 case 'y':
806 ++str;
807 *y = strtoul(str, &ret, 10);
808 str = ret;
809 break;
810
811 case 'w':
812 ++str;
813 tmp = strtoul(str, &ret, 10);
814 *width = tmp > 80 ? tmp : 80; /* 80 is chosen arbitrarily */
815 str = ret;
816 break;
817
818 /*
819 * Prevent setting height to less than 50. If the height is set to less,
820 * the text of the Y axis labels on the graph will start overlapping.
821 */
822 case 'h':
823 ++str;
824 tmp = strtoul(str, &ret, 10);
825 *height = tmp > 50 ? tmp : 50;
826 str = ret;
827 break;
828
829 case 'c':
830 ++str;
831 tmp = strtoul(str, &ret, 10);
832 *ceiling = tmp > 10 ? tmp : 10;
833 str = ret;
834 break;
835
836 case 'd':
837 ++str;
838 ret = str;
839 *dyn_ceiling = true;
840 break;
841
842 default:
843 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str);
844 }
845
846 }
847
848 return ret;
849 }
850
851 static boolean
852 has_occlusion_query(struct pipe_screen *screen)
853 {
854 return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) != 0;
855 }
856
857 static boolean
858 has_streamout(struct pipe_screen *screen)
859 {
860 return screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
861 }
862
863 static boolean
864 has_pipeline_stats_query(struct pipe_screen *screen)
865 {
866 return screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) != 0;
867 }
868
869 static void
870 hud_parse_env_var(struct hud_context *hud, const char *env)
871 {
872 unsigned num, i;
873 char name_a[256], s[256];
874 char *name;
875 struct hud_pane *pane = NULL;
876 unsigned x = 10, y = 10;
877 unsigned width = 251, height = 100;
878 unsigned period = 500 * 1000; /* default period (1/2 second) */
879 uint64_t ceiling = UINT64_MAX;
880 unsigned column_width = 251;
881 boolean dyn_ceiling = false;
882 const char *period_env;
883
884 /*
885 * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
886 * The env var is in seconds (a float).
887 * Zero means update after every frame.
888 */
889 period_env = getenv("GALLIUM_HUD_PERIOD");
890 if (period_env) {
891 float p = (float) atof(period_env);
892 if (p >= 0.0f) {
893 period = (unsigned) (p * 1000 * 1000);
894 }
895 }
896
897 while ((num = parse_string(env, name_a)) != 0) {
898 env += num;
899
900 /* check for explicit location, size and etc. settings */
901 name = read_pane_settings(name_a, &x, &y, &width, &height, &ceiling,
902 &dyn_ceiling);
903
904 /*
905 * Keep track of overall column width to avoid pane overlapping in case
906 * later we create a new column while the bottom pane in the current
907 * column is less wide than the rest of the panes in it.
908 */
909 column_width = width > column_width ? width : column_width;
910
911 if (!pane) {
912 pane = hud_pane_create(x, y, x + width, y + height, period, 10,
913 ceiling, dyn_ceiling);
914 if (!pane)
915 return;
916 }
917
918 /* Add a graph. */
919 /* IF YOU CHANGE THIS, UPDATE print_help! */
920 if (strcmp(name, "fps") == 0) {
921 hud_fps_graph_install(pane);
922 }
923 else if (strcmp(name, "cpu") == 0) {
924 hud_cpu_graph_install(pane, ALL_CPUS);
925 }
926 else if (sscanf(name, "cpu%u%s", &i, s) == 1) {
927 hud_cpu_graph_install(pane, i);
928 }
929 else if (strcmp(name, "samples-passed") == 0 &&
930 has_occlusion_query(hud->pipe->screen)) {
931 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
932 "samples-passed",
933 PIPE_QUERY_OCCLUSION_COUNTER, 0, 0,
934 PIPE_DRIVER_QUERY_TYPE_UINT64,
935 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
936 0);
937 }
938 else if (strcmp(name, "primitives-generated") == 0 &&
939 has_streamout(hud->pipe->screen)) {
940 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
941 "primitives-generated",
942 PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0,
943 PIPE_DRIVER_QUERY_TYPE_UINT64,
944 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
945 0);
946 }
947 else {
948 boolean processed = FALSE;
949
950 /* pipeline statistics queries */
951 if (has_pipeline_stats_query(hud->pipe->screen)) {
952 static const char *pipeline_statistics_names[] =
953 {
954 "ia-vertices",
955 "ia-primitives",
956 "vs-invocations",
957 "gs-invocations",
958 "gs-primitives",
959 "clipper-invocations",
960 "clipper-primitives-generated",
961 "ps-invocations",
962 "hs-invocations",
963 "ds-invocations",
964 "cs-invocations"
965 };
966 for (i = 0; i < ARRAY_SIZE(pipeline_statistics_names); ++i)
967 if (strcmp(name, pipeline_statistics_names[i]) == 0)
968 break;
969 if (i < ARRAY_SIZE(pipeline_statistics_names)) {
970 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, name,
971 PIPE_QUERY_PIPELINE_STATISTICS, i,
972 0, PIPE_DRIVER_QUERY_TYPE_UINT64,
973 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
974 0);
975 processed = TRUE;
976 }
977 }
978
979 /* driver queries */
980 if (!processed) {
981 if (!hud_driver_query_install(&hud->batch_query, pane, hud->pipe,
982 name)) {
983 fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name);
984 }
985 }
986 }
987
988 if (*env == ':') {
989 env++;
990
991 if (!pane) {
992 fprintf(stderr, "gallium_hud: syntax error: unexpected ':', "
993 "expected a name\n");
994 break;
995 }
996
997 num = parse_string(env, s);
998 env += num;
999
1000 if (num && sscanf(s, "%u", &i) == 1) {
1001 hud_pane_set_max_value(pane, i);
1002 pane->initial_max_value = i;
1003 }
1004 else {
1005 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
1006 "after ':'\n", *env, *env);
1007 }
1008 }
1009
1010 if (*env == 0)
1011 break;
1012
1013 /* parse a separator */
1014 switch (*env) {
1015 case '+':
1016 env++;
1017 break;
1018
1019 case ',':
1020 env++;
1021 if (!pane)
1022 break;
1023
1024 y += height + hud->font.glyph_height * (pane->num_graphs + 2);
1025 height = 100;
1026
1027 if (pane && pane->num_graphs) {
1028 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1029 pane = NULL;
1030 }
1031 break;
1032
1033 case ';':
1034 env++;
1035 y = 10;
1036 x += column_width + hud->font.glyph_width * 9;
1037 height = 100;
1038
1039 if (pane && pane->num_graphs) {
1040 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1041 pane = NULL;
1042 }
1043
1044 /* Starting a new column; reset column width. */
1045 column_width = 251;
1046 break;
1047
1048 default:
1049 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
1050 }
1051
1052 /* Reset to defaults for the next pane in case these were modified. */
1053 width = 251;
1054 ceiling = UINT64_MAX;
1055 dyn_ceiling = false;
1056
1057 }
1058
1059 if (pane) {
1060 if (pane->num_graphs) {
1061 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1062 }
1063 else {
1064 FREE(pane);
1065 }
1066 }
1067 }
1068
1069 static void
1070 print_help(struct pipe_screen *screen)
1071 {
1072 int i, num_queries, num_cpus = hud_get_num_cpus();
1073
1074 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
1075 puts("");
1076 puts(" Names are identifiers of data sources which will be drawn as graphs");
1077 puts(" in panes. Multiple graphs can be drawn in the same pane.");
1078 puts(" There can be multiple panes placed in rows and columns.");
1079 puts("");
1080 puts(" '+' separates names which will share a pane.");
1081 puts(" ':[value]' specifies the initial maximum value of the Y axis");
1082 puts(" for the given pane.");
1083 puts(" ',' creates a new pane below the last one.");
1084 puts(" ';' creates a new pane at the top of the next column.");
1085 puts("");
1086 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
1087 puts("");
1088 puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
1089 puts(" a name, it is possible to explicitly set the location and size");
1090 puts(" of a pane, along with limiting overall maximum value of the");
1091 puts(" Y axis and activating dynamic readjustment of the Y axis.");
1092 puts(" Several modifiers may be applied to the same pane simultaneously.");
1093 puts("");
1094 puts(" 'x[value]' sets the location of the pane on the x axis relative");
1095 puts(" to the upper-left corner of the viewport, in pixels.");
1096 puts(" 'y[value]' sets the location of the pane on the y axis relative");
1097 puts(" to the upper-left corner of the viewport, in pixels.");
1098 puts(" 'w[value]' sets width of the graph pixels.");
1099 puts(" 'h[value]' sets height of the graph in pixels.");
1100 puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
1101 puts(" If the graph needs to draw values higher than");
1102 puts(" the ceiling allows, the value is clamped.");
1103 puts(" 'd' activates dynamic Y axis readjustment to set the value of");
1104 puts(" the Y axis to match the highest value still visible in the graph.");
1105 puts("");
1106 puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
1107 puts(" the Y axis does not go above the restriction imposed by 'c' while");
1108 puts(" still adjusting the value of the Y axis down when appropriate.");
1109 puts("");
1110 puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
1111 puts("");
1112 puts(" Available names:");
1113 puts(" fps");
1114 puts(" cpu");
1115
1116 for (i = 0; i < num_cpus; i++)
1117 printf(" cpu%i\n", i);
1118
1119 if (has_occlusion_query(screen))
1120 puts(" samples-passed");
1121 if (has_streamout(screen))
1122 puts(" primitives-generated");
1123
1124 if (has_pipeline_stats_query(screen)) {
1125 puts(" ia-vertices");
1126 puts(" ia-primitives");
1127 puts(" vs-invocations");
1128 puts(" gs-invocations");
1129 puts(" gs-primitives");
1130 puts(" clipper-invocations");
1131 puts(" clipper-primitives-generated");
1132 puts(" ps-invocations");
1133 puts(" hs-invocations");
1134 puts(" ds-invocations");
1135 puts(" cs-invocations");
1136 }
1137
1138 if (screen->get_driver_query_info){
1139 boolean skipping = false;
1140 struct pipe_driver_query_info info;
1141 num_queries = screen->get_driver_query_info(screen, 0, NULL);
1142
1143 for (i = 0; i < num_queries; i++){
1144 screen->get_driver_query_info(screen, i, &info);
1145 if (info.flags & PIPE_DRIVER_QUERY_FLAG_DONT_LIST) {
1146 if (!skipping)
1147 puts(" ...");
1148 skipping = true;
1149 } else {
1150 printf(" %s\n", info.name);
1151 skipping = false;
1152 }
1153 }
1154 }
1155
1156 puts("");
1157 fflush(stdout);
1158 }
1159
1160 struct hud_context *
1161 hud_create(struct pipe_context *pipe, struct cso_context *cso)
1162 {
1163 struct pipe_screen *screen = pipe->screen;
1164 struct hud_context *hud;
1165 struct pipe_sampler_view view_templ;
1166 unsigned i;
1167 const char *env = debug_get_option("GALLIUM_HUD", NULL);
1168 unsigned signo = debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0);
1169 #ifdef PIPE_OS_UNIX
1170 static boolean sig_handled = FALSE;
1171 struct sigaction action = {};
1172 #endif
1173 huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE);
1174
1175 if (!env || !*env)
1176 return NULL;
1177
1178 if (strcmp(env, "help") == 0) {
1179 print_help(pipe->screen);
1180 return NULL;
1181 }
1182
1183 hud = CALLOC_STRUCT(hud_context);
1184 if (!hud)
1185 return NULL;
1186
1187 hud->pipe = pipe;
1188 hud->cso = cso;
1189 hud->uploader = u_upload_create(pipe, 256 * 1024,
1190 PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_STREAM);
1191
1192 /* font */
1193 if (!util_font_create(pipe, UTIL_FONT_FIXED_8X13, &hud->font)) {
1194 u_upload_destroy(hud->uploader);
1195 FREE(hud);
1196 return NULL;
1197 }
1198
1199 hud->has_srgb = screen->is_format_supported(screen,
1200 PIPE_FORMAT_B8G8R8A8_SRGB,
1201 PIPE_TEXTURE_2D, 0,
1202 PIPE_BIND_RENDER_TARGET) != 0;
1203
1204 /* blend state */
1205 hud->no_blend.rt[0].colormask = PIPE_MASK_RGBA;
1206
1207 hud->alpha_blend.rt[0].colormask = PIPE_MASK_RGBA;
1208 hud->alpha_blend.rt[0].blend_enable = 1;
1209 hud->alpha_blend.rt[0].rgb_func = PIPE_BLEND_ADD;
1210 hud->alpha_blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
1211 hud->alpha_blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
1212 hud->alpha_blend.rt[0].alpha_func = PIPE_BLEND_ADD;
1213 hud->alpha_blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
1214 hud->alpha_blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
1215
1216 /* fragment shader */
1217 hud->fs_color =
1218 util_make_fragment_passthrough_shader(pipe,
1219 TGSI_SEMANTIC_COLOR,
1220 TGSI_INTERPOLATE_CONSTANT,
1221 TRUE);
1222
1223 {
1224 /* Read a texture and do .xxxx swizzling. */
1225 static const char *fragment_shader_text = {
1226 "FRAG\n"
1227 "DCL IN[0], GENERIC[0], LINEAR\n"
1228 "DCL SAMP[0]\n"
1229 "DCL SVIEW[0], RECT, FLOAT\n"
1230 "DCL OUT[0], COLOR[0]\n"
1231 "DCL TEMP[0]\n"
1232
1233 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
1234 "MOV OUT[0], TEMP[0].xxxx\n"
1235 "END\n"
1236 };
1237
1238 struct tgsi_token tokens[1000];
1239 struct pipe_shader_state state;
1240
1241 if (!tgsi_text_translate(fragment_shader_text, tokens, ARRAY_SIZE(tokens))) {
1242 assert(0);
1243 pipe_resource_reference(&hud->font.texture, NULL);
1244 u_upload_destroy(hud->uploader);
1245 FREE(hud);
1246 return NULL;
1247 }
1248 pipe_shader_state_from_tgsi(&state, tokens);
1249 hud->fs_text = pipe->create_fs_state(pipe, &state);
1250 }
1251
1252 /* rasterizer */
1253 hud->rasterizer.half_pixel_center = 1;
1254 hud->rasterizer.bottom_edge_rule = 1;
1255 hud->rasterizer.depth_clip = 1;
1256 hud->rasterizer.line_width = 1;
1257 hud->rasterizer.line_last_pixel = 1;
1258
1259 hud->rasterizer_aa_lines = hud->rasterizer;
1260 hud->rasterizer_aa_lines.line_smooth = 1;
1261
1262 /* vertex shader */
1263 {
1264 static const char *vertex_shader_text = {
1265 "VERT\n"
1266 "DCL IN[0..1]\n"
1267 "DCL OUT[0], POSITION\n"
1268 "DCL OUT[1], COLOR[0]\n" /* color */
1269 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
1270 /* [0] = color,
1271 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
1272 * [2] = (xscale, yscale, 0, 0) */
1273 "DCL CONST[0..2]\n"
1274 "DCL TEMP[0]\n"
1275 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
1276
1277 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
1278 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
1279 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
1280 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
1281 "MOV OUT[0].zw, IMM[0]\n"
1282
1283 "MOV OUT[1], CONST[0]\n"
1284 "MOV OUT[2], IN[1]\n"
1285 "END\n"
1286 };
1287
1288 struct tgsi_token tokens[1000];
1289 struct pipe_shader_state state;
1290 if (!tgsi_text_translate(vertex_shader_text, tokens, ARRAY_SIZE(tokens))) {
1291 assert(0);
1292 pipe_resource_reference(&hud->font.texture, NULL);
1293 u_upload_destroy(hud->uploader);
1294 FREE(hud);
1295 return NULL;
1296 }
1297 pipe_shader_state_from_tgsi(&state, tokens);
1298 hud->vs = pipe->create_vs_state(pipe, &state);
1299 }
1300
1301 /* vertex elements */
1302 for (i = 0; i < 2; i++) {
1303 hud->velems[i].src_offset = i * 2 * sizeof(float);
1304 hud->velems[i].src_format = PIPE_FORMAT_R32G32_FLOAT;
1305 hud->velems[i].vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
1306 }
1307
1308 /* sampler view */
1309 u_sampler_view_default_template(
1310 &view_templ, hud->font.texture, hud->font.texture->format);
1311 hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
1312 &view_templ);
1313
1314 /* sampler state (for font drawing) */
1315 hud->font_sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1316 hud->font_sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1317 hud->font_sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1318 hud->font_sampler_state.normalized_coords = 0;
1319
1320 /* constants */
1321 hud->constbuf.buffer_size = sizeof(hud->constants);
1322 hud->constbuf.user_buffer = &hud->constants;
1323
1324 LIST_INITHEAD(&hud->pane_list);
1325
1326 /* setup sig handler once for all hud contexts */
1327 #ifdef PIPE_OS_UNIX
1328 if (!sig_handled && signo != 0) {
1329 action.sa_sigaction = &signal_visible_handler;
1330 action.sa_flags = SA_SIGINFO;
1331
1332 if (signo >= NSIG)
1333 fprintf(stderr, "gallium_hud: invalid signal %u\n", signo);
1334 else if (sigaction(signo, &action, NULL) < 0)
1335 fprintf(stderr, "gallium_hud: unable to set handler for signal %u\n", signo);
1336 fflush(stderr);
1337
1338 sig_handled = TRUE;
1339 }
1340 #endif
1341
1342 hud_parse_env_var(hud, env);
1343 return hud;
1344 }
1345
1346 void
1347 hud_destroy(struct hud_context *hud)
1348 {
1349 struct pipe_context *pipe = hud->pipe;
1350 struct hud_pane *pane, *pane_tmp;
1351 struct hud_graph *graph, *graph_tmp;
1352
1353 LIST_FOR_EACH_ENTRY_SAFE(pane, pane_tmp, &hud->pane_list, head) {
1354 LIST_FOR_EACH_ENTRY_SAFE(graph, graph_tmp, &pane->graph_list, head) {
1355 LIST_DEL(&graph->head);
1356 hud_graph_destroy(graph);
1357 }
1358 LIST_DEL(&pane->head);
1359 FREE(pane);
1360 }
1361
1362 hud_batch_query_cleanup(&hud->batch_query);
1363 pipe->delete_fs_state(pipe, hud->fs_color);
1364 pipe->delete_fs_state(pipe, hud->fs_text);
1365 pipe->delete_vs_state(pipe, hud->vs);
1366 pipe_sampler_view_reference(&hud->font_sampler_view, NULL);
1367 pipe_resource_reference(&hud->font.texture, NULL);
1368 u_upload_destroy(hud->uploader);
1369 FREE(hud);
1370 }