intel / DRI2: When available, use DRI2GetBuffersWithFormat
[mesa.git] / src / mesa / state_tracker / st_atom_sampler.c
index 151d724863011dd4b6b2bbccc17561a48d72ea80..50ce82811c567c31da8a53df1c34e57dd4b2225e 100644 (file)
   */
  
 
+#include "main/macros.h"
+
 #include "st_context.h"
-#include "st_cache.h"
+#include "st_cb_texture.h"
 #include "st_atom.h"
+#include "st_program.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 
+#include "cso_cache/cso_context.h"
+
 
 /**
  * Convert GLenum texcoord wrap tokens to pipe tokens.
  */
 static GLuint
-gl_wrap_to_sp(GLenum wrap)
+gl_wrap_xlate(GLenum wrap)
 {
    switch (wrap) {
    case GL_REPEAT:
@@ -63,7 +68,7 @@ gl_wrap_to_sp(GLenum wrap)
    case GL_MIRROR_CLAMP_TO_BORDER_EXT:
       return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
    default:
-      abort();
+      assert(0);
       return 0;
    }
 }
@@ -113,68 +118,133 @@ gl_filter_to_img_filter(GLenum filter)
 }
 
 
+static void
+xlate_border_color(const GLfloat *colorIn, GLenum baseFormat, GLfloat *colorOut)
+{
+   switch (baseFormat) {
+   case GL_RGB:
+      colorOut[0] = colorIn[0];
+      colorOut[1] = colorIn[1];
+      colorOut[2] = colorIn[2];
+      colorOut[3] = 1.0F;
+      break;
+   case GL_ALPHA:
+      colorOut[0] = colorOut[1] = colorOut[2] = 0.0;
+      colorOut[3] = colorIn[3];
+      break;
+   case GL_LUMINANCE:
+      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
+      colorOut[3] = 1.0;
+      break;
+   case GL_LUMINANCE_ALPHA:
+      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
+      colorOut[3] = colorIn[3];
+      break;
+   case GL_INTENSITY:
+      colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];
+      break;
+   default:
+      COPY_4V(colorOut, colorIn);
+   }
+}
+
 
 static void 
 update_samplers(struct st_context *st)
 {
-   GLuint u;
-
-   for (u = 0; u < st->ctx->Const.MaxTextureImageUnits; u++) {
-      const struct gl_texture_object *texobj
-         = st->ctx->Texture.Unit[u]._Current;
-      struct pipe_sampler_state sampler;
-      const struct cso_sampler *cso;
-
-      memset(&sampler, 0, sizeof(sampler));
-
-      if (texobj) {
-         sampler.wrap_s = gl_wrap_to_sp(texobj->WrapS);
-         sampler.wrap_t = gl_wrap_to_sp(texobj->WrapT);
-         sampler.wrap_r = gl_wrap_to_sp(texobj->WrapR);
-
-         sampler.min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);
-         sampler.min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);
-         sampler.mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);
-
-         sampler.lod_bias = st->ctx->Texture.Unit[u].LodBias;
-#if 1
-         sampler.min_lod = texobj->MinLod;
-         sampler.max_lod = texobj->MaxLod;
-#else
-         /* min/max lod should really be as follows (untested).
-          * Also, calculate_first_last_level() needs to be overhauled
-          * since today's hardware had real support for LOD clamping.
-          */
-         sampler.min_lod = MAX2(texobj->BaseLevel, texobj->MinLod);
-         sampler.max_lod = MIN2(texobj->MaxLevel, texobj->MaxLod);
-#endif
-
-        sampler.max_anisotropy = texobj->MaxAnisotropy;
-
-         /* XXX more sampler state here */
+   struct gl_vertex_program *vprog = st->ctx->VertexProgram._Current;
+   struct gl_fragment_program *fprog = st->ctx->FragmentProgram._Current;
+   const GLbitfield samplersUsed = (vprog->Base.SamplersUsed |
+                                    fprog->Base.SamplersUsed);
+   GLuint su;
+
+   st->state.num_samplers = 0;
+
+   /* loop over sampler units (aka tex image units) */
+   for (su = 0; su < st->ctx->Const.MaxTextureImageUnits; su++) {
+      struct pipe_sampler_state *sampler = st->state.samplers + su;
+
+      memset(sampler, 0, sizeof(*sampler));
+
+      if (samplersUsed & (1 << su)) {
+         struct gl_texture_object *texobj;
+         struct gl_texture_image *teximg;
+         GLuint texUnit;
+
+         if (fprog->Base.SamplersUsed & (1 << su))
+            texUnit = fprog->Base.SamplerUnits[su];
+         else
+            texUnit = vprog->Base.SamplerUnits[su];
+
+         texobj = st->ctx->Texture.Unit[texUnit]._Current;
+         if (!texobj) {
+            texobj = st_get_default_texture(st);
+         }
+
+         teximg = texobj->Image[0][texobj->BaseLevel];
+
+         sampler->wrap_s = gl_wrap_xlate(texobj->WrapS);
+         sampler->wrap_t = gl_wrap_xlate(texobj->WrapT);
+         sampler->wrap_r = gl_wrap_xlate(texobj->WrapR);
+
+         sampler->min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);
+         sampler->min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);
+         sampler->mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);
+
+         if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB)
+            sampler->normalized_coords = 1;
+
+         sampler->lod_bias = st->ctx->Texture.Unit[su].LodBias;
+         sampler->min_lod = MAX2(0.0f, texobj->MinLod);
+         sampler->max_lod = MIN2(texobj->MaxLevel - texobj->BaseLevel,
+                                 texobj->MaxLod);
+         if (sampler->max_lod < sampler->min_lod) {
+            /* The GL spec doesn't seem to specify what to do in this case.
+             * Swap the values.
+             */
+            float tmp = sampler->max_lod;
+            sampler->max_lod = sampler->min_lod;
+            sampler->min_lod = tmp;
+            assert(sampler->min_lod <= sampler->max_lod);
+         }
+
+         xlate_border_color(texobj->BorderColor,
+                            teximg ? teximg->TexFormat->BaseFormat : GL_RGBA,
+                            sampler->border_color);
+
+        sampler->max_anisotropy = texobj->MaxAnisotropy;
+         if (sampler->max_anisotropy > 1.0) {
+            sampler->min_img_filter = PIPE_TEX_FILTER_ANISO;
+            sampler->mag_img_filter = PIPE_TEX_FILTER_ANISO;
+         }
+
+         /* only care about ARB_shadow, not SGI shadow */
+         if (texobj->CompareMode == GL_COMPARE_R_TO_TEXTURE) {
+            sampler->compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;
+            sampler->compare_func
+               = st_compare_func_to_pipe(texobj->CompareFunc);
+         }
+
+         st->state.num_samplers = su + 1;
+
+         /*printf("%s su=%u non-null\n", __FUNCTION__, su);*/
+         cso_single_sampler(st->cso_context, su, sampler);
       }
-
-      cso = st_cached_sampler_state(st, &sampler);
-
-      if (cso != st->state.sampler[u]) {
-         /* state has changed */
-         st->state.sampler[u] = cso;
-         st->pipe->bind_sampler_state(st->pipe, u, cso->data);
+      else {
+         /*printf("%s su=%u null\n", __FUNCTION__, su);*/
+         cso_single_sampler(st->cso_context, su, NULL);
       }
    }
+
+   cso_single_sampler_done(st->cso_context);
 }
 
 
 const struct st_tracked_state st_update_sampler = {
-   .name = "st_update_sampler",
-   .dirty = {
-      .mesa = _NEW_TEXTURE,
-      .st  = 0,
+   "st_update_sampler",                                        /* name */
+   {                                                   /* dirty */
+      _NEW_TEXTURE,                                    /* mesa */
+      0,                                               /* st */
    },
-   .update = update_samplers
+   update_samplers                                     /* update */
 };
-
-
-
-
-