X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsvga%2Fsvga_tgsi_decl_sm30.c;h=5e0f52bd8992ae27f855ab69949fe97f68941ede;hb=4087b5343d8d85f46ead6656f58c94cec0289cb0;hp=d1c7336dec497b0861b32cc74fb31d27cfc864fc;hpb=fd70841121475d7aad98812d6bf9c9c67567b89a;p=mesa.git

diff --git a/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c b/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c
index d1c7336dec4..5e0f52bd899 100644
--- a/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c
+++ b/src/gallium/drivers/svga/svga_tgsi_decl_sm30.c
@@ -29,19 +29,24 @@
 #include "util/u_memory.h"
 
 #include "svga_tgsi_emit.h"
-#include "svga_context.h"
 
-static boolean translate_vs_ps_semantic( struct tgsi_declaration_semantic semantic,
-                                         unsigned *usage,
-                                         unsigned *idx )
+
+/**
+ * Translate TGSI semantic info into SVGA3d semantic info.
+ * This is called for VS outputs and PS inputs only.
+ */
+static boolean
+translate_vs_ps_semantic(struct svga_shader_emitter *emit,
+                         struct tgsi_declaration_semantic semantic,
+                         unsigned *usage,
+                         unsigned *idx)
 {
    switch (semantic.Name) {
-   case TGSI_SEMANTIC_POSITION:  
+   case TGSI_SEMANTIC_POSITION:
       *idx = semantic.Index;
       *usage = SVGA3D_DECLUSAGE_POSITION;
       break;
-   case TGSI_SEMANTIC_COLOR:     
-
+   case TGSI_SEMANTIC_COLOR:
       *idx = semantic.Index;
       *usage = SVGA3D_DECLUSAGE_COLOR;
       break;
@@ -49,23 +54,31 @@ static boolean translate_vs_ps_semantic( struct tgsi_declaration_semantic semant
       *idx = semantic.Index + 2; /* sharing with COLOR */
       *usage = SVGA3D_DECLUSAGE_COLOR;
       break;
-   case TGSI_SEMANTIC_FOG:       
+   case TGSI_SEMANTIC_FOG:
       *idx = 0;
       assert(semantic.Index == 0);
       *usage = SVGA3D_DECLUSAGE_TEXCOORD;
       break;
-   case TGSI_SEMANTIC_PSIZE:     
+   case TGSI_SEMANTIC_PSIZE:
       *idx = semantic.Index;
       *usage = SVGA3D_DECLUSAGE_PSIZE;
       break;
-   case TGSI_SEMANTIC_GENERIC:   
-      *idx = semantic.Index + 1; /* texcoord[0] is reserved for fog */
+   case TGSI_SEMANTIC_GENERIC:
+      *idx = svga_remap_generic_index(emit->key.generic_remap_table,
+                                      semantic.Index);
       *usage = SVGA3D_DECLUSAGE_TEXCOORD;
       break;
-   case TGSI_SEMANTIC_NORMAL:    
+   case TGSI_SEMANTIC_NORMAL:
       *idx = semantic.Index;
       *usage = SVGA3D_DECLUSAGE_NORMAL;
       break;
+   case TGSI_SEMANTIC_CLIPDIST:
+   case TGSI_SEMANTIC_CLIPVERTEX:
+      /* XXX at this time we don't support clip distance or clip vertices */
+      debug_warn_once("unsupported clip distance/vertex attribute\n");
+      *usage = SVGA3D_DECLUSAGE_TEXCOORD;
+      *idx = 0;
+      return TRUE;
    default:
       assert(0);
       *usage = SVGA3D_DECLUSAGE_TEXCOORD;
@@ -77,15 +90,25 @@ static boolean translate_vs_ps_semantic( struct tgsi_declaration_semantic semant
 }
 
 
-static boolean emit_decl( struct svga_shader_emitter *emit,
-                          SVGA3dShaderDestToken reg,
-                          unsigned usage, 
-                          unsigned index )
+/**
+ * Emit a PS input (or VS depth/fog output) register declaration.
+ * For example, if usage = SVGA3D_DECLUSAGE_TEXCOORD, reg.num = 1, and
+ * index = 3, we'll emit "dcl_texcoord3 v1".
+ */
+static boolean
+emit_decl(struct svga_shader_emitter *emit,
+          SVGA3dShaderDestToken reg,
+          unsigned usage,
+          unsigned index)
 {
    SVGA3DOpDclArgs dcl;
    SVGA3dShaderInstToken opcode;
 
-   opcode = inst_token( SVGA3DOP_DCL );
+   /* check values against bitfield sizes */
+   assert(index < 16);
+   assert(usage <= SVGA3D_DECLUSAGE_MAX);
+
+   opcode = inst_token(SVGA3DOP_DCL);
    dcl.values[0] = 0;
    dcl.values[1] = 0;
 
@@ -94,18 +117,22 @@ static boolean emit_decl( struct svga_shader_emitter *emit,
    dcl.index = index;
    dcl.values[0] |= 1<<31;
 
-   return  (emit_instruction(emit, opcode) &&
-            svga_shader_emit_dwords( emit, dcl.values, Elements(dcl.values)));
+   return (emit_instruction(emit, opcode) &&
+           svga_shader_emit_dwords(emit, dcl.values, ARRAY_SIZE(dcl.values)));
 }
 
-static boolean emit_vface_decl( struct svga_shader_emitter *emit )
+
+/**
+ * Emit declaration for PS front/back-face input register.
+ */
+static boolean
+emit_vface_decl(struct svga_shader_emitter *emit)
 {
    if (!emit->emitted_vface) {
       SVGA3dShaderDestToken reg =
-         dst_register( SVGA3DREG_MISCTYPE,
-                       SVGA3DMISCREG_FACE );
+         dst_register(SVGA3DREG_MISCTYPE, SVGA3DMISCREG_FACE);
 
-      if (!emit_decl( emit, reg, 0, 0 ))
+      if (!emit_decl(emit, reg, 0, 0))
          return FALSE;
 
       emit->emitted_vface = TRUE;
@@ -113,101 +140,242 @@ static boolean emit_vface_decl( struct svga_shader_emitter *emit )
    return TRUE;
 }
 
-static boolean ps30_input( struct svga_shader_emitter *emit,
-                           struct tgsi_declaration_semantic semantic,
-                           unsigned idx )
+
+/**
+ * Emit PS input register to pass depth/fog coordinates.
+ * Note that this always goes into texcoord[0].
+ */
+static boolean
+ps30_input_emit_depth_fog(struct svga_shader_emitter *emit,
+                          struct src_register *out)
+{
+   struct src_register reg;
+
+   if (emit->emitted_depth_fog) {
+      *out = emit->ps_depth_fog;
+      return TRUE;
+   }
+
+   if (emit->ps30_input_count >= SVGA3D_INPUTREG_MAX)
+      return FALSE;
+
+   reg = src_register(SVGA3DREG_INPUT,
+                       emit->ps30_input_count++);
+
+   *out = emit->ps_depth_fog = reg;
+
+   emit->emitted_depth_fog = TRUE;
+
+   return emit_decl(emit, dst(reg), SVGA3D_DECLUSAGE_TEXCOORD, 0);
+}
+
+
+/**
+ * Process a PS input declaration.
+ * We'll emit a declaration like "dcl_texcoord1 v2"
+ */
+static boolean
+ps30_input(struct svga_shader_emitter *emit,
+           struct tgsi_declaration_semantic semantic,
+           unsigned idx)
 {
    unsigned usage, index;
    SVGA3dShaderDestToken reg;
 
    if (semantic.Name == TGSI_SEMANTIC_POSITION) {
-      emit->input_map[idx] = src_register( SVGA3DREG_MISCTYPE,
-                                           SVGA3DMISCREG_POSITION );
-
-      emit->input_map[idx].base.swizzle = TRANSLATE_SWIZZLE( TGSI_SWIZZLE_X,
-                                                             TGSI_SWIZZLE_Y,
-                                                             TGSI_SWIZZLE_Y,
-                                                             TGSI_SWIZZLE_Y );
 
-      reg = writemask( dst(emit->input_map[idx]),
-                       TGSI_WRITEMASK_XY );
+      emit->ps_true_pos = src_register(SVGA3DREG_MISCTYPE,
+                                        SVGA3DMISCREG_POSITION);
+      emit->ps_true_pos.base.swizzle = TRANSLATE_SWIZZLE(TGSI_SWIZZLE_X,
+                                                          TGSI_SWIZZLE_Y,
+                                                          TGSI_SWIZZLE_Y,
+                                                          TGSI_SWIZZLE_Y);
+      reg = writemask(dst(emit->ps_true_pos),
+                       TGSI_WRITEMASK_XY);
+      emit->ps_reads_pos = TRUE;
+
+      if (emit->info.reads_z) {
+         emit->ps_temp_pos = dst_register(SVGA3DREG_TEMP,
+                                           emit->nr_hw_temp);
+
+         emit->input_map[idx] = src_register(SVGA3DREG_TEMP,
+                                              emit->nr_hw_temp);
+         emit->nr_hw_temp++;
+
+         if (!ps30_input_emit_depth_fog(emit, &emit->ps_depth_pos))
+            return FALSE;
+
+         emit->ps_depth_pos.base.swizzle = TRANSLATE_SWIZZLE(TGSI_SWIZZLE_Z,
+                                                              TGSI_SWIZZLE_Z,
+                                                              TGSI_SWIZZLE_Z,
+                                                              TGSI_SWIZZLE_W);
+      }
+      else {
+         emit->input_map[idx] = emit->ps_true_pos;
+      }
 
-      return emit_decl( emit, reg, 0, 0 );
+      return emit_decl(emit, reg, 0, 0);
    }
-   else if (emit->key.fkey.light_twoside &&
+   else if (emit->key.fs.light_twoside &&
             (semantic.Name == TGSI_SEMANTIC_COLOR)) {
 
-      if (!translate_vs_ps_semantic( semantic, &usage, &index ))
+      if (!translate_vs_ps_semantic(emit, semantic, &usage, &index))
          return FALSE;
 
       emit->internal_color_idx[emit->internal_color_count] = idx;
-      emit->input_map[idx] = src_register( SVGA3DREG_INPUT, emit->ps30_input_count );
+      emit->input_map[idx] =
+         src_register(SVGA3DREG_INPUT, emit->ps30_input_count);
       emit->ps30_input_count++;
       emit->internal_color_count++;
 
-      reg = dst( emit->input_map[idx] );
+      reg = dst(emit->input_map[idx]);
 
-      if (!emit_decl( emit, reg, usage, index ))
+      if (!emit_decl(emit, reg, usage, index))
          return FALSE;
 
       semantic.Name = TGSI_SEMANTIC_BCOLOR;
-      if (!translate_vs_ps_semantic( semantic, &usage, &index ))
+      if (!translate_vs_ps_semantic(emit, semantic, &usage, &index))
          return FALSE;
 
-      reg = dst_register( SVGA3DREG_INPUT, emit->ps30_input_count++ );
+      if (emit->ps30_input_count >= SVGA3D_INPUTREG_MAX)
+         return FALSE;
+
+      reg = dst_register(SVGA3DREG_INPUT, emit->ps30_input_count++);
 
-      if (!emit_decl( emit, reg, usage, index ))
+      if (!emit_decl(emit, reg, usage, index))
          return FALSE;
 
-      if (!emit_vface_decl( emit ))
+      if (!emit_vface_decl(emit))
          return FALSE;
 
       return TRUE;
    }
    else if (semantic.Name == TGSI_SEMANTIC_FACE) {
-      if (!emit_vface_decl( emit ))
+      if (!emit_vface_decl(emit))
          return FALSE;
       emit->emit_frontface = TRUE;
       emit->internal_frontface_idx = idx;
       return TRUE;
    }
+   else if (semantic.Name == TGSI_SEMANTIC_FOG) {
+
+      assert(semantic.Index == 0);
+
+      if (!ps30_input_emit_depth_fog(emit, &emit->input_map[idx]))
+         return FALSE;
+
+      emit->input_map[idx].base.swizzle = TRANSLATE_SWIZZLE(TGSI_SWIZZLE_X,
+                                                             TGSI_SWIZZLE_X,
+                                                             TGSI_SWIZZLE_X,
+                                                             TGSI_SWIZZLE_X);
+      return TRUE;
+   }
    else {
 
-      if (!translate_vs_ps_semantic( semantic, &usage, &index ))
+      if (!translate_vs_ps_semantic(emit, semantic, &usage, &index))
          return FALSE;
 
-      emit->input_map[idx] = src_register( SVGA3DREG_INPUT, emit->ps30_input_count++ );
-      reg = dst( emit->input_map[idx] );
+      if (emit->ps30_input_count >= SVGA3D_INPUTREG_MAX)
+         return FALSE;
 
-      return emit_decl( emit, reg, usage, index );
+      emit->input_map[idx] =
+         src_register(SVGA3DREG_INPUT, emit->ps30_input_count++);
+
+      reg = dst(emit->input_map[idx]);
+
+      if (!emit_decl(emit, reg, usage, index))
+         return FALSE;
+
+      if (semantic.Name == TGSI_SEMANTIC_GENERIC &&
+          emit->key.sprite_origin_lower_left &&
+          index >= 1 &&
+          emit->key.sprite_coord_enable & (1 << semantic.Index)) {
+         /* This is a sprite texture coord with lower-left origin.
+          * We need to invert the texture T coordinate since the SVGA3D
+          * device only supports an upper-left origin.
+          */
+         unsigned unit = index - 1;
+
+         emit->inverted_texcoords |= (1 << unit);
+
+         /* save original texcoord reg */
+         emit->ps_true_texcoord[unit] = emit->input_map[idx];
+
+         /* this temp register will be the results of the MAD instruction */
+         emit->ps_inverted_texcoord[unit] =
+            src_register(SVGA3DREG_TEMP, emit->nr_hw_temp);
+         emit->nr_hw_temp++;
+
+         emit->ps_inverted_texcoord_input[unit] = idx;
+
+         /* replace input_map entry with the temp register */
+         emit->input_map[idx] = emit->ps_inverted_texcoord[unit];
+      }
+
+      return TRUE;
    }
 
 }
 
 
-/* PS output registers are the same as 2.0
+/**
+ * Process a PS output declaration.
+ * Note that we don't actually emit a SVGA3DOpDcl for PS outputs.
+ * \idx  register index, such as OUT[2] (not semantic index)
  */
-static boolean ps30_output( struct svga_shader_emitter *emit,
-                            struct tgsi_declaration_semantic semantic,
-                            unsigned idx )
+static boolean
+ps30_output(struct svga_shader_emitter *emit,
+            struct tgsi_declaration_semantic semantic,
+            unsigned idx)
 {
-   SVGA3dShaderDestToken reg;
-
    switch (semantic.Name) {
    case TGSI_SEMANTIC_COLOR:
-      emit->output_map[idx] = dst_register( SVGA3DREG_COLOROUT, 
-                                            semantic.Index );
+      if (emit->unit == PIPE_SHADER_FRAGMENT) {
+         if (emit->key.fs.white_fragments) {
+            /* Used for XOR logicop mode */
+            emit->output_map[idx] = dst_register(SVGA3DREG_TEMP,
+                                                  emit->nr_hw_temp++);
+            emit->temp_color_output[idx] = emit->output_map[idx];
+            emit->true_color_output[idx] = dst_register(SVGA3DREG_COLOROUT,
+                                                        semantic.Index);
+         }
+         else if (emit->key.fs.write_color0_to_n_cbufs) {
+            /* We'll write color output [0] to all render targets.
+             * Prepare all the output registers here, but only when the
+             * semantic.Index == 0 so we don't do this more than once.
+             */
+            if (semantic.Index == 0) {
+               unsigned i;
+               for (i = 0; i < emit->key.fs.write_color0_to_n_cbufs; i++) {
+                  emit->output_map[idx+i] = dst_register(SVGA3DREG_TEMP,
+                                                     emit->nr_hw_temp++);
+                  emit->temp_color_output[i] = emit->output_map[idx+i];
+                  emit->true_color_output[i] = dst_register(SVGA3DREG_COLOROUT,
+                                                            i);
+               }
+            }
+         }
+         else {
+            emit->output_map[idx] =
+               dst_register(SVGA3DREG_COLOROUT, semantic.Index);
+         }
+      }
+      else {
+         emit->output_map[idx] = dst_register(SVGA3DREG_COLOROUT,
+                                               semantic.Index);
+      }
       break;
    case TGSI_SEMANTIC_POSITION:
-      emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
-                                            emit->nr_hw_temp++ );
+      emit->output_map[idx] = dst_register(SVGA3DREG_TEMP,
+                                            emit->nr_hw_temp++);
       emit->temp_pos = emit->output_map[idx];
-      emit->true_pos = dst_register( SVGA3DREG_DEPTHOUT, 
-                                     semantic.Index );
+      emit->true_pos = dst_register(SVGA3DREG_DEPTHOUT,
+                                     semantic.Index);
       break;
    default:
       assert(0);
-      reg = dst_register( SVGA3DREG_COLOROUT, 0 );
+      /* A wild stab in the dark. */
+      emit->output_map[idx] = dst_register(SVGA3DREG_COLOROUT, 0);
       break;
    }
 
@@ -215,158 +383,233 @@ static boolean ps30_output( struct svga_shader_emitter *emit,
 }
 
 
-/* We still make up the input semantics the same as in 2.0
+/**
+ * Declare a VS input register.
+ * We still make up the input semantics the same as in 2.0
  */
-static boolean vs30_input( struct svga_shader_emitter *emit,
-                           struct tgsi_declaration_semantic semantic,
-                           unsigned idx )
+static boolean
+vs30_input(struct svga_shader_emitter *emit,
+           struct tgsi_declaration_semantic semantic,
+           unsigned idx)
 {
    SVGA3DOpDclArgs dcl;
    SVGA3dShaderInstToken opcode;
    unsigned usage, index;
 
-   opcode = inst_token( SVGA3DOP_DCL );
+   opcode = inst_token(SVGA3DOP_DCL);
    dcl.values[0] = 0;
    dcl.values[1] = 0;
 
-   if (emit->key.vkey.zero_stride_vertex_elements & (1 << idx)) {
-      unsigned i;
-      unsigned offset = 0;
-      unsigned start_idx = emit->info.file_max[TGSI_FILE_CONSTANT] + 1;
-      /* adjust for prescale constants */
-      start_idx += emit->key.vkey.need_prescale ? 2 : 0;
-      /* compute the offset from the start of zero stride constants */
-      for (i = 0; i < PIPE_MAX_ATTRIBS && i < idx; ++i) {
-         if (emit->key.vkey.zero_stride_vertex_elements & (1<<i))
-            ++offset;
-      }
-      emit->input_map[idx] = src_register( SVGA3DREG_CONST,
-                                           start_idx + offset );
-   } else {
-      emit->input_map[idx] = src_register( SVGA3DREG_INPUT, idx );
-      dcl.dst = dst_register( SVGA3DREG_INPUT, idx );
+   emit->input_map[idx] = src_register(SVGA3DREG_INPUT, idx);
+   dcl.dst = dst_register(SVGA3DREG_INPUT, idx);
+
+   assert(dcl.dst.reserved0);
+
+   svga_generate_vdecl_semantics(idx, &usage, &index);
+
+   dcl.usage = usage;
+   dcl.index = index;
+   dcl.values[0] |= 1<<31;
 
-      assert(dcl.dst.reserved0);
+   return (emit_instruction(emit, opcode) &&
+           svga_shader_emit_dwords(emit, dcl.values, ARRAY_SIZE(dcl.values)));
+}
 
-      svga_generate_vdecl_semantics( idx, &usage, &index );
 
-      dcl.usage = usage;
-      dcl.index = index;
-      dcl.values[0] |= 1<<31;
+/**
+ * Declare VS output for holding depth/fog.
+ */
+static boolean
+vs30_output_emit_depth_fog(struct svga_shader_emitter *emit,
+                           SVGA3dShaderDestToken *out)
+{
+   SVGA3dShaderDestToken reg;
 
-      return  (emit_instruction(emit, opcode) &&
-               svga_shader_emit_dwords( emit, dcl.values, Elements(dcl.values)));
+   if (emit->emitted_depth_fog) {
+      *out = emit->vs_depth_fog;
+      return TRUE;
    }
-   return TRUE;
+
+   reg = dst_register(SVGA3DREG_OUTPUT, emit->vs30_output_count++);
+
+   *out = emit->vs_depth_fog = reg;
+
+   emit->emitted_depth_fog = TRUE;
+
+   return emit_decl(emit, reg, SVGA3D_DECLUSAGE_TEXCOORD, 0);
 }
 
-/* VS3.0 outputs have proper declarations and semantic info for
+
+/**
+ * Declare a VS output.
+ * VS3.0 outputs have proper declarations and semantic info for
  * matching against PS inputs.
  */
-static boolean vs30_output( struct svga_shader_emitter *emit,
-                         struct tgsi_declaration_semantic semantic,
-                         unsigned idx )
+static boolean
+vs30_output(struct svga_shader_emitter *emit,
+            struct tgsi_declaration_semantic semantic,
+            unsigned idx)
 {
    SVGA3DOpDclArgs dcl;
    SVGA3dShaderInstToken opcode;
    unsigned usage, index;
 
-   opcode = inst_token( SVGA3DOP_DCL );
+   opcode = inst_token(SVGA3DOP_DCL);
    dcl.values[0] = 0;
    dcl.values[1] = 0;
 
-   if (!translate_vs_ps_semantic( semantic, &usage, &index ))
+   if (!translate_vs_ps_semantic(emit, semantic, &usage, &index))
+      return FALSE;
+
+   if (emit->vs30_output_count >= SVGA3D_OUTPUTREG_MAX)
       return FALSE;
 
-   dcl.dst = dst_register( SVGA3DREG_OUTPUT, idx );
+   dcl.dst = dst_register(SVGA3DREG_OUTPUT, emit->vs30_output_count++);
    dcl.usage = usage;
    dcl.index = index;
    dcl.values[0] |= 1<<31;
 
    if (semantic.Name == TGSI_SEMANTIC_POSITION) {
       assert(idx == 0);
-      emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
-                                            emit->nr_hw_temp++ );
+      emit->output_map[idx] = dst_register(SVGA3DREG_TEMP,
+                                            emit->nr_hw_temp++);
       emit->temp_pos = emit->output_map[idx];
       emit->true_pos = dcl.dst;
+
+      /* Grab an extra output for the depth output */
+      if (!vs30_output_emit_depth_fog(emit, &emit->depth_pos))
+         return FALSE;
+
    }
    else if (semantic.Name == TGSI_SEMANTIC_PSIZE) {
-      emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
-                                            emit->nr_hw_temp++ );
+      emit->output_map[idx] = dst_register(SVGA3DREG_TEMP,
+                                            emit->nr_hw_temp++);
       emit->temp_psiz = emit->output_map[idx];
 
-      /* This has the effect of not declaring psiz (below) and not 
+      /* This has the effect of not declaring psiz (below) and not
        * emitting the final MOV to true_psiz in the postamble.
        */
-      if (!emit->key.vkey.allow_psiz)
+      if (!emit->key.vs.allow_psiz)
          return TRUE;
 
       emit->true_psiz = dcl.dst;
    }
+   else if (semantic.Name == TGSI_SEMANTIC_FOG) {
+      /*
+       * Fog is shared with depth.
+       * So we need to decrement out_count since emit_depth_fog will increment it.
+       */
+      emit->vs30_output_count--;
+
+      if (!vs30_output_emit_depth_fog(emit, &emit->output_map[idx]))
+         return FALSE;
+
+      return TRUE;
+   }
    else {
       emit->output_map[idx] = dcl.dst;
    }
 
+   return (emit_instruction(emit, opcode) &&
+           svga_shader_emit_dwords(emit, dcl.values, ARRAY_SIZE(dcl.values)));
+}
+
+
+/** Translate PIPE_TEXTURE_x to SVGA3DSAMP_x */
+static ubyte
+svga_tgsi_sampler_type(const struct svga_shader_emitter *emit, int idx)
+{
+   switch (emit->sampler_target[idx]) {
+   case TGSI_TEXTURE_1D:
+      return SVGA3DSAMP_2D;
+   case TGSI_TEXTURE_2D:
+   case TGSI_TEXTURE_RECT:
+      return SVGA3DSAMP_2D;
+   case TGSI_TEXTURE_SHADOW2D:
+      return SVGA3DSAMP_2D_SHADOW;
+   case TGSI_TEXTURE_3D:
+      return SVGA3DSAMP_VOLUME;
+   case TGSI_TEXTURE_CUBE:
+      return SVGA3DSAMP_CUBE;
+   }
 
-   return  (emit_instruction(emit, opcode) &&
-            svga_shader_emit_dwords( emit, dcl.values, Elements(dcl.values)));
+   return SVGA3DSAMP_UNKNOWN;
 }
 
-static boolean ps30_sampler( struct svga_shader_emitter *emit,
-                          struct tgsi_declaration_semantic semantic,
-                          unsigned idx )
+
+static boolean
+ps30_sampler(struct svga_shader_emitter *emit,
+              unsigned idx)
 {
    SVGA3DOpDclArgs dcl;
    SVGA3dShaderInstToken opcode;
 
-   opcode = inst_token( SVGA3DOP_DCL );
+   opcode = inst_token(SVGA3DOP_DCL);
    dcl.values[0] = 0;
    dcl.values[1] = 0;
 
-   dcl.dst = dst_register( SVGA3DREG_SAMPLER, idx );
-   dcl.type = svga_tgsi_sampler_type( emit, idx );
+   dcl.dst = dst_register(SVGA3DREG_SAMPLER, idx);
+   dcl.type = svga_tgsi_sampler_type(emit, idx);
    dcl.values[0] |= 1<<31;
 
-   return  (emit_instruction(emit, opcode) &&
-            svga_shader_emit_dwords( emit, dcl.values, Elements(dcl.values)));
+   return (emit_instruction(emit, opcode) &&
+           svga_shader_emit_dwords(emit, dcl.values, ARRAY_SIZE(dcl.values)));
 }
 
 
-boolean svga_translate_decl_sm30( struct svga_shader_emitter *emit,
-                             const struct tgsi_full_declaration *decl )
+boolean
+svga_shader_emit_samplers_decl(struct svga_shader_emitter *emit)
+{
+   unsigned i;
+
+   for (i = 0; i < emit->num_samplers; i++) {
+      if (!ps30_sampler(emit, i))
+         return FALSE;
+   }
+   return TRUE;
+}
+
+
+boolean
+svga_translate_decl_sm30(struct svga_shader_emitter *emit,
+                         const struct tgsi_full_declaration *decl)
 {
    unsigned first = decl->Range.First;
    unsigned last = decl->Range.Last;
-   unsigned semantic = 0;
-   unsigned semantic_idx = 0;
    unsigned idx;
 
-   if (decl->Declaration.Semantic) {
-      semantic = decl->Semantic.Name;
-      semantic_idx = decl->Semantic.Index;
-   }
-
-   for( idx = first; idx <= last; idx++ ) {
-      boolean ok;
+   for (idx = first; idx <= last; idx++) {
+      boolean ok = TRUE;
 
       switch (decl->Declaration.File) {
       case TGSI_FILE_SAMPLER:
          assert (emit->unit == PIPE_SHADER_FRAGMENT);
-         ok = ps30_sampler( emit, decl->Semantic, idx );
+         /* just keep track of the number of samplers here.
+          * Will emit the declaration in the helpers function.
+          */
+         emit->num_samplers = MAX2(emit->num_samplers, decl->Range.Last + 1);
          break;
 
       case TGSI_FILE_INPUT:
          if (emit->unit == PIPE_SHADER_VERTEX)
-            ok = vs30_input( emit, decl->Semantic, idx );
+            ok = vs30_input(emit, decl->Semantic, idx);
          else
-            ok = ps30_input( emit, decl->Semantic, idx );
+            ok = ps30_input(emit, decl->Semantic, idx);
          break;
 
       case TGSI_FILE_OUTPUT:
          if (emit->unit == PIPE_SHADER_VERTEX)
-            ok = vs30_output( emit, decl->Semantic, idx );
+            ok = vs30_output(emit, decl->Semantic, idx);
          else
-            ok = ps30_output( emit, decl->Semantic, idx );
+            ok = ps30_output(emit, decl->Semantic, idx);
+         break;
+
+      case TGSI_FILE_SAMPLER_VIEW:
+         {
+            unsigned unit = decl->Range.First;
+            assert(decl->Range.First == decl->Range.Last);
+            emit->sampler_target[unit] = decl->SamplerView.Resource;
+         }
          break;
 
       default:
@@ -380,6 +623,3 @@ boolean svga_translate_decl_sm30( struct svga_shader_emitter *emit,
 
    return TRUE;
 }
-
-
-