Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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.    _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
  211.    _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
  212.  
  213.    ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
  214.    if (ureg == NULL) {
  215.       FREE(vpv);
  216.       return NULL;
  217.    }
  218.  
  219.    vpv->key = *key;
  220.  
  221.    vpv->num_inputs = stvp->num_inputs;
  222.    num_outputs = stvp->num_outputs;
  223.    if (key->passthrough_edgeflags) {
  224.       vpv->num_inputs++;
  225.       num_outputs++;
  226.    }
  227.  
  228.    if (ST_DEBUG & DEBUG_MESA) {
  229.       _mesa_print_program(&stvp->Base.Base);
  230.       _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
  231.       debug_printf("\n");
  232.    }
  233.  
  234.    error =
  235.       st_translate_mesa_program(st->ctx,
  236.                                 TGSI_PROCESSOR_VERTEX,
  237.                                 ureg,
  238.                                 &stvp->Base.Base,
  239.                                 /* inputs */
  240.                                 vpv->num_inputs,
  241.                                 stvp->input_to_index,
  242.                                 NULL, /* input semantic name */
  243.                                 NULL, /* input semantic index */
  244.                                 NULL,
  245.                                 /* outputs */
  246.                                 num_outputs,
  247.                                 stvp->result_to_output,
  248.                                 stvp->output_semantic_name,
  249.                                 stvp->output_semantic_index,
  250.                                 key->passthrough_edgeflags );
  251.  
  252.    if (error)
  253.       goto fail;
  254.  
  255.    vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
  256.    if (!vpv->tgsi.tokens)
  257.       goto fail;
  258.  
  259.    ureg_destroy( ureg );
  260.  
  261.    vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
  262.  
  263.    if (ST_DEBUG & DEBUG_TGSI) {
  264.       tgsi_dump( vpv->tgsi.tokens, 0 );
  265.       debug_printf("\n");
  266.    }
  267.  
  268.    return vpv;
  269.  
  270. fail:
  271.    debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
  272.    _mesa_print_program(&stvp->Base.Base);
  273.    debug_assert(0);
  274.  
  275.    ureg_destroy( ureg );
  276.    return NULL;
  277. }
  278.  
  279.  
  280.  
  281. /**
  282.  * Translate a Mesa fragment shader into a TGSI shader.
  283.  * \return  pointer to cached pipe_shader object.
  284.  */
  285. void
  286. st_translate_fragment_program(struct st_context *st,
  287.                               struct st_fragment_program *stfp )
  288. {
  289.    struct pipe_context *pipe = st->pipe;
  290.    GLuint outputMapping[FRAG_RESULT_MAX];
  291.    GLuint inputMapping[FRAG_ATTRIB_MAX];
  292.    GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
  293.    GLuint attr;
  294.    enum pipe_error error;
  295.    const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
  296.    struct ureg_program *ureg;
  297.  
  298.    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
  299.    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
  300.    uint fs_num_inputs = 0;
  301.  
  302.    ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
  303.    ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
  304.    uint fs_num_outputs = 0;
  305.  
  306.    _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
  307.  
  308.    /*
  309.     * Convert Mesa program inputs to TGSI input register semantics.
  310.     */
  311.    for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
  312.       if (inputsRead & (1 << attr)) {
  313.          const GLuint slot = fs_num_inputs++;
  314.  
  315.          inputMapping[attr] = slot;
  316.  
  317.          switch (attr) {
  318.          case FRAG_ATTRIB_WPOS:
  319.             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  320.             input_semantic_index[slot] = 0;
  321.             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  322.             break;
  323.          case FRAG_ATTRIB_COL0:
  324.             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  325.             input_semantic_index[slot] = 0;
  326.             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  327.             break;
  328.          case FRAG_ATTRIB_COL1:
  329.             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  330.             input_semantic_index[slot] = 1;
  331.             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  332.             break;
  333.          case FRAG_ATTRIB_FOGC:
  334.             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  335.             input_semantic_index[slot] = 0;
  336.             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
  337.             break;
  338.          case FRAG_ATTRIB_FACE:
  339.             input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
  340.             input_semantic_index[slot] = 0;
  341.             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
  342.             break;
  343.             /* In most cases, there is nothing special about these
  344.              * inputs, so adopt a convention to use the generic
  345.              * semantic name and the mesa FRAG_ATTRIB_ number as the
  346.              * index.
  347.              *
  348.              * All that is required is that the vertex shader labels
  349.              * its own outputs similarly, and that the vertex shader
  350.              * generates at least every output required by the
  351.              * fragment shader plus fixed-function hardware (such as
  352.              * BFC).
  353.              *
  354.              * There is no requirement that semantic indexes start at
  355.              * zero or be restricted to a particular range -- nobody
  356.              * should be building tables based on semantic index.
  357.              */
  358.          case FRAG_ATTRIB_PNTC:
  359.          case FRAG_ATTRIB_TEX0:
  360.          case FRAG_ATTRIB_TEX1:
  361.          case FRAG_ATTRIB_TEX2:
  362.          case FRAG_ATTRIB_TEX3:
  363.          case FRAG_ATTRIB_TEX4:
  364.          case FRAG_ATTRIB_TEX5:
  365.          case FRAG_ATTRIB_TEX6:
  366.          case FRAG_ATTRIB_TEX7:
  367.          case FRAG_ATTRIB_VAR0:
  368.          default:
  369.             /* Actually, let's try and zero-base this just for
  370.              * readability of the generated TGSI.
  371.              */
  372.             assert(attr >= FRAG_ATTRIB_TEX0);
  373.             input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
  374.             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  375.             if (attr == FRAG_ATTRIB_PNTC)
  376.                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  377.             else
  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.       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
  404.          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
  405.          fs_output_semantic_index[fs_num_outputs] = 0;
  406.          outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
  407.          fs_num_outputs++;
  408.          outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
  409.       }
  410.  
  411.       /* handle remaning outputs (color) */
  412.       for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
  413.          if (outputsWritten & BITFIELD64_BIT(attr)) {
  414.             switch (attr) {
  415.             case FRAG_RESULT_DEPTH:
  416.             case FRAG_RESULT_STENCIL:
  417.                /* handled above */
  418.                assert(0);
  419.                break;
  420.             default:
  421.                assert(attr == FRAG_RESULT_COLOR ||
  422.                       (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
  423.                fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
  424.                fs_output_semantic_index[fs_num_outputs] = numColors;
  425.                outputMapping[attr] = fs_num_outputs;
  426.                numColors++;
  427.                break;
  428.             }
  429.  
  430.             fs_num_outputs++;
  431.          }
  432.       }
  433.    }
  434.  
  435.    ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
  436.    if (ureg == NULL)
  437.       return;
  438.  
  439.    if (ST_DEBUG & DEBUG_MESA) {
  440.       _mesa_print_program(&stfp->Base.Base);
  441.       _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
  442.       debug_printf("\n");
  443.    }
  444.  
  445.    error =
  446.       st_translate_mesa_program(st->ctx,
  447.                                 TGSI_PROCESSOR_FRAGMENT,
  448.                                 ureg,
  449.                                 &stfp->Base.Base,
  450.                                 /* inputs */
  451.                                 fs_num_inputs,
  452.                                 inputMapping,
  453.                                 input_semantic_name,
  454.                                 input_semantic_index,
  455.                                 interpMode,
  456.                                 /* outputs */
  457.                                 fs_num_outputs,
  458.                                 outputMapping,
  459.                                 fs_output_semantic_name,
  460.                                 fs_output_semantic_index, FALSE );
  461.  
  462.    stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
  463.    ureg_destroy( ureg );
  464.    stfp->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
  465.  
  466.    if (ST_DEBUG & DEBUG_TGSI) {
  467.       tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
  468.       debug_printf("\n");
  469.    }
  470. }
  471.  
  472. void
  473. st_translate_geometry_program(struct st_context *st,
  474.                               struct st_geometry_program *stgp)
  475. {
  476.    GLuint inputMapping[GEOM_ATTRIB_MAX];
  477.    GLuint outputMapping[GEOM_RESULT_MAX];
  478.    struct pipe_context *pipe = st->pipe;
  479.    enum pipe_error error;
  480.    GLuint attr;
  481.    const GLbitfield inputsRead = stgp->Base.Base.InputsRead;
  482.    GLuint vslot = 0;
  483.    GLuint num_generic = 0;
  484.  
  485.    uint gs_num_inputs = 0;
  486.    uint gs_builtin_inputs = 0;
  487.    uint gs_array_offset = 0;
  488.  
  489.    ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
  490.    ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
  491.    uint gs_num_outputs = 0;
  492.  
  493.    GLint i;
  494.    GLuint maxSlot = 0;
  495.    struct ureg_program *ureg;
  496.  
  497.    _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
  498.    _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);
  499.  
  500.    ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
  501.    if (ureg == NULL) {
  502.       return;
  503.    }
  504.  
  505.    /* which vertex output goes to the first geometry input */
  506.    vslot = 0;
  507.  
  508.    memset(inputMapping, 0, sizeof(inputMapping));
  509.    memset(outputMapping, 0, sizeof(outputMapping));
  510.  
  511.    /*
  512.     * Convert Mesa program inputs to TGSI input register semantics.
  513.     */
  514.    for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {
  515.       if (inputsRead & (1 << attr)) {
  516.          const GLuint slot = gs_num_inputs;
  517.  
  518.          gs_num_inputs++;
  519.  
  520.          inputMapping[attr] = slot;
  521.  
  522.          stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
  523.          stgp->input_to_index[attr] = vslot;
  524.          stgp->index_to_input[vslot] = attr;
  525.          ++vslot;
  526.  
  527.          if (attr != GEOM_ATTRIB_PRIMITIVE_ID) {
  528.             gs_array_offset += 2;
  529.          } else
  530.             ++gs_builtin_inputs;
  531.  
  532. #if 1
  533.          debug_printf("input map at %d = %d\n",
  534.                       slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
  535. #endif
  536.  
  537.          switch (attr) {
  538.          case GEOM_ATTRIB_PRIMITIVE_ID:
  539.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
  540.             stgp->input_semantic_index[slot] = 0;
  541.             break;
  542.          case GEOM_ATTRIB_POSITION:
  543.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  544.             stgp->input_semantic_index[slot] = 0;
  545.             break;
  546.          case GEOM_ATTRIB_COLOR0:
  547.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  548.             stgp->input_semantic_index[slot] = 0;
  549.             break;
  550.          case GEOM_ATTRIB_COLOR1:
  551.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  552.             stgp->input_semantic_index[slot] = 1;
  553.             break;
  554.          case GEOM_ATTRIB_FOG_FRAG_COORD:
  555.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  556.             stgp->input_semantic_index[slot] = 0;
  557.             break;
  558.          case GEOM_ATTRIB_TEX_COORD:
  559.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  560.             stgp->input_semantic_index[slot] = num_generic++;
  561.             break;
  562.          case GEOM_ATTRIB_VAR0:
  563.             /* fall-through */
  564.          default:
  565.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  566.             stgp->input_semantic_index[slot] = num_generic++;
  567.          }
  568.       }
  569.    }
  570.  
  571.    /* initialize output semantics to defaults */
  572.    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
  573.       gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
  574.       gs_output_semantic_index[i] = 0;
  575.    }
  576.  
  577.    num_generic = 0;
  578.    /*
  579.     * Determine number of outputs, the (default) output register
  580.     * mapping and the semantic information for each output.
  581.     */
  582.    for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
  583.       if (stgp->Base.Base.OutputsWritten & (1 << attr)) {
  584.          GLuint slot;
  585.  
  586.          slot = gs_num_outputs;
  587.          gs_num_outputs++;
  588.          outputMapping[attr] = slot;
  589.  
  590.          switch (attr) {
  591.          case GEOM_RESULT_POS:
  592.             assert(slot == 0);
  593.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  594.             gs_output_semantic_index[slot] = 0;
  595.             break;
  596.          case GEOM_RESULT_COL0:
  597.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  598.             gs_output_semantic_index[slot] = 0;
  599.             break;
  600.          case GEOM_RESULT_COL1:
  601.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  602.             gs_output_semantic_index[slot] = 1;
  603.             break;
  604.          case GEOM_RESULT_SCOL0:
  605.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
  606.             gs_output_semantic_index[slot] = 0;
  607.             break;
  608.          case GEOM_RESULT_SCOL1:
  609.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
  610.             gs_output_semantic_index[slot] = 1;
  611.             break;
  612.          case GEOM_RESULT_FOGC:
  613.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  614.             gs_output_semantic_index[slot] = 0;
  615.             break;
  616.          case GEOM_RESULT_PSIZ:
  617.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
  618.             gs_output_semantic_index[slot] = 0;
  619.             break;
  620.          case GEOM_RESULT_TEX0:
  621.          case GEOM_RESULT_TEX1:
  622.          case GEOM_RESULT_TEX2:
  623.          case GEOM_RESULT_TEX3:
  624.          case GEOM_RESULT_TEX4:
  625.          case GEOM_RESULT_TEX5:
  626.          case GEOM_RESULT_TEX6:
  627.          case GEOM_RESULT_TEX7:
  628.             /* fall-through */
  629.          case GEOM_RESULT_VAR0:
  630.             /* fall-through */
  631.          default:
  632.             assert(slot < Elements(gs_output_semantic_name));
  633.             /* use default semantic info */
  634.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  635.             gs_output_semantic_index[slot] = num_generic++;
  636.          }
  637.       }
  638.    }
  639.  
  640.    assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
  641.  
  642.    /* find max output slot referenced to compute gs_num_outputs */
  643.    for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
  644.       if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
  645.          maxSlot = outputMapping[attr];
  646.    }
  647.    gs_num_outputs = maxSlot + 1;
  648.  
  649. #if 0 /* debug */
  650.    {
  651.       GLuint i;
  652.       printf("outputMapping? %d\n", outputMapping ? 1 : 0);
  653.       if (outputMapping) {
  654.          printf("attr -> slot\n");
  655.          for (i = 0; i < 16;  i++) {
  656.             printf(" %2d       %3d\n", i, outputMapping[i]);
  657.          }
  658.       }
  659.       printf("slot    sem_name  sem_index\n");
  660.       for (i = 0; i < gs_num_outputs; i++) {
  661.          printf(" %2d         %d         %d\n",
  662.                 i,
  663.                 gs_output_semantic_name[i],
  664.                 gs_output_semantic_index[i]);
  665.       }
  666.    }
  667. #endif
  668.  
  669.    /* free old shader state, if any */
  670.    if (stgp->tgsi.tokens) {
  671.       st_free_tokens(stgp->tgsi.tokens);
  672.       stgp->tgsi.tokens = NULL;
  673.    }
  674.    if (stgp->driver_shader) {
  675.       cso_delete_geometry_shader(st->cso_context, stgp->driver_shader);
  676.       stgp->driver_shader = NULL;
  677.    }
  678.  
  679.    ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
  680.    ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
  681.    ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
  682.  
  683.    error  = st_translate_mesa_program(st->ctx,
  684.                                       TGSI_PROCESSOR_GEOMETRY,
  685.                                       ureg,
  686.                                       &stgp->Base.Base,
  687.                                       /* inputs */
  688.                                       gs_num_inputs,
  689.                                       inputMapping,
  690.                                       stgp->input_semantic_name,
  691.                                       stgp->input_semantic_index,
  692.                                       NULL,
  693.                                       /* outputs */
  694.                                       gs_num_outputs,
  695.                                       outputMapping,
  696.                                       gs_output_semantic_name,
  697.                                       gs_output_semantic_index,
  698.                                       FALSE);
  699.  
  700.  
  701.    stgp->num_inputs = gs_num_inputs;
  702.    stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
  703.    ureg_destroy( ureg );
  704.    stgp->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
  705.  
  706.    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
  707.       _mesa_print_program(&stgp->Base.Base);
  708.       debug_printf("\n");
  709.    }
  710.  
  711.    if (ST_DEBUG & DEBUG_TGSI) {
  712.       tgsi_dump(stgp->tgsi.tokens, 0);
  713.       debug_printf("\n");
  714.    }
  715. }
  716.  
  717. /**
  718.  * Debug- print current shader text
  719.  */
  720. void
  721. st_print_shaders(struct gl_context *ctx)
  722. {
  723.    struct gl_shader_program *shProg[3] = {
  724.       ctx->Shader.CurrentVertexProgram,
  725.       ctx->Shader.CurrentGeometryProgram,
  726.       ctx->Shader.CurrentFragmentProgram,
  727.    };
  728.    unsigned j;
  729.  
  730.    for (j = 0; j < 3; j++) {
  731.       unsigned i;
  732.  
  733.       if (shProg[j] == NULL)
  734.          continue;
  735.  
  736.       for (i = 0; i < shProg[j]->NumShaders; i++) {
  737.          struct gl_shader *sh;
  738.  
  739.          switch (shProg[j]->Shaders[i]->Type) {
  740.          case GL_VERTEX_SHADER:
  741.             sh = (i != 0) ? NULL : shProg[j]->Shaders[i];
  742.             break;
  743.          case GL_GEOMETRY_SHADER_ARB:
  744.             sh = (i != 1) ? NULL : shProg[j]->Shaders[i];
  745.             break;
  746.          case GL_FRAGMENT_SHADER:
  747.             sh = (i != 2) ? NULL : shProg[j]->Shaders[i];
  748.             break;
  749.          default:
  750.             assert(0);
  751.             sh = NULL;
  752.             break;
  753.          }
  754.  
  755.          if (sh != NULL) {
  756.             printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);
  757.             printf("%s\n", sh->Source);
  758.          }
  759.       }
  760.    }
  761. }
  762.