WIP: Constant texture object sampler stateconstant_texture_sampler_wip

16 files changed, 317 insertions, 179 deletions

diff --git a/src/mesa/drivers/dri/intel/intel_tex_image.c b/src/mesa/drivers/dri/intel/intel_tex_image.c
index 11ad53edc0..ca0dbbd122 100644
--- a/src/mesa/drivers/dri/intel/intel_tex_image.c
+++ b/src/mesa/drivers/dri/intel/intel_tex_image.c
@@ -79,8 +79,8 @@ intel_miptree_create_for_teximage(struct intel_context *intel,
        * resizable buffers, or require that buffers implement lazy
        * pagetable arrangements.
        */
-      if ((intelObj->base.Sampler.MinFilter == GL_NEAREST ||
-	   intelObj->base.Sampler.MinFilter == GL_LINEAR) &&
+      if ((intelObj->base.Sampler->MinFilter == GL_NEAREST ||
+	   intelObj->base.Sampler->MinFilter == GL_LINEAR) &&
 	  intelImage->base.Base.Level == firstLevel &&
 	  (intel->gen < 4 || firstLevel == 0)) {
 	 lastLevel = firstLevel;
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_texture.c b/src/mesa/drivers/dri/nouveau/nouveau_texture.c
index 0e42758040..a10bc191c7 100644
--- a/src/mesa/drivers/dri/nouveau/nouveau_texture.c
+++ b/src/mesa/drivers/dri/nouveau/nouveau_texture.c
@@ -364,8 +364,8 @@ get_last_level(struct gl_texture_object *t)
 {
 	struct gl_texture_image *base = t->Image[0][t->BaseLevel];
 
-	if (t->Sampler.MinFilter == GL_NEAREST ||
-	    t->Sampler.MinFilter == GL_LINEAR || !base)
+	if (t->Sampler->MinFilter == GL_NEAREST ||
+	    t->Sampler->MinFilter == GL_LINEAR || !base)
 		return t->BaseLevel;
 	else
 		return MIN2(t->BaseLevel + base->MaxLog2, t->MaxLevel);
diff --git a/src/mesa/drivers/dri/r200/r200_tex.c b/src/mesa/drivers/dri/r200/r200_tex.c
index f72cad3665..c524a1f101 100644
--- a/src/mesa/drivers/dri/r200/r200_tex.c
+++ b/src/mesa/drivers/dri/r200/r200_tex.c
@@ -471,13 +471,14 @@ static struct gl_texture_object *r200NewTextureObject(struct gl_context * ctx,
 	   _mesa_lookup_enum_by_nr(target), t);
 
    _mesa_initialize_texture_object(&t->base, name, target);
-   t->base.Sampler.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
+   t->base.Sampler = _mesa_mutable_sampler_object(t->base.Sampler);
+   t->base.Sampler->MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
 
    /* Initialize hardware state */
-   r200SetTexWrap( t, t->base.Sampler.WrapS, t->base.Sampler.WrapT, t->base.Sampler.WrapR );
-   r200SetTexMaxAnisotropy( t, t->base.Sampler.MaxAnisotropy );
-   r200SetTexFilter(t, t->base.Sampler.MinFilter, t->base.Sampler.MagFilter);
-   r200SetTexBorderColor(t, t->base.Sampler.BorderColor.f);
+   r200SetTexWrap( t, t->base.Sampler->WrapS, t->base.Sampler->WrapT, t->base.Sampler->WrapR );
+   r200SetTexMaxAnisotropy( t, t->base.Sampler->MaxAnisotropy );
+   r200SetTexFilter(t, t->base.Sampler->MinFilter, t->base.Sampler->MagFilter);
+   r200SetTexBorderColor(t, t->base.Sampler->BorderColor.f);
 
    return &t->base;
 }
@@ -507,8 +508,8 @@ void r200InitTextureFuncs( radeonContextPtr radeon, struct dd_function_table *fu
    //   functions->BindTexture		= r200BindTexture;
    functions->DeleteTexture		= r200DeleteTexture;
 
+   functions->TexParameter              = r200TexParameter;
    functions->TexEnv			= r200TexEnv;
-   functions->TexParameter		= r200TexParameter;
    functions->TexGen			= r200TexGen;
-   functions->NewSamplerObject		= r200NewSamplerObject;
+   functions->NewSamplerObject          = r200NewSamplerObject;
 }
diff --git a/src/mesa/drivers/dri/radeon/radeon_mipmap_tree.c b/src/mesa/drivers/dri/radeon/radeon_mipmap_tree.c
index ca5dadc5d3..034a736782 100644
--- a/src/mesa/drivers/dri/radeon/radeon_mipmap_tree.c
+++ b/src/mesa/drivers/dri/radeon/radeon_mipmap_tree.c
@@ -260,15 +260,15 @@ static void calculate_min_max_lod(struct gl_texture_object *tObj,
 	case GL_TEXTURE_2D:
 	case GL_TEXTURE_3D:
 	case GL_TEXTURE_CUBE_MAP:
-		if (tObj->Sampler.MinFilter == GL_NEAREST || tObj->Sampler.MinFilter == GL_LINEAR) {
+		if (tObj->Sampler->MinFilter == GL_NEAREST || tObj->Sampler->MinFilter == GL_LINEAR) {
 			/* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
 			*/
 			minLod = maxLod = tObj->BaseLevel;
 		} else {
-			minLod = tObj->BaseLevel + (GLint)(tObj->Sampler.MinLod);
+			minLod = tObj->BaseLevel + (GLint)(tObj->Sampler->MinLod);
 			minLod = MAX2(minLod, tObj->BaseLevel);
 			minLod = MIN2(minLod, tObj->MaxLevel);
-			maxLod = tObj->BaseLevel + (GLint)(tObj->Sampler.MaxLod + 0.5);
+			maxLod = tObj->BaseLevel + (GLint)(tObj->Sampler->MaxLod + 0.5);
 			maxLod = MIN2(maxLod, tObj->MaxLevel);
 			maxLod = MIN2(maxLod, tObj->Image[0][minLod]->MaxLog2 + minLod);
 			maxLod = MAX2(maxLod, minLod); /* need at least one level */
diff --git a/src/mesa/drivers/dri/radeon/radeon_tex.c b/src/mesa/drivers/dri/radeon/radeon_tex.c
index af29dda48b..ea0e964570 100644
--- a/src/mesa/drivers/dri/radeon/radeon_tex.c
+++ b/src/mesa/drivers/dri/radeon/radeon_tex.c
@@ -412,7 +412,8 @@ radeonNewTextureObject( struct gl_context *ctx, GLuint name, GLenum target )
    radeonTexObj* t = CALLOC_STRUCT(radeon_tex_obj);
 
    _mesa_initialize_texture_object(&t->base, name, target);
-   t->base.Sampler.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
+   t->base.Sampler = _mesa_mutable_sampler_object(t->base.Sampler);
+   t->base.Sampler->MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
 
    t->border_fallback = GL_FALSE;
 
@@ -420,10 +421,10 @@ radeonNewTextureObject( struct gl_context *ctx, GLuint name, GLenum target )
    t->pp_txformat = (RADEON_TXFORMAT_ENDIAN_NO_SWAP |
 		     RADEON_TXFORMAT_PERSPECTIVE_ENABLE);
    
-   radeonSetTexWrap( t, t->base.Sampler.WrapS, t->base.Sampler.WrapT );
-   radeonSetTexMaxAnisotropy( t, t->base.Sampler.MaxAnisotropy );
-   radeonSetTexFilter( t, t->base.Sampler.MinFilter, t->base.Sampler.MagFilter );
-   radeonSetTexBorderColor( t, t->base.Sampler.BorderColor.f );
+   radeonSetTexWrap( t, t->base.Sampler->WrapS, t->base.Sampler->WrapT );
+   radeonSetTexMaxAnisotropy( t, t->base.Sampler->MaxAnisotropy );
+   radeonSetTexFilter( t, t->base.Sampler->MinFilter, t->base.Sampler->MagFilter );
+   radeonSetTexBorderColor( t, t->base.Sampler->BorderColor.f );
    return &t->base;
 }
 
diff --git a/src/mesa/drivers/dri/radeon/radeon_texstate.c b/src/mesa/drivers/dri/radeon/radeon_texstate.c
index 86a5ea529f..04f1df1686 100644
--- a/src/mesa/drivers/dri/radeon/radeon_texstate.c
+++ b/src/mesa/drivers/dri/radeon/radeon_texstate.c
@@ -1075,7 +1075,6 @@ static GLboolean radeon_validate_texture(struct gl_context *ctx, struct gl_textu
    rmesa->hw.tcl.cmd[TCL_OUTPUT_VTXFMT] |= RADEON_ST_BIT(unit);
 
    rmesa->recheck_texgen[unit] = GL_TRUE;
-
    radeonTexUpdateParameters(ctx, unit);
    import_tex_obj_state( rmesa, unit, t );
 
diff --git a/src/mesa/drivers/dri/radeon/radeon_texture.c b/src/mesa/drivers/dri/radeon/radeon_texture.c
index 157cc096a3..6e7c5ee3b7 100644
--- a/src/mesa/drivers/dri/radeon/radeon_texture.c
+++ b/src/mesa/drivers/dri/radeon/radeon_texture.c
@@ -816,8 +816,8 @@ static radeon_mipmap_tree *radeon_miptree_create_for_teximage(radeonContextPtr r
 			if (depth != 1)
 				depth <<= 1;
 		}
-		if ((texObj->Sampler.MinFilter == GL_NEAREST ||
-		     texObj->Sampler.MinFilter == GL_LINEAR) &&
+		if ((texObj->Sampler->MinFilter == GL_NEAREST ||
+		     texObj->Sampler->MinFilter == GL_LINEAR) &&
 		    texImage->Level == firstLevel) {
 			lastLevel = firstLevel;
 		} else {
diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c
index 8bc7c348fa..5d8d11b614 100644
--- a/src/mesa/main/attrib.c
+++ b/src/mesa/main/attrib.c
@@ -776,7 +776,7 @@ pop_texture_group(struct gl_context *ctx, struct texture_state *texstate)
 
          _mesa_BindTexture(target, obj->Name);
 
-         samp = &obj->Sampler;
+         samp = obj->Sampler;
 
          _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, samp->BorderColor.f);
          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, samp->WrapS);
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 7c6f36942b..021809fa9a 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1307,7 +1307,7 @@ struct gl_texture_object
    GLuint Name;			/**< the user-visible texture object ID */
    GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
 
-   struct gl_sampler_object Sampler;
+   struct gl_sampler_object *Sampler;
 
    /* deprecated sampler state */
    GLenum DepthMode;		/**< GL_ARB_depth_texture */
diff --git a/src/mesa/main/samplerobj.c b/src/mesa/main/samplerobj.c
index f2d99a035e..fbf8549377 100644
--- a/src/mesa/main/samplerobj.c
+++ b/src/mesa/main/samplerobj.c
@@ -39,6 +39,75 @@
 #include "main/mtypes.h"
 #include "main/samplerobj.h"
 
+static const struct gl_sampler_object sampler_default = {
+   .RefCount = 0,
+   .WrapS = GL_REPEAT,
+   .WrapT = GL_REPEAT,
+   .WrapR = GL_REPEAT,
+   .MinFilter = GL_NEAREST_MIPMAP_LINEAR,
+   .MagFilter = GL_LINEAR,
+   .BorderColor = {.f = {0.0, 0.0, 0.0, 0.0}},
+   .MinLod = -1000.0F,
+   .MaxLod = 1000.0F,
+   .LodBias = 0.0F,
+   .MaxAnisotropy = 1.0F,
+   .CompareMode = GL_NONE,
+   .CompareFunc = GL_LEQUAL,
+   .CompareFailValue = 0.0,
+   .sRGBDecode = GL_DECODE_EXT,
+   .CubeMapSeamless = GL_FALSE,
+};
+
+static const struct gl_sampler_object sampler_default_nearest = {
+   .RefCount = 0,
+   .WrapS = GL_REPEAT,
+   .WrapT = GL_REPEAT,
+   .WrapR = GL_REPEAT,
+   .MinFilter = GL_NEAREST,
+   .MagFilter = GL_NEAREST,
+   .BorderColor = {.f = {0.0, 0.0, 0.0, 0.0}},
+   .MinLod = -1000.0F,
+   .MaxLod = 1000.0F,
+   .LodBias = 0.0F,
+   .MaxAnisotropy = 1.0F,
+   .CompareMode = GL_NONE,
+   .CompareFunc = GL_LEQUAL,
+   .CompareFailValue = 0.0,
+   .sRGBDecode = GL_DECODE_EXT,
+   .CubeMapSeamless = GL_FALSE,
+};
+
+static const struct gl_sampler_object sampler_clamp = {
+   .RefCount = 0,
+   .WrapS = GL_CLAMP_TO_EDGE,
+   .WrapT = GL_CLAMP_TO_EDGE,
+   .WrapR = GL_CLAMP_TO_EDGE,
+   .MinFilter = GL_LINEAR,
+   .MagFilter = GL_LINEAR,
+   .BorderColor = {.f = {0.0, 0.0, 0.0, 0.0}},
+   .MinLod = -1000.0F,
+   .MaxLod = 1000.0F,
+   .LodBias = 0.0F,
+   .MaxAnisotropy = 1.0F,
+   .CompareMode = GL_NONE,
+   .CompareFunc = GL_LEQUAL,
+   .CompareFailValue = 0.0,
+   .sRGBDecode = GL_DECODE_EXT,
+   .CubeMapSeamless = GL_FALSE,
+};
+
+struct gl_sampler_object *
+_mesa_sampler_default = (struct gl_sampler_object *)&sampler_default;
+struct gl_sampler_object *
+_mesa_sampler_default_nearest = (struct gl_sampler_object *)&sampler_default_nearest;
+struct gl_sampler_object *
+_mesa_sampler_default_clamp_to_edge = (struct gl_sampler_object *)&sampler_clamp;
+
+static GLboolean
+const_sampler(const struct gl_sampler_object *sampler)
+{
+   return sampler->RefCount == 0;
+}
 
 static struct gl_sampler_object *
 _mesa_lookup_samplerobj(struct gl_context *ctx, GLuint name)
@@ -66,19 +135,21 @@ _mesa_reference_sampler_object_(struct gl_context *ctx,
       GLboolean deleteFlag = GL_FALSE;
       struct gl_sampler_object *oldSamp = *ptr;
 
-      /*_glthread_LOCK_MUTEX(oldSamp->Mutex);*/
-      ASSERT(oldSamp->RefCount > 0);
-      oldSamp->RefCount--;
+      if (!const_sampler(*ptr)) {
+         /*_glthread_LOCK_MUTEX(oldSamp->Mutex);*/
+         ASSERT(oldSamp->RefCount > 0);
+         oldSamp->RefCount--;
 #if 0
-      printf("SamplerObj %p %d DECR to %d\n",
-             (void *) oldSamp, oldSamp->Name, oldSamp->RefCount);
+         printf("SamplerObj %p %d DECR to %d\n",
+                (void *) oldSamp, oldSamp->Name, oldSamp->RefCount);
 #endif
-      deleteFlag = (oldSamp->RefCount == 0);
-      /*_glthread_UNLOCK_MUTEX(oldSamp->Mutex);*/
+         deleteFlag = (oldSamp->RefCount == 0);
+         /*_glthread_UNLOCK_MUTEX(oldSamp->Mutex);*/
 
-      if (deleteFlag) {
-	 ASSERT(ctx->Driver.DeleteSamplerObject);
-         ctx->Driver.DeleteSamplerObject(ctx, oldSamp);
+         if (deleteFlag) {
+            ASSERT(ctx->Driver.DeleteSamplerObject);
+            ctx->Driver.DeleteSamplerObject(ctx, oldSamp);
+         }
       }
 
       *ptr = NULL;
@@ -87,25 +158,97 @@ _mesa_reference_sampler_object_(struct gl_context *ctx,
 
    if (samp) {
       /* reference new sampler */
-      /*_glthread_LOCK_MUTEX(samp->Mutex);*/
-      if (samp->RefCount == 0) {
-         /* this sampler's being deleted (look just above) */
-         /* Not sure this can every really happen.  Warn if it does. */
-         _mesa_problem(NULL, "referencing deleted sampler object");
-         *ptr = NULL;
-      }
-      else {
-         samp->RefCount++;
+      if (!const_sampler(samp)) {
+         /*_glthread_LOCK_MUTEX(samp->Mutex);*/
+         if (samp->RefCount == 0) {
+            /* this sampler's being deleted (look just above) */
+            /* Not sure this can every really happen.  Warn if it does. */
+            _mesa_problem(NULL, "referencing deleted sampler object");
+            *ptr = NULL;
+         }
+         else {
+            samp->RefCount++;
 #if 0
-         printf("SamplerObj %p %d INCR to %d\n",
-                (void *) samp, samp->Name, samp->RefCount);
+            printf("SamplerObj %p %d INCR to %d\n",
+                   (void *) samp, samp->Name, samp->RefCount);
 #endif
-         *ptr = samp;
+         }
+         /*_glthread_UNLOCK_MUTEX(samp->Mutex);*/
       }
-      /*_glthread_UNLOCK_MUTEX(samp->Mutex);*/
+      *ptr = samp;
    }
 }
 
+struct gl_sampler_object *
+_mesa_mutable_sampler_object(struct gl_sampler_object *samp)
+{
+   struct gl_sampler_object *r;
+   if (!const_sampler(samp))
+      return samp;
+
+   r = CALLOC_STRUCT(gl_sampler_object);
+   r->RefCount = 1;
+   r->WrapS = samp->WrapS;
+   r->WrapT = samp->WrapT;
+   r->WrapR = samp->WrapR;
+   r->MinFilter = samp->MinFilter;
+   r->MagFilter = samp->MagFilter;
+   memcpy(&r->BorderColor, &samp->BorderColor, sizeof samp->BorderColor);
+   r->MinLod = samp->MinLod;
+   r->MaxLod = samp->MaxLod;
+   r->LodBias = samp->LodBias;
+   r->MaxAnisotropy = samp->MaxAnisotropy;
+   r->CompareMode = samp->CompareMode;
+   r->CompareFunc = samp->CompareFunc;
+   r->CompareFailValue = samp->CompareFailValue;
+   r->sRGBDecode = samp->sRGBDecode;
+   r->CubeMapSeamless = samp->CubeMapSeamless;
+   return r;
+}
+
+void
+_mesa_copy_sampler_object(struct gl_sampler_object **dst,
+                          const struct gl_sampler_object *src)
+{
+   if (*dst == src)
+      return;
+
+   /* Special case for state restore to restore constant state object */
+   if (const_sampler(src) && (!(*dst) || (*dst)->Name == 0)) {
+      GLboolean deleteflag;
+      if (*dst) {
+         /* _glthread_LOCK_MUTEX((*dst)->Mutex); */
+         (*dst)->RefCount--;
+         deleteflag = (*dst)->RefCount == 0;
+         /* _glthread_UNLOCK_MUTEX((*dst)->Mutex); */
+         if (deleteflag)
+            FREE(*dst);
+      }
+      *dst = (struct gl_sampler_object *)src;
+      return;
+   }
+
+   if (!(*dst)) {
+      (*dst) = CALLOC_STRUCT(gl_sampler_object);
+      (*dst)->RefCount = 1;
+   }
+
+   (*dst)->WrapS = src->WrapS;
+   (*dst)->WrapT = src->WrapT;
+   (*dst)->WrapR = src->WrapR;
+   (*dst)->MinFilter = src->MinFilter;
+   (*dst)->MagFilter = src->MagFilter;
+   memcpy(&(*dst)->BorderColor, &src->BorderColor, sizeof src->BorderColor);
+   (*dst)->MinLod = src->MinLod;
+   (*dst)->MaxLod = src->MaxLod;
+   (*dst)->LodBias = src->LodBias;
+   (*dst)->MaxAnisotropy = src->MaxAnisotropy;
+   (*dst)->CompareMode = src->CompareMode;
+   (*dst)->CompareFunc = src->CompareFunc;
+   (*dst)->CompareFailValue = src->CompareFailValue;
+   (*dst)->sRGBDecode = src->sRGBDecode;
+   (*dst)->CubeMapSeamless = src->CubeMapSeamless;
+}
 
 /**
  * Initialize the fields of the given sampler object.
diff --git a/src/mesa/main/samplerobj.h b/src/mesa/main/samplerobj.h
index e70ee4881a..526def01d8 100644
--- a/src/mesa/main/samplerobj.h
+++ b/src/mesa/main/samplerobj.h
@@ -28,13 +28,17 @@
 
 struct dd_function_table;
 
+extern struct gl_sampler_object *_mesa_sampler_default;
+extern struct gl_sampler_object *_mesa_sampler_default_nearest;
+extern struct gl_sampler_object *_mesa_sampler_default_clamp_to_edge;
+
 static inline struct gl_sampler_object *
 _mesa_get_samplerobj(struct gl_context *ctx, GLuint unit)
 {
    if (ctx->Texture.Unit[unit].Sampler)
       return ctx->Texture.Unit[unit].Sampler;
    else if (ctx->Texture.Unit[unit]._Current)
-      return &ctx->Texture.Unit[unit]._Current->Sampler;
+      return ctx->Texture.Unit[unit]._Current->Sampler;
    else
       return NULL;
 }
@@ -70,6 +74,13 @@ extern struct gl_sampler_object *
 _mesa_new_sampler_object(struct gl_context *ctx, GLuint name);
 
 extern void
+_mesa_copy_sampler_object(struct gl_sampler_object **dst,
+                          const struct gl_sampler_object *src);
+
+extern struct gl_sampler_object *
+_mesa_mutable_sampler_object(struct gl_sampler_object *samp);
+
+extern void
 _mesa_delete_sampler_object(struct gl_context *ctx,
                             struct gl_sampler_object *sampObj);
 
diff --git a/src/mesa/main/texobj.c b/src/mesa/main/texobj.c
index 62339618e2..68306faea7 100644
--- a/src/mesa/main/texobj.c
+++ b/src/mesa/main/texobj.c
@@ -126,33 +126,17 @@ _mesa_initialize_texture_object( struct gl_texture_object *obj,
    /* sampler state */
    if (target == GL_TEXTURE_RECTANGLE_NV ||
        target == GL_TEXTURE_EXTERNAL_OES) {
-      obj->Sampler.WrapS = GL_CLAMP_TO_EDGE;
-      obj->Sampler.WrapT = GL_CLAMP_TO_EDGE;
-      obj->Sampler.WrapR = GL_CLAMP_TO_EDGE;
-      obj->Sampler.MinFilter = GL_LINEAR;
+      obj->Sampler = _mesa_sampler_default_clamp_to_edge;
    }
    else {
-      obj->Sampler.WrapS = GL_REPEAT;
-      obj->Sampler.WrapT = GL_REPEAT;
-      obj->Sampler.WrapR = GL_REPEAT;
-      obj->Sampler.MinFilter = GL_NEAREST_MIPMAP_LINEAR;
+      obj->Sampler = _mesa_sampler_default;
    }
-   obj->Sampler.MagFilter = GL_LINEAR;
-   obj->Sampler.MinLod = -1000.0;
-   obj->Sampler.MaxLod = 1000.0;
-   obj->Sampler.LodBias = 0.0;
-   obj->Sampler.MaxAnisotropy = 1.0;
-   obj->Sampler.CompareMode = GL_NONE;         /* ARB_shadow */
-   obj->Sampler.CompareFunc = GL_LEQUAL;       /* ARB_shadow */
-   obj->Sampler.CompareFailValue = 0.0F;       /* ARB_shadow_ambient */
    obj->DepthMode = GL_LUMINANCE;
-   obj->Sampler.CubeMapSeamless = GL_FALSE;
    obj->Swizzle[0] = GL_RED;
    obj->Swizzle[1] = GL_GREEN;
    obj->Swizzle[2] = GL_BLUE;
    obj->Swizzle[3] = GL_ALPHA;
    obj->_Swizzle = SWIZZLE_NOOP;
-   obj->Sampler.sRGBDecode = GL_DECODE_EXT;
    obj->BufferObjectFormat = GL_LUMINANCE8;
    obj->_BufferObjectFormat = MESA_FORMAT_L8;
 }
@@ -171,10 +155,8 @@ finish_texture_init(struct gl_context *ctx, GLenum target,
    if (target == GL_TEXTURE_RECTANGLE_NV ||
        target == GL_TEXTURE_EXTERNAL_OES) {
       /* have to init wrap and filter state here - kind of klunky */
-      obj->Sampler.WrapS = GL_CLAMP_TO_EDGE;
-      obj->Sampler.WrapT = GL_CLAMP_TO_EDGE;
-      obj->Sampler.WrapR = GL_CLAMP_TO_EDGE;
-      obj->Sampler.MinFilter = GL_LINEAR;
+      ASSERT(obj->Sampler == _mesa_sampler_default);
+      obj->Sampler = _mesa_sampler_default_clamp_to_edge;
       if (ctx->Driver.TexParameter) {
          static const GLfloat fparam_wrap[1] = {(GLfloat) GL_CLAMP_TO_EDGE};
          static const GLfloat fparam_filter[1] = {(GLfloat) GL_LINEAR};
@@ -216,6 +198,7 @@ _mesa_delete_texture_object(struct gl_context *ctx,
    }
 
    _mesa_reference_buffer_object(ctx, &texObj->BufferObject, NULL);
+   _mesa_reference_sampler_object(ctx, &texObj->Sampler, NULL);
 
    /* destroy the mutex -- it may have allocated memory (eg on bsd) */
    _glthread_DESTROY_MUTEX(texObj->Mutex);
@@ -240,27 +223,10 @@ _mesa_copy_texture_object( struct gl_texture_object *dest,
    dest->Target = src->Target;
    dest->Name = src->Name;
    dest->Priority = src->Priority;
-   dest->Sampler.BorderColor.f[0] = src->Sampler.BorderColor.f[0];
-   dest->Sampler.BorderColor.f[1] = src->Sampler.BorderColor.f[1];
-   dest->Sampler.BorderColor.f[2] = src->Sampler.BorderColor.f[2];
-   dest->Sampler.BorderColor.f[3] = src->Sampler.BorderColor.f[3];
-   dest->Sampler.WrapS = src->Sampler.WrapS;
-   dest->Sampler.WrapT = src->Sampler.WrapT;
-   dest->Sampler.WrapR = src->Sampler.WrapR;
-   dest->Sampler.MinFilter = src->Sampler.MinFilter;
-   dest->Sampler.MagFilter = src->Sampler.MagFilter;
-   dest->Sampler.MinLod = src->Sampler.MinLod;
-   dest->Sampler.MaxLod = src->Sampler.MaxLod;
-   dest->Sampler.LodBias = src->Sampler.LodBias;
+   _mesa_copy_sampler_object(&dest->Sampler, src->Sampler);
+   dest->DepthMode = src->DepthMode;
    dest->BaseLevel = src->BaseLevel;
    dest->MaxLevel = src->MaxLevel;
-   dest->Sampler.MaxAnisotropy = src->Sampler.MaxAnisotropy;
-   dest->Sampler.CompareMode = src->Sampler.CompareMode;
-   dest->Sampler.CompareFunc = src->Sampler.CompareFunc;
-   dest->Sampler.CompareFailValue = src->Sampler.CompareFailValue;
-   dest->Sampler.CubeMapSeamless = src->Sampler.CubeMapSeamless;
-   dest->DepthMode = src->DepthMode;
-   dest->Sampler.sRGBDecode = src->Sampler.sRGBDecode;
    dest->_MaxLevel = src->_MaxLevel;
    dest->_MaxLambda = src->_MaxLambda;
    dest->GenerateMipmap = src->GenerateMipmap;
@@ -782,8 +748,7 @@ _mesa_get_fallback_texture(struct gl_context *ctx, gl_texture_index tex)
          return NULL;
 
       assert(texObj->RefCount == 1);
-      texObj->Sampler.MinFilter = GL_NEAREST;
-      texObj->Sampler.MagFilter = GL_NEAREST;
+      texObj->Sampler = _mesa_sampler_default_nearest;
 
       texFormat = ctx->Driver.ChooseTextureFormat(ctx, GL_RGBA, GL_RGBA,
                                                   GL_UNSIGNED_BYTE);
diff --git a/src/mesa/main/texparam.c b/src/mesa/main/texparam.c
index a7625e4e31..3fa6cc5d07 100644
--- a/src/mesa/main/texparam.c
+++ b/src/mesa/main/texparam.c
@@ -236,13 +236,14 @@ set_tex_parameteri(struct gl_context *ctx,
 {
    switch (pname) {
    case GL_TEXTURE_MIN_FILTER:
-      if (texObj->Sampler.MinFilter == params[0])
+      if (texObj->Sampler->MinFilter == params[0])
          return GL_FALSE;
       switch (params[0]) {
       case GL_NEAREST:
       case GL_LINEAR:
          flush(ctx);
-         texObj->Sampler.MinFilter = params[0];
+         texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+         texObj->Sampler->MinFilter = params[0];
          return GL_TRUE;
       case GL_NEAREST_MIPMAP_NEAREST:
       case GL_LINEAR_MIPMAP_NEAREST:
@@ -251,7 +252,8 @@ set_tex_parameteri(struct gl_context *ctx,
          if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
              texObj->Target != GL_TEXTURE_EXTERNAL_OES) {
             flush(ctx);
-            texObj->Sampler.MinFilter = params[0];
+            texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+            texObj->Sampler->MinFilter = params[0];
             return GL_TRUE;
          }
          /* fall-through */
@@ -261,13 +263,14 @@ set_tex_parameteri(struct gl_context *ctx,
       return GL_FALSE;
 
    case GL_TEXTURE_MAG_FILTER:
-      if (texObj->Sampler.MagFilter == params[0])
+      if (texObj->Sampler->MagFilter == params[0])
          return GL_FALSE;
       switch (params[0]) {
       case GL_NEAREST:
       case GL_LINEAR:
          flush(ctx); /* does not effect completeness */
-         texObj->Sampler.MagFilter = params[0];
+         texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+         texObj->Sampler->MagFilter = params[0];
          return GL_TRUE;
       default:
          goto invalid_param;
@@ -275,31 +278,34 @@ set_tex_parameteri(struct gl_context *ctx,
       return GL_FALSE;
 
    case GL_TEXTURE_WRAP_S:
-      if (texObj->Sampler.WrapS == params[0])
+      if (texObj->Sampler->WrapS == params[0])
          return GL_FALSE;
       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
          flush(ctx);
-         texObj->Sampler.WrapS = params[0];
+         texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+         texObj->Sampler->WrapS = params[0];
          return GL_TRUE;
       }
       return GL_FALSE;
 
    case GL_TEXTURE_WRAP_T:
-      if (texObj->Sampler.WrapT == params[0])
+      if (texObj->Sampler->WrapT == params[0])
          return GL_FALSE;
       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
          flush(ctx);
-         texObj->Sampler.WrapT = params[0];
+         texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+         texObj->Sampler->WrapT = params[0];
          return GL_TRUE;
       }
       return GL_FALSE;
 
    case GL_TEXTURE_WRAP_R:
-      if (texObj->Sampler.WrapR == params[0])
+      if (texObj->Sampler->WrapR == params[0])
          return GL_FALSE;
       if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
          flush(ctx);
-         texObj->Sampler.WrapR = params[0];
+         texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+         texObj->Sampler->WrapR = params[0];
          return GL_TRUE;
       }
       return GL_FALSE;
@@ -341,12 +347,13 @@ set_tex_parameteri(struct gl_context *ctx,
 
    case GL_TEXTURE_COMPARE_MODE_ARB:
       if (ctx->Extensions.ARB_shadow) {
-         if (texObj->Sampler.CompareMode == params[0])
+         if (texObj->Sampler->CompareMode == params[0])
             return GL_FALSE;
          if (params[0] == GL_NONE ||
              params[0] == GL_COMPARE_R_TO_TEXTURE_ARB) {
             flush(ctx);
-            texObj->Sampler.CompareMode = params[0];
+            texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+            texObj->Sampler->CompareMode = params[0];
             return GL_TRUE;
          }
          goto invalid_param;
@@ -355,13 +362,14 @@ set_tex_parameteri(struct gl_context *ctx,
 
    case GL_TEXTURE_COMPARE_FUNC_ARB:
       if (ctx->Extensions.ARB_shadow) {
-         if (texObj->Sampler.CompareFunc == params[0])
+         if (texObj->Sampler->CompareFunc == params[0])
             return GL_FALSE;
          switch (params[0]) {
          case GL_LEQUAL:
          case GL_GEQUAL:
             flush(ctx);
-            texObj->Sampler.CompareFunc = params[0];
+            texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+            texObj->Sampler->CompareFunc = params[0];
             return GL_TRUE;
          case GL_EQUAL:
          case GL_NOTEQUAL:
@@ -371,7 +379,8 @@ set_tex_parameteri(struct gl_context *ctx,
          case GL_NEVER:
             if (ctx->Extensions.EXT_shadow_funcs) {
                flush(ctx);
-               texObj->Sampler.CompareFunc = params[0];
+               texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+               texObj->Sampler->CompareFunc = params[0];
                return GL_TRUE;
             }
             /* fall-through */
@@ -451,9 +460,10 @@ set_tex_parameteri(struct gl_context *ctx,
       if (ctx->Extensions.EXT_texture_sRGB_decode) {
 	 GLenum decode = params[0];
 	 if (decode == GL_DECODE_EXT || decode == GL_SKIP_DECODE_EXT) {
-	    if (texObj->Sampler.sRGBDecode != decode) {
+	    if (texObj->Sampler->sRGBDecode != decode) {
 	       flush(ctx);
-	       texObj->Sampler.sRGBDecode = decode;
+	       texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+	       texObj->Sampler->sRGBDecode = decode;
 	    }
 	    return GL_TRUE;
 	 }
@@ -466,9 +476,10 @@ set_tex_parameteri(struct gl_context *ctx,
          if (param != GL_TRUE && param != GL_FALSE) {
             goto invalid_param;
          }
-         if (param != texObj->Sampler.CubeMapSeamless) {
+         if (param != texObj->Sampler->CubeMapSeamless) {
             flush(ctx);
-            texObj->Sampler.CubeMapSeamless = param;
+            texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+            texObj->Sampler->CubeMapSeamless = param;
          }
          return GL_TRUE;
       }
@@ -501,17 +512,19 @@ set_tex_parameterf(struct gl_context *ctx,
 {
    switch (pname) {
    case GL_TEXTURE_MIN_LOD:
-      if (texObj->Sampler.MinLod == params[0])
+      if (texObj->Sampler->MinLod == params[0])
          return GL_FALSE;
       flush(ctx);
-      texObj->Sampler.MinLod = params[0];
+      texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+      texObj->Sampler->MinLod = params[0];
       return GL_TRUE;
 
    case GL_TEXTURE_MAX_LOD:
-      if (texObj->Sampler.MaxLod == params[0])
+      if (texObj->Sampler->MaxLod == params[0])
          return GL_FALSE;
       flush(ctx);
-      texObj->Sampler.MaxLod = params[0];
+      texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+      texObj->Sampler->MaxLod = params[0];
       return GL_TRUE;
 
    case GL_TEXTURE_PRIORITY:
@@ -521,7 +534,7 @@ set_tex_parameterf(struct gl_context *ctx,
 
    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-         if (texObj->Sampler.MaxAnisotropy == params[0])
+         if (texObj->Sampler->MaxAnisotropy == params[0])
             return GL_FALSE;
          if (params[0] < 1.0) {
             _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
@@ -529,7 +542,8 @@ set_tex_parameterf(struct gl_context *ctx,
          }
          flush(ctx);
          /* clamp to max, that's what NVIDIA does */
-         texObj->Sampler.MaxAnisotropy = MIN2(params[0],
+         texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+         texObj->Sampler->MaxAnisotropy = MIN2(params[0],
                                       ctx->Const.MaxTextureMaxAnisotropy);
          return GL_TRUE;
       }
@@ -543,9 +557,10 @@ set_tex_parameterf(struct gl_context *ctx,
 
    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
       if (ctx->Extensions.ARB_shadow_ambient) {
-         if (texObj->Sampler.CompareFailValue != params[0]) {
+         if (texObj->Sampler->CompareFailValue != params[0]) {
             flush(ctx);
-            texObj->Sampler.CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
+            texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+            texObj->Sampler->CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
             return GL_TRUE;
          }
       }
@@ -557,9 +572,10 @@ set_tex_parameterf(struct gl_context *ctx,
 
    case GL_TEXTURE_LOD_BIAS:
       /* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias */
-      if (texObj->Sampler.LodBias != params[0]) {
+      if (texObj->Sampler->LodBias != params[0]) {
 	 flush(ctx);
-	 texObj->Sampler.LodBias = params[0];
+	 texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+	 texObj->Sampler->LodBias = params[0];
 	 return GL_TRUE;
       }
       break;
@@ -567,16 +583,17 @@ set_tex_parameterf(struct gl_context *ctx,
    case GL_TEXTURE_BORDER_COLOR:
       flush(ctx);
       /* ARB_texture_float disables clamping */
+      texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
       if (ctx->Extensions.ARB_texture_float) {
-         texObj->Sampler.BorderColor.f[RCOMP] = params[0];
-         texObj->Sampler.BorderColor.f[GCOMP] = params[1];
-         texObj->Sampler.BorderColor.f[BCOMP] = params[2];
-         texObj->Sampler.BorderColor.f[ACOMP] = params[3];
+         texObj->Sampler->BorderColor.f[RCOMP] = params[0];
+         texObj->Sampler->BorderColor.f[GCOMP] = params[1];
+         texObj->Sampler->BorderColor.f[BCOMP] = params[2];
+         texObj->Sampler->BorderColor.f[ACOMP] = params[3];
       } else {
-         texObj->Sampler.BorderColor.f[RCOMP] = CLAMP(params[0], 0.0F, 1.0F);
-         texObj->Sampler.BorderColor.f[GCOMP] = CLAMP(params[1], 0.0F, 1.0F);
-         texObj->Sampler.BorderColor.f[BCOMP] = CLAMP(params[2], 0.0F, 1.0F);
-         texObj->Sampler.BorderColor.f[ACOMP] = CLAMP(params[3], 0.0F, 1.0F);
+         texObj->Sampler->BorderColor.f[RCOMP] = CLAMP(params[0], 0.0F, 1.0F);
+         texObj->Sampler->BorderColor.f[GCOMP] = CLAMP(params[1], 0.0F, 1.0F);
+         texObj->Sampler->BorderColor.f[BCOMP] = CLAMP(params[2], 0.0F, 1.0F);
+         texObj->Sampler->BorderColor.f[ACOMP] = CLAMP(params[3], 0.0F, 1.0F);
       }
       return GL_TRUE;
 
@@ -845,7 +862,8 @@ _mesa_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
    case GL_TEXTURE_BORDER_COLOR:
       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
       /* set the integer-valued border color */
-      COPY_4V(texObj->Sampler.BorderColor.i, params);
+      texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+      COPY_4V(texObj->Sampler->BorderColor.i, params);
       break;
    default:
       _mesa_TexParameteriv(target, pname, params);
@@ -875,7 +893,8 @@ _mesa_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
    case GL_TEXTURE_BORDER_COLOR:
       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
       /* set the unsigned integer-valued border color */
-      COPY_4V(texObj->Sampler.BorderColor.ui, params);
+      texObj->Sampler = _mesa_mutable_sampler_object(texObj->Sampler);
+      COPY_4V(texObj->Sampler->BorderColor.ui, params);
       break;
    default:
       _mesa_TexParameteriv(target, pname, (const GLint *) params);
@@ -1083,34 +1102,34 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
    _mesa_lock_texture(ctx, obj);
    switch (pname) {
       case GL_TEXTURE_MAG_FILTER:
-	 *params = ENUM_TO_FLOAT(obj->Sampler.MagFilter);
+	 *params = ENUM_TO_FLOAT(obj->Sampler->MagFilter);
 	 break;
       case GL_TEXTURE_MIN_FILTER:
-         *params = ENUM_TO_FLOAT(obj->Sampler.MinFilter);
+         *params = ENUM_TO_FLOAT(obj->Sampler->MinFilter);
          break;
       case GL_TEXTURE_WRAP_S:
-         *params = ENUM_TO_FLOAT(obj->Sampler.WrapS);
+         *params = ENUM_TO_FLOAT(obj->Sampler->WrapS);
          break;
       case GL_TEXTURE_WRAP_T:
-         *params = ENUM_TO_FLOAT(obj->Sampler.WrapT);
+         *params = ENUM_TO_FLOAT(obj->Sampler->WrapT);
          break;
       case GL_TEXTURE_WRAP_R:
-         *params = ENUM_TO_FLOAT(obj->Sampler.WrapR);
+         *params = ENUM_TO_FLOAT(obj->Sampler->WrapR);
          break;
       case GL_TEXTURE_BORDER_COLOR:
          if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
             _mesa_update_state_locked(ctx);
          if (ctx->Color._ClampFragmentColor) {
-            params[0] = CLAMP(obj->Sampler.BorderColor.f[0], 0.0F, 1.0F);
-            params[1] = CLAMP(obj->Sampler.BorderColor.f[1], 0.0F, 1.0F);
-            params[2] = CLAMP(obj->Sampler.BorderColor.f[2], 0.0F, 1.0F);
-            params[3] = CLAMP(obj->Sampler.BorderColor.f[3], 0.0F, 1.0F);
+            params[0] = CLAMP(obj->Sampler->BorderColor.f[0], 0.0F, 1.0F);
+            params[1] = CLAMP(obj->Sampler->BorderColor.f[1], 0.0F, 1.0F);
+            params[2] = CLAMP(obj->Sampler->BorderColor.f[2], 0.0F, 1.0F);
+            params[3] = CLAMP(obj->Sampler->BorderColor.f[3], 0.0F, 1.0F);
          }
          else {
-            params[0] = obj->Sampler.BorderColor.f[0];
-            params[1] = obj->Sampler.BorderColor.f[1];
-            params[2] = obj->Sampler.BorderColor.f[2];
-            params[3] = obj->Sampler.BorderColor.f[3];
+            params[0] = obj->Sampler->BorderColor.f[0];
+            params[1] = obj->Sampler->BorderColor.f[1];
+            params[2] = obj->Sampler->BorderColor.f[2];
+            params[3] = obj->Sampler->BorderColor.f[3];
          }
          break;
       case GL_TEXTURE_RESIDENT:
@@ -1120,10 +1139,10 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
          *params = obj->Priority;
          break;
       case GL_TEXTURE_MIN_LOD:
-         *params = obj->Sampler.MinLod;
+         *params = obj->Sampler->MinLod;
          break;
       case GL_TEXTURE_MAX_LOD:
-         *params = obj->Sampler.MaxLod;
+         *params = obj->Sampler->MaxLod;
          break;
       case GL_TEXTURE_BASE_LEVEL:
          *params = (GLfloat) obj->BaseLevel;
@@ -1134,12 +1153,12 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
          if (!ctx->Extensions.EXT_texture_filter_anisotropic)
             goto invalid_pname;
-         *params = obj->Sampler.MaxAnisotropy;
+         *params = obj->Sampler->MaxAnisotropy;
          break;
       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
          if (!ctx->Extensions.ARB_shadow_ambient)
             goto invalid_pname;
-         *params = obj->Sampler.CompareFailValue;
+         *params = obj->Sampler->CompareFailValue;
          break;
       case GL_GENERATE_MIPMAP_SGIS:
 	 *params = (GLfloat) obj->GenerateMipmap;
@@ -1147,12 +1166,12 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
       case GL_TEXTURE_COMPARE_MODE_ARB:
          if (!ctx->Extensions.ARB_shadow)
             goto invalid_pname;
-         *params = (GLfloat) obj->Sampler.CompareMode;
+         *params = (GLfloat) obj->Sampler->CompareMode;
          break;
       case GL_TEXTURE_COMPARE_FUNC_ARB:
          if (!ctx->Extensions.ARB_shadow)
             goto invalid_pname;
-         *params = (GLfloat) obj->Sampler.CompareFunc;
+         *params = (GLfloat) obj->Sampler->CompareFunc;
          break;
       case GL_DEPTH_TEXTURE_MODE_ARB:
          if (!ctx->Extensions.ARB_depth_texture)
@@ -1160,7 +1179,7 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
          *params = (GLfloat) obj->DepthMode;
          break;
       case GL_TEXTURE_LOD_BIAS:
-         *params = obj->Sampler.LodBias;
+         *params = obj->Sampler->LodBias;
          break;
 #if FEATURE_OES_draw_texture
       case GL_TEXTURE_CROP_RECT_OES:
@@ -1195,7 +1214,7 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
          if (!ctx->Extensions.AMD_seamless_cubemap_per_texture)
             goto invalid_pname;
-         *params = (GLfloat) obj->Sampler.CubeMapSeamless;
+         *params = (GLfloat) obj->Sampler->CubeMapSeamless;
          break;
 
       case GL_TEXTURE_IMMUTABLE_FORMAT:
@@ -1232,27 +1251,27 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
    _mesa_lock_texture(ctx, obj);
    switch (pname) {
       case GL_TEXTURE_MAG_FILTER:
-         *params = (GLint) obj->Sampler.MagFilter;
+         *params = (GLint) obj->Sampler->MagFilter;
          break;
       case GL_TEXTURE_MIN_FILTER:
-         *params = (GLint) obj->Sampler.MinFilter;
+         *params = (GLint) obj->Sampler->MinFilter;
          break;
       case GL_TEXTURE_WRAP_S:
-         *params = (GLint) obj->Sampler.WrapS;
+         *params = (GLint) obj->Sampler->WrapS;
          break;
       case GL_TEXTURE_WRAP_T:
-         *params = (GLint) obj->Sampler.WrapT;
+         *params = (GLint) obj->Sampler->WrapT;
          break;
       case GL_TEXTURE_WRAP_R:
-         *params = (GLint) obj->Sampler.WrapR;
+         *params = (GLint) obj->Sampler->WrapR;
          break;
       case GL_TEXTURE_BORDER_COLOR:
          {
             GLfloat b[4];
-            b[0] = CLAMP(obj->Sampler.BorderColor.f[0], 0.0F, 1.0F);
-            b[1] = CLAMP(obj->Sampler.BorderColor.f[1], 0.0F, 1.0F);
-            b[2] = CLAMP(obj->Sampler.BorderColor.f[2], 0.0F, 1.0F);
-            b[3] = CLAMP(obj->Sampler.BorderColor.f[3], 0.0F, 1.0F);
+            b[0] = CLAMP(obj->Sampler->BorderColor.f[0], 0.0F, 1.0F);
+            b[1] = CLAMP(obj->Sampler->BorderColor.f[1], 0.0F, 1.0F);
+            b[2] = CLAMP(obj->Sampler->BorderColor.f[2], 0.0F, 1.0F);
+            b[3] = CLAMP(obj->Sampler->BorderColor.f[3], 0.0F, 1.0F);
             params[0] = FLOAT_TO_INT(b[0]);
             params[1] = FLOAT_TO_INT(b[1]);
             params[2] = FLOAT_TO_INT(b[2]);
@@ -1266,10 +1285,10 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
          *params = FLOAT_TO_INT(obj->Priority);
          break;
       case GL_TEXTURE_MIN_LOD:
-         *params = (GLint) obj->Sampler.MinLod;
+         *params = (GLint) obj->Sampler->MinLod;
          break;
       case GL_TEXTURE_MAX_LOD:
-         *params = (GLint) obj->Sampler.MaxLod;
+         *params = (GLint) obj->Sampler->MaxLod;
          break;
       case GL_TEXTURE_BASE_LEVEL:
          *params = obj->BaseLevel;
@@ -1280,12 +1299,12 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
          if (!ctx->Extensions.EXT_texture_filter_anisotropic)
             goto invalid_pname;
-         *params = (GLint) obj->Sampler.MaxAnisotropy;
+         *params = (GLint) obj->Sampler->MaxAnisotropy;
          break;
       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
          if (!ctx->Extensions.ARB_shadow_ambient)
             goto invalid_pname;
-         *params = (GLint) FLOAT_TO_INT(obj->Sampler.CompareFailValue);
+         *params = (GLint) FLOAT_TO_INT(obj->Sampler->CompareFailValue);
          break;
       case GL_GENERATE_MIPMAP_SGIS:
 	 *params = (GLint) obj->GenerateMipmap;
@@ -1293,12 +1312,12 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
       case GL_TEXTURE_COMPARE_MODE_ARB:
          if (!ctx->Extensions.ARB_shadow)
             goto invalid_pname;
-         *params = (GLint) obj->Sampler.CompareMode;
+         *params = (GLint) obj->Sampler->CompareMode;
          break;
       case GL_TEXTURE_COMPARE_FUNC_ARB:
          if (!ctx->Extensions.ARB_shadow)
             goto invalid_pname;
-         *params = (GLint) obj->Sampler.CompareFunc;
+         *params = (GLint) obj->Sampler->CompareFunc;
          break;
       case GL_DEPTH_TEXTURE_MODE_ARB:
          if (!ctx->Extensions.ARB_depth_texture)
@@ -1306,7 +1325,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
          *params = (GLint) obj->DepthMode;
          break;
       case GL_TEXTURE_LOD_BIAS:
-         *params = (GLint) obj->Sampler.LodBias;
+         *params = (GLint) obj->Sampler->LodBias;
          break;
 #if FEATURE_OES_draw_texture
       case GL_TEXTURE_CROP_RECT_OES:
@@ -1334,7 +1353,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
          if (!ctx->Extensions.AMD_seamless_cubemap_per_texture)
             goto invalid_pname;
-         *params = (GLint) obj->Sampler.CubeMapSeamless;
+         *params = (GLint) obj->Sampler->CubeMapSeamless;
          break;
 
       case GL_TEXTURE_IMMUTABLE_FORMAT:
@@ -1377,7 +1396,7 @@ _mesa_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
    
    switch (pname) {
    case GL_TEXTURE_BORDER_COLOR:
-      COPY_4V(params, texObj->Sampler.BorderColor.i);
+      COPY_4V(params, texObj->Sampler->BorderColor.i);
       break;
    default:
       _mesa_GetTexParameteriv(target, pname, params);
@@ -1399,7 +1418,7 @@ _mesa_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
    
    switch (pname) {
    case GL_TEXTURE_BORDER_COLOR:
-      COPY_4V(params, texObj->Sampler.BorderColor.i);
+      COPY_4V(params, texObj->Sampler->BorderColor.i);
       break;
    default:
       {
diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c
index 7e944120fa..9d30b2a8e7 100644
--- a/src/mesa/main/texstate.c
+++ b/src/mesa/main/texstate.c
@@ -585,7 +585,7 @@ update_texture_state( struct gl_context *ctx )
          if (enabledTargets & (1 << texIndex)) {
             struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];
             struct gl_sampler_object *sampler = texUnit->Sampler ?
-               texUnit->Sampler : &texObj->Sampler;
+               texUnit->Sampler : texObj->Sampler;
 
             if (!_mesa_is_texture_complete(texObj, sampler)) {
                _mesa_test_texobj_completeness(ctx, texObj);
@@ -597,7 +597,6 @@ update_texture_state( struct gl_context *ctx )
             }
          }
       }
-
       if (!texUnit->_ReallyEnabled) {
          if (fprog) {
             /* If we get here it means the shader is expecting a texture
diff --git a/src/mesa/state_tracker/st_atom_texture.c b/src/mesa/state_tracker/st_atom_texture.c
index fefa598609..0a1e350d0f 100644
--- a/src/mesa/state_tracker/st_atom_texture.c
+++ b/src/mesa/state_tracker/st_atom_texture.c
@@ -203,7 +203,7 @@ update_single_texture(struct st_context *st,
 
    if (!texObj) {
       texObj = _mesa_get_fallback_texture(ctx, TEXTURE_2D_INDEX);
-      samp = &texObj->Sampler;
+      samp = texObj->Sampler;
    }
    stObj = st_texture_object(texObj);
 
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index a9a330413a..e29945cf0c 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -360,8 +360,8 @@ guess_and_alloc_texture(struct st_context *st,
     * to re-allocating a texture buffer with space for more (or fewer)
     * mipmap levels later.
     */
-   if ((stObj->base.Sampler.MinFilter == GL_NEAREST ||
-        stObj->base.Sampler.MinFilter == GL_LINEAR ||
+   if ((stObj->base.Sampler->MinFilter == GL_NEAREST ||
+        stObj->base.Sampler->MinFilter == GL_LINEAR ||
         stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
         stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) &&
        !stObj->base.GenerateMipmap &&
@@ -1160,15 +1160,15 @@ st_finalize_texture(struct gl_context *ctx,
    enum pipe_format firstImageFormat;
    GLuint ptWidth, ptHeight, ptDepth, ptLayers;
 
-   if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) {
+   if (_mesa_is_texture_complete(tObj, tObj->Sampler)) {
       /* The texture is complete and we know exactly how many mipmap levels
        * are present/needed.  This is conditional because we may be called
        * from the st_generate_mipmap() function when the texture object is
        * incomplete.  In that case, we'll have set stObj->lastLevel before
        * we get here.
        */
-      if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
-          stObj->base.Sampler.MinFilter == GL_NEAREST)
+      if (stObj->base.Sampler->MinFilter == GL_LINEAR ||
+          stObj->base.Sampler->MinFilter == GL_NEAREST)
          stObj->lastLevel = stObj->base.BaseLevel;
       else
          stObj->lastLevel = stObj->base._MaxLevel;