st_atom_shader.c File Reference

Include dependency graph for st_atom_shader.c:

Go to the source code of this file.

Data Structures
struct	translated_vertex_program
	State validation for vertex/fragment shaders. More...
Functions
static GLint	vp_out_to_fp_in (GLuint vertResult)
	Given a vertex program output attribute, return the corresponding fragment program input attribute.
static struct translated_vertex_program *	find_translated_vp (struct st_context *st, struct st_vertex_program *stvp, struct st_fragment_program *stfp)
	Find a translated vertex program that corresponds to stvp and has outputs matched to stfp's inputs.
void	st_free_translated_vertex_programs (struct st_context *st, struct translated_vertex_program *xvp)
static void *	get_passthrough_fs (struct st_context *st)
static void	update_linkage (struct st_context *st)
Variables
struct st_tracked_state	st_update_shader

---

Function Documentation

static struct translated_vertex_program* find_translated_vp	(	struct st_context *	st,
		struct st_vertex_program *	stvp,
		struct st_fragment_program *	stfp
	)			[static, read]

Find a translated vertex program that corresponds to stvp and has outputs matched to stfp's inputs.

This performs vertex and fragment translation (to TGSI) when needed.

Definition at line 124 of file st_atom_shader.c.

References assert, st_vertex_program::Base, st_fragment_program::Base, CALLOC_STRUCT, translated_vertex_program::frag_inputs, st_fragment_program::input_map, st_fragment_program::input_semantic_index, st_fragment_program::input_semantic_name, st_fragment_program::input_to_slot, translated_vertex_program::master, MAX2, translated_vertex_program::next, st_fragment_program::num_input_slots, translated_vertex_program::output_to_semantic_index, translated_vertex_program::output_to_semantic_name, translated_vertex_program::output_to_slot, st_vertex_program::serialNo, translated_vertex_program::serialNo, st_translate_fragment_program(), st_translate_vertex_program(), st_fragment_program::state, TGSI_SEMANTIC_COLOR, TGSI_SEMANTIC_COUNT, TGSI_SEMANTIC_GENERIC, TGSI_SEMANTIC_POSITION, TGSI_SEMANTIC_PSIZE, pipe_shader_state::tokens, st_fragment_program::vertex_programs, translated_vertex_program::vp, and vp_out_to_fp_in().

{
   static const GLuint UNUSED = ~0;
   struct translated_vertex_program *xvp;
   const GLbitfield fragInputsRead = stfp->Base.Base.InputsRead;

   /*
    * Translate fragment program if needed.
    */
   if (!stfp->state.tokens) {
      GLuint inAttr, numIn = 0;

      for (inAttr = 0; inAttr < FRAG_ATTRIB_MAX; inAttr++) {
         if (fragInputsRead & (1 << inAttr)) {
            stfp->input_to_slot[inAttr] = numIn;
            numIn++;
         }
         else {
            stfp->input_to_slot[inAttr] = UNUSED;
         }
      }

      stfp->num_input_slots = numIn;

      assert(stfp->Base.Base.NumInstructions > 1);

      st_translate_fragment_program(st, stfp, stfp->input_to_slot);
   }


   /* See if we've got a translated vertex program whose outputs match
    * the fragment program's inputs.
    * XXX This could be a hash lookup, using InputsRead as the key.
    */
   for (xvp = stfp->vertex_programs; xvp; xvp = xvp->next) {
      if (xvp->master == stvp && xvp->frag_inputs == fragInputsRead) {
         break;
      }
   }

   /* No?  Allocate translated vp object now */
   if (!xvp) {
      xvp = CALLOC_STRUCT(translated_vertex_program);
      xvp->frag_inputs = fragInputsRead;
      xvp->master = stvp;

      xvp->next = stfp->vertex_programs;
      stfp->vertex_programs = xvp;
   }

   /* See if we need to translate vertex program to TGSI form */
   if (xvp->serialNo != stvp->serialNo) {
      GLuint outAttr, dummySlot;
      const GLbitfield outputsWritten = stvp->Base.Base.OutputsWritten;
      GLuint numVpOuts = 0;
      GLboolean emitPntSize = GL_FALSE, emitBFC0 = GL_FALSE, emitBFC1 = GL_FALSE;
      GLint maxGeneric;

      /* Compute mapping of vertex program outputs to slots, which depends
       * on the fragment program's input->slot mapping.
       */
      for (outAttr = 0; outAttr < VERT_RESULT_MAX; outAttr++) {
         /* set defaults: */
         xvp->output_to_slot[outAttr] = UNUSED;
         xvp->output_to_semantic_name[outAttr] = TGSI_SEMANTIC_COUNT;
         xvp->output_to_semantic_index[outAttr] = 99;

         if (outAttr == VERT_RESULT_HPOS) {
            /* always put xformed position into slot zero */
            xvp->output_to_slot[VERT_RESULT_HPOS] = 0;
            xvp->output_to_semantic_name[outAttr] = TGSI_SEMANTIC_POSITION;
            xvp->output_to_semantic_index[outAttr] = 0;
            numVpOuts++;
         }
         else if (outputsWritten & (1 << outAttr)) {
            /* see if the frag prog wants this vert output */
            GLint fpInAttrib = vp_out_to_fp_in(outAttr);
            if (fpInAttrib >= 0) {
               GLuint fpInSlot = stfp->input_to_slot[fpInAttrib];
               if (fpInSlot != ~0) {
                  /* match this vp output to the fp input */
                  GLuint vpOutSlot = stfp->input_map[fpInSlot];
                  xvp->output_to_slot[outAttr] = vpOutSlot;
                  xvp->output_to_semantic_name[outAttr] = stfp->input_semantic_name[fpInSlot];
                  xvp->output_to_semantic_index[outAttr] = stfp->input_semantic_index[fpInSlot];
                  numVpOuts++;
               }
            }
            else if (outAttr == VERT_RESULT_PSIZ)
               emitPntSize = GL_TRUE;
            else if (outAttr == VERT_RESULT_BFC0)
               emitBFC0 = GL_TRUE;
            else if (outAttr == VERT_RESULT_BFC1)
               emitBFC1 = GL_TRUE;
         }
#if 0 /*debug*/
         printf("assign vp output_to_slot[%d] = %d\n", outAttr, 
                xvp->output_to_slot[outAttr]);
#endif
      }

      /* must do these last */
      if (emitPntSize) {
         xvp->output_to_slot[VERT_RESULT_PSIZ] = numVpOuts++;
         xvp->output_to_semantic_name[VERT_RESULT_PSIZ] = TGSI_SEMANTIC_PSIZE;
         xvp->output_to_semantic_index[VERT_RESULT_PSIZ] = 0;
      }
      if (emitBFC0) {
         xvp->output_to_slot[VERT_RESULT_BFC0] = numVpOuts++;
         xvp->output_to_semantic_name[VERT_RESULT_BFC0] = TGSI_SEMANTIC_COLOR;
         xvp->output_to_semantic_index[VERT_RESULT_BFC0] = 0;
      }
      if (emitBFC1) {
         xvp->output_to_slot[VERT_RESULT_BFC1] = numVpOuts++;
         xvp->output_to_semantic_name[VERT_RESULT_BFC0] = TGSI_SEMANTIC_COLOR;
         xvp->output_to_semantic_index[VERT_RESULT_BFC0] = 1;
      }

      /* Unneeded vertex program outputs will go to this slot.
       * We could use this info to do dead code elimination in the
       * vertex program.
       */
      dummySlot = numVpOuts;

      /* find max GENERIC slot index */
      maxGeneric = -1;
      for (outAttr = 0; outAttr < VERT_RESULT_MAX; outAttr++) {
         if (xvp->output_to_semantic_name[outAttr] == TGSI_SEMANTIC_GENERIC) {
            maxGeneric = MAX2(maxGeneric,
                              xvp->output_to_semantic_index[outAttr]);
         }
      }

      /* Map vert program outputs that aren't used to the dummy slot
       * (and an unused generic attribute slot).
       */
      for (outAttr = 0; outAttr < VERT_RESULT_MAX; outAttr++) {
         if (outputsWritten & (1 << outAttr)) {
            if (xvp->output_to_slot[outAttr] == UNUSED) {
               xvp->output_to_slot[outAttr] = dummySlot;
               xvp->output_to_semantic_name[outAttr] = TGSI_SEMANTIC_GENERIC;
               xvp->output_to_semantic_index[outAttr] = maxGeneric + 1;
            }
         }

#if 0 /*debug*/
         printf("vp output_to_slot[%d] = %d\n", outAttr, 
                xvp->output_to_slot[outAttr]);
#endif
      }

      assert(stvp->Base.Base.NumInstructions > 1);

      st_translate_vertex_program(st, stvp, xvp->output_to_slot,
                                  xvp->output_to_semantic_name,
                                  xvp->output_to_semantic_index);

      xvp->vp = stvp;

      /* translated VP is up to date now */
      xvp->serialNo = stvp->serialNo;
   }

   return xvp;
}

static void* get_passthrough_fs

(

struct st_context *

st

)

[static]

Definition at line 308 of file st_atom_shader.c.

References st_context::passthrough_fs, st_context::pipe, util_free_shader(), and util_make_fragment_passthrough_shader().

{
   struct pipe_shader_state shader;

   if (!st->passthrough_fs) {
      st->passthrough_fs =
         util_make_fragment_passthrough_shader(st->pipe, &shader);
#if 0      /* We actually need to keep the tokens around at this time */
      util_free_shader(&shader);
#endif
   }

   return st->passthrough_fs;
}

void st_free_translated_vertex_programs	(	struct st_context *	st,
		struct translated_vertex_program *	xvp
	)

Definition at line 294 of file st_atom_shader.c.

References translated_vertex_program::next.

{
   struct translated_vertex_program *next;

   while (xvp) {
      next = xvp->next;
      free(xvp);
      xvp = next;
   }
}

static void update_linkage

(

struct st_context *

st

)

[static]

Definition at line 325 of file st_atom_shader.c.

References assert, st_fragment_program::Base, st_vertex_program::Base, st_context::cso_context, cso_set_fragment_shader_handle(), cso_set_vertex_shader_handle(), st_context::ctx, st_fragment_program::driver_shader, st_vertex_program::driver_shader, find_translated_vp(), st_context::fp, get_passthrough_fs(), st_context::missing_textures, translated_vertex_program::output_to_slot, st_fragment_program(), st_reference_fragprog(), st_reference_vertprog(), st_vertex_program(), st_context::vertex_result_to_slot, and st_context::vp.

{
   struct st_vertex_program *stvp;
   struct st_fragment_program *stfp;
   struct translated_vertex_program *xvp;

   /* find active shader and params -- Should be covered by
    * ST_NEW_VERTEX_PROGRAM
    */
   assert(st->ctx->VertexProgram._Current);
   stvp = st_vertex_program(st->ctx->VertexProgram._Current);
   assert(stvp->Base.Base.Target == GL_VERTEX_PROGRAM_ARB);

   assert(st->ctx->FragmentProgram._Current);
   stfp = st_fragment_program(st->ctx->FragmentProgram._Current);
   assert(stfp->Base.Base.Target == GL_FRAGMENT_PROGRAM_ARB);

   xvp = find_translated_vp(st, stvp, stfp);

   st_reference_vertprog(st, &st->vp, stvp);
   st_reference_fragprog(st, &st->fp, stfp);

   cso_set_vertex_shader_handle(st->cso_context, stvp->driver_shader);

   if (st->missing_textures) {
      /* use a pass-through frag shader that uses no textures */
      void *fs = get_passthrough_fs(st);
      cso_set_fragment_shader_handle(st->cso_context, fs);
   }
   else {
      cso_set_fragment_shader_handle(st->cso_context, stfp->driver_shader);
   }

   st->vertex_result_to_slot = xvp->output_to_slot;
}

static GLint vp_out_to_fp_in

(

GLuint

vertResult

)

[static]

Given a vertex program output attribute, return the corresponding fragment program input attribute.

Returns:

-1 for vertex outputs that have no corresponding fragment input

Definition at line 92 of file st_atom_shader.c.

{
   if (vertResult >= VERT_RESULT_TEX0 &&
       vertResult < VERT_RESULT_TEX0 + MAX_TEXTURE_COORD_UNITS)
      return FRAG_ATTRIB_TEX0 + (vertResult - VERT_RESULT_TEX0);

   if (vertResult >= VERT_RESULT_VAR0 &&
       vertResult < VERT_RESULT_VAR0 + MAX_VARYING)
      return FRAG_ATTRIB_VAR0 + (vertResult - VERT_RESULT_VAR0);

   switch (vertResult) {
   case VERT_RESULT_HPOS:
      return FRAG_ATTRIB_WPOS;
   case VERT_RESULT_COL0:
      return FRAG_ATTRIB_COL0;
   case VERT_RESULT_COL1:
      return FRAG_ATTRIB_COL1;
   case VERT_RESULT_FOGC:
      return FRAG_ATTRIB_FOGC;
   default:
      /* Back-face colors, edge flags, etc */
      return -1;
   }
}

---

Variable Documentation

struct st_tracked_state st_update_shader

Initial value:

 {
   "st_update_shader",                                  
   {                                                    
      0,                                                
       0x4  |  0x2      
   },
   update_linkage                                       
}

Definition at line 362 of file st_atom_shader.c.

---