gallivm,llvmpipe,draw: Support multiple constant buffers.

[mesa.git] / src / gallium / drivers / llvmpipe / lp_state_derived.c

diff --git a/src/gallium/drivers/llvmpipe/lp_state_derived.c b/src/gallium/drivers/llvmpipe/lp_state_derived.c
index 113d77ab7880003f73c9e856b5a8959f96b65dbb..aef222d20f63f1bbffe27e41a2d2e7a7fc346257 100644 (file)
--- a/src/gallium/drivers/llvmpipe/lp_state_derived.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_derived.c
@@ -50,12 +50,18 @@ compute_vertex_info(struct llvmpipe_context *llvmpipe)
 {
    const struct lp_fragment_shader *lpfs = llvmpipe->fs;
    struct vertex_info *vinfo = &llvmpipe->vertex_info;
-   struct lp_shader_input inputs[1 + PIPE_MAX_SHADER_INPUTS];
    unsigned vs_index;
    uint i;
 
+   llvmpipe->color_slot[0] = -1;
+   llvmpipe->color_slot[1] = -1;
+   llvmpipe->bcolor_slot[0] = -1;
+   llvmpipe->bcolor_slot[1] = -1;
+
    /*
-    * Match FS inputs against VS outputs, emitting the necessary attributes.
+    * Match FS inputs against VS outputs, emitting the necessary
+    * attributes.  Could cache these structs and look them up with a
+    * combination of fragment shader, vertex shader ids.
     */
 
    vinfo->num_attribs = 0;
@@ -66,71 +72,52 @@ compute_vertex_info(struct llvmpipe_context *llvmpipe)
 
    draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, vs_index);
 
-   for (i = 0; i < lpfs->info.num_inputs; i++) {
+   for (i = 0; i < lpfs->info.base.num_inputs; i++) {
       /*
        * Search for each input in current vs output:
        */
 
       vs_index = draw_find_shader_output(llvmpipe->draw,
-                                         lpfs->info.input_semantic_name[i],
-                                         lpfs->info.input_semantic_index[i]);
+                                         lpfs->info.base.input_semantic_name[i],
+                                         lpfs->info.base.input_semantic_index[i]);
 
-      /* This can be pre-computed, except for flatshade:
-       */
-      switch (lpfs->info.input_semantic_name[i]) {
-      case TGSI_SEMANTIC_FACE:
-         inputs[i].interp = LP_INTERP_FACING;
-         break;
-      case TGSI_SEMANTIC_POSITION:
-         /* Position was already emitted above
-          */
-         inputs[i].interp = LP_INTERP_POSITION;
-         inputs[i].src_index = 0;
-         continue;
-      case TGSI_SEMANTIC_COLOR:
-         /* Colors are linearly inputs[i].interpolated in the fragment shader
-          * even when flatshading is active.  This just tells the
-          * setup module to use coefficients with ddx==0 and
-          * ddy==0.
-          */
-         if (llvmpipe->rasterizer->flatshade)
-            inputs[i].interp = LP_INTERP_CONSTANT;
-         else
-            inputs[i].interp = LP_INTERP_LINEAR;
-         break;
-
-      default:
-         switch (lpfs->info.input_interpolate[i]) {
-         case TGSI_INTERPOLATE_CONSTANT:
-            inputs[i].interp = LP_INTERP_CONSTANT;
-            break;
-         case TGSI_INTERPOLATE_LINEAR:
-            inputs[i].interp = LP_INTERP_LINEAR;
-            break;
-         case TGSI_INTERPOLATE_PERSPECTIVE:
-            inputs[i].interp = LP_INTERP_PERSPECTIVE;
-            break;
-         default:
-            assert(0);
-            break;
-         }
+      if (lpfs->info.base.input_semantic_name[i] == TGSI_SEMANTIC_COLOR &&
+          lpfs->info.base.input_semantic_index[i] < 2) {
+         int idx = lpfs->info.base.input_semantic_index[i];
+         llvmpipe->color_slot[idx] = (int)vinfo->num_attribs;
       }
 
       /*
        * Emit the requested fs attribute for all but position.
        */
-
-      inputs[i].src_index = vinfo->num_attribs;
       draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, vs_index);
    }
 
-   draw_compute_vertex_size(vinfo);
+   /* Figure out if we need bcolor as well.
+    */
+   for (i = 0; i < 2; i++) {
+      vs_index = draw_find_shader_output(llvmpipe->draw,
+                                         TGSI_SEMANTIC_BCOLOR, i);
+
+      if (vs_index > 0) {
+         llvmpipe->bcolor_slot[i] = (int)vinfo->num_attribs;
+         draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, vs_index);
+      }
+   }
 
-   lp_setup_set_vertex_info(llvmpipe->setup, vinfo);
 
-   lp_setup_set_fs_inputs(llvmpipe->setup,
-                          inputs,
-                          lpfs->info.num_inputs);
+   /* Figure out if we need pointsize as well.
+    */
+   vs_index = draw_find_shader_output(llvmpipe->draw,
+                                      TGSI_SEMANTIC_PSIZE, 0);
+
+   if (vs_index > 0) {
+      llvmpipe->psize_slot = vinfo->num_attribs;
+      draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_CONSTANT, vs_index);
+   }
+
+   draw_compute_vertex_size(vinfo);
+   lp_setup_set_vertex_info(llvmpipe->setup, vinfo);
 }
 
 
@@ -158,14 +145,20 @@ void llvmpipe_update_derived( struct llvmpipe_context *llvmpipe )
       compute_vertex_info( llvmpipe );
 
    if (llvmpipe->dirty & (LP_NEW_FS |
+                          LP_NEW_FRAMEBUFFER |
                           LP_NEW_BLEND |
                           LP_NEW_SCISSOR |
                           LP_NEW_DEPTH_STENCIL_ALPHA |
                           LP_NEW_RASTERIZER |
                           LP_NEW_SAMPLER |
-                          LP_NEW_SAMPLER_VIEW))
+                          LP_NEW_SAMPLER_VIEW |
+                          LP_NEW_OCCLUSION_QUERY))
       llvmpipe_update_fs( llvmpipe );
 
+   if (llvmpipe->dirty & (LP_NEW_FS |
+                         LP_NEW_RASTERIZER))
+      llvmpipe_update_setup( llvmpipe );
+
    if (llvmpipe->dirty & LP_NEW_BLEND_COLOR)
       lp_setup_set_blend_color(llvmpipe->setup,
                                &llvmpipe->blend_color);
@@ -181,13 +174,19 @@ void llvmpipe_update_derived( struct llvmpipe_context *llvmpipe )
    }
 
    if (llvmpipe->dirty & LP_NEW_CONSTANTS)
-      lp_setup_set_fs_constants(llvmpipe->setup, 
+      lp_setup_set_fs_constants(llvmpipe->setup,
+                                Elements(llvmpipe->constants[PIPE_SHADER_FRAGMENT]),
                                 llvmpipe->constants[PIPE_SHADER_FRAGMENT]);
 
-   if (llvmpipe->dirty & LP_NEW_SAMPLER_VIEW)
-      lp_setup_set_fragment_sampler_views(llvmpipe->setup, 
-                                          llvmpipe->num_fragment_sampler_views,
-                                          llvmpipe->fragment_sampler_views);
+   if (llvmpipe->dirty & (LP_NEW_SAMPLER_VIEW))
+      lp_setup_set_fragment_sampler_views(llvmpipe->setup,
+                                          llvmpipe->num_sampler_views[PIPE_SHADER_FRAGMENT],
+                                          llvmpipe->sampler_views[PIPE_SHADER_FRAGMENT]);
+
+   if (llvmpipe->dirty & (LP_NEW_SAMPLER))
+      lp_setup_set_fragment_sampler_state(llvmpipe->setup,
+                                          llvmpipe->num_samplers[PIPE_SHADER_FRAGMENT],
+                                          llvmpipe->samplers[PIPE_SHADER_FRAGMENT]);
 
    llvmpipe->dirty = 0;
 }