X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_atom_shader.c;h=9187bac87786d626e7ff968c26ac268e45e25d37;hb=64dfc823409e9a89a1dd9a14ee4fddf0b59fb86a;hp=b6b3222212642103f28298995669c04b671b9f99;hpb=56a28ace35c513ba22d754192127c359c28ed7e5;p=mesa.git

diff --git a/src/mesa/state_tracker/st_atom_shader.c b/src/mesa/state_tracker/st_atom_shader.c
index b6b32222126..9187bac8778 100644
--- a/src/mesa/state_tracker/st_atom_shader.c
+++ b/src/mesa/state_tracker/st_atom_shader.c
@@ -38,6 +38,7 @@
 #include "main/imports.h"
 #include "main/mtypes.h"
 #include "main/framebuffer.h"
+#include "main/state.h"
 #include "main/texobj.h"
 #include "main/texstate.h"
 #include "program/program.h"
@@ -52,6 +53,7 @@
 #include "st_atom.h"
 #include "st_program.h"
 #include "st_texture.h"
+#include "st_util.h"
 
 
 static unsigned
@@ -97,7 +99,6 @@ void
 st_update_fp( struct st_context *st )
 {
    struct st_fragment_program *stfp;
-   struct st_fp_variant_key key;
 
    assert(st->ctx->FragmentProgram._Current);
    stfp = st_fragment_program(st->ctx->FragmentProgram._Current);
@@ -108,12 +109,30 @@ st_update_fp( struct st_context *st )
    if (st->shader_has_one_variant[MESA_SHADER_FRAGMENT] &&
        !stfp->ati_fs && /* ATI_fragment_shader always has multiple variants */
        !stfp->Base.ExternalSamplersUsed && /* external samplers need variants */
-       stfp->variants) {
+       stfp->variants &&
+       !stfp->variants->key.drawpixels &&
+       !stfp->variants->key.bitmap) {
       shader = stfp->variants->driver_shader;
    } else {
+      struct st_fp_variant_key key;
+
+      /* use memset, not an initializer to be sure all memory is zeroed */
       memset(&key, 0, sizeof(key));
+
       key.st = st->has_shareable_shaders ? NULL : st;
 
+      key.lower_flatshade = st->lower_flatshade &&
+                            st->ctx->Light.ShadeModel == GL_FLAT;
+
+      /* _NEW_COLOR */
+      key.lower_alpha_func = COMPARE_FUNC_NEVER;
+      if (st->lower_alpha_test && _mesa_is_alpha_test_enabled(st->ctx))
+         key.lower_alpha_func = st->ctx->Color.AlphaFunc;
+
+      /* _NEW_LIGHT | _NEW_PROGRAM */
+      key.lower_two_sided_color = st->lower_two_sided_color &&
+         _mesa_vertex_program_two_side_enabled(st->ctx);
+
       /* _NEW_FRAG_CLAMP */
       key.clamp_color = st->clamp_frag_color_in_shader &&
                         st->ctx->Color._ClampFragmentColor;
@@ -126,6 +145,11 @@ st_update_fp( struct st_context *st )
          st->ctx->Multisample.MinSampleShadingValue *
          _mesa_geometric_samples(st->ctx->DrawBuffer) > 1;
 
+      key.lower_depth_clamp =
+         st->clamp_frag_depth_in_shader &&
+         (st->ctx->Transform.DepthClampNear ||
+          st->ctx->Transform.DepthClampFar);
+
       if (stfp->ati_fs) {
          key.fog = st->ctx->Fog._PackedEnabledMode;
 
@@ -153,7 +177,6 @@ void
 st_update_vp( struct st_context *st )
 {
    struct st_vertex_program *stvp;
-   struct st_vp_variant_key key;
 
    /* find active shader and params -- Should be covered by
     * ST_NEW_VERTEX_PROGRAM
@@ -167,7 +190,10 @@ st_update_vp( struct st_context *st )
        stvp->variants->key.passthrough_edgeflags == st->vertdata_edgeflags) {
       st->vp_variant = stvp->variants;
    } else {
-      memset(&key, 0, sizeof key);
+      struct st_vp_variant_key key;
+
+      memset(&key, 0, sizeof(key));
+
       key.st = st->has_shareable_shaders ? NULL : st;
 
       /* When this is true, we will add an extra input to the vertex
@@ -186,6 +212,24 @@ st_update_vp( struct st_context *st )
                           VARYING_SLOT_BFC0 |
                           VARYING_SLOT_BFC1));
 
+      key.lower_depth_clamp =
+            !st->gp && !st->tep &&
+            st->clamp_frag_depth_in_shader &&
+            (st->ctx->Transform.DepthClampNear ||
+             st->ctx->Transform.DepthClampFar);
+
+      if (key.lower_depth_clamp)
+         key.clip_negative_one_to_one =
+               st->ctx->Transform.ClipDepthMode == GL_NEGATIVE_ONE_TO_ONE;
+
+      /* _NEW_POINT */
+      key.lower_point_size = st->lower_point_size &&
+                             !st_point_size_per_vertex(st->ctx);
+
+      /* _NEW_TRANSFORM */
+      if (st->lower_ucp && st_user_clip_planes_enabled(st->ctx))
+         key.lower_ucp = st->ctx->Transform.ClipPlanesEnabled;
+
       st->vp_variant = st_get_vp_variant(st, stvp, &key);
    }
 
@@ -196,117 +240,91 @@ st_update_vp( struct st_context *st )
 }
 
 
-void
-st_update_gp( struct st_context *st )
+static void *
+st_update_common_program(struct st_context *st, struct gl_program *prog,
+                         unsigned pipe_shader, struct st_common_program **dst)
 {
-   struct st_common_program *stgp;
+   struct st_common_program *stp;
 
-   if (!st->ctx->GeometryProgram._Current) {
-      cso_set_geometry_shader_handle(st->cso_context, NULL);
-      st_reference_prog(st, &st->gp, NULL);
-      return;
+   if (!prog) {
+      st_reference_prog(st, dst, NULL);
+      return NULL;
    }
 
-   stgp = st_common_program(st->ctx->GeometryProgram._Current);
-   assert(stgp->Base.Target == GL_GEOMETRY_PROGRAM_NV);
+   stp = st_common_program(prog);
+   st_reference_prog(st, dst, stp);
 
-   void *shader;
+   if (st->shader_has_one_variant[prog->info.stage] && stp->variants)
+      return stp->variants->driver_shader;
 
-   if (st->shader_has_one_variant[MESA_SHADER_GEOMETRY] && stgp->variants) {
-      shader = stgp->variants->driver_shader;
-   } else {
-      shader = st_get_basic_variant(st, PIPE_SHADER_GEOMETRY, &stgp->tgsi,
-                                    &stgp->variants)->driver_shader;
-   }
+   struct st_common_variant_key key;
 
-   st_reference_prog(st, &st->gp, stgp);
+   /* use memset, not an initializer to be sure all memory is zeroed */
+   memset(&key, 0, sizeof(key));
 
-   cso_set_geometry_shader_handle(st->cso_context, shader);
-}
-
-
-void
-st_update_tcp( struct st_context *st )
-{
-   struct st_common_program *sttcp;
+   key.st = st->has_shareable_shaders ? NULL : st;
 
-   if (!st->ctx->TessCtrlProgram._Current) {
-      cso_set_tessctrl_shader_handle(st->cso_context, NULL);
-      st_reference_prog(st, &st->tcp, NULL);
-      return;
-   }
+   if (pipe_shader == PIPE_SHADER_GEOMETRY ||
+       pipe_shader == PIPE_SHADER_TESS_EVAL) {
+      key.clamp_color = st->clamp_vert_color_in_shader &&
+                        st->ctx->Light._ClampVertexColor &&
+                        (stp->Base.info.outputs_written &
+                         (VARYING_SLOT_COL0 |
+                          VARYING_SLOT_COL1 |
+                          VARYING_SLOT_BFC0 |
+                          VARYING_SLOT_BFC1));
 
-   sttcp = st_common_program(st->ctx->TessCtrlProgram._Current);
-   assert(sttcp->Base.Target == GL_TESS_CONTROL_PROGRAM_NV);
+      key.lower_depth_clamp =
+            (pipe_shader == PIPE_SHADER_GEOMETRY || !st->gp) &&
+            st->clamp_frag_depth_in_shader &&
+            (st->ctx->Transform.DepthClampNear ||
+             st->ctx->Transform.DepthClampFar);
 
-   void *shader;
+      if (key.lower_depth_clamp)
+         key.clip_negative_one_to_one =
+               st->ctx->Transform.ClipDepthMode == GL_NEGATIVE_ONE_TO_ONE;
 
-   if (st->shader_has_one_variant[MESA_SHADER_TESS_CTRL] && sttcp->variants) {
-      shader = sttcp->variants->driver_shader;
-   } else {
-      shader = st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL, &sttcp->tgsi,
-                                    &sttcp->variants)->driver_shader;
    }
 
-   st_reference_prog(st, &st->tcp, sttcp);
-
-   cso_set_tessctrl_shader_handle(st->cso_context, shader);
+   return st_get_common_variant(st, stp, &key)->driver_shader;
 }
 
 
 void
-st_update_tep( struct st_context *st )
+st_update_gp(struct st_context *st)
 {
-   struct st_common_program *sttep;
-
-   if (!st->ctx->TessEvalProgram._Current) {
-      cso_set_tesseval_shader_handle(st->cso_context, NULL);
-      st_reference_prog(st, &st->tep, NULL);
-      return;
-   }
-
-   sttep = st_common_program(st->ctx->TessEvalProgram._Current);
-   assert(sttep->Base.Target == GL_TESS_EVALUATION_PROGRAM_NV);
+   void *shader = st_update_common_program(st,
+                                           st->ctx->GeometryProgram._Current,
+                                           PIPE_SHADER_GEOMETRY, &st->gp);
+   cso_set_geometry_shader_handle(st->cso_context, shader);
+}
 
-   void *shader;
 
-   if (st->shader_has_one_variant[MESA_SHADER_TESS_EVAL] && sttep->variants) {
-      shader = sttep->variants->driver_shader;
-   } else {
-      shader = st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL, &sttep->tgsi,
-                                    &sttep->variants)->driver_shader;
-   }
+void
+st_update_tcp(struct st_context *st)
+{
+   void *shader = st_update_common_program(st,
+                                           st->ctx->TessCtrlProgram._Current,
+                                           PIPE_SHADER_TESS_CTRL, &st->tcp);
+   cso_set_tessctrl_shader_handle(st->cso_context, shader);
+}
 
-   st_reference_prog(st, &st->tep, sttep);
 
+void
+st_update_tep(struct st_context *st)
+{
+   void *shader = st_update_common_program(st,
+                                           st->ctx->TessEvalProgram._Current,
+                                           PIPE_SHADER_TESS_EVAL, &st->tep);
    cso_set_tesseval_shader_handle(st->cso_context, shader);
 }
 
 
 void
-st_update_cp( struct st_context *st )
+st_update_cp(struct st_context *st)
 {
-   struct st_compute_program *stcp;
-
-   if (!st->ctx->ComputeProgram._Current) {
-      cso_set_compute_shader_handle(st->cso_context, NULL);
-      st_reference_compprog(st, &st->cp, NULL);
-      return;
-   }
-
-   stcp = st_compute_program(st->ctx->ComputeProgram._Current);
-   assert(stcp->Base.Target == GL_COMPUTE_PROGRAM_NV);
-
-   void *shader;
-
-   if (st->shader_has_one_variant[MESA_SHADER_COMPUTE] && stcp->variants) {
-      shader = stcp->variants->driver_shader;
-   } else {
-      shader = st_get_cp_variant(st, &stcp->tgsi,
-                                 &stcp->variants)->driver_shader;
-   }
-
-   st_reference_compprog(st, &st->cp, stcp);
-
+   void *shader = st_update_common_program(st,
+                                           st->ctx->ComputeProgram._Current,
+                                           PIPE_SHADER_COMPUTE, &st->cp);
    cso_set_compute_shader_handle(st->cso_context, shader);
 }