Subversion Repositories Kolibri OS

Rev

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