src/gallium/drivers/r300/r300_vs.c

   1 /*
   2  * Copyright 2009 Corbin Simpson <MostAwesomeDude@gmail.com>
   3  * Copyright 2009 Marek Olšák <maraeo@gmail.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #include "r300_vs.h"
  25
  26 #include "r300_context.h"
  27 #include "r300_screen.h"
  28 #include "r300_tgsi_to_rc.h"
  29 #include "r300_reg.h"
  30
  31 #include "tgsi/tgsi_dump.h"
  32 #include "tgsi/tgsi_parse.h"
  33
  34 #include "radeon_compiler.h"
  35
  36 /* Convert info about VS output semantics into r300_shader_semantics. */
  37 static void r300_shader_read_vs_outputs(
  38     struct tgsi_shader_info* info,
  39     struct r300_shader_semantics* vs_outputs)
  40 {
  41     int i;
  42     unsigned index;
  43
  44     r300_shader_semantics_reset(vs_outputs);
  45
  46     for (i = 0; i < info->num_outputs; i++) {
  47         index = info->output_semantic_index[i];
  48
  49         switch (info->output_semantic_name[i]) {
  50             case TGSI_SEMANTIC_POSITION:
  51                 assert(index == 0);
  52                 vs_outputs->pos = i;
  53                 break;
  54
  55             case TGSI_SEMANTIC_PSIZE:
  56                 assert(index == 0);
  57                 vs_outputs->psize = i;
  58                 break;
  59
  60             case TGSI_SEMANTIC_COLOR:
  61                 assert(index <= ATTR_COLOR_COUNT);
  62                 vs_outputs->color[index] = i;
  63                 break;
  64
  65             case TGSI_SEMANTIC_BCOLOR:
  66                 assert(index <= ATTR_COLOR_COUNT);
  67                 vs_outputs->bcolor[index] = i;
  68                 break;
  69
  70             case TGSI_SEMANTIC_GENERIC:
  71                 assert(index <= ATTR_GENERIC_COUNT);
  72                 vs_outputs->generic[index] = i;
  73                 break;
  74
  75             case TGSI_SEMANTIC_FOG:
  76                 assert(index == 0);
  77                 vs_outputs->fog = i;
  78                 break;
  79
  80             default:
  81                 assert(0);
  82         }
  83     }
  84 }
  85
  86 static void r300_shader_vap_output_fmt(
  87     struct r300_shader_semantics* vs_outputs,
  88     uint* hwfmt)
  89 {
  90     int i, gen_count;
  91
  92     /* Do the actual vertex_info setup.
  93      *
  94      * vertex_info has four uints of hardware-specific data in it.
  95      * vinfo.hwfmt[0] is R300_VAP_VTX_STATE_CNTL
  96      * vinfo.hwfmt[1] is R300_VAP_VSM_VTX_ASSM
  97      * vinfo.hwfmt[2] is R300_VAP_OUTPUT_VTX_FMT_0
  98      * vinfo.hwfmt[3] is R300_VAP_OUTPUT_VTX_FMT_1 */
  99
 100     hwfmt[0] = 0x5555; /* XXX this is classic Mesa bonghits */
 101
 102     /* Position. */
 103     if (vs_outputs->pos != ATTR_UNUSED) {
 104         hwfmt[1] |= R300_INPUT_CNTL_POS;
 105         hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
 106     } else {
 107         assert(0);
 108     }
 109
 110     /* Point size. */
 111     if (vs_outputs->psize != ATTR_UNUSED) {
 112         hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT;
 113     }
 114
 115     /* Colors. */
 116     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 117         if (vs_outputs->color[i] != ATTR_UNUSED) {
 118             hwfmt[1] |= R300_INPUT_CNTL_COLOR;
 119             hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_0_PRESENT << i;
 120         }
 121     }
 122
 123     /* XXX Back-face colors. */
 124
 125     /* Texture coordinates. */
 126     gen_count = 0;
 127     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
 128         if (vs_outputs->generic[i] != ATTR_UNUSED) {
 129             hwfmt[1] |= (R300_INPUT_CNTL_TC0 << gen_count);
 130             hwfmt[3] |= (4 << (3 * gen_count));
 131             gen_count++;
 132         }
 133     }
 134
 135     /* Fog coordinates. */
 136     if (vs_outputs->fog != ATTR_UNUSED) {
 137         hwfmt[1] |= (R300_INPUT_CNTL_TC0 << gen_count);
 138         hwfmt[3] |= (4 << (3 * gen_count));
 139         gen_count++;
 140     }
 141
 142     /* XXX magic */
 143     assert(gen_count <= 8);
 144 }
 145
 146 /* Sets up stream mapping to equivalent VS outputs if TCL is bypassed
 147  * or isn't present. */
 148 static void r300_stream_locations_notcl(
 149     struct r300_shader_semantics* vs_outputs,
 150     int* stream_loc)
 151 {
 152     int i, tabi = 0, gen_count;
 153
 154     /* Position. */
 155     stream_loc[tabi++] = 0;
 156
 157     /* Point size. */
 158     if (vs_outputs->psize != ATTR_UNUSED) {
 159         stream_loc[tabi++] = 1;
 160     }
 161
 162     /* Colors. */
 163     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 164         if (vs_outputs->color[i] != ATTR_UNUSED) {
 165             stream_loc[tabi++] = 2 + i;
 166         }
 167     }
 168
 169     /* Back-face colors. */
 170     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 171         if (vs_outputs->bcolor[i] != ATTR_UNUSED) {
 172             stream_loc[tabi++] = 4 + i;
 173         }
 174     }
 175
 176     /* Texture coordinates. */
 177     gen_count = 0;
 178     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
 179         if (vs_outputs->bcolor[i] != ATTR_UNUSED) {
 180             assert(tabi < 16);
 181             stream_loc[tabi++] = 6 + gen_count;
 182             gen_count++;
 183         }
 184     }
 185
 186     /* Fog coordinates. */
 187     if (vs_outputs->fog != ATTR_UNUSED) {
 188         assert(tabi < 16);
 189         stream_loc[tabi++] = 6 + gen_count;
 190         gen_count++;
 191     }
 192
 193     /* XXX magic */
 194     assert(gen_count <= 8);
 195
 196     for (; tabi < 16;) {
 197         stream_loc[tabi++] = -1;
 198     }
 199 }
 200
 201 static void set_vertex_inputs_outputs(struct r300_vertex_program_compiler * c)
 202 {
 203     struct r300_vertex_shader * vs = c->UserData;
 204     struct r300_shader_semantics* outputs = &vs->outputs;
 205     struct tgsi_shader_info* info = &vs->info;
 206     int i, reg = 0;
 207
 208     /* Fill in the input mapping */
 209     for (i = 0; i < info->num_inputs; i++)
 210         c->code->inputs[i] = i;
 211
 212     /* Position. */
 213     if (outputs->pos != ATTR_UNUSED) {
 214         c->code->outputs[outputs->pos] = reg++;
 215     } else {
 216         assert(0);
 217     }
 218
 219     /* Point size. */
 220     if (outputs->psize != ATTR_UNUSED) {
 221         c->code->outputs[outputs->psize] = reg++;
 222     }
 223
 224     /* Colors. */
 225     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 226         if (outputs->color[i] != ATTR_UNUSED) {
 227             c->code->outputs[outputs->color[i]] = reg++;
 228         }
 229     }
 230
 231     /* XXX Back-face colors. */
 232
 233     /* Texture coordinates. */
 234     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
 235         if (outputs->generic[i] != ATTR_UNUSED) {
 236             c->code->outputs[outputs->generic[i]] = reg++;
 237         }
 238     }
 239
 240     /* Fog coordinates. */
 241     if (outputs->fog != ATTR_UNUSED) {
 242         c->code->outputs[outputs->fog] = reg++;
 243     }
 244 }
 245
 246 void r300_translate_vertex_shader(struct r300_context* r300,
 247                                   struct r300_vertex_shader* vs)
 248 {
 249     struct r300_vertex_program_compiler compiler;
 250     struct tgsi_to_rc ttr;
 251
 252     /* Initialize. */
 253     r300_shader_read_vs_outputs(&vs->info, &vs->outputs);
 254     r300_shader_vap_output_fmt(&vs->outputs, vs->hwfmt);
 255     r300_stream_locations_notcl(&vs->outputs, vs->stream_loc_notcl);
 256
 257     /* Setup the compiler */
 258     rc_init(&compiler.Base);
 259
 260     compiler.Base.Debug = DBG_ON(r300, DBG_VP);
 261     compiler.code = &vs->code;
 262     compiler.UserData = vs;
 263
 264     if (compiler.Base.Debug) {
 265         debug_printf("r300: Initial vertex program\n");
 266         tgsi_dump(vs->state.tokens, 0);
 267     }
 268
 269     /* Translate TGSI to our internal representation */
 270     ttr.compiler = &compiler.Base;
 271     ttr.info = &vs->info;
 272
 273     r300_tgsi_to_rc(&ttr, vs->state.tokens);
 274
 275     compiler.RequiredOutputs = ~(~0 << vs->info.num_outputs);
 276     compiler.SetHwInputOutput = &set_vertex_inputs_outputs;
 277
 278     /* Invoke the compiler */
 279     r3xx_compile_vertex_program(&compiler);
 280     if (compiler.Base.Error) {
 281         /* XXX We should fallback using Draw. */
 282         fprintf(stderr, "r300 VP: Compiler error\n");
 283         abort();
 284     }
 285
 286     /* And, finally... */
 287     rc_destroy(&compiler.Base);
 288     vs->translated = TRUE;
 289 }