3453bdae3b05eebb5999cf91205789dd078a029e
[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 const unsigned last_line = pane->last_line;
348
349 /* draw background */
350 hud_draw_background_quad(hud,
351 pane->x1, pane->y1,
352 pane->x2, pane->y2);
353
354 /* draw numbers on the right-hand side */
355 for (i = 0; i <= last_line; i++) {
356 unsigned x = pane->x2 + 2;
357 unsigned y = pane->inner_y1 +
358 pane->inner_height * (last_line - i) / last_line -
359 hud->font.glyph_height / 2;
360
361 number_to_human_readable(pane->max_value * i / last_line, pane->max_value,
362 pane->type, str);
363 hud_draw_string(hud, x, y, "%s", str);
364 }
365
366 /* draw info below the pane */
367 i = 0;
368 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
369 unsigned x = pane->x1 + 2;
370 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
371
372 number_to_human_readable(gr->current_value, pane->max_value,
373 pane->type, str);
374 hud_draw_string(hud, x, y, " %s: %s", gr->name, str);
375 i++;
376 }
377
378 /* draw border */
379 assert(hud->whitelines.num_vertices + num/2 + 8 <= hud->whitelines.max_num_vertices);
380 line_verts[num++] = (float) pane->x1;
381 line_verts[num++] = (float) pane->y1;
382 line_verts[num++] = (float) pane->x2;
383 line_verts[num++] = (float) pane->y1;
384
385 line_verts[num++] = (float) pane->x2;
386 line_verts[num++] = (float) pane->y1;
387 line_verts[num++] = (float) pane->x2;
388 line_verts[num++] = (float) pane->y2;
389
390 line_verts[num++] = (float) pane->x1;
391 line_verts[num++] = (float) pane->y2;
392 line_verts[num++] = (float) pane->x2;
393 line_verts[num++] = (float) pane->y2;
394
395 line_verts[num++] = (float) pane->x1;
396 line_verts[num++] = (float) pane->y1;
397 line_verts[num++] = (float) pane->x1;
398 line_verts[num++] = (float) pane->y2;
399
400 /* draw horizontal lines inside the graph */
401 for (i = 0; i <= last_line; i++) {
402 float y = round((pane->max_value * i / (double)last_line) *
403 pane->yscale + pane->inner_y2);
404
405 assert(hud->whitelines.num_vertices + num/2 + 2 <= hud->whitelines.max_num_vertices);
406 line_verts[num++] = pane->x1;
407 line_verts[num++] = y;
408 line_verts[num++] = pane->x2;
409 line_verts[num++] = y;
410 }
411
412 hud->whitelines.num_vertices += num/2;
413 }
414
415 static void
416 hud_pane_draw_colored_objects(struct hud_context *hud,
417 const struct hud_pane *pane)
418 {
419 struct hud_graph *gr;
420 unsigned i;
421
422 /* draw colored quads below the pane */
423 i = 0;
424 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
425 unsigned x = pane->x1 + 2;
426 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
427
428 hud_draw_colored_quad(hud, PIPE_PRIM_QUADS, x + 1, y + 1, x + 12, y + 13,
429 gr->color[0], gr->color[1], gr->color[2], 1);
430 i++;
431 }
432
433 /* draw the line strips */
434 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
435 hud_draw_graph_line_strip(hud, gr, pane->inner_x1, pane->inner_y2, pane->yscale);
436 }
437 }
438
439 static void
440 hud_alloc_vertices(struct hud_context *hud, struct vertex_queue *v,
441 unsigned num_vertices, unsigned stride)
442 {
443 v->num_vertices = 0;
444 v->max_num_vertices = num_vertices;
445 v->vbuf.stride = stride;
446 u_upload_alloc(hud->uploader, 0, v->vbuf.stride * v->max_num_vertices,
447 16, &v->vbuf.buffer_offset, &v->vbuf.buffer,
448 (void**)&v->vertices);
449 }
450
451 /**
452 * Draw the HUD to the texture \p tex.
453 * The texture is usually the back buffer being displayed.
454 */
455 void
456 hud_draw(struct hud_context *hud, struct pipe_resource *tex)
457 {
458 struct cso_context *cso = hud->cso;
459 struct pipe_context *pipe = hud->pipe;
460 struct pipe_framebuffer_state fb;
461 struct pipe_surface surf_templ, *surf;
462 struct pipe_viewport_state viewport;
463 const struct pipe_sampler_state *sampler_states[] =
464 { &hud->font_sampler_state };
465 struct hud_pane *pane;
466 struct hud_graph *gr;
467
468 if (!huds_visible)
469 return;
470
471 hud->fb_width = tex->width0;
472 hud->fb_height = tex->height0;
473 hud->constants.two_div_fb_width = 2.0f / hud->fb_width;
474 hud->constants.two_div_fb_height = 2.0f / hud->fb_height;
475
476 cso_save_state(cso, (CSO_BIT_FRAMEBUFFER |
477 CSO_BIT_SAMPLE_MASK |
478 CSO_BIT_MIN_SAMPLES |
479 CSO_BIT_BLEND |
480 CSO_BIT_DEPTH_STENCIL_ALPHA |
481 CSO_BIT_FRAGMENT_SHADER |
482 CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
483 CSO_BIT_FRAGMENT_SAMPLERS |
484 CSO_BIT_RASTERIZER |
485 CSO_BIT_VIEWPORT |
486 CSO_BIT_STREAM_OUTPUTS |
487 CSO_BIT_GEOMETRY_SHADER |
488 CSO_BIT_TESSCTRL_SHADER |
489 CSO_BIT_TESSEVAL_SHADER |
490 CSO_BIT_VERTEX_SHADER |
491 CSO_BIT_VERTEX_ELEMENTS |
492 CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
493 CSO_BIT_PAUSE_QUERIES |
494 CSO_BIT_RENDER_CONDITION));
495 cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
496
497 /* set states */
498 memset(&surf_templ, 0, sizeof(surf_templ));
499 surf_templ.format = tex->format;
500
501 /* Without this, AA lines look thinner if they are between 2 pixels
502 * because the alpha is 0.5 on both pixels. (it's ugly)
503 *
504 * sRGB makes the width of all AA lines look the same.
505 */
506 if (hud->has_srgb) {
507 enum pipe_format srgb_format = util_format_srgb(tex->format);
508
509 if (srgb_format != PIPE_FORMAT_NONE)
510 surf_templ.format = srgb_format;
511 }
512 surf = pipe->create_surface(pipe, tex, &surf_templ);
513
514 memset(&fb, 0, sizeof(fb));
515 fb.nr_cbufs = 1;
516 fb.cbufs[0] = surf;
517 fb.zsbuf = NULL;
518 fb.width = hud->fb_width;
519 fb.height = hud->fb_height;
520
521 viewport.scale[0] = 0.5f * hud->fb_width;
522 viewport.scale[1] = 0.5f * hud->fb_height;
523 viewport.scale[2] = 1.0f;
524 viewport.translate[0] = 0.5f * hud->fb_width;
525 viewport.translate[1] = 0.5f * hud->fb_height;
526 viewport.translate[2] = 0.0f;
527
528 cso_set_framebuffer(cso, &fb);
529 cso_set_sample_mask(cso, ~0);
530 cso_set_min_samples(cso, 1);
531 cso_set_depth_stencil_alpha(cso, &hud->dsa);
532 cso_set_rasterizer(cso, &hud->rasterizer);
533 cso_set_viewport(cso, &viewport);
534 cso_set_stream_outputs(cso, 0, NULL, NULL);
535 cso_set_tessctrl_shader_handle(cso, NULL);
536 cso_set_tesseval_shader_handle(cso, NULL);
537 cso_set_geometry_shader_handle(cso, NULL);
538 cso_set_vertex_shader_handle(cso, hud->vs);
539 cso_set_vertex_elements(cso, 2, hud->velems);
540 cso_set_render_condition(cso, NULL, FALSE, 0);
541 cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1,
542 &hud->font_sampler_view);
543 cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states);
544 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
545
546 /* prepare vertex buffers */
547 hud_alloc_vertices(hud, &hud->bg, 4 * 256, 2 * sizeof(float));
548 hud_alloc_vertices(hud, &hud->whitelines, 4 * 256, 2 * sizeof(float));
549 hud_alloc_vertices(hud, &hud->text, 4 * 1024, 4 * sizeof(float));
550
551 /* prepare all graphs */
552 hud_batch_query_update(hud->batch_query);
553
554 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
555 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
556 gr->query_new_value(gr);
557 }
558
559 hud_pane_accumulate_vertices(hud, pane);
560 }
561
562 /* unmap the uploader's vertex buffer before drawing */
563 u_upload_unmap(hud->uploader);
564
565 /* draw accumulated vertices for background quads */
566 cso_set_blend(cso, &hud->alpha_blend);
567 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
568
569 if (hud->bg.num_vertices) {
570 hud->constants.color[0] = 0;
571 hud->constants.color[1] = 0;
572 hud->constants.color[2] = 0;
573 hud->constants.color[3] = 0.666f;
574 hud->constants.translate[0] = 0;
575 hud->constants.translate[1] = 0;
576 hud->constants.scale[0] = 1;
577 hud->constants.scale[1] = 1;
578
579 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
580 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
581 &hud->bg.vbuf);
582 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->bg.num_vertices);
583 }
584 pipe_resource_reference(&hud->bg.vbuf.buffer, NULL);
585
586 /* draw accumulated vertices for white lines */
587 cso_set_blend(cso, &hud->no_blend);
588
589 hud->constants.color[0] = 1;
590 hud->constants.color[1] = 1;
591 hud->constants.color[2] = 1;
592 hud->constants.color[3] = 1;
593 hud->constants.translate[0] = 0;
594 hud->constants.translate[1] = 0;
595 hud->constants.scale[0] = 1;
596 hud->constants.scale[1] = 1;
597 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
598
599 if (hud->whitelines.num_vertices) {
600 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
601 &hud->whitelines.vbuf);
602 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
603 cso_draw_arrays(cso, PIPE_PRIM_LINES, 0, hud->whitelines.num_vertices);
604 }
605 pipe_resource_reference(&hud->whitelines.vbuf.buffer, NULL);
606
607 /* draw accumulated vertices for text */
608 cso_set_blend(cso, &hud->alpha_blend);
609 if (hud->text.num_vertices) {
610 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
611 &hud->text.vbuf);
612 cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
613 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->text.num_vertices);
614 }
615 pipe_resource_reference(&hud->text.vbuf.buffer, NULL);
616
617 /* draw the rest */
618 cso_set_rasterizer(cso, &hud->rasterizer_aa_lines);
619 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
620 if (pane)
621 hud_pane_draw_colored_objects(hud, pane);
622 }
623
624 cso_restore_state(cso);
625 cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
626
627 pipe_surface_reference(&surf, NULL);
628 }
629
630 static void
631 fixup_bytes(enum pipe_driver_query_type type, int position, uint64_t *exp10)
632 {
633 if (type == PIPE_DRIVER_QUERY_TYPE_BYTES && position % 3 == 0)
634 *exp10 = (*exp10 / 1000) * 1024;
635 }
636
637 /**
638 * Set the maximum value for the Y axis of the graph.
639 * This scales the graph accordingly.
640 */
641 void
642 hud_pane_set_max_value(struct hud_pane *pane, uint64_t value)
643 {
644 double leftmost_digit;
645 uint64_t exp10;
646 int i;
647
648 /* The following code determines the max_value in the graph as well as
649 * how many describing lines are drawn. The max_value is rounded up,
650 * so that all drawn numbers are rounded for readability.
651 * We want to print multiples of a simple number instead of multiples of
652 * hard-to-read numbers like 1.753.
653 */
654
655 /* Find the left-most digit. */
656 exp10 = 1;
657 for (i = 0; value > 9 * exp10; i++) {
658 exp10 *= 10;
659 fixup_bytes(pane->type, i + 1, &exp10);
660 }
661
662 leftmost_digit = DIV_ROUND_UP(value, exp10);
663
664 /* Round 9 to 10. */
665 if (leftmost_digit == 9) {
666 leftmost_digit = 1;
667 exp10 *= 10;
668 fixup_bytes(pane->type, i + 1, &exp10);
669 }
670
671 switch ((unsigned)leftmost_digit) {
672 case 1:
673 pane->last_line = 5; /* lines in +1/5 increments */
674 break;
675 case 2:
676 pane->last_line = 8; /* lines in +1/4 increments. */
677 break;
678 case 3:
679 case 4:
680 pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments */
681 break;
682 case 5:
683 case 6:
684 case 7:
685 case 8:
686 pane->last_line = leftmost_digit; /* lines in +1 increments */
687 break;
688 default:
689 assert(0);
690 }
691
692 /* Truncate {3,4} to {2.5, 3.5} if possible. */
693 for (i = 3; i <= 4; i++) {
694 if (leftmost_digit == i && value <= (i - 0.5) * exp10) {
695 leftmost_digit = i - 0.5;
696 pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments. */
697 }
698 }
699
700 /* Truncate 2 to a multiple of 0.2 in (1, 1.6] if possible. */
701 if (leftmost_digit == 2) {
702 for (i = 1; i <= 3; i++) {
703 if (value <= (1 + i*0.2) * exp10) {
704 leftmost_digit = 1 + i*0.2;
705 pane->last_line = 5 + i; /* lines in +1/5 increments. */
706 break;
707 }
708 }
709 }
710
711 pane->max_value = leftmost_digit * exp10;
712 pane->yscale = -(int)pane->inner_height / (float)pane->max_value;
713 }
714
715 static void
716 hud_pane_update_dyn_ceiling(struct hud_graph *gr, struct hud_pane *pane)
717 {
718 unsigned i;
719 float tmp = 0.0f;
720
721 if (pane->dyn_ceil_last_ran != gr->index) {
722 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
723 for (i = 0; i < gr->num_vertices; ++i) {
724 tmp = gr->vertices[i * 2 + 1] > tmp ?
725 gr->vertices[i * 2 + 1] : tmp;
726 }
727 }
728
729 /* Avoid setting it lower than the initial starting height. */
730 tmp = tmp > pane->initial_max_value ? tmp : pane->initial_max_value;
731 hud_pane_set_max_value(pane, tmp);
732 }
733
734 /*
735 * Mark this adjustment run so we could avoid repeating a full update
736 * again needlessly in case the pane has more than one graph.
737 */
738 pane->dyn_ceil_last_ran = gr->index;
739 }
740
741 static struct hud_pane *
742 hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
743 unsigned period, uint64_t max_value, uint64_t ceiling,
744 boolean dyn_ceiling)
745 {
746 struct hud_pane *pane = CALLOC_STRUCT(hud_pane);
747
748 if (!pane)
749 return NULL;
750
751 pane->x1 = x1;
752 pane->y1 = y1;
753 pane->x2 = x2;
754 pane->y2 = y2;
755 pane->inner_x1 = x1 + 1;
756 pane->inner_x2 = x2 - 1;
757 pane->inner_y1 = y1 + 1;
758 pane->inner_y2 = y2 - 1;
759 pane->inner_width = pane->inner_x2 - pane->inner_x1;
760 pane->inner_height = pane->inner_y2 - pane->inner_y1;
761 pane->period = period;
762 pane->max_num_vertices = (x2 - x1 + 2) / 2;
763 pane->ceiling = ceiling;
764 pane->dyn_ceiling = dyn_ceiling;
765 pane->dyn_ceil_last_ran = 0;
766 pane->initial_max_value = max_value;
767 hud_pane_set_max_value(pane, max_value);
768 LIST_INITHEAD(&pane->graph_list);
769 return pane;
770 }
771
772 /**
773 * Add a graph to an existing pane.
774 * One pane can contain multiple graphs over each other.
775 */
776 void
777 hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr)
778 {
779 static const float colors[][3] = {
780 {0, 1, 0},
781 {1, 0, 0},
782 {0, 1, 1},
783 {1, 0, 1},
784 {1, 1, 0},
785 {0.5, 0.5, 1},
786 {0.5, 0.5, 0.5},
787 };
788 char *name = gr->name;
789
790 /* replace '-' with a space */
791 while (*name) {
792 if (*name == '-')
793 *name = ' ';
794 name++;
795 }
796
797 assert(pane->num_graphs < ARRAY_SIZE(colors));
798 gr->vertices = MALLOC(pane->max_num_vertices * sizeof(float) * 2);
799 gr->color[0] = colors[pane->num_graphs][0];
800 gr->color[1] = colors[pane->num_graphs][1];
801 gr->color[2] = colors[pane->num_graphs][2];
802 gr->pane = pane;
803 LIST_ADDTAIL(&gr->head, &pane->graph_list);
804 pane->num_graphs++;
805 }
806
807 void
808 hud_graph_add_value(struct hud_graph *gr, uint64_t value)
809 {
810 gr->current_value = value;
811 value = value > gr->pane->ceiling ? gr->pane->ceiling : value;
812
813 if (gr->index == gr->pane->max_num_vertices) {
814 gr->vertices[0] = 0;
815 gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
816 gr->index = 1;
817 }
818 gr->vertices[(gr->index)*2+0] = (float) (gr->index * 2);
819 gr->vertices[(gr->index)*2+1] = (float) value;
820 gr->index++;
821
822 if (gr->num_vertices < gr->pane->max_num_vertices) {
823 gr->num_vertices++;
824 }
825
826 if (gr->pane->dyn_ceiling == true) {
827 hud_pane_update_dyn_ceiling(gr, gr->pane);
828 }
829 if (value > gr->pane->max_value) {
830 hud_pane_set_max_value(gr->pane, value);
831 }
832 }
833
834 static void
835 hud_graph_destroy(struct hud_graph *graph)
836 {
837 FREE(graph->vertices);
838 if (graph->free_query_data)
839 graph->free_query_data(graph->query_data);
840 FREE(graph);
841 }
842
843 /**
844 * Read a string from the environment variable.
845 * The separators "+", ",", ":", and ";" terminate the string.
846 * Return the number of read characters.
847 */
848 static int
849 parse_string(const char *s, char *out)
850 {
851 int i;
852
853 for (i = 0; *s && *s != '+' && *s != ',' && *s != ':' && *s != ';';
854 s++, out++, i++)
855 *out = *s;
856
857 *out = 0;
858
859 if (*s && !i)
860 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) while "
861 "parsing a string\n", *s, *s);
862 return i;
863 }
864
865 static char *
866 read_pane_settings(char *str, unsigned * const x, unsigned * const y,
867 unsigned * const width, unsigned * const height,
868 uint64_t * const ceiling, boolean * const dyn_ceiling)
869 {
870 char *ret = str;
871 unsigned tmp;
872
873 while (*str == '.') {
874 ++str;
875 switch (*str) {
876 case 'x':
877 ++str;
878 *x = strtoul(str, &ret, 10);
879 str = ret;
880 break;
881
882 case 'y':
883 ++str;
884 *y = strtoul(str, &ret, 10);
885 str = ret;
886 break;
887
888 case 'w':
889 ++str;
890 tmp = strtoul(str, &ret, 10);
891 *width = tmp > 80 ? tmp : 80; /* 80 is chosen arbitrarily */
892 str = ret;
893 break;
894
895 /*
896 * Prevent setting height to less than 50. If the height is set to less,
897 * the text of the Y axis labels on the graph will start overlapping.
898 */
899 case 'h':
900 ++str;
901 tmp = strtoul(str, &ret, 10);
902 *height = tmp > 50 ? tmp : 50;
903 str = ret;
904 break;
905
906 case 'c':
907 ++str;
908 tmp = strtoul(str, &ret, 10);
909 *ceiling = tmp > 10 ? tmp : 10;
910 str = ret;
911 break;
912
913 case 'd':
914 ++str;
915 ret = str;
916 *dyn_ceiling = true;
917 break;
918
919 default:
920 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str);
921 }
922
923 }
924
925 return ret;
926 }
927
928 static boolean
929 has_occlusion_query(struct pipe_screen *screen)
930 {
931 return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) != 0;
932 }
933
934 static boolean
935 has_streamout(struct pipe_screen *screen)
936 {
937 return screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
938 }
939
940 static boolean
941 has_pipeline_stats_query(struct pipe_screen *screen)
942 {
943 return screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) != 0;
944 }
945
946 static void
947 hud_parse_env_var(struct hud_context *hud, const char *env)
948 {
949 unsigned num, i;
950 char name_a[256], s[256];
951 char *name;
952 struct hud_pane *pane = NULL;
953 unsigned x = 10, y = 10;
954 unsigned width = 251, height = 100;
955 unsigned period = 500 * 1000; /* default period (1/2 second) */
956 uint64_t ceiling = UINT64_MAX;
957 unsigned column_width = 251;
958 boolean dyn_ceiling = false;
959 const char *period_env;
960
961 /*
962 * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
963 * The env var is in seconds (a float).
964 * Zero means update after every frame.
965 */
966 period_env = getenv("GALLIUM_HUD_PERIOD");
967 if (period_env) {
968 float p = (float) atof(period_env);
969 if (p >= 0.0f) {
970 period = (unsigned) (p * 1000 * 1000);
971 }
972 }
973
974 while ((num = parse_string(env, name_a)) != 0) {
975 env += num;
976
977 /* check for explicit location, size and etc. settings */
978 name = read_pane_settings(name_a, &x, &y, &width, &height, &ceiling,
979 &dyn_ceiling);
980
981 /*
982 * Keep track of overall column width to avoid pane overlapping in case
983 * later we create a new column while the bottom pane in the current
984 * column is less wide than the rest of the panes in it.
985 */
986 column_width = width > column_width ? width : column_width;
987
988 if (!pane) {
989 pane = hud_pane_create(x, y, x + width, y + height, period, 10,
990 ceiling, dyn_ceiling);
991 if (!pane)
992 return;
993 }
994
995 /* Add a graph. */
996 /* IF YOU CHANGE THIS, UPDATE print_help! */
997 if (strcmp(name, "fps") == 0) {
998 hud_fps_graph_install(pane);
999 }
1000 else if (strcmp(name, "cpu") == 0) {
1001 hud_cpu_graph_install(pane, ALL_CPUS);
1002 }
1003 else if (sscanf(name, "cpu%u%s", &i, s) == 1) {
1004 hud_cpu_graph_install(pane, i);
1005 }
1006 else if (strcmp(name, "samples-passed") == 0 &&
1007 has_occlusion_query(hud->pipe->screen)) {
1008 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
1009 "samples-passed",
1010 PIPE_QUERY_OCCLUSION_COUNTER, 0, 0,
1011 PIPE_DRIVER_QUERY_TYPE_UINT64,
1012 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1013 0);
1014 }
1015 else if (strcmp(name, "primitives-generated") == 0 &&
1016 has_streamout(hud->pipe->screen)) {
1017 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
1018 "primitives-generated",
1019 PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0,
1020 PIPE_DRIVER_QUERY_TYPE_UINT64,
1021 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1022 0);
1023 }
1024 else {
1025 boolean processed = FALSE;
1026
1027 /* pipeline statistics queries */
1028 if (has_pipeline_stats_query(hud->pipe->screen)) {
1029 static const char *pipeline_statistics_names[] =
1030 {
1031 "ia-vertices",
1032 "ia-primitives",
1033 "vs-invocations",
1034 "gs-invocations",
1035 "gs-primitives",
1036 "clipper-invocations",
1037 "clipper-primitives-generated",
1038 "ps-invocations",
1039 "hs-invocations",
1040 "ds-invocations",
1041 "cs-invocations"
1042 };
1043 for (i = 0; i < ARRAY_SIZE(pipeline_statistics_names); ++i)
1044 if (strcmp(name, pipeline_statistics_names[i]) == 0)
1045 break;
1046 if (i < ARRAY_SIZE(pipeline_statistics_names)) {
1047 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, name,
1048 PIPE_QUERY_PIPELINE_STATISTICS, i,
1049 0, PIPE_DRIVER_QUERY_TYPE_UINT64,
1050 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1051 0);
1052 processed = TRUE;
1053 }
1054 }
1055
1056 /* driver queries */
1057 if (!processed) {
1058 if (!hud_driver_query_install(&hud->batch_query, pane, hud->pipe,
1059 name)) {
1060 fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name);
1061 }
1062 }
1063 }
1064
1065 if (*env == ':') {
1066 env++;
1067
1068 if (!pane) {
1069 fprintf(stderr, "gallium_hud: syntax error: unexpected ':', "
1070 "expected a name\n");
1071 break;
1072 }
1073
1074 num = parse_string(env, s);
1075 env += num;
1076
1077 if (num && sscanf(s, "%u", &i) == 1) {
1078 hud_pane_set_max_value(pane, i);
1079 pane->initial_max_value = i;
1080 }
1081 else {
1082 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
1083 "after ':'\n", *env, *env);
1084 }
1085 }
1086
1087 if (*env == 0)
1088 break;
1089
1090 /* parse a separator */
1091 switch (*env) {
1092 case '+':
1093 env++;
1094 break;
1095
1096 case ',':
1097 env++;
1098 if (!pane)
1099 break;
1100
1101 y += height + hud->font.glyph_height * (pane->num_graphs + 2);
1102 height = 100;
1103
1104 if (pane && pane->num_graphs) {
1105 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1106 pane = NULL;
1107 }
1108 break;
1109
1110 case ';':
1111 env++;
1112 y = 10;
1113 x += column_width + hud->font.glyph_width * 9;
1114 height = 100;
1115
1116 if (pane && pane->num_graphs) {
1117 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1118 pane = NULL;
1119 }
1120
1121 /* Starting a new column; reset column width. */
1122 column_width = 251;
1123 break;
1124
1125 default:
1126 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
1127 }
1128
1129 /* Reset to defaults for the next pane in case these were modified. */
1130 width = 251;
1131 ceiling = UINT64_MAX;
1132 dyn_ceiling = false;
1133
1134 }
1135
1136 if (pane) {
1137 if (pane->num_graphs) {
1138 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1139 }
1140 else {
1141 FREE(pane);
1142 }
1143 }
1144 }
1145
1146 static void
1147 print_help(struct pipe_screen *screen)
1148 {
1149 int i, num_queries, num_cpus = hud_get_num_cpus();
1150
1151 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
1152 puts("");
1153 puts(" Names are identifiers of data sources which will be drawn as graphs");
1154 puts(" in panes. Multiple graphs can be drawn in the same pane.");
1155 puts(" There can be multiple panes placed in rows and columns.");
1156 puts("");
1157 puts(" '+' separates names which will share a pane.");
1158 puts(" ':[value]' specifies the initial maximum value of the Y axis");
1159 puts(" for the given pane.");
1160 puts(" ',' creates a new pane below the last one.");
1161 puts(" ';' creates a new pane at the top of the next column.");
1162 puts("");
1163 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
1164 puts("");
1165 puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
1166 puts(" a name, it is possible to explicitly set the location and size");
1167 puts(" of a pane, along with limiting overall maximum value of the");
1168 puts(" Y axis and activating dynamic readjustment of the Y axis.");
1169 puts(" Several modifiers may be applied to the same pane simultaneously.");
1170 puts("");
1171 puts(" 'x[value]' sets the location of the pane on the x axis relative");
1172 puts(" to the upper-left corner of the viewport, in pixels.");
1173 puts(" 'y[value]' sets the location of the pane on the y axis relative");
1174 puts(" to the upper-left corner of the viewport, in pixels.");
1175 puts(" 'w[value]' sets width of the graph pixels.");
1176 puts(" 'h[value]' sets height of the graph in pixels.");
1177 puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
1178 puts(" If the graph needs to draw values higher than");
1179 puts(" the ceiling allows, the value is clamped.");
1180 puts(" 'd' activates dynamic Y axis readjustment to set the value of");
1181 puts(" the Y axis to match the highest value still visible in the graph.");
1182 puts("");
1183 puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
1184 puts(" the Y axis does not go above the restriction imposed by 'c' while");
1185 puts(" still adjusting the value of the Y axis down when appropriate.");
1186 puts("");
1187 puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
1188 puts("");
1189 puts(" Available names:");
1190 puts(" fps");
1191 puts(" cpu");
1192
1193 for (i = 0; i < num_cpus; i++)
1194 printf(" cpu%i\n", i);
1195
1196 if (has_occlusion_query(screen))
1197 puts(" samples-passed");
1198 if (has_streamout(screen))
1199 puts(" primitives-generated");
1200
1201 if (has_pipeline_stats_query(screen)) {
1202 puts(" ia-vertices");
1203 puts(" ia-primitives");
1204 puts(" vs-invocations");
1205 puts(" gs-invocations");
1206 puts(" gs-primitives");
1207 puts(" clipper-invocations");
1208 puts(" clipper-primitives-generated");
1209 puts(" ps-invocations");
1210 puts(" hs-invocations");
1211 puts(" ds-invocations");
1212 puts(" cs-invocations");
1213 }
1214
1215 if (screen->get_driver_query_info){
1216 boolean skipping = false;
1217 struct pipe_driver_query_info info;
1218 num_queries = screen->get_driver_query_info(screen, 0, NULL);
1219
1220 for (i = 0; i < num_queries; i++){
1221 screen->get_driver_query_info(screen, i, &info);
1222 if (info.flags & PIPE_DRIVER_QUERY_FLAG_DONT_LIST) {
1223 if (!skipping)
1224 puts(" ...");
1225 skipping = true;
1226 } else {
1227 printf(" %s\n", info.name);
1228 skipping = false;
1229 }
1230 }
1231 }
1232
1233 puts("");
1234 fflush(stdout);
1235 }
1236
1237 struct hud_context *
1238 hud_create(struct pipe_context *pipe, struct cso_context *cso)
1239 {
1240 struct pipe_screen *screen = pipe->screen;
1241 struct hud_context *hud;
1242 struct pipe_sampler_view view_templ;
1243 unsigned i;
1244 const char *env = debug_get_option("GALLIUM_HUD", NULL);
1245 unsigned signo = debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0);
1246 #ifdef PIPE_OS_UNIX
1247 static boolean sig_handled = FALSE;
1248 struct sigaction action = {};
1249 #endif
1250 huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE);
1251
1252 if (!env || !*env)
1253 return NULL;
1254
1255 if (strcmp(env, "help") == 0) {
1256 print_help(pipe->screen);
1257 return NULL;
1258 }
1259
1260 hud = CALLOC_STRUCT(hud_context);
1261 if (!hud)
1262 return NULL;
1263
1264 hud->pipe = pipe;
1265 hud->cso = cso;
1266 hud->uploader = u_upload_create(pipe, 256 * 1024,
1267 PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_STREAM);
1268
1269 /* font */
1270 if (!util_font_create(pipe, UTIL_FONT_FIXED_8X13, &hud->font)) {
1271 u_upload_destroy(hud->uploader);
1272 FREE(hud);
1273 return NULL;
1274 }
1275
1276 hud->has_srgb = screen->is_format_supported(screen,
1277 PIPE_FORMAT_B8G8R8A8_SRGB,
1278 PIPE_TEXTURE_2D, 0,
1279 PIPE_BIND_RENDER_TARGET) != 0;
1280
1281 /* blend state */
1282 hud->no_blend.rt[0].colormask = PIPE_MASK_RGBA;
1283
1284 hud->alpha_blend.rt[0].colormask = PIPE_MASK_RGBA;
1285 hud->alpha_blend.rt[0].blend_enable = 1;
1286 hud->alpha_blend.rt[0].rgb_func = PIPE_BLEND_ADD;
1287 hud->alpha_blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
1288 hud->alpha_blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
1289 hud->alpha_blend.rt[0].alpha_func = PIPE_BLEND_ADD;
1290 hud->alpha_blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
1291 hud->alpha_blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
1292
1293 /* fragment shader */
1294 hud->fs_color =
1295 util_make_fragment_passthrough_shader(pipe,
1296 TGSI_SEMANTIC_COLOR,
1297 TGSI_INTERPOLATE_CONSTANT,
1298 TRUE);
1299
1300 {
1301 /* Read a texture and do .xxxx swizzling. */
1302 static const char *fragment_shader_text = {
1303 "FRAG\n"
1304 "DCL IN[0], GENERIC[0], LINEAR\n"
1305 "DCL SAMP[0]\n"
1306 "DCL SVIEW[0], RECT, FLOAT\n"
1307 "DCL OUT[0], COLOR[0]\n"
1308 "DCL TEMP[0]\n"
1309
1310 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
1311 "MOV OUT[0], TEMP[0].xxxx\n"
1312 "END\n"
1313 };
1314
1315 struct tgsi_token tokens[1000];
1316 struct pipe_shader_state state;
1317
1318 if (!tgsi_text_translate(fragment_shader_text, tokens, ARRAY_SIZE(tokens))) {
1319 assert(0);
1320 pipe_resource_reference(&hud->font.texture, NULL);
1321 u_upload_destroy(hud->uploader);
1322 FREE(hud);
1323 return NULL;
1324 }
1325 pipe_shader_state_from_tgsi(&state, tokens);
1326 hud->fs_text = pipe->create_fs_state(pipe, &state);
1327 }
1328
1329 /* rasterizer */
1330 hud->rasterizer.half_pixel_center = 1;
1331 hud->rasterizer.bottom_edge_rule = 1;
1332 hud->rasterizer.depth_clip = 1;
1333 hud->rasterizer.line_width = 1;
1334 hud->rasterizer.line_last_pixel = 1;
1335
1336 hud->rasterizer_aa_lines = hud->rasterizer;
1337 hud->rasterizer_aa_lines.line_smooth = 1;
1338
1339 /* vertex shader */
1340 {
1341 static const char *vertex_shader_text = {
1342 "VERT\n"
1343 "DCL IN[0..1]\n"
1344 "DCL OUT[0], POSITION\n"
1345 "DCL OUT[1], COLOR[0]\n" /* color */
1346 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
1347 /* [0] = color,
1348 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
1349 * [2] = (xscale, yscale, 0, 0) */
1350 "DCL CONST[0..2]\n"
1351 "DCL TEMP[0]\n"
1352 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
1353
1354 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
1355 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
1356 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
1357 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
1358 "MOV OUT[0].zw, IMM[0]\n"
1359
1360 "MOV OUT[1], CONST[0]\n"
1361 "MOV OUT[2], IN[1]\n"
1362 "END\n"
1363 };
1364
1365 struct tgsi_token tokens[1000];
1366 struct pipe_shader_state state;
1367 if (!tgsi_text_translate(vertex_shader_text, tokens, ARRAY_SIZE(tokens))) {
1368 assert(0);
1369 pipe_resource_reference(&hud->font.texture, NULL);
1370 u_upload_destroy(hud->uploader);
1371 FREE(hud);
1372 return NULL;
1373 }
1374 pipe_shader_state_from_tgsi(&state, tokens);
1375 hud->vs = pipe->create_vs_state(pipe, &state);
1376 }
1377
1378 /* vertex elements */
1379 for (i = 0; i < 2; i++) {
1380 hud->velems[i].src_offset = i * 2 * sizeof(float);
1381 hud->velems[i].src_format = PIPE_FORMAT_R32G32_FLOAT;
1382 hud->velems[i].vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
1383 }
1384
1385 /* sampler view */
1386 u_sampler_view_default_template(
1387 &view_templ, hud->font.texture, hud->font.texture->format);
1388 hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
1389 &view_templ);
1390
1391 /* sampler state (for font drawing) */
1392 hud->font_sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1393 hud->font_sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1394 hud->font_sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1395 hud->font_sampler_state.normalized_coords = 0;
1396
1397 /* constants */
1398 hud->constbuf.buffer_size = sizeof(hud->constants);
1399 hud->constbuf.user_buffer = &hud->constants;
1400
1401 LIST_INITHEAD(&hud->pane_list);
1402
1403 /* setup sig handler once for all hud contexts */
1404 #ifdef PIPE_OS_UNIX
1405 if (!sig_handled && signo != 0) {
1406 action.sa_sigaction = &signal_visible_handler;
1407 action.sa_flags = SA_SIGINFO;
1408
1409 if (signo >= NSIG)
1410 fprintf(stderr, "gallium_hud: invalid signal %u\n", signo);
1411 else if (sigaction(signo, &action, NULL) < 0)
1412 fprintf(stderr, "gallium_hud: unable to set handler for signal %u\n", signo);
1413 fflush(stderr);
1414
1415 sig_handled = TRUE;
1416 }
1417 #endif
1418
1419 hud_parse_env_var(hud, env);
1420 return hud;
1421 }
1422
1423 void
1424 hud_destroy(struct hud_context *hud)
1425 {
1426 struct pipe_context *pipe = hud->pipe;
1427 struct hud_pane *pane, *pane_tmp;
1428 struct hud_graph *graph, *graph_tmp;
1429
1430 LIST_FOR_EACH_ENTRY_SAFE(pane, pane_tmp, &hud->pane_list, head) {
1431 LIST_FOR_EACH_ENTRY_SAFE(graph, graph_tmp, &pane->graph_list, head) {
1432 LIST_DEL(&graph->head);
1433 hud_graph_destroy(graph);
1434 }
1435 LIST_DEL(&pane->head);
1436 FREE(pane);
1437 }
1438
1439 hud_batch_query_cleanup(&hud->batch_query);
1440 pipe->delete_fs_state(pipe, hud->fs_color);
1441 pipe->delete_fs_state(pipe, hud->fs_text);
1442 pipe->delete_vs_state(pipe, hud->vs);
1443 pipe_sampler_view_reference(&hud->font_sampler_view, NULL);
1444 pipe_resource_reference(&hud->font.texture, NULL);
1445 u_upload_destroy(hud->uploader);
1446 FREE(hud);
1447 }