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             case TGSI_SEMANTIC_EDGEFLAG:
  81                 assert(index == 0);
  82                 fprintf(stderr, "r300 VP: cannot handle edgeflag output\n");
  83                 assert(0);
  84                 break;
  85             default:
  86                 assert(0);
  87         }
  88     }
  89 }
  90
  91 static void r300_shader_vap_output_fmt(
  92     struct r300_shader_semantics* vs_outputs,
  93     uint* hwfmt)
  94 {
  95     int i, gen_count;
  96
  97     /* Do the actual vertex_info setup.
  98      *
  99      * vertex_info has four uints of hardware-specific data in it.
 100      * vinfo.hwfmt[0] is R300_VAP_VTX_STATE_CNTL
 101      * vinfo.hwfmt[1] is R300_VAP_VSM_VTX_ASSM
 102      * vinfo.hwfmt[2] is R300_VAP_OUTPUT_VTX_FMT_0
 103      * vinfo.hwfmt[3] is R300_VAP_OUTPUT_VTX_FMT_1 */
 104
 105     hwfmt[0] = 0x5555; /* XXX this is classic Mesa bonghits */
 106
 107     /* Position. */
 108     if (vs_outputs->pos != ATTR_UNUSED) {
 109         hwfmt[1] |= R300_INPUT_CNTL_POS;
 110         hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
 111     } else {
 112         assert(0);
 113     }
 114
 115     /* Point size. */
 116     if (vs_outputs->psize != ATTR_UNUSED) {
 117         hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT;
 118     }
 119
 120     /* Colors. */
 121     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 122         if (vs_outputs->color[i] != ATTR_UNUSED) {
 123             hwfmt[1] |= R300_INPUT_CNTL_COLOR;
 124             hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_0_PRESENT << i;
 125         }
 126     }
 127
 128     /* XXX Back-face colors. */
 129
 130     /* Texture coordinates. */
 131     gen_count = 0;
 132     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
 133         if (vs_outputs->generic[i] != ATTR_UNUSED) {
 134             hwfmt[1] |= (R300_INPUT_CNTL_TC0 << gen_count);
 135             hwfmt[3] |= (4 << (3 * gen_count));
 136             gen_count++;
 137         }
 138     }
 139
 140     /* Fog coordinates. */
 141     if (vs_outputs->fog != ATTR_UNUSED) {
 142         hwfmt[1] |= (R300_INPUT_CNTL_TC0 << gen_count);
 143         hwfmt[3] |= (4 << (3 * gen_count));
 144         gen_count++;
 145     }
 146
 147     /* XXX magic */
 148     assert(gen_count <= 8);
 149 }
 150
 151 /* Sets up stream mapping to equivalent VS outputs if TCL is bypassed
 152  * or isn't present. */
 153 static void r300_stream_locations_notcl(
 154     struct r300_shader_semantics* vs_outputs,
 155     int* stream_loc)
 156 {
 157     int i, tabi = 0, gen_count;
 158
 159     /* Position. */
 160     stream_loc[tabi++] = 0;
 161
 162     /* Point size. */
 163     if (vs_outputs->psize != ATTR_UNUSED) {
 164         stream_loc[tabi++] = 1;
 165     }
 166
 167     /* Colors. */
 168     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 169         if (vs_outputs->color[i] != ATTR_UNUSED) {
 170             stream_loc[tabi++] = 2 + i;
 171         }
 172     }
 173
 174     /* Back-face colors. */
 175     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 176         if (vs_outputs->bcolor[i] != ATTR_UNUSED) {
 177             stream_loc[tabi++] = 4 + i;
 178         }
 179     }
 180
 181     /* Texture coordinates. */
 182     gen_count = 0;
 183     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
 184         if (vs_outputs->bcolor[i] != ATTR_UNUSED) {
 185             assert(tabi < 16);
 186             stream_loc[tabi++] = 6 + gen_count;
 187             gen_count++;
 188         }
 189     }
 190
 191     /* Fog coordinates. */
 192     if (vs_outputs->fog != ATTR_UNUSED) {
 193         assert(tabi < 16);
 194         stream_loc[tabi++] = 6 + gen_count;
 195         gen_count++;
 196     }
 197
 198     /* XXX magic */
 199     assert(gen_count <= 8);
 200
 201     for (; tabi < 16;) {
 202         stream_loc[tabi++] = -1;
 203     }
 204 }
 205
 206 static void set_vertex_inputs_outputs(struct r300_vertex_program_compiler * c)
 207 {
 208     struct r300_vertex_shader * vs = c->UserData;
 209     struct r300_shader_semantics* outputs = &vs->outputs;
 210     struct tgsi_shader_info* info = &vs->info;
 211     int i, reg = 0;
 212
 213     /* Fill in the input mapping */
 214     for (i = 0; i < info->num_inputs; i++)
 215         c->code->inputs[i] = i;
 216
 217     /* Position. */
 218     if (outputs->pos != ATTR_UNUSED) {
 219         c->code->outputs[outputs->pos] = reg++;
 220     } else {
 221         assert(0);
 222     }
 223
 224     /* Point size. */
 225     if (outputs->psize != ATTR_UNUSED) {
 226         c->code->outputs[outputs->psize] = reg++;
 227     }
 228
 229     /* Colors. */
 230     for (i = 0; i < ATTR_COLOR_COUNT; i++) {
 231         if (outputs->color[i] != ATTR_UNUSED) {
 232             c->code->outputs[outputs->color[i]] = reg++;
 233         }
 234     }
 235
 236     /* XXX Back-face colors. */
 237
 238     /* Texture coordinates. */
 239     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
 240         if (outputs->generic[i] != ATTR_UNUSED) {
 241             c->code->outputs[outputs->generic[i]] = reg++;
 242         }
 243     }
 244
 245     /* Fog coordinates. */
 246     if (outputs->fog != ATTR_UNUSED) {
 247         c->code->outputs[outputs->fog] = reg++;
 248     }
 249 }
 250
 251 void r300_translate_vertex_shader(struct r300_context* r300,
 252                                   struct r300_vertex_shader* vs)
 253 {
 254     struct r300_vertex_program_compiler compiler;
 255     struct tgsi_to_rc ttr;
 256
 257     /* Initialize. */
 258     r300_shader_read_vs_outputs(&vs->info, &vs->outputs);
 259     r300_shader_vap_output_fmt(&vs->outputs, vs->hwfmt);
 260     r300_stream_locations_notcl(&vs->outputs, vs->stream_loc_notcl);
 261
 262     /* Setup the compiler */
 263     rc_init(&compiler.Base);
 264
 265     compiler.Base.Debug = DBG_ON(r300, DBG_VP);
 266     compiler.code = &vs->code;
 267     compiler.UserData = vs;
 268
 269     if (compiler.Base.Debug) {
 270         debug_printf("r300: Initial vertex program\n");
 271         tgsi_dump(vs->state.tokens, 0);
 272     }
 273
 274     /* Translate TGSI to our internal representation */
 275     ttr.compiler = &compiler.Base;
 276     ttr.info = &vs->info;
 277
 278     r300_tgsi_to_rc(&ttr, vs->state.tokens);
 279
 280     compiler.RequiredOutputs = ~(~0 << vs->info.num_outputs);
 281     compiler.SetHwInputOutput = &set_vertex_inputs_outputs;
 282
 283     /* Invoke the compiler */
 284     r3xx_compile_vertex_program(&compiler);
 285     if (compiler.Base.Error) {
 286         /* XXX We should fallback using Draw. */
 287         fprintf(stderr, "r300 VP: Compiler error\n");
 288         abort();
 289     }
 290
 291     /* And, finally... */
 292     rc_destroy(&compiler.Base);
 293     vs->translated = TRUE;
 294 }