Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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 <stdio.h>
  37.  
  38. #include "hud/hud_context.h"
  39. #include "hud/hud_private.h"
  40. #include "hud/font.h"
  41.  
  42. #include "cso_cache/cso_context.h"
  43. #include "util/u_draw_quad.h"
  44. #include "util/u_inlines.h"
  45. #include "util/u_memory.h"
  46. #include "util/u_math.h"
  47. #include "util/u_simple_shaders.h"
  48. #include "util/u_string.h"
  49. #include "util/u_upload_mgr.h"
  50. #include "tgsi/tgsi_text.h"
  51. #include "tgsi/tgsi_dump.h"
  52.  
  53.  
  54. struct hud_context {
  55.    struct pipe_context *pipe;
  56.    struct cso_context *cso;
  57.    struct u_upload_mgr *uploader;
  58.  
  59.    struct list_head pane_list;
  60.  
  61.    /* states */
  62.    struct pipe_blend_state alpha_blend;
  63.    struct pipe_depth_stencil_alpha_state dsa;
  64.    void *fs_color, *fs_text;
  65.    struct pipe_rasterizer_state rasterizer;
  66.    void *vs;
  67.    struct pipe_vertex_element velems[2];
  68.  
  69.    /* font */
  70.    struct util_font font;
  71.    struct pipe_sampler_view *font_sampler_view;
  72.    struct pipe_sampler_state font_sampler_state;
  73.  
  74.    /* VS constant buffer */
  75.    struct {
  76.       float color[4];
  77.       float two_div_fb_width;
  78.       float two_div_fb_height;
  79.       float translate[2];
  80.       float scale[2];
  81.       float padding[2];
  82.    } constants;
  83.    struct pipe_constant_buffer constbuf;
  84.  
  85.    unsigned fb_width, fb_height;
  86.  
  87.    /* vertices for text and background drawing are accumulated here and then
  88.     * drawn all at once */
  89.    struct vertex_queue {
  90.       float *vertices;
  91.       struct pipe_vertex_buffer vbuf;
  92.       unsigned max_num_vertices;
  93.       unsigned num_vertices;
  94.    } text, bg, whitelines;
  95. };
  96.  
  97.  
  98. static void
  99. hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
  100.                        float *buffer, unsigned num_vertices,
  101.                        float r, float g, float b, float a,
  102.                        int xoffset, int yoffset, float yscale)
  103. {
  104.    struct cso_context *cso = hud->cso;
  105.    struct pipe_vertex_buffer vbuffer = {0};
  106.  
  107.    hud->constants.color[0] = r;
  108.    hud->constants.color[1] = g;
  109.    hud->constants.color[2] = b;
  110.    hud->constants.color[3] = a;
  111.    hud->constants.translate[0] = (float) xoffset;
  112.    hud->constants.translate[1] = (float) yoffset;
  113.    hud->constants.scale[0] = 1;
  114.    hud->constants.scale[1] = yscale;
  115.    cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
  116.  
  117.    vbuffer.user_buffer = buffer;
  118.    vbuffer.stride = 2 * sizeof(float);
  119.  
  120.    cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso),
  121.                           1, &vbuffer);
  122.    cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
  123.    cso_draw_arrays(cso, prim, 0, num_vertices);
  124. }
  125.  
  126. static void
  127. hud_draw_colored_quad(struct hud_context *hud, unsigned prim,
  128.                       unsigned x1, unsigned y1, unsigned x2, unsigned y2,
  129.                       float r, float g, float b, float a)
  130. {
  131.    float buffer[] = {
  132.       (float) x1, (float) y1,
  133.       (float) x1, (float) y2,
  134.       (float) x2, (float) y2,
  135.       (float) x2, (float) y1,
  136.    };
  137.  
  138.    hud_draw_colored_prims(hud, prim, buffer, 4, r, g, b, a, 0, 0, 1);
  139. }
  140.  
  141. static void
  142. hud_draw_background_quad(struct hud_context *hud,
  143.                          unsigned x1, unsigned y1, unsigned x2, unsigned y2)
  144. {
  145.    float *vertices = hud->bg.vertices + hud->bg.num_vertices*2;
  146.    unsigned num = 0;
  147.  
  148.    assert(hud->bg.num_vertices + 4 <= hud->bg.max_num_vertices);
  149.  
  150.    vertices[num++] = (float) x1;
  151.    vertices[num++] = (float) y1;
  152.  
  153.    vertices[num++] = (float) x1;
  154.    vertices[num++] = (float) y2;
  155.  
  156.    vertices[num++] = (float) x2;
  157.    vertices[num++] = (float) y2;
  158.  
  159.    vertices[num++] = (float) x2;
  160.    vertices[num++] = (float) y1;
  161.  
  162.    hud->bg.num_vertices += num/2;
  163. }
  164.  
  165. static void
  166. hud_draw_string(struct hud_context *hud, unsigned x, unsigned y,
  167.                 const char *str, ...)
  168. {
  169.    char buf[256];
  170.    char *s = buf;
  171.    float *vertices = hud->text.vertices + hud->text.num_vertices*4;
  172.    unsigned num = 0;
  173.  
  174.    va_list ap;
  175.    va_start(ap, str);
  176.    util_vsnprintf(buf, sizeof(buf), str, ap);
  177.    va_end(ap);
  178.  
  179.    if (!*s)
  180.       return;
  181.  
  182.    hud_draw_background_quad(hud,
  183.                             x, y,
  184.                             x + strlen(buf)*hud->font.glyph_width,
  185.                             y + hud->font.glyph_height);
  186.  
  187.    while (*s) {
  188.       unsigned x1 = x;
  189.       unsigned y1 = y;
  190.       unsigned x2 = x + hud->font.glyph_width;
  191.       unsigned y2 = y + hud->font.glyph_height;
  192.       unsigned tx1 = (*s % 16) * hud->font.glyph_width;
  193.       unsigned ty1 = (*s / 16) * hud->font.glyph_height;
  194.       unsigned tx2 = tx1 + hud->font.glyph_width;
  195.       unsigned ty2 = ty1 + hud->font.glyph_height;
  196.  
  197.       if (*s == ' ') {
  198.          x += hud->font.glyph_width;
  199.          s++;
  200.          continue;
  201.       }
  202.  
  203.       assert(hud->text.num_vertices + num/4 + 4 <= hud->text.max_num_vertices);
  204.  
  205.       vertices[num++] = (float) x1;
  206.       vertices[num++] = (float) y1;
  207.       vertices[num++] = (float) tx1;
  208.       vertices[num++] = (float) ty1;
  209.  
  210.       vertices[num++] = (float) x1;
  211.       vertices[num++] = (float) y2;
  212.       vertices[num++] = (float) tx1;
  213.       vertices[num++] = (float) ty2;
  214.  
  215.       vertices[num++] = (float) x2;
  216.       vertices[num++] = (float) y2;
  217.       vertices[num++] = (float) tx2;
  218.       vertices[num++] = (float) ty2;
  219.  
  220.       vertices[num++] = (float) x2;
  221.       vertices[num++] = (float) y1;
  222.       vertices[num++] = (float) tx2;
  223.       vertices[num++] = (float) ty1;
  224.  
  225.       x += hud->font.glyph_width;
  226.       s++;
  227.    }
  228.  
  229.    hud->text.num_vertices += num/4;
  230. }
  231.  
  232. static void
  233. number_to_human_readable(uint64_t num, boolean is_in_bytes, char *out)
  234. {
  235.    static const char *byte_units[] =
  236.       {"", " KB", " MB", " GB", " TB", " PB", " EB"};
  237.    static const char *metric_units[] =
  238.       {"", " k", " M", " G", " T", " P", " E"};
  239.    const char **units = is_in_bytes ? byte_units : metric_units;
  240.    double divisor = is_in_bytes ? 1024 : 1000;
  241.    int unit = 0;
  242.    double d = num;
  243.  
  244.    while (d > divisor) {
  245.       d /= divisor;
  246.       unit++;
  247.    }
  248.  
  249.    if (d >= 100 || d == (int)d)
  250.       sprintf(out, "%.0f%s", d, units[unit]);
  251.    else if (d >= 10 || d*10 == (int)(d*10))
  252.       sprintf(out, "%.1f%s", d, units[unit]);
  253.    else
  254.       sprintf(out, "%.2f%s", d, units[unit]);
  255. }
  256.  
  257. static void
  258. hud_draw_graph_line_strip(struct hud_context *hud, const struct hud_graph *gr,
  259.                           unsigned xoffset, unsigned yoffset, float yscale)
  260. {
  261.    if (gr->num_vertices <= 1)
  262.       return;
  263.  
  264.    assert(gr->index <= gr->num_vertices);
  265.  
  266.    hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
  267.                           gr->vertices, gr->index,
  268.                           gr->color[0], gr->color[1], gr->color[2], 1,
  269.                           xoffset + (gr->pane->max_num_vertices - gr->index - 1) * 2 - 1,
  270.                           yoffset, yscale);
  271.  
  272.    if (gr->num_vertices <= gr->index)
  273.       return;
  274.  
  275.    hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
  276.                           gr->vertices + gr->index*2,
  277.                           gr->num_vertices - gr->index,
  278.                           gr->color[0], gr->color[1], gr->color[2], 1,
  279.                           xoffset - gr->index*2 - 1, yoffset, yscale);
  280. }
  281.  
  282. static void
  283. hud_pane_accumulate_vertices(struct hud_context *hud,
  284.                              const struct hud_pane *pane)
  285. {
  286.    struct hud_graph *gr;
  287.    float *line_verts = hud->whitelines.vertices + hud->whitelines.num_vertices*2;
  288.    unsigned i, num = 0;
  289.    char str[32];
  290.  
  291.    /* draw background */
  292.    hud_draw_background_quad(hud,
  293.                             pane->x1, pane->y1,
  294.                             pane->x2, pane->y2);
  295.  
  296.    /* draw numbers on the right-hand side */
  297.    for (i = 0; i < 6; i++) {
  298.       unsigned x = pane->x2 + 2;
  299.       unsigned y = pane->inner_y1 + pane->inner_height * (5 - i) / 5 -
  300.                    hud->font.glyph_height / 2;
  301.  
  302.       number_to_human_readable(pane->max_value * i / 5,
  303.                                pane->uses_byte_units, str);
  304.       hud_draw_string(hud, x, y, str);
  305.    }
  306.  
  307.    /* draw info below the pane */
  308.    i = 0;
  309.    LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
  310.       unsigned x = pane->x1 + 2;
  311.       unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
  312.  
  313.       number_to_human_readable(gr->current_value,
  314.                                pane->uses_byte_units, str);
  315.       hud_draw_string(hud, x, y, "  %s: %s", gr->name, str);
  316.       i++;
  317.    }
  318.  
  319.    /* draw border */
  320.    assert(hud->whitelines.num_vertices + num/2 + 8 <= hud->whitelines.max_num_vertices);
  321.    line_verts[num++] = (float) pane->x1;
  322.    line_verts[num++] = (float) pane->y1;
  323.    line_verts[num++] = (float) pane->x2;
  324.    line_verts[num++] = (float) pane->y1;
  325.  
  326.    line_verts[num++] = (float) pane->x2;
  327.    line_verts[num++] = (float) pane->y1;
  328.    line_verts[num++] = (float) pane->x2;
  329.    line_verts[num++] = (float) pane->y2;
  330.  
  331.    line_verts[num++] = (float) pane->x1;
  332.    line_verts[num++] = (float) pane->y2;
  333.    line_verts[num++] = (float) pane->x2;
  334.    line_verts[num++] = (float) pane->y2;
  335.  
  336.    line_verts[num++] = (float) pane->x1;
  337.    line_verts[num++] = (float) pane->y1;
  338.    line_verts[num++] = (float) pane->x1;
  339.    line_verts[num++] = (float) pane->y2;
  340.  
  341.    /* draw horizontal lines inside the graph */
  342.    for (i = 0; i <= 5; i++) {
  343.       float y = round((pane->max_value * i / 5.0) * pane->yscale + pane->inner_y2);
  344.  
  345.       assert(hud->whitelines.num_vertices + num/2 + 2 <= hud->whitelines.max_num_vertices);
  346.       line_verts[num++] = pane->x1;
  347.       line_verts[num++] = y;
  348.       line_verts[num++] = pane->x2;
  349.       line_verts[num++] = y;
  350.    }
  351.  
  352.    hud->whitelines.num_vertices += num/2;
  353. }
  354.  
  355. static void
  356. hud_pane_draw_colored_objects(struct hud_context *hud,
  357.                               const struct hud_pane *pane)
  358. {
  359.    struct hud_graph *gr;
  360.    unsigned i;
  361.  
  362.    /* draw colored quads below the pane */
  363.    i = 0;
  364.    LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
  365.       unsigned x = pane->x1 + 2;
  366.       unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
  367.  
  368.       hud_draw_colored_quad(hud, PIPE_PRIM_QUADS, x + 1, y + 1, x + 12, y + 13,
  369.                             gr->color[0], gr->color[1], gr->color[2], 1);
  370.       i++;
  371.    }
  372.  
  373.    /* draw the line strips */
  374.    LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
  375.       hud_draw_graph_line_strip(hud, gr, pane->inner_x1, pane->inner_y2, pane->yscale);
  376.    }
  377. }
  378.  
  379. static void
  380. hud_alloc_vertices(struct hud_context *hud, struct vertex_queue *v,
  381.                    unsigned num_vertices, unsigned stride)
  382. {
  383.    v->num_vertices = 0;
  384.    v->max_num_vertices = num_vertices;
  385.    v->vbuf.stride = stride;
  386.    u_upload_alloc(hud->uploader, 0, v->vbuf.stride * v->max_num_vertices,
  387.                   &v->vbuf.buffer_offset, &v->vbuf.buffer,
  388.                   (void**)&v->vertices);
  389. }
  390.  
  391. /**
  392.  * Draw the HUD to the texture \p tex.
  393.  * The texture is usually the back buffer being displayed.
  394.  */
  395. void
  396. hud_draw(struct hud_context *hud, struct pipe_resource *tex)
  397. {
  398.    struct cso_context *cso = hud->cso;
  399.    struct pipe_context *pipe = hud->pipe;
  400.    struct pipe_framebuffer_state fb;
  401.    struct pipe_surface surf_templ, *surf;
  402.    struct pipe_viewport_state viewport;
  403.    const struct pipe_sampler_state *sampler_states[] =
  404.          { &hud->font_sampler_state };
  405.    struct hud_pane *pane;
  406.    struct hud_graph *gr;
  407.  
  408.    hud->fb_width = tex->width0;
  409.    hud->fb_height = tex->height0;
  410.    hud->constants.two_div_fb_width = 2.0f / hud->fb_width;
  411.    hud->constants.two_div_fb_height = 2.0f / hud->fb_height;
  412.  
  413.    cso_save_framebuffer(cso);
  414.    cso_save_sample_mask(cso);
  415.    cso_save_blend(cso);
  416.    cso_save_depth_stencil_alpha(cso);
  417.    cso_save_fragment_shader(cso);
  418.    cso_save_sampler_views(cso, PIPE_SHADER_FRAGMENT);
  419.    cso_save_samplers(cso, PIPE_SHADER_FRAGMENT);
  420.    cso_save_rasterizer(cso);
  421.    cso_save_viewport(cso);
  422.    cso_save_stream_outputs(cso);
  423.    cso_save_geometry_shader(cso);
  424.    cso_save_vertex_shader(cso);
  425.    cso_save_vertex_elements(cso);
  426.    cso_save_aux_vertex_buffer_slot(cso);
  427.    cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
  428.    cso_save_render_condition(cso);
  429.  
  430.    /* set states */
  431.    memset(&surf_templ, 0, sizeof(surf_templ));
  432.    surf_templ.format = tex->format;
  433.    surf = pipe->create_surface(pipe, tex, &surf_templ);
  434.  
  435.    memset(&fb, 0, sizeof(fb));
  436.    fb.nr_cbufs = 1;
  437.    fb.cbufs[0] = surf;
  438.    fb.zsbuf = NULL;
  439.    fb.width = hud->fb_width;
  440.    fb.height = hud->fb_height;
  441.  
  442.    viewport.scale[0] = 0.5f * hud->fb_width;
  443.    viewport.scale[1] = 0.5f * hud->fb_height;
  444.    viewport.scale[2] = 1.0f;
  445.    viewport.scale[3] = 1.0f;
  446.    viewport.translate[0] = 0.5f * hud->fb_width;
  447.    viewport.translate[1] = 0.5f * hud->fb_height;
  448.    viewport.translate[2] = 0.0f;
  449.    viewport.translate[3] = 0.0f;
  450.  
  451.    cso_set_framebuffer(cso, &fb);
  452.    cso_set_sample_mask(cso, ~0);
  453.    cso_set_blend(cso, &hud->alpha_blend);
  454.    cso_set_depth_stencil_alpha(cso, &hud->dsa);
  455.    cso_set_rasterizer(cso, &hud->rasterizer);
  456.    cso_set_viewport(cso, &viewport);
  457.    cso_set_stream_outputs(cso, 0, NULL, 0);
  458.    cso_set_geometry_shader_handle(cso, NULL);
  459.    cso_set_vertex_shader_handle(cso, hud->vs);
  460.    cso_set_vertex_elements(cso, 2, hud->velems);
  461.    cso_set_render_condition(cso, NULL, FALSE, 0);
  462.    cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1,
  463.                          &hud->font_sampler_view);
  464.    cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states);
  465.    cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
  466.  
  467.    /* prepare vertex buffers */
  468.    hud_alloc_vertices(hud, &hud->bg, 4 * 128, 2 * sizeof(float));
  469.    hud_alloc_vertices(hud, &hud->whitelines, 4 * 256, 2 * sizeof(float));
  470.    hud_alloc_vertices(hud, &hud->text, 4 * 512, 4 * sizeof(float));
  471.  
  472.    /* prepare all graphs */
  473.    LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
  474.       LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
  475.          gr->query_new_value(gr);
  476.       }
  477.  
  478.       hud_pane_accumulate_vertices(hud, pane);
  479.    }
  480.  
  481.    /* unmap the uploader's vertex buffer before drawing */
  482.    u_upload_flush(hud->uploader);
  483.  
  484.    /* draw accumulated vertices for background quads */
  485.    cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
  486.  
  487.    if (hud->bg.num_vertices) {
  488.       hud->constants.color[0] = 0;
  489.       hud->constants.color[1] = 0;
  490.       hud->constants.color[2] = 0;
  491.       hud->constants.color[3] = 0.666f;
  492.       hud->constants.translate[0] = 0;
  493.       hud->constants.translate[1] = 0;
  494.       hud->constants.scale[0] = 1;
  495.       hud->constants.scale[1] = 1;
  496.  
  497.       cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
  498.       cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
  499.                              &hud->bg.vbuf);
  500.       cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->bg.num_vertices);
  501.    }
  502.    pipe_resource_reference(&hud->bg.vbuf.buffer, NULL);
  503.  
  504.    /* draw accumulated vertices for white lines */
  505.    hud->constants.color[0] = 1;
  506.    hud->constants.color[1] = 1;
  507.    hud->constants.color[2] = 1;
  508.    hud->constants.color[3] = 1;
  509.    hud->constants.translate[0] = 0;
  510.    hud->constants.translate[1] = 0;
  511.    hud->constants.scale[0] = 1;
  512.    hud->constants.scale[1] = 1;
  513.    cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
  514.  
  515.    if (hud->whitelines.num_vertices) {
  516.       cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
  517.                              &hud->whitelines.vbuf);
  518.       cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
  519.       cso_draw_arrays(cso, PIPE_PRIM_LINES, 0, hud->whitelines.num_vertices);
  520.    }
  521.    pipe_resource_reference(&hud->whitelines.vbuf.buffer, NULL);
  522.  
  523.    /* draw accumulated vertices for text */
  524.    if (hud->text.num_vertices) {
  525.       cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
  526.                              &hud->text.vbuf);
  527.       cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
  528.       cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->text.num_vertices);
  529.    }
  530.    pipe_resource_reference(&hud->text.vbuf.buffer, NULL);
  531.  
  532.    /* draw the rest */
  533.    LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
  534.       if (pane)
  535.          hud_pane_draw_colored_objects(hud, pane);
  536.    }
  537.  
  538.    /* restore states */
  539.    cso_restore_framebuffer(cso);
  540.    cso_restore_sample_mask(cso);
  541.    cso_restore_blend(cso);
  542.    cso_restore_depth_stencil_alpha(cso);
  543.    cso_restore_fragment_shader(cso);
  544.    cso_restore_sampler_views(cso, PIPE_SHADER_FRAGMENT);
  545.    cso_restore_samplers(cso, PIPE_SHADER_FRAGMENT);
  546.    cso_restore_rasterizer(cso);
  547.    cso_restore_viewport(cso);
  548.    cso_restore_stream_outputs(cso);
  549.    cso_restore_geometry_shader(cso);
  550.    cso_restore_vertex_shader(cso);
  551.    cso_restore_vertex_elements(cso);
  552.    cso_restore_aux_vertex_buffer_slot(cso);
  553.    cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
  554.    cso_restore_render_condition(cso);
  555.  
  556.    pipe_surface_reference(&surf, NULL);
  557. }
  558.  
  559. /**
  560.  * Set the maximum value for the Y axis of the graph.
  561.  * This scales the graph accordingly.
  562.  */
  563. void
  564. hud_pane_set_max_value(struct hud_pane *pane, uint64_t value)
  565. {
  566.    pane->max_value = value;
  567.    pane->yscale = -(int)pane->inner_height / (float)pane->max_value;
  568. }
  569.  
  570. static struct hud_pane *
  571. hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
  572.                 unsigned period, uint64_t max_value)
  573. {
  574.    struct hud_pane *pane = CALLOC_STRUCT(hud_pane);
  575.  
  576.    if (!pane)
  577.       return NULL;
  578.  
  579.    pane->x1 = x1;
  580.    pane->y1 = y1;
  581.    pane->x2 = x2;
  582.    pane->y2 = y2;
  583.    pane->inner_x1 = x1 + 1;
  584.    pane->inner_x2 = x2 - 1;
  585.    pane->inner_y1 = y1 + 1;
  586.    pane->inner_y2 = y2 - 1;
  587.    pane->inner_width = pane->inner_x2 - pane->inner_x1;
  588.    pane->inner_height = pane->inner_y2 - pane->inner_y1;
  589.    pane->period = period;
  590.    pane->max_num_vertices = (x2 - x1 + 2) / 2;
  591.    hud_pane_set_max_value(pane, max_value);
  592.    LIST_INITHEAD(&pane->graph_list);
  593.    return pane;
  594. }
  595.  
  596. /**
  597.  * Add a graph to an existing pane.
  598.  * One pane can contain multiple graphs over each other.
  599.  */
  600. void
  601. hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr)
  602. {
  603.    static const float colors[][3] = {
  604.       {0, 1, 0},
  605.       {1, 0, 0},
  606.       {0, 1, 1},
  607.       {1, 0, 1},
  608.       {1, 1, 0},
  609.       {0.5, 0.5, 1},
  610.       {0.5, 0.5, 0.5},
  611.    };
  612.    char *name = gr->name;
  613.  
  614.    /* replace '-' with a space */
  615.    while (*name) {
  616.       if (*name == '-')
  617.          *name = ' ';
  618.       name++;
  619.    }
  620.  
  621.    assert(pane->num_graphs < Elements(colors));
  622.    gr->vertices = MALLOC(pane->max_num_vertices * sizeof(float) * 2);
  623.    gr->color[0] = colors[pane->num_graphs][0];
  624.    gr->color[1] = colors[pane->num_graphs][1];
  625.    gr->color[2] = colors[pane->num_graphs][2];
  626.    gr->pane = pane;
  627.    LIST_ADDTAIL(&gr->head, &pane->graph_list);
  628.    pane->num_graphs++;
  629. }
  630.  
  631. void
  632. hud_graph_add_value(struct hud_graph *gr, uint64_t value)
  633. {
  634.    if (gr->index == gr->pane->max_num_vertices) {
  635.       gr->vertices[0] = 0;
  636.       gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
  637.       gr->index = 1;
  638.    }
  639.    gr->vertices[(gr->index)*2+0] = (float) (gr->index * 2);
  640.    gr->vertices[(gr->index)*2+1] = (float) value;
  641.    gr->index++;
  642.  
  643.    if (gr->num_vertices < gr->pane->max_num_vertices) {
  644.       gr->num_vertices++;
  645.    }
  646.  
  647.    gr->current_value = value;
  648.    if (value > gr->pane->max_value) {
  649.       hud_pane_set_max_value(gr->pane, value);
  650.    }
  651. }
  652.  
  653. static void
  654. hud_graph_destroy(struct hud_graph *graph)
  655. {
  656.    FREE(graph->vertices);
  657.    if (graph->free_query_data)
  658.       graph->free_query_data(graph->query_data);
  659.    FREE(graph);
  660. }
  661.  
  662. /**
  663.  * Read a string from the environment variable.
  664.  * The separators "+", ",", ":", and ";" terminate the string.
  665.  * Return the number of read characters.
  666.  */
  667. static int
  668. parse_string(const char *s, char *out)
  669. {
  670.    int i;
  671.  
  672.    for (i = 0; *s && *s != '+' && *s != ',' && *s != ':' && *s != ';';
  673.         s++, out++, i++)
  674.       *out = *s;
  675.  
  676.    *out = 0;
  677.  
  678.    if (*s && !i)
  679.       fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) while "
  680.               "parsing a string\n", *s, *s);
  681.    return i;
  682. }
  683.  
  684. static boolean
  685. has_occlusion_query(struct pipe_screen *screen)
  686. {
  687.    return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) != 0;
  688. }
  689.  
  690. static boolean
  691. has_streamout(struct pipe_screen *screen)
  692. {
  693.    return screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
  694. }
  695.  
  696. static boolean
  697. has_pipeline_stats_query(struct pipe_screen *screen)
  698. {
  699.    return screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) != 0;
  700. }
  701.  
  702. static void
  703. hud_parse_env_var(struct hud_context *hud, const char *env)
  704. {
  705.    unsigned num, i;
  706.    char name[256], s[256];
  707.    struct hud_pane *pane = NULL;
  708.    unsigned x = 10, y = 10;
  709.    unsigned width = 251, height = 100;
  710.    unsigned period = 500 * 1000;  /* default period (1/2 second) */
  711.    const char *period_env;
  712.  
  713.    /*
  714.     * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
  715.     * The env var is in seconds (a float).
  716.     * Zero means update after every frame.
  717.     */
  718.    period_env = getenv("GALLIUM_HUD_PERIOD");
  719.    if (period_env) {
  720.       float p = (float) atof(period_env);
  721.       if (p >= 0.0f) {
  722.          period = (unsigned) (p * 1000 * 1000);
  723.       }
  724.    }
  725.  
  726.    while ((num = parse_string(env, name)) != 0) {
  727.       env += num;
  728.  
  729.       if (!pane) {
  730.          pane = hud_pane_create(x, y, x + width, y + height, period, 10);
  731.          if (!pane)
  732.             return;
  733.       }
  734.  
  735.       /* Add a graph. */
  736.       /* IF YOU CHANGE THIS, UPDATE print_help! */
  737.       if (strcmp(name, "fps") == 0) {
  738.          hud_fps_graph_install(pane);
  739.       }
  740.       else if (strcmp(name, "cpu") == 0) {
  741.          hud_cpu_graph_install(pane, ALL_CPUS);
  742.       }
  743.       else if (sscanf(name, "cpu%u%s", &i, s) == 1) {
  744.          hud_cpu_graph_install(pane, i);
  745.       }
  746.       else if (strcmp(name, "samples-passed") == 0 &&
  747.                has_occlusion_query(hud->pipe->screen)) {
  748.          hud_pipe_query_install(pane, hud->pipe, "samples-passed",
  749.                                 PIPE_QUERY_OCCLUSION_COUNTER, 0, 0, FALSE);
  750.       }
  751.       else if (strcmp(name, "primitives-generated") == 0 &&
  752.                has_streamout(hud->pipe->screen)) {
  753.          hud_pipe_query_install(pane, hud->pipe, "primitives-generated",
  754.                                 PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0, FALSE);
  755.       }
  756.       else {
  757.          boolean processed = FALSE;
  758.  
  759.          /* pipeline statistics queries */
  760.          if (has_pipeline_stats_query(hud->pipe->screen)) {
  761.             static const char *pipeline_statistics_names[] =
  762.             {
  763.                "ia-vertices",
  764.                "ia-primitives",
  765.                "vs-invocations",
  766.                "gs-invocations",
  767.                "gs-primitives",
  768.                "clipper-invocations",
  769.                "clipper-primitives-generated",
  770.                "ps-invocations",
  771.                "hs-invocations",
  772.                "ds-invocations",
  773.                "cs-invocations"
  774.             };
  775.             for (i = 0; i < Elements(pipeline_statistics_names); ++i)
  776.                if (strcmp(name, pipeline_statistics_names[i]) == 0)
  777.                   break;
  778.             if (i < Elements(pipeline_statistics_names)) {
  779.                hud_pipe_query_install(pane, hud->pipe, name,
  780.                                       PIPE_QUERY_PIPELINE_STATISTICS, i,
  781.                                       0, FALSE);
  782.                processed = TRUE;
  783.             }
  784.          }
  785.  
  786.          /* driver queries */
  787.          if (!processed) {
  788.             if (!hud_driver_query_install(pane, hud->pipe, name)){
  789.                fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name);
  790.             }
  791.          }
  792.       }
  793.  
  794.       if (*env == ':') {
  795.          env++;
  796.  
  797.          if (!pane) {
  798.             fprintf(stderr, "gallium_hud: syntax error: unexpected ':', "
  799.                     "expected a name\n");
  800.             break;
  801.          }
  802.  
  803.          num = parse_string(env, s);
  804.          env += num;
  805.  
  806.          if (num && sscanf(s, "%u", &i) == 1) {
  807.             hud_pane_set_max_value(pane, i);
  808.          }
  809.          else {
  810.             fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
  811.                     "after ':'\n", *env, *env);
  812.          }
  813.       }
  814.  
  815.       if (*env == 0)
  816.          break;
  817.  
  818.       /* parse a separator */
  819.       switch (*env) {
  820.       case '+':
  821.          env++;
  822.          break;
  823.  
  824.       case ',':
  825.          env++;
  826.          y += height + hud->font.glyph_height * (pane->num_graphs + 2);
  827.  
  828.          if (pane && pane->num_graphs) {
  829.             LIST_ADDTAIL(&pane->head, &hud->pane_list);
  830.             pane = NULL;
  831.          }
  832.          break;
  833.  
  834.       case ';':
  835.          env++;
  836.          y = 10;
  837.          x += width + hud->font.glyph_width * 7;
  838.  
  839.          if (pane && pane->num_graphs) {
  840.             LIST_ADDTAIL(&pane->head, &hud->pane_list);
  841.             pane = NULL;
  842.          }
  843.          break;
  844.  
  845.       default:
  846.          fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
  847.       }
  848.    }
  849.  
  850.    if (pane) {
  851.       if (pane->num_graphs) {
  852.          LIST_ADDTAIL(&pane->head, &hud->pane_list);
  853.       }
  854.       else {
  855.          FREE(pane);
  856.       }
  857.    }
  858. }
  859.  
  860. static void
  861. print_help(struct pipe_screen *screen)
  862. {
  863.    int i, num_queries, num_cpus = hud_get_num_cpus();
  864.  
  865.    puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
  866.    puts("");
  867.    puts("  Names are identifiers of data sources which will be drawn as graphs");
  868.    puts("  in panes. Multiple graphs can be drawn in the same pane.");
  869.    puts("  There can be multiple panes placed in rows and columns.");
  870.    puts("");
  871.    puts("  '+' separates names which will share a pane.");
  872.    puts("  ':[value]' specifies the initial maximum value of the Y axis");
  873.    puts("             for the given pane.");
  874.    puts("  ',' creates a new pane below the last one.");
  875.    puts("  ';' creates a new pane at the top of the next column.");
  876.    puts("");
  877.    puts("  Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
  878.    puts("");
  879.    puts("  Available names:");
  880.    puts("    fps");
  881.    puts("    cpu");
  882.  
  883.    for (i = 0; i < num_cpus; i++)
  884.       printf("    cpu%i\n", i);
  885.  
  886.    if (has_occlusion_query(screen))
  887.       puts("    samples-passed");
  888.    if (has_streamout(screen))
  889.       puts("    primitives-generated");
  890.  
  891.    if (has_pipeline_stats_query(screen)) {
  892.       puts("    ia-vertices");
  893.       puts("    ia-primitives");
  894.       puts("    vs-invocations");
  895.       puts("    gs-invocations");
  896.       puts("    gs-primitives");
  897.       puts("    clipper-invocations");
  898.       puts("    clipper-primitives-generated");
  899.       puts("    ps-invocations");
  900.       puts("    hs-invocations");
  901.       puts("    ds-invocations");
  902.       puts("    cs-invocations");
  903.    }
  904.  
  905.    if (screen->get_driver_query_info){
  906.       struct pipe_driver_query_info info;
  907.       num_queries = screen->get_driver_query_info(screen, 0, NULL);
  908.  
  909.       for (i = 0; i < num_queries; i++){
  910.          screen->get_driver_query_info(screen, i, &info);
  911.          printf("    %s\n", info.name);
  912.       }
  913.    }
  914.  
  915.    puts("");
  916. }
  917.  
  918. struct hud_context *
  919. hud_create(struct pipe_context *pipe, struct cso_context *cso)
  920. {
  921.    struct hud_context *hud;
  922.    struct pipe_sampler_view view_templ;
  923.    unsigned i;
  924.    const char *env = debug_get_option("GALLIUM_HUD", NULL);
  925.  
  926.    if (!env || !*env)
  927.       return NULL;
  928.  
  929.    if (strcmp(env, "help") == 0) {
  930.       print_help(pipe->screen);
  931.       return NULL;
  932.    }
  933.  
  934.    hud = CALLOC_STRUCT(hud_context);
  935.    if (!hud)
  936.       return NULL;
  937.  
  938.    hud->pipe = pipe;
  939.    hud->cso = cso;
  940.    hud->uploader = u_upload_create(pipe, 256 * 1024, 16,
  941.                                    PIPE_BIND_VERTEX_BUFFER);
  942.  
  943.    /* font */
  944.    if (!util_font_create(pipe, UTIL_FONT_FIXED_8X13, &hud->font)) {
  945.       u_upload_destroy(hud->uploader);
  946.       FREE(hud);
  947.       return NULL;
  948.    }
  949.  
  950.    /* blend state */
  951.    hud->alpha_blend.rt[0].colormask = PIPE_MASK_RGBA;
  952.    hud->alpha_blend.rt[0].blend_enable = 1;
  953.    hud->alpha_blend.rt[0].rgb_func = PIPE_BLEND_ADD;
  954.    hud->alpha_blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
  955.    hud->alpha_blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
  956.    hud->alpha_blend.rt[0].alpha_func = PIPE_BLEND_ADD;
  957.    hud->alpha_blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
  958.    hud->alpha_blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
  959.  
  960.    /* fragment shader */
  961.    hud->fs_color =
  962.          util_make_fragment_passthrough_shader(pipe,
  963.                                                TGSI_SEMANTIC_COLOR,
  964.                                                TGSI_INTERPOLATE_CONSTANT,
  965.                                                TRUE);
  966.  
  967.    {
  968.       /* Read a texture and do .xxxx swizzling. */
  969.       static const char *fragment_shader_text = {
  970.          "FRAG\n"
  971.          "DCL IN[0], GENERIC[0], LINEAR\n"
  972.          "DCL SAMP[0]\n"
  973.          "DCL OUT[0], COLOR[0]\n"
  974.          "DCL TEMP[0]\n"
  975.  
  976.          "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
  977.          "MOV OUT[0], TEMP[0].xxxx\n"
  978.          "END\n"
  979.       };
  980.  
  981.       struct tgsi_token tokens[1000];
  982.       struct pipe_shader_state state = {tokens};
  983.  
  984.       if (!tgsi_text_translate(fragment_shader_text, tokens, Elements(tokens))) {
  985.          assert(0);
  986.          pipe_resource_reference(&hud->font.texture, NULL);
  987.          u_upload_destroy(hud->uploader);
  988.          FREE(hud);
  989.          return NULL;
  990.       }
  991.  
  992.       hud->fs_text = pipe->create_fs_state(pipe, &state);
  993.    }
  994.  
  995.    /* rasterizer */
  996.    hud->rasterizer.half_pixel_center = 1;
  997.    hud->rasterizer.bottom_edge_rule = 1;
  998.    hud->rasterizer.depth_clip = 1;
  999.    hud->rasterizer.line_width = 1;
  1000.    hud->rasterizer.line_last_pixel = 1;
  1001.  
  1002.    /* vertex shader */
  1003.    {
  1004.       static const char *vertex_shader_text = {
  1005.          "VERT\n"
  1006.          "DCL IN[0..1]\n"
  1007.          "DCL OUT[0], POSITION\n"
  1008.          "DCL OUT[1], COLOR[0]\n" /* color */
  1009.          "DCL OUT[2], GENERIC[0]\n" /* texcoord */
  1010.          /* [0] = color,
  1011.           * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
  1012.           * [2] = (xscale, yscale, 0, 0) */
  1013.          "DCL CONST[0..2]\n"
  1014.          "DCL TEMP[0]\n"
  1015.          "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
  1016.  
  1017.          /* v = in * (xscale, yscale) + (xoffset, yoffset) */
  1018.          "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
  1019.          /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
  1020.          "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
  1021.          "MOV OUT[0].zw, IMM[0]\n"
  1022.  
  1023.          "MOV OUT[1], CONST[0]\n"
  1024.          "MOV OUT[2], IN[1]\n"
  1025.          "END\n"
  1026.       };
  1027.  
  1028.       struct tgsi_token tokens[1000];
  1029.       struct pipe_shader_state state = {tokens};
  1030.  
  1031.       if (!tgsi_text_translate(vertex_shader_text, tokens, Elements(tokens))) {
  1032.          assert(0);
  1033.          pipe_resource_reference(&hud->font.texture, NULL);
  1034.          u_upload_destroy(hud->uploader);
  1035.          FREE(hud);
  1036.          return NULL;
  1037.       }
  1038.  
  1039.       hud->vs = pipe->create_vs_state(pipe, &state);
  1040.    }
  1041.  
  1042.    /* vertex elements */
  1043.    for (i = 0; i < 2; i++) {
  1044.       hud->velems[i].src_offset = i * 2 * sizeof(float);
  1045.       hud->velems[i].src_format = PIPE_FORMAT_R32G32_FLOAT;
  1046.       hud->velems[i].vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
  1047.    }
  1048.  
  1049.    /* sampler view */
  1050.    memset(&view_templ, 0, sizeof(view_templ));
  1051.    view_templ.format = hud->font.texture->format;
  1052.    view_templ.swizzle_r = PIPE_SWIZZLE_RED;
  1053.    view_templ.swizzle_g = PIPE_SWIZZLE_GREEN;
  1054.    view_templ.swizzle_b = PIPE_SWIZZLE_BLUE;
  1055.    view_templ.swizzle_a = PIPE_SWIZZLE_ALPHA;
  1056.    hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
  1057.                                                       &view_templ);
  1058.  
  1059.    /* sampler state (for font drawing) */
  1060.    hud->font_sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
  1061.    hud->font_sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
  1062.    hud->font_sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
  1063.    hud->font_sampler_state.normalized_coords = 0;
  1064.  
  1065.    /* constants */
  1066.    hud->constbuf.buffer_size = sizeof(hud->constants);
  1067.    hud->constbuf.user_buffer = &hud->constants;
  1068.  
  1069.    LIST_INITHEAD(&hud->pane_list);
  1070.  
  1071.    hud_parse_env_var(hud, env);
  1072.    return hud;
  1073. }
  1074.  
  1075. void
  1076. hud_destroy(struct hud_context *hud)
  1077. {
  1078.    struct pipe_context *pipe = hud->pipe;
  1079.    struct hud_pane *pane, *pane_tmp;
  1080.    struct hud_graph *graph, *graph_tmp;
  1081.  
  1082.    LIST_FOR_EACH_ENTRY_SAFE(pane, pane_tmp, &hud->pane_list, head) {
  1083.       LIST_FOR_EACH_ENTRY_SAFE(graph, graph_tmp, &pane->graph_list, head) {
  1084.          LIST_DEL(&graph->head);
  1085.          hud_graph_destroy(graph);
  1086.       }
  1087.       LIST_DEL(&pane->head);
  1088.       FREE(pane);
  1089.    }
  1090.  
  1091.    pipe->delete_fs_state(pipe, hud->fs_color);
  1092.    pipe->delete_fs_state(pipe, hud->fs_text);
  1093.    pipe->delete_vs_state(pipe, hud->vs);
  1094.    pipe_sampler_view_reference(&hud->font_sampler_view, NULL);
  1095.    pipe_resource_reference(&hud->font.texture, NULL);
  1096.    u_upload_destroy(hud->uploader);
  1097.    FREE(hud);
  1098. }
  1099.