src/gallium/tests/graw/tex-swizzle.c

   1 /* Test texture swizzles */
   2
   3 #include <stdio.h>
   4
   5 #include "graw_util.h"
   6
   7
   8 static struct graw_info info;
   9
  10 static struct pipe_resource *texture = NULL;
  11 static struct pipe_sampler_view *sv = NULL;
  12 static void *sampler = NULL;
  13
  14 static const int WIDTH = 300;
  15 static const int HEIGHT = 300;
  16
  17 struct vertex {
  18    float position[4];
  19    float color[4];
  20 };
  21
  22 static struct vertex vertices[] =
  23 {
  24    { { 0.9, -0.9, 0.0, 1.0 },
  25      { 1, 0, 0, 1 } },
  26
  27    { { 0.9,  0.9, 0.0, 1.0 },
  28      { 1, 1, 0, 1 } },
  29
  30    { {-0.9,  0.9, 0.0, 1.0 },
  31      { 0, 1, 0, 1 } },
  32
  33    { {-0.9,  -0.9, 0.0, 1.0 },
  34      { 0, 0, 0, 1 } },
  35 };
  36
  37
  38 static void set_vertices(void)
  39 {
  40    struct pipe_vertex_element ve[2];
  41    struct pipe_vertex_buffer vbuf;
  42    void *handle;
  43
  44    memset(ve, 0, sizeof ve);
  45
  46    ve[0].src_offset = Offset(struct vertex, position);
  47    ve[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
  48    ve[1].src_offset = Offset(struct vertex, color);
  49    ve[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
  50
  51    handle = info.ctx->create_vertex_elements_state(info.ctx, 2, ve);
  52    info.ctx->bind_vertex_elements_state(info.ctx, handle);
  53
  54    memset(&vbuf, 0, sizeof vbuf);
  55
  56    vbuf.stride = sizeof(struct vertex);
  57    vbuf.buffer_offset = 0;
  58    vbuf.buffer = pipe_buffer_create_with_data(info.ctx,
  59                                               PIPE_BIND_VERTEX_BUFFER,
  60                                               PIPE_USAGE_STATIC,
  61                                               sizeof(vertices),
  62                                               vertices);
  63
  64    info.ctx->set_vertex_buffers(info.ctx, 0, 1, &vbuf);
  65 }
  66
  67 static void set_vertex_shader(void)
  68 {
  69    void *handle;
  70    const char *text =
  71       "VERT\n"
  72       "DCL IN[0]\n"
  73       "DCL IN[1]\n"
  74       "DCL OUT[0], POSITION\n"
  75       "DCL OUT[1], GENERIC[0]\n"
  76       "  0: MOV OUT[1], IN[1]\n"
  77       "  1: MOV OUT[0], IN[0]\n"
  78       "  2: END\n";
  79
  80    handle = graw_parse_vertex_shader(info.ctx, text);
  81    info.ctx->bind_vs_state(info.ctx, handle);
  82 }
  83
  84 static void set_fragment_shader(void)
  85 {
  86    void *handle;
  87    const char *text =
  88       "FRAG\n"
  89       "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
  90       "DCL OUT[0], COLOR\n"
  91       "DCL SAMP[0]\n"
  92       "  0: TXP OUT[0], IN[0], SAMP[0], 2D\n"
  93       "  2: END\n";
  94
  95    handle = graw_parse_fragment_shader(info.ctx, text);
  96    info.ctx->bind_fs_state(info.ctx, handle);
  97 }
  98
  99
 100 static void draw(void)
 101 {
 102    union pipe_color_union clear_color;
 103
 104    clear_color.f[0] = 0.5;
 105    clear_color.f[1] = 0.5;
 106    clear_color.f[2] = 0.5;
 107    clear_color.f[3] = 1.0;
 108
 109    info.ctx->clear(info.ctx, PIPE_CLEAR_COLOR, &clear_color, 0, 0);
 110    util_draw_arrays(info.ctx, PIPE_PRIM_QUADS, 0, 4);
 111    info.ctx->flush(info.ctx, NULL, 0);
 112
 113    graw_util_flush_front(&info);
 114 }
 115
 116
 117
 118 static void
 119 init_tex(const unsigned swizzle[4])
 120 {
 121 #define SIZE 256
 122    struct pipe_sampler_view sv_template;
 123    ubyte tex2d[SIZE][SIZE][4];
 124    int s, t;
 125
 126    for (s = 0; s < SIZE; s++) {
 127       for (t = 0; t < SIZE; t++) {
 128          tex2d[t][s][0] = 0;  /*B*/
 129          tex2d[t][s][1] = t;  /*G*/
 130          tex2d[t][s][2] = s;  /*R*/
 131          tex2d[t][s][3] = 1;  /*A*/
 132       }
 133    }
 134
 135    texture = graw_util_create_tex2d(&info, SIZE, SIZE,
 136                                     PIPE_FORMAT_B8G8R8A8_UNORM, tex2d);
 137
 138    memset(&sv_template, 0, sizeof sv_template);
 139    sv_template.format = texture->format;
 140    sv_template.texture = texture;
 141    sv_template.swizzle_r = swizzle[0];
 142    sv_template.swizzle_g = swizzle[1];
 143    sv_template.swizzle_b = swizzle[2];
 144    sv_template.swizzle_a = swizzle[3];
 145    sv = info.ctx->create_sampler_view(info.ctx, texture, &sv_template);
 146    if (sv == NULL)
 147       exit(5);
 148
 149    info.ctx->set_sampler_views(info.ctx, PIPE_SHADER_FRAGMENT, 0, 1, &sv);
 150
 151    sampler = graw_util_create_simple_sampler(&info,
 152                                              PIPE_TEX_WRAP_REPEAT,
 153                                              PIPE_TEX_FILTER_NEAREST);
 154
 155    info.ctx->bind_sampler_states(info.ctx, PIPE_SHADER_FRAGMENT,
 156                                  0, 1, &sampler);
 157 #undef SIZE
 158 }
 159
 160
 161 static void
 162 init(const unsigned swizzle[4])
 163 {
 164    if (!graw_util_create_window(&info, WIDTH, HEIGHT, 1, FALSE))
 165       exit(1);
 166
 167    graw_util_default_state(&info, FALSE);
 168
 169    graw_util_viewport(&info, 0, 0, WIDTH, HEIGHT, 30, 10000);
 170
 171    init_tex(swizzle);
 172
 173    set_vertices();
 174    set_vertex_shader();
 175    set_fragment_shader();
 176 }
 177
 178
 179 static unsigned
 180 char_to_swizzle(char c)
 181 {
 182    switch (c) {
 183    case 'r':
 184       return PIPE_SWIZZLE_RED;
 185    case 'g':
 186       return PIPE_SWIZZLE_GREEN;
 187    case 'b':
 188       return PIPE_SWIZZLE_BLUE;
 189    case 'a':
 190       return PIPE_SWIZZLE_ALPHA;
 191    case '0':
 192       return PIPE_SWIZZLE_ZERO;
 193    case '1':
 194       return PIPE_SWIZZLE_ONE;
 195    default:
 196       return PIPE_SWIZZLE_RED;
 197    }
 198 }
 199
 200
 201 int main(int argc, char *argv[])
 202 {
 203    const char swizzle_names[] = "rgba01";
 204    uint swizzle[4];
 205    int i;
 206
 207    swizzle[0] = PIPE_SWIZZLE_RED;
 208    swizzle[1] = PIPE_SWIZZLE_GREEN;
 209    swizzle[2] = PIPE_SWIZZLE_BLUE;
 210    swizzle[3] = PIPE_SWIZZLE_ALPHA;
 211
 212    for (i = 1; i < argc; i++) {
 213       swizzle[i-1] = char_to_swizzle(argv[i][0]);
 214    }
 215
 216    printf("Example:\n");
 217    printf("  tex-swizzle r 0 g 1\n");
 218    printf("Current swizzle = ");
 219    for (i = 0; i < 4; i++) {
 220       printf("%c", swizzle_names[swizzle[i]]);
 221    }
 222    printf("\n");
 223
 224    init(swizzle);
 225
 226    graw_set_display_func(draw);
 227    graw_main_loop();
 228    return 0;
 229 }