st/mesa: Use compressed fog mode for atifs.

[mesa.git] / src / mesa / state_tracker / st_atom_shader.c

diff --git a/src/mesa/state_tracker/st_atom_shader.c b/src/mesa/state_tracker/st_atom_shader.c
index ff90bd61d5b098fb381ef9def7371071a3d658a6..ee97c69df338d12a9c11ac2e1854d8dfa21297b5 100644 (file)
--- a/src/mesa/state_tracker/st_atom_shader.c
+++ b/src/mesa/state_tracker/st_atom_shader.c
@@ -38,16 +38,55 @@
 #include "main/imports.h"
 #include "main/mtypes.h"
 #include "main/framebuffer.h"
+#include "main/texobj.h"
+#include "main/texstate.h"
 #include "program/program.h"
 
 #include "pipe/p_context.h"
 #include "pipe/p_shader_tokens.h"
 #include "util/u_simple_shaders.h"
 #include "cso_cache/cso_context.h"
+#include "util/u_debug.h"
 
 #include "st_context.h"
 #include "st_atom.h"
 #include "st_program.h"
+#include "st_texture.h"
+
+
+static unsigned
+get_texture_target(struct gl_context *ctx, const unsigned unit)
+{
+   struct gl_texture_object *texObj = _mesa_get_tex_unit(ctx, unit)->_Current;
+   gl_texture_index index;
+
+   if (texObj) {
+      index = _mesa_tex_target_to_index(ctx, texObj->Target);
+   } else {
+      /* fallback for missing texture */
+      index = TEXTURE_2D_INDEX;
+   }
+
+   /* Map mesa texture target to TGSI texture target.
+    * Copied from st_mesa_to_tgsi.c, the shadow part is omitted */
+   switch(index) {
+   case TEXTURE_2D_MULTISAMPLE_INDEX: return TGSI_TEXTURE_2D_MSAA;
+   case TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX: return TGSI_TEXTURE_2D_ARRAY_MSAA;
+   case TEXTURE_BUFFER_INDEX: return TGSI_TEXTURE_BUFFER;
+   case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_1D;
+   case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_2D;
+   case TEXTURE_3D_INDEX:   return TGSI_TEXTURE_3D;
+   case TEXTURE_CUBE_INDEX: return TGSI_TEXTURE_CUBE;
+   case TEXTURE_CUBE_ARRAY_INDEX: return TGSI_TEXTURE_CUBE_ARRAY;
+   case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_RECT;
+   case TEXTURE_1D_ARRAY_INDEX:   return TGSI_TEXTURE_1D_ARRAY;
+   case TEXTURE_2D_ARRAY_INDEX:   return TGSI_TEXTURE_2D_ARRAY;
+   case TEXTURE_EXTERNAL_INDEX:   return TGSI_TEXTURE_2D;
+   default:
+      debug_assert(0);
+      return TGSI_TEXTURE_1D;
+   }
+}
 
 
 /**
@@ -62,7 +101,7 @@ update_fp( struct st_context *st )
 
    assert(st->ctx->FragmentProgram._Current);
    stfp = st_fragment_program(st->ctx->FragmentProgram._Current);
-   assert(stfp->Base.Base.Target == GL_FRAGMENT_PROGRAM_ARB);
+   assert(stfp->Base.Target == GL_FRAGMENT_PROGRAM_ARB);
 
    memset(&key, 0, sizeof(key));
    key.st = st->has_shareable_shaders ? NULL : st;
@@ -74,11 +113,21 @@ update_fp( struct st_context *st )
    /* _NEW_MULTISAMPLE | _NEW_BUFFERS */
    key.persample_shading =
       st->force_persample_in_shader &&
-      st->ctx->Multisample._Enabled &&
+      _mesa_is_multisample_enabled(st->ctx) &&
       st->ctx->Multisample.SampleShading &&
       st->ctx->Multisample.MinSampleShadingValue *
       _mesa_geometric_samples(st->ctx->DrawBuffer) > 1;
 
+   if (stfp->ati_fs) {
+      key.fog = st->ctx->Fog._PackedEnabledMode;
+
+      for (unsigned u = 0; u < MAX_NUM_FRAGMENT_REGISTERS_ATI; u++) {
+         key.texture_targets[u] = get_texture_target(st->ctx, u);
+      }
+   }
+
+   key.external = st_get_external_sampler_key(st, &stfp->Base);
+
    st->fp_variant = st_get_fp_variant(st, stfp, &key);
 
    st_reference_fragprog(st, &st->fp, stfp);
@@ -89,11 +138,6 @@ update_fp( struct st_context *st )
 
 
 const struct st_tracked_state st_update_fp = {
-   "st_update_fp",                                     /* name */
-   {                                                   /* dirty */
-      _NEW_BUFFERS | _NEW_MULTISAMPLE,                 /* mesa */
-      ST_NEW_FRAGMENT_PROGRAM                           /* st */
-   },
    update_fp                                   /* update */
 };
 
@@ -114,7 +158,7 @@ update_vp( struct st_context *st )
     */
    assert(st->ctx->VertexProgram._Current);
    stvp = st_vertex_program(st->ctx->VertexProgram._Current);
-   assert(stvp->Base.Base.Target == GL_VERTEX_PROGRAM_ARB);
+   assert(stvp->Base.Target == GL_VERTEX_PROGRAM_ARB);
 
    memset(&key, 0, sizeof key);
    key.st = st->has_shareable_shaders ? NULL : st;
@@ -129,7 +173,7 @@ update_vp( struct st_context *st )
 
    key.clamp_color = st->clamp_vert_color_in_shader &&
                      st->ctx->Light._ClampVertexColor &&
-                     (stvp->Base.Base.OutputsWritten &
+                     (stvp->Base.info.outputs_written &
                       (VARYING_SLOT_COL0 |
                        VARYING_SLOT_COL1 |
                        VARYING_SLOT_BFC0 |
@@ -147,11 +191,6 @@ update_vp( struct st_context *st )
 
 
 const struct st_tracked_state st_update_vp = {
-   "st_update_vp",                                     /* name */
-   {                                                   /* dirty */
-      0,                                                /* mesa */
-      ST_NEW_VERTEX_PROGRAM                             /* st */
-   },
    update_vp                                           /* update */
 };
 
@@ -164,11 +203,12 @@ update_gp( struct st_context *st )
 
    if (!st->ctx->GeometryProgram._Current) {
       cso_set_geometry_shader_handle(st->cso_context, NULL);
+      st_reference_geomprog(st, &st->gp, NULL);
       return;
    }
 
    stgp = st_geometry_program(st->ctx->GeometryProgram._Current);
-   assert(stgp->Base.Base.Target == GL_GEOMETRY_PROGRAM_NV);
+   assert(stgp->Base.Target == GL_GEOMETRY_PROGRAM_NV);
 
    st->gp_variant = st_get_basic_variant(st, PIPE_SHADER_GEOMETRY,
                                          &stgp->tgsi, &stgp->variants);
@@ -180,11 +220,6 @@ update_gp( struct st_context *st )
 }
 
 const struct st_tracked_state st_update_gp = {
-   "st_update_gp",                     /* name */
-   {                                   /* dirty */
-      0,                               /* mesa */
-      ST_NEW_GEOMETRY_PROGRAM           /* st */
-   },
    update_gp                           /* update */
 };
 
@@ -197,11 +232,12 @@ update_tcp( struct st_context *st )
 
    if (!st->ctx->TessCtrlProgram._Current) {
       cso_set_tessctrl_shader_handle(st->cso_context, NULL);
+      st_reference_tesscprog(st, &st->tcp, NULL);
       return;
    }
 
    sttcp = st_tessctrl_program(st->ctx->TessCtrlProgram._Current);
-   assert(sttcp->Base.Base.Target == GL_TESS_CONTROL_PROGRAM_NV);
+   assert(sttcp->Base.Target == GL_TESS_CONTROL_PROGRAM_NV);
 
    st->tcp_variant = st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL,
                                           &sttcp->tgsi, &sttcp->variants);
@@ -213,11 +249,6 @@ update_tcp( struct st_context *st )
 }
 
 const struct st_tracked_state st_update_tcp = {
-   "st_update_tcp",                    /* name */
-   {                                   /* dirty */
-      0,                               /* mesa */
-      ST_NEW_TESSCTRL_PROGRAM           /* st */
-   },
    update_tcp                                  /* update */
 };
 
@@ -230,11 +261,12 @@ update_tep( struct st_context *st )
 
    if (!st->ctx->TessEvalProgram._Current) {
       cso_set_tesseval_shader_handle(st->cso_context, NULL);
+      st_reference_tesseprog(st, &st->tep, NULL);
       return;
    }
 
    sttep = st_tesseval_program(st->ctx->TessEvalProgram._Current);
-   assert(sttep->Base.Base.Target == GL_TESS_EVALUATION_PROGRAM_NV);
+   assert(sttep->Base.Target == GL_TESS_EVALUATION_PROGRAM_NV);
 
    st->tep_variant = st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL,
                                           &sttep->tgsi, &sttep->variants);
@@ -246,11 +278,6 @@ update_tep( struct st_context *st )
 }
 
 const struct st_tracked_state st_update_tep = {
-   "st_update_tep",                    /* name */
-   {                                   /* dirty */
-      0,                               /* mesa */
-      ST_NEW_TESSEVAL_PROGRAM           /* st */
-   },
    update_tep                                  /* update */
 };
 
@@ -263,11 +290,12 @@ update_cp( struct st_context *st )
 
    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.Base.Target == GL_COMPUTE_PROGRAM_NV);
+   assert(stcp->Base.Target == GL_COMPUTE_PROGRAM_NV);
 
    st->cp_variant = st_get_cp_variant(st, &stcp->tgsi, &stcp->variants);
 
@@ -278,10 +306,5 @@ update_cp( struct st_context *st )
 }
 
 const struct st_tracked_state st_update_cp = {
-   "st_update_cp",                     /* name */
-   {                                   /* dirty */
-      0,                               /* mesa */
-      ST_NEW_COMPUTE_PROGRAM           /* st */
-   },
    update_cp                           /* update */
 };