src/mesa/state_tracker/st_program.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   *   Brian Paul
  31   */
  32
  33
  34 #include "main/imports.h"
  35 #include "main/mtypes.h"
  36 #include "program/prog_print.h"
  37 #include "program/programopt.h"
  38
  39 #include "pipe/p_context.h"
  40 #include "pipe/p_defines.h"
  41 #include "pipe/p_shader_tokens.h"
  42 #include "draw/draw_context.h"
  43 #include "tgsi/tgsi_dump.h"
  44 #include "tgsi/tgsi_ureg.h"
  45
  46 #include "st_debug.h"
  47 #include "st_context.h"
  48 #include "st_program.h"
  49 #include "st_mesa_to_tgsi.h"
  50 #include "cso_cache/cso_context.h"
  51
  52
  53
  54 /**
  55  * Clean out any old compilations:
  56  */
  57 void
  58 st_vp_release_varients( struct st_context *st,
  59                         struct st_vertex_program *stvp )
  60 {
  61    struct st_vp_varient *vpv;
  62
  63    for (vpv = stvp->varients; vpv; ) {
  64       struct st_vp_varient *next = vpv->next;
  65
  66       if (vpv->driver_shader)
  67          cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
  68
  69 #if FEATURE_feedback || FEATURE_rastpos
  70       if (vpv->draw_shader)
  71          draw_delete_vertex_shader( st->draw, vpv->draw_shader );
  72 #endif
  73
  74       if (vpv->tgsi.tokens)
  75          st_free_tokens(vpv->tgsi.tokens);
  76
  77       FREE( vpv );
  78
  79       vpv = next;
  80    }
  81
  82    stvp->varients = NULL;
  83 }
  84
  85
  86
  87
  88 /**
  89  * Translate a Mesa vertex shader into a TGSI shader.
  90  * \param outputMapping  to map vertex program output registers (VERT_RESULT_x)
  91  *       to TGSI output slots
  92  * \param tokensOut  destination for TGSI tokens
  93  * \return  pointer to cached pipe_shader object.
  94  */
  95 void
  96 st_prepare_vertex_program(struct st_context *st,
  97                             struct st_vertex_program *stvp)
  98 {
  99    GLuint attr;
 100
 101    stvp->num_inputs = 0;
 102    stvp->num_outputs = 0;
 103
 104    if (stvp->Base.IsPositionInvariant)
 105       _mesa_insert_mvp_code(st->ctx, &stvp->Base);
 106
 107    assert(stvp->Base.Base.NumInstructions > 1);
 108
 109    /*
 110     * Determine number of inputs, the mappings between VERT_ATTRIB_x
 111     * and TGSI generic input indexes, plus input attrib semantic info.
 112     */
 113    for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
 114       if (stvp->Base.Base.InputsRead & (1 << attr)) {
 115          stvp->input_to_index[attr] = stvp->num_inputs;
 116          stvp->index_to_input[stvp->num_inputs] = attr;
 117          stvp->num_inputs++;
 118       }
 119    }
 120    /* bit of a hack, presetup potentially unused edgeflag input */
 121    stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
 122    stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
 123
 124    /* Compute mapping of vertex program outputs to slots.
 125     */
 126    for (attr = 0; attr < VERT_RESULT_MAX; attr++) {
 127       if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
 128          stvp->result_to_output[attr] = ~0;
 129       }
 130       else {
 131          unsigned slot = stvp->num_outputs++;
 132
 133          stvp->result_to_output[attr] = slot;
 134
 135          switch (attr) {
 136          case VERT_RESULT_HPOS:
 137             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 138             stvp->output_semantic_index[slot] = 0;
 139             break;
 140          case VERT_RESULT_COL0:
 141             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 142             stvp->output_semantic_index[slot] = 0;
 143             break;
 144          case VERT_RESULT_COL1:
 145             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 146             stvp->output_semantic_index[slot] = 1;
 147             break;
 148          case VERT_RESULT_BFC0:
 149             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 150             stvp->output_semantic_index[slot] = 0;
 151             break;
 152          case VERT_RESULT_BFC1:
 153             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 154             stvp->output_semantic_index[slot] = 1;
 155             break;
 156          case VERT_RESULT_FOGC:
 157             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 158             stvp->output_semantic_index[slot] = 0;
 159             break;
 160          case VERT_RESULT_PSIZ:
 161             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
 162             stvp->output_semantic_index[slot] = 0;
 163             break;
 164          case VERT_RESULT_EDGE:
 165             assert(0);
 166             break;
 167
 168          case VERT_RESULT_TEX0:
 169          case VERT_RESULT_TEX1:
 170          case VERT_RESULT_TEX2:
 171          case VERT_RESULT_TEX3:
 172          case VERT_RESULT_TEX4:
 173          case VERT_RESULT_TEX5:
 174          case VERT_RESULT_TEX6:
 175          case VERT_RESULT_TEX7:
 176             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 177             stvp->output_semantic_index[slot] = attr - VERT_RESULT_TEX0;
 178             break;
 179
 180          case VERT_RESULT_VAR0:
 181          default:
 182             assert(attr < VERT_RESULT_MAX);
 183             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 184             stvp->output_semantic_index[slot] = (FRAG_ATTRIB_VAR0 -
 185                                                 FRAG_ATTRIB_TEX0 +
 186                                                 attr -
 187                                                 VERT_RESULT_VAR0);
 188             break;
 189          }
 190       }
 191    }
 192    /* similar hack to above, presetup potentially unused edgeflag output */
 193    stvp->result_to_output[VERT_RESULT_EDGE] = stvp->num_outputs;
 194    stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
 195    stvp->output_semantic_index[stvp->num_outputs] = 0;
 196 }
 197
 198
 199 struct st_vp_varient *
 200 st_translate_vertex_program(struct st_context *st,
 201                             struct st_vertex_program *stvp,
 202                             const struct st_vp_varient_key *key)
 203 {
 204    struct st_vp_varient *vpv = CALLOC_STRUCT(st_vp_varient);
 205    struct pipe_context *pipe = st->pipe;
 206    struct ureg_program *ureg;
 207    enum pipe_error error;
 208    unsigned num_outputs;
 209
 210    ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
 211    if (ureg == NULL) {
 212       FREE(vpv);
 213       return NULL;
 214    }
 215
 216    vpv->num_inputs = stvp->num_inputs;
 217    num_outputs = stvp->num_outputs;
 218    if (key->passthrough_edgeflags) {
 219       vpv->num_inputs++;
 220       num_outputs++;
 221    }
 222
 223    if (ST_DEBUG & DEBUG_MESA) {
 224       _mesa_print_program(&stvp->Base.Base);
 225       _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
 226       debug_printf("\n");
 227    }
 228
 229    error =
 230       st_translate_mesa_program(st->ctx,
 231                                 TGSI_PROCESSOR_VERTEX,
 232                                 ureg,
 233                                 &stvp->Base.Base,
 234                                 /* inputs */
 235                                 vpv->num_inputs,
 236                                 stvp->input_to_index,
 237                                 NULL, /* input semantic name */
 238                                 NULL, /* input semantic index */
 239                                 NULL,
 240                                 /* outputs */
 241                                 num_outputs,
 242                                 stvp->result_to_output,
 243                                 stvp->output_semantic_name,
 244                                 stvp->output_semantic_index,
 245                                 key->passthrough_edgeflags );
 246
 247    if (error)
 248       goto fail;
 249
 250    vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
 251    if (!vpv->tgsi.tokens)
 252       goto fail;
 253
 254    ureg_destroy( ureg );
 255
 256    vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
 257
 258    if (ST_DEBUG & DEBUG_TGSI) {
 259       tgsi_dump( vpv->tgsi.tokens, 0 );
 260       debug_printf("\n");
 261    }
 262
 263    return vpv;
 264
 265 fail:
 266    debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
 267    _mesa_print_program(&stvp->Base.Base);
 268    debug_assert(0);
 269
 270    ureg_destroy( ureg );
 271    return NULL;
 272 }
 273
 274
 275
 276 /**
 277  * Translate a Mesa fragment shader into a TGSI shader.
 278  * \return  pointer to cached pipe_shader object.
 279  */
 280 void
 281 st_translate_fragment_program(struct st_context *st,
 282                               struct st_fragment_program *stfp )
 283 {
 284    struct pipe_context *pipe = st->pipe;
 285    GLuint outputMapping[FRAG_RESULT_MAX];
 286    GLuint inputMapping[FRAG_ATTRIB_MAX];
 287    GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
 288    GLuint attr;
 289    enum pipe_error error;
 290    const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
 291    struct ureg_program *ureg;
 292
 293    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
 294    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
 295    uint fs_num_inputs = 0;
 296
 297    ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
 298    ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 299    uint fs_num_outputs = 0;
 300
 301    /*
 302     * Convert Mesa program inputs to TGSI input register semantics.
 303     */
 304    for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
 305       if (inputsRead & (1 << attr)) {
 306          const GLuint slot = fs_num_inputs++;
 307
 308          inputMapping[attr] = slot;
 309
 310          switch (attr) {
 311          case FRAG_ATTRIB_WPOS:
 312             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 313             input_semantic_index[slot] = 0;
 314             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 315             break;
 316          case FRAG_ATTRIB_COL0:
 317             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 318             input_semantic_index[slot] = 0;
 319             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 320             break;
 321          case FRAG_ATTRIB_COL1:
 322             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 323             input_semantic_index[slot] = 1;
 324             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 325             break;
 326          case FRAG_ATTRIB_FOGC:
 327             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 328             input_semantic_index[slot] = 0;
 329             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 330             break;
 331          case FRAG_ATTRIB_FACE:
 332             input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
 333             input_semantic_index[slot] = 0;
 334             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 335             break;
 336          case FRAG_ATTRIB_PNTC:
 337             /* This is a hack.  We really need a new semantic label for
 338              * point coord.  The draw module needs to know which fragment
 339              * shader input is the point coord attribute so that it can set
 340              * up the right vertex attribute values.
 341              */
 342             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 343             input_semantic_index[slot] = 0;
 344             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 345             break;
 346
 347             /* In most cases, there is nothing special about these
 348              * inputs, so adopt a convention to use the generic
 349              * semantic name and the mesa FRAG_ATTRIB_ number as the
 350              * index.
 351              *
 352              * All that is required is that the vertex shader labels
 353              * its own outputs similarly, and that the vertex shader
 354              * generates at least every output required by the
 355              * fragment shader plus fixed-function hardware (such as
 356              * BFC).
 357              *
 358              * There is no requirement that semantic indexes start at
 359              * zero or be restricted to a particular range -- nobody
 360              * should be building tables based on semantic index.
 361              */
 362          case FRAG_ATTRIB_TEX0:
 363          case FRAG_ATTRIB_TEX1:
 364          case FRAG_ATTRIB_TEX2:
 365          case FRAG_ATTRIB_TEX3:
 366          case FRAG_ATTRIB_TEX4:
 367          case FRAG_ATTRIB_TEX5:
 368          case FRAG_ATTRIB_TEX6:
 369          case FRAG_ATTRIB_TEX7:
 370          case FRAG_ATTRIB_VAR0:
 371          default:
 372             /* Actually, let's try and zero-base this just for
 373              * readability of the generated TGSI.
 374              */
 375             assert(attr >= FRAG_ATTRIB_TEX0);
 376             input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
 377             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 378             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 379             break;
 380          }
 381       }
 382       else {
 383          inputMapping[attr] = -1;
 384       }
 385    }
 386
 387    /*
 388     * Semantics and mapping for outputs
 389     */
 390    {
 391       uint numColors = 0;
 392       GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
 393
 394       /* if z is written, emit that first */
 395       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 396          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
 397          fs_output_semantic_index[fs_num_outputs] = 0;
 398          outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
 399          fs_num_outputs++;
 400          outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
 401       }
 402
 403       /* handle remaning outputs (color) */
 404       for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
 405          if (outputsWritten & BITFIELD64_BIT(attr)) {
 406             switch (attr) {
 407             case FRAG_RESULT_DEPTH:
 408                /* handled above */
 409                assert(0);
 410                break;
 411             default:
 412                assert(attr == FRAG_RESULT_COLOR ||
 413                       (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
 414                fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
 415                fs_output_semantic_index[fs_num_outputs] = numColors;
 416                outputMapping[attr] = fs_num_outputs;
 417                numColors++;
 418                break;
 419             }
 420
 421             fs_num_outputs++;
 422          }
 423       }
 424    }
 425
 426    ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
 427    if (ureg == NULL)
 428       return;
 429
 430    if (ST_DEBUG & DEBUG_MESA) {
 431       _mesa_print_program(&stfp->Base.Base);
 432       _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
 433       debug_printf("\n");
 434    }
 435
 436    error =
 437       st_translate_mesa_program(st->ctx,
 438                                 TGSI_PROCESSOR_FRAGMENT,
 439                                 ureg,
 440                                 &stfp->Base.Base,
 441                                 /* inputs */
 442                                 fs_num_inputs,
 443                                 inputMapping,
 444                                 input_semantic_name,
 445                                 input_semantic_index,
 446                                 interpMode,
 447                                 /* outputs */
 448                                 fs_num_outputs,
 449                                 outputMapping,
 450                                 fs_output_semantic_name,
 451                                 fs_output_semantic_index, FALSE );
 452
 453    stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
 454    ureg_destroy( ureg );
 455    stfp->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
 456
 457    if (ST_DEBUG & DEBUG_TGSI) {
 458       tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
 459       debug_printf("\n");
 460    }
 461 }
 462
 463 void
 464 st_translate_geometry_program(struct st_context *st,
 465                               struct st_geometry_program *stgp)
 466 {
 467    GLuint inputMapping[GEOM_ATTRIB_MAX];
 468    GLuint outputMapping[GEOM_RESULT_MAX];
 469    struct pipe_context *pipe = st->pipe;
 470    enum pipe_error error;
 471    GLuint attr;
 472    const GLbitfield inputsRead = stgp->Base.Base.InputsRead;
 473    GLuint vslot = 0;
 474    GLuint num_generic = 0;
 475
 476    uint gs_num_inputs = 0;
 477    uint gs_builtin_inputs = 0;
 478    uint gs_array_offset = 0;
 479
 480    ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
 481    ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 482    uint gs_num_outputs = 0;
 483
 484    GLint i;
 485    GLuint maxSlot = 0;
 486    struct ureg_program *ureg;
 487
 488    ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
 489    if (ureg == NULL) {
 490       return;
 491    }
 492
 493    /* which vertex output goes to the first geometry input */
 494    vslot = 0;
 495
 496    memset(inputMapping, 0, sizeof(inputMapping));
 497    memset(outputMapping, 0, sizeof(outputMapping));
 498
 499    /*
 500     * Convert Mesa program inputs to TGSI input register semantics.
 501     */
 502    for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {
 503       if (inputsRead & (1 << attr)) {
 504          const GLuint slot = gs_num_inputs;
 505
 506          gs_num_inputs++;
 507
 508          inputMapping[attr] = slot;
 509
 510          stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
 511          stgp->input_to_index[attr] = vslot;
 512          stgp->index_to_input[vslot] = attr;
 513          ++vslot;
 514
 515          if (attr != GEOM_ATTRIB_PRIMITIVE_ID) {
 516             gs_array_offset += 2;
 517          } else
 518             ++gs_builtin_inputs;
 519
 520 #if 1
 521          debug_printf("input map at %d = %d\n",
 522                       slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
 523 #endif
 524
 525          switch (attr) {
 526          case GEOM_ATTRIB_PRIMITIVE_ID:
 527             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
 528             stgp->input_semantic_index[slot] = 0;
 529             break;
 530          case GEOM_ATTRIB_POSITION:
 531             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 532             stgp->input_semantic_index[slot] = 0;
 533             break;
 534          case GEOM_ATTRIB_COLOR0:
 535             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 536             stgp->input_semantic_index[slot] = 0;
 537             break;
 538          case GEOM_ATTRIB_COLOR1:
 539             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 540             stgp->input_semantic_index[slot] = 1;
 541             break;
 542          case GEOM_ATTRIB_FOG_FRAG_COORD:
 543             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 544             stgp->input_semantic_index[slot] = 0;
 545             break;
 546          case GEOM_ATTRIB_TEX_COORD:
 547             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 548             stgp->input_semantic_index[slot] = num_generic++;
 549             break;
 550          case GEOM_ATTRIB_VAR0:
 551             /* fall-through */
 552          default:
 553             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 554             stgp->input_semantic_index[slot] = num_generic++;
 555          }
 556       }
 557    }
 558
 559    /* initialize output semantics to defaults */
 560    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
 561       gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
 562       gs_output_semantic_index[i] = 0;
 563    }
 564
 565    num_generic = 0;
 566    /*
 567     * Determine number of outputs, the (default) output register
 568     * mapping and the semantic information for each output.
 569     */
 570    for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
 571       if (stgp->Base.Base.OutputsWritten & (1 << attr)) {
 572          GLuint slot;
 573
 574          slot = gs_num_outputs;
 575          gs_num_outputs++;
 576          outputMapping[attr] = slot;
 577
 578          switch (attr) {
 579          case GEOM_RESULT_POS:
 580             assert(slot == 0);
 581             gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 582             gs_output_semantic_index[slot] = 0;
 583             break;
 584          case GEOM_RESULT_COL0:
 585             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 586             gs_output_semantic_index[slot] = 0;
 587             break;
 588          case GEOM_RESULT_COL1:
 589             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 590             gs_output_semantic_index[slot] = 1;
 591             break;
 592          case GEOM_RESULT_SCOL0:
 593             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 594             gs_output_semantic_index[slot] = 0;
 595             break;
 596          case GEOM_RESULT_SCOL1:
 597             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 598             gs_output_semantic_index[slot] = 1;
 599             break;
 600          case GEOM_RESULT_FOGC:
 601             gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 602             gs_output_semantic_index[slot] = 0;
 603             break;
 604          case GEOM_RESULT_PSIZ:
 605             gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
 606             gs_output_semantic_index[slot] = 0;
 607             break;
 608          case GEOM_RESULT_TEX0:
 609          case GEOM_RESULT_TEX1:
 610          case GEOM_RESULT_TEX2:
 611          case GEOM_RESULT_TEX3:
 612          case GEOM_RESULT_TEX4:
 613          case GEOM_RESULT_TEX5:
 614          case GEOM_RESULT_TEX6:
 615          case GEOM_RESULT_TEX7:
 616             /* fall-through */
 617          case GEOM_RESULT_VAR0:
 618             /* fall-through */
 619          default:
 620             assert(slot < Elements(gs_output_semantic_name));
 621             /* use default semantic info */
 622             gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 623             gs_output_semantic_index[slot] = num_generic++;
 624          }
 625       }
 626    }
 627
 628    assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
 629
 630    /* find max output slot referenced to compute gs_num_outputs */
 631    for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
 632       if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
 633          maxSlot = outputMapping[attr];
 634    }
 635    gs_num_outputs = maxSlot + 1;
 636
 637 #if 0 /* debug */
 638    {
 639       GLuint i;
 640       printf("outputMapping? %d\n", outputMapping ? 1 : 0);
 641       if (outputMapping) {
 642          printf("attr -> slot\n");
 643          for (i = 0; i < 16;  i++) {
 644             printf(" %2d       %3d\n", i, outputMapping[i]);
 645          }
 646       }
 647       printf("slot    sem_name  sem_index\n");
 648       for (i = 0; i < gs_num_outputs; i++) {
 649          printf(" %2d         %d         %d\n",
 650                 i,
 651                 gs_output_semantic_name[i],
 652                 gs_output_semantic_index[i]);
 653       }
 654    }
 655 #endif
 656
 657    /* free old shader state, if any */
 658    if (stgp->tgsi.tokens) {
 659       st_free_tokens(stgp->tgsi.tokens);
 660       stgp->tgsi.tokens = NULL;
 661    }
 662    if (stgp->driver_shader) {
 663       cso_delete_geometry_shader(st->cso_context, stgp->driver_shader);
 664       stgp->driver_shader = NULL;
 665    }
 666
 667    ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
 668    ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
 669    ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
 670
 671    error  = st_translate_mesa_program(st->ctx,
 672                                       TGSI_PROCESSOR_GEOMETRY,
 673                                       ureg,
 674                                       &stgp->Base.Base,
 675                                       /* inputs */
 676                                       gs_num_inputs,
 677                                       inputMapping,
 678                                       stgp->input_semantic_name,
 679                                       stgp->input_semantic_index,
 680                                       NULL,
 681                                       /* outputs */
 682                                       gs_num_outputs,
 683                                       outputMapping,
 684                                       gs_output_semantic_name,
 685                                       gs_output_semantic_index,
 686                                       FALSE);
 687
 688
 689    stgp->num_inputs = gs_num_inputs;
 690    stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
 691    ureg_destroy( ureg );
 692    stgp->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
 693
 694    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
 695       _mesa_print_program(&stgp->Base.Base);
 696       debug_printf("\n");
 697    }
 698
 699    if (ST_DEBUG & DEBUG_TGSI) {
 700       tgsi_dump(stgp->tgsi.tokens, 0);
 701       debug_printf("\n");
 702    }
 703 }
 704
 705 /**
 706  * Debug- print current shader text
 707  */
 708 void
 709 st_print_shaders(GLcontext *ctx)
 710 {
 711    struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
 712    if (shProg) {
 713       GLuint i;
 714       for (i = 0; i < shProg->NumShaders; i++) {
 715          printf("GLSL shader %u of %u:\n", i, shProg->NumShaders);
 716          printf("%s\n", shProg->Shaders[i]->Source);
 717       }
 718    }
 719 }