X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_texfilter.c;h=e17a7aa0b352301afd758a81dc0201e763d5f498;hb=e26e9f77e761775592204edb53b6028eef0c1f11;hp=efe6f234740250a5653254e93606dea3836509cf;hpb=d504a7669d7b71229c2d15503a095d71ee1584e6;p=mesa.git diff --git a/src/mesa/swrast/s_texfilter.c b/src/mesa/swrast/s_texfilter.c index efe6f234740..e17a7aa0b35 100644 --- a/src/mesa/swrast/s_texfilter.c +++ b/src/mesa/swrast/s_texfilter.c @@ -27,7 +27,6 @@ #include "main/context.h" #include "main/colormac.h" #include "main/imports.h" -#include "main/texformat.h" #include "s_context.h" #include "s_texfilter.h" @@ -135,8 +134,11 @@ lerp_rgba_3d(GLfloat result[4], GLfloat a, GLfloat b, GLfloat c, /** - * If A is a signed integer, A % B doesn't give the right value for A < 0 - * (in terms of texture repeat). Just casting to unsigned fixes that. + * Used for GL_REPEAT wrap mode. Using A % B doesn't produce the + * right results for A<0. Casting to A to be unsigned only works if B + * is a power of two. Adding a bias to A (which is a multiple of B) + * avoids the problems with A < 0 (for reasonable A) without using a + * conditional. */ #define REMAINDER(A, B) (((A) + (B) * 1024) % (B)) @@ -445,7 +447,7 @@ clamp_rect_coord_linear(GLenum wrapMode, GLfloat coord, GLint max, switch (wrapMode) { case GL_CLAMP: /* Not exactly what the spec says, but it matches NVIDIA output */ - fcol = CLAMP(coord - 0.5F, 0.0, max-1); + fcol = CLAMP(coord - 0.5F, 0.0F, max - 1); i0 = IFLOOR(fcol); i1 = i0 + 1; break; @@ -474,45 +476,58 @@ clamp_rect_coord_linear(GLenum wrapMode, GLfloat coord, GLint max, } +/** + * Compute slice/image to use for 1D or 2D array texture. + */ +static INLINE GLint +tex_array_slice(GLfloat coord, GLsizei size) +{ + GLint slice = IFLOOR(coord + 0.5f); + slice = CLAMP(slice, 0, size - 1); + return slice; +} + + /** * Compute nearest integer texcoords for given texobj and coordinate. + * NOTE: only used for depth texture sampling. */ static INLINE void nearest_texcoord(const struct gl_texture_object *texObj, + GLuint level, const GLfloat texcoord[4], GLint *i, GLint *j, GLint *k) { - const GLint baseLevel = texObj->BaseLevel; - const struct gl_texture_image *img = texObj->Image[0][baseLevel]; + const struct gl_texture_image *img = texObj->Image[0][level]; const GLint width = img->Width; const GLint height = img->Height; const GLint depth = img->Depth; switch (texObj->Target) { case GL_TEXTURE_RECTANGLE_ARB: - *i = clamp_rect_coord_nearest(texObj->WrapS, texcoord[0], width); - *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height); + *i = clamp_rect_coord_nearest(texObj->Sampler.WrapS, texcoord[0], width); + *j = clamp_rect_coord_nearest(texObj->Sampler.WrapT, texcoord[1], height); *k = 0; break; case GL_TEXTURE_1D: - *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]); + *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]); *j = 0; *k = 0; break; case GL_TEXTURE_2D: - *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]); - *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]); + *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]); + *j = nearest_texel_location(texObj->Sampler.WrapT, img, height, texcoord[1]); *k = 0; break; case GL_TEXTURE_1D_ARRAY_EXT: - *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]); - *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height); + *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]); + *j = tex_array_slice(texcoord[1], height); *k = 0; break; case GL_TEXTURE_2D_ARRAY_EXT: - *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]); - *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]); - *k = clamp_rect_coord_nearest(texObj->WrapR, texcoord[2], depth); + *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]); + *j = nearest_texel_location(texObj->Sampler.WrapT, img, height, texcoord[1]); + *k = tex_array_slice(texcoord[2], depth); break; default: *i = *j = *k = 0; @@ -522,51 +537,52 @@ nearest_texcoord(const struct gl_texture_object *texObj, /** * Compute linear integer texcoords for given texobj and coordinate. + * NOTE: only used for depth texture sampling. */ static INLINE void linear_texcoord(const struct gl_texture_object *texObj, + GLuint level, const GLfloat texcoord[4], GLint *i0, GLint *i1, GLint *j0, GLint *j1, GLint *slice, GLfloat *wi, GLfloat *wj) { - const GLint baseLevel = texObj->BaseLevel; - const struct gl_texture_image *img = texObj->Image[0][baseLevel]; + const struct gl_texture_image *img = texObj->Image[0][level]; const GLint width = img->Width; const GLint height = img->Height; const GLint depth = img->Depth; switch (texObj->Target) { case GL_TEXTURE_RECTANGLE_ARB: - clamp_rect_coord_linear(texObj->WrapS, texcoord[0], + clamp_rect_coord_linear(texObj->Sampler.WrapS, texcoord[0], width, i0, i1, wi); - clamp_rect_coord_linear(texObj->WrapT, texcoord[1], + clamp_rect_coord_linear(texObj->Sampler.WrapT, texcoord[1], height, j0, j1, wj); *slice = 0; break; case GL_TEXTURE_1D: case GL_TEXTURE_2D: - linear_texel_locations(texObj->WrapS, img, width, + linear_texel_locations(texObj->Sampler.WrapS, img, width, texcoord[0], i0, i1, wi); - linear_texel_locations(texObj->WrapT, img, height, + linear_texel_locations(texObj->Sampler.WrapT, img, height, texcoord[1], j0, j1, wj); *slice = 0; break; case GL_TEXTURE_1D_ARRAY_EXT: - linear_texel_locations(texObj->WrapS, img, width, + linear_texel_locations(texObj->Sampler.WrapS, img, width, texcoord[0], i0, i1, wi); - *j0 = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height); + *j0 = tex_array_slice(texcoord[1], height); *j1 = *j0; *slice = 0; break; case GL_TEXTURE_2D_ARRAY_EXT: - linear_texel_locations(texObj->WrapS, img, width, + linear_texel_locations(texObj->Sampler.WrapS, img, width, texcoord[0], i0, i1, wi); - linear_texel_locations(texObj->WrapT, img, height, + linear_texel_locations(texObj->Sampler.WrapT, img, height, texcoord[1], j0, j1, wj); - *slice = clamp_rect_coord_nearest(texObj->WrapR, texcoord[2], depth); + *slice = tex_array_slice(texcoord[2], depth); break; default: @@ -640,12 +656,12 @@ compute_min_mag_ranges(const struct gl_texture_object *tObj, GLfloat minMagThresh; /* we shouldn't be here if minfilter == magfilter */ - ASSERT(tObj->MinFilter != tObj->MagFilter); + ASSERT(tObj->Sampler.MinFilter != tObj->Sampler.MagFilter); /* This bit comes from the OpenGL spec: */ - if (tObj->MagFilter == GL_LINEAR - && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST || - tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) { + if (tObj->Sampler.MagFilter == GL_LINEAR + && (tObj->Sampler.MinFilter == GL_NEAREST_MIPMAP_NEAREST || + tObj->Sampler.MinFilter == GL_NEAREST_MIPMAP_LINEAR)) { minMagThresh = 0.5F; } else { @@ -745,30 +761,30 @@ get_border_color(const struct gl_texture_object *tObj, const struct gl_texture_image *img, GLfloat rgba[4]) { - switch (img->TexFormat->BaseFormat) { + switch (img->_BaseFormat) { case GL_RGB: - rgba[0] = tObj->BorderColor[0]; - rgba[1] = tObj->BorderColor[1]; - rgba[2] = tObj->BorderColor[2]; + rgba[0] = tObj->Sampler.BorderColor.f[0]; + rgba[1] = tObj->Sampler.BorderColor.f[1]; + rgba[2] = tObj->Sampler.BorderColor.f[2]; rgba[3] = 1.0F; break; case GL_ALPHA: rgba[0] = rgba[1] = rgba[2] = 0.0; - rgba[3] = tObj->BorderColor[3]; + rgba[3] = tObj->Sampler.BorderColor.f[3]; break; case GL_LUMINANCE: - rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor[0]; + rgba[0] = rgba[1] = rgba[2] = tObj->Sampler.BorderColor.f[0]; rgba[3] = 1.0; break; case GL_LUMINANCE_ALPHA: - rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor[0]; - rgba[3] = tObj->BorderColor[3]; + rgba[0] = rgba[1] = rgba[2] = tObj->Sampler.BorderColor.f[0]; + rgba[3] = tObj->Sampler.BorderColor.f[3]; break; case GL_INTENSITY: - rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->BorderColor[0]; + rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->Sampler.BorderColor.f[0]; break; default: - COPY_4V(rgba, tObj->BorderColor); + COPY_4V(rgba, tObj->Sampler.BorderColor.f); } } @@ -781,14 +797,14 @@ get_border_color(const struct gl_texture_object *tObj, * Return the texture sample for coordinate (s) using GL_NEAREST filter. */ static INLINE void -sample_1d_nearest(GLcontext *ctx, +sample_1d_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], GLfloat rgba[4]) { const GLint width = img->Width2; /* without border, power of two */ GLint i; - i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]); + i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]); /* skip over the border, if any */ i += img->Border; if (i < 0 || i >= (GLint) img->Width) { @@ -805,7 +821,7 @@ sample_1d_nearest(GLcontext *ctx, * Return the texture sample for coordinate (s) using GL_LINEAR filter. */ static INLINE void -sample_1d_linear(GLcontext *ctx, +sample_1d_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], GLfloat rgba[4]) @@ -816,7 +832,7 @@ sample_1d_linear(GLcontext *ctx, GLfloat a; GLfloat t0[4], t1[4]; /* texels */ - linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a); + linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a); if (img->Border) { i0 += img->Border; @@ -846,7 +862,7 @@ sample_1d_linear(GLcontext *ctx, static void -sample_1d_nearest_mipmap_nearest(GLcontext *ctx, +sample_1d_nearest_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -861,7 +877,7 @@ sample_1d_nearest_mipmap_nearest(GLcontext *ctx, static void -sample_1d_linear_mipmap_nearest(GLcontext *ctx, +sample_1d_linear_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -876,7 +892,7 @@ sample_1d_linear_mipmap_nearest(GLcontext *ctx, static void -sample_1d_nearest_mipmap_linear(GLcontext *ctx, +sample_1d_nearest_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -901,7 +917,7 @@ sample_1d_nearest_mipmap_linear(GLcontext *ctx, static void -sample_1d_linear_mipmap_linear(GLcontext *ctx, +sample_1d_linear_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -927,7 +943,7 @@ sample_1d_linear_mipmap_linear(GLcontext *ctx, /** Sample 1D texture, nearest filtering for both min/magnification */ static void -sample_nearest_1d( GLcontext *ctx, +sample_nearest_1d( struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4] ) @@ -943,7 +959,7 @@ sample_nearest_1d( GLcontext *ctx, /** Sample 1D texture, linear filtering for both min/magnification */ static void -sample_linear_1d( GLcontext *ctx, +sample_linear_1d( struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4] ) @@ -959,7 +975,7 @@ sample_linear_1d( GLcontext *ctx, /** Sample 1D texture, using lambda to choose between min/magnification */ static void -sample_lambda_1d( GLcontext *ctx, +sample_lambda_1d( struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4] ) @@ -975,7 +991,7 @@ sample_lambda_1d( GLcontext *ctx, if (minStart < minEnd) { /* do the minified texels */ const GLuint m = minEnd - minStart; - switch (tObj->MinFilter) { + switch (tObj->Sampler.MinFilter) { case GL_NEAREST: for (i = minStart; i < minEnd; i++) sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -1010,7 +1026,7 @@ sample_lambda_1d( GLcontext *ctx, if (magStart < magEnd) { /* do the magnified texels */ - switch (tObj->MagFilter) { + switch (tObj->Sampler.MagFilter) { case GL_NEAREST: for (i = magStart; i < magEnd; i++) sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -1038,7 +1054,7 @@ sample_lambda_1d( GLcontext *ctx, * Return the texture sample for coordinate (s,t) using GL_NEAREST filter. */ static INLINE void -sample_2d_nearest(GLcontext *ctx, +sample_2d_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -1049,8 +1065,8 @@ sample_2d_nearest(GLcontext *ctx, GLint i, j; (void) ctx; - i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]); - j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]); + i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]); + j = nearest_texel_location(tObj->Sampler.WrapT, img, height, texcoord[1]); /* skip over the border, if any */ i += img->Border; @@ -1071,7 +1087,7 @@ sample_2d_nearest(GLcontext *ctx, * New sampling code contributed by Lynn Quam . */ static INLINE void -sample_2d_linear(GLcontext *ctx, +sample_2d_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -1084,8 +1100,8 @@ sample_2d_linear(GLcontext *ctx, GLfloat a, b; GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */ - linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a); - linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b); + linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a); + linear_texel_locations(tObj->Sampler.WrapT, img, height, texcoord[1], &j0, &j1, &b); if (img->Border) { i0 += img->Border; @@ -1135,7 +1151,7 @@ sample_2d_linear(GLcontext *ctx, * We don't have to worry about the texture border. */ static INLINE void -sample_2d_linear_repeat(GLcontext *ctx, +sample_2d_linear_repeat(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -1149,10 +1165,10 @@ sample_2d_linear_repeat(GLcontext *ctx, (void) ctx; - ASSERT(tObj->WrapS == GL_REPEAT); - ASSERT(tObj->WrapT == GL_REPEAT); + ASSERT(tObj->Sampler.WrapS == GL_REPEAT); + ASSERT(tObj->Sampler.WrapT == GL_REPEAT); ASSERT(img->Border == 0); - ASSERT(img->TexFormat->BaseFormat != GL_COLOR_INDEX); + ASSERT(img->_BaseFormat != GL_COLOR_INDEX); ASSERT(img->_IsPowerOfTwo); linear_repeat_texel_location(width, texcoord[0], &i0, &i1, &wi); @@ -1168,7 +1184,7 @@ sample_2d_linear_repeat(GLcontext *ctx, static void -sample_2d_nearest_mipmap_nearest(GLcontext *ctx, +sample_2d_nearest_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1182,7 +1198,7 @@ sample_2d_nearest_mipmap_nearest(GLcontext *ctx, static void -sample_2d_linear_mipmap_nearest(GLcontext *ctx, +sample_2d_linear_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1197,7 +1213,7 @@ sample_2d_linear_mipmap_nearest(GLcontext *ctx, static void -sample_2d_nearest_mipmap_linear(GLcontext *ctx, +sample_2d_nearest_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1222,7 +1238,7 @@ sample_2d_nearest_mipmap_linear(GLcontext *ctx, static void -sample_2d_linear_mipmap_linear( GLcontext *ctx, +sample_2d_linear_mipmap_linear( struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4] ) @@ -1247,15 +1263,15 @@ sample_2d_linear_mipmap_linear( GLcontext *ctx, static void -sample_2d_linear_mipmap_linear_repeat(GLcontext *ctx, +sample_2d_linear_mipmap_linear_repeat(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) { GLuint i; ASSERT(lambda != NULL); - ASSERT(tObj->WrapS == GL_REPEAT); - ASSERT(tObj->WrapT == GL_REPEAT); + ASSERT(tObj->Sampler.WrapS == GL_REPEAT); + ASSERT(tObj->Sampler.WrapT == GL_REPEAT); for (i = 0; i < n; i++) { GLint level = linear_mipmap_level(tObj, lambda[i]); if (level >= tObj->_MaxLevel) { @@ -1277,7 +1293,7 @@ sample_2d_linear_mipmap_linear_repeat(GLcontext *ctx, /** Sample 2D texture, nearest filtering for both min/magnification */ static void -sample_nearest_2d(GLcontext *ctx, +sample_nearest_2d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1293,7 +1309,7 @@ sample_nearest_2d(GLcontext *ctx, /** Sample 2D texture, linear filtering for both min/magnification */ static void -sample_linear_2d(GLcontext *ctx, +sample_linear_2d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1301,8 +1317,8 @@ sample_linear_2d(GLcontext *ctx, GLuint i; struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel]; (void) lambda; - if (tObj->WrapS == GL_REPEAT && - tObj->WrapT == GL_REPEAT && + if (tObj->Sampler.WrapS == GL_REPEAT && + tObj->Sampler.WrapT == GL_REPEAT && image->_IsPowerOfTwo && image->Border == 0) { for (i = 0; i < n; i++) { @@ -1326,7 +1342,7 @@ sample_linear_2d(GLcontext *ctx, * Format = GL_RGB */ static void -opt_sample_rgb_2d(GLcontext *ctx, +opt_sample_rgb_2d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1340,20 +1356,21 @@ opt_sample_rgb_2d(GLcontext *ctx, GLuint k; (void) ctx; (void) lambda; - ASSERT(tObj->WrapS==GL_REPEAT); - ASSERT(tObj->WrapT==GL_REPEAT); + ASSERT(tObj->Sampler.WrapS==GL_REPEAT); + ASSERT(tObj->Sampler.WrapT==GL_REPEAT); ASSERT(img->Border==0); - ASSERT(img->TexFormat->MesaFormat==MESA_FORMAT_RGB); + ASSERT(img->TexFormat == MESA_FORMAT_RGB888); ASSERT(img->_IsPowerOfTwo); for (k=0; kData) + 3*pos; - rgba[k][RCOMP] = CHAN_TO_FLOAT(texel[0]); - rgba[k][GCOMP] = CHAN_TO_FLOAT(texel[1]); - rgba[k][BCOMP] = CHAN_TO_FLOAT(texel[2]); + GLubyte *texel = ((GLubyte *) img->Data) + 3*pos; + rgba[k][RCOMP] = UBYTE_TO_FLOAT(texel[2]); + rgba[k][GCOMP] = UBYTE_TO_FLOAT(texel[1]); + rgba[k][BCOMP] = UBYTE_TO_FLOAT(texel[0]); + rgba[k][ACOMP] = 1.0F; } } @@ -1367,7 +1384,7 @@ opt_sample_rgb_2d(GLcontext *ctx, * Format = GL_RGBA */ static void -opt_sample_rgba_2d(GLcontext *ctx, +opt_sample_rgba_2d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1381,28 +1398,28 @@ opt_sample_rgba_2d(GLcontext *ctx, GLuint i; (void) ctx; (void) lambda; - ASSERT(tObj->WrapS==GL_REPEAT); - ASSERT(tObj->WrapT==GL_REPEAT); + ASSERT(tObj->Sampler.WrapS==GL_REPEAT); + ASSERT(tObj->Sampler.WrapT==GL_REPEAT); ASSERT(img->Border==0); - ASSERT(img->TexFormat->MesaFormat==MESA_FORMAT_RGBA); + ASSERT(img->TexFormat == MESA_FORMAT_RGBA8888); ASSERT(img->_IsPowerOfTwo); for (i = 0; i < n; i++) { const GLint col = IFLOOR(texcoords[i][0] * width) & colMask; const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask; const GLint pos = (row << shift) | col; - const GLchan *texel = ((GLchan *) img->Data) + (pos << 2); /* pos*4 */ - rgba[i][RCOMP] = CHAN_TO_FLOAT(texel[0]); - rgba[i][GCOMP] = CHAN_TO_FLOAT(texel[1]); - rgba[i][BCOMP] = CHAN_TO_FLOAT(texel[2]); - rgba[i][ACOMP] = CHAN_TO_FLOAT(texel[3]); + const GLuint texel = *((GLuint *) img->Data + pos); + rgba[i][RCOMP] = UBYTE_TO_FLOAT( (texel >> 24) ); + rgba[i][GCOMP] = UBYTE_TO_FLOAT( (texel >> 16) & 0xff ); + rgba[i][BCOMP] = UBYTE_TO_FLOAT( (texel >> 8) & 0xff ); + rgba[i][ACOMP] = UBYTE_TO_FLOAT( (texel ) & 0xff ); } } /** Sample 2D texture, using lambda to choose between min/magnification */ static void -sample_lambda_2d(GLcontext *ctx, +sample_lambda_2d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1411,10 +1428,10 @@ sample_lambda_2d(GLcontext *ctx, GLuint minStart, minEnd; /* texels with minification */ GLuint magStart, magEnd; /* texels with magnification */ - const GLboolean repeatNoBorderPOT = (tObj->WrapS == GL_REPEAT) - && (tObj->WrapT == GL_REPEAT) + const GLboolean repeatNoBorderPOT = (tObj->Sampler.WrapS == GL_REPEAT) + && (tObj->Sampler.WrapT == GL_REPEAT) && (tImg->Border == 0 && (tImg->Width == tImg->RowStride)) - && (tImg->TexFormat->BaseFormat != GL_COLOR_INDEX) + && (tImg->_BaseFormat != GL_COLOR_INDEX) && tImg->_IsPowerOfTwo; ASSERT(lambda != NULL); @@ -1424,15 +1441,15 @@ sample_lambda_2d(GLcontext *ctx, if (minStart < minEnd) { /* do the minified texels */ const GLuint m = minEnd - minStart; - switch (tObj->MinFilter) { + switch (tObj->Sampler.MinFilter) { case GL_NEAREST: if (repeatNoBorderPOT) { - switch (tImg->TexFormat->MesaFormat) { - case MESA_FORMAT_RGB: + switch (tImg->TexFormat) { + case MESA_FORMAT_RGB888: opt_sample_rgb_2d(ctx, tObj, m, texcoords + minStart, NULL, rgba + minStart); break; - case MESA_FORMAT_RGBA: + case MESA_FORMAT_RGBA8888: opt_sample_rgba_2d(ctx, tObj, m, texcoords + minStart, NULL, rgba + minStart); break; @@ -1481,15 +1498,15 @@ sample_lambda_2d(GLcontext *ctx, /* do the magnified texels */ const GLuint m = magEnd - magStart; - switch (tObj->MagFilter) { + switch (tObj->Sampler.MagFilter) { case GL_NEAREST: if (repeatNoBorderPOT) { - switch (tImg->TexFormat->MesaFormat) { - case MESA_FORMAT_RGB: + switch (tImg->TexFormat) { + case MESA_FORMAT_RGB888: opt_sample_rgb_2d(ctx, tObj, m, texcoords + magStart, NULL, rgba + magStart); break; - case MESA_FORMAT_RGBA: + case MESA_FORMAT_RGBA8888: opt_sample_rgba_2d(ctx, tObj, m, texcoords + magStart, NULL, rgba + magStart); break; @@ -1514,6 +1531,396 @@ sample_lambda_2d(GLcontext *ctx, } +/* For anisotropic filtering */ +#define WEIGHT_LUT_SIZE 1024 + +static GLfloat *weightLut = NULL; + +/** + * Creates the look-up table used to speed-up EWA sampling + */ +static void +create_filter_table(void) +{ + GLuint i; + if (!weightLut) { + weightLut = (GLfloat *) malloc(WEIGHT_LUT_SIZE * sizeof(GLfloat)); + + for (i = 0; i < WEIGHT_LUT_SIZE; ++i) { + GLfloat alpha = 2; + GLfloat r2 = (GLfloat) i / (GLfloat) (WEIGHT_LUT_SIZE - 1); + GLfloat weight = (GLfloat) exp(-alpha * r2); + weightLut[i] = weight; + } + } +} + + +/** + * Elliptical weighted average (EWA) filter for producing high quality + * anisotropic filtered results. + * Based on the Higher Quality Elliptical Weighted Avarage Filter + * published by Paul S. Heckbert in his Master's Thesis + * "Fundamentals of Texture Mapping and Image Warping" (1989) + */ +static void +sample_2d_ewa(struct gl_context *ctx, + const struct gl_texture_object *tObj, + const GLfloat texcoord[4], + const GLfloat dudx, const GLfloat dvdx, + const GLfloat dudy, const GLfloat dvdy, const GLint lod, + GLfloat rgba[]) +{ + GLint level = lod > 0 ? lod : 0; + GLfloat scaling = 1.0 / (1 << level); + const struct gl_texture_image *img = tObj->Image[0][level]; + const struct gl_texture_image *mostDetailedImage = + tObj->Image[0][tObj->BaseLevel]; + GLfloat tex_u=-0.5 + texcoord[0] * mostDetailedImage->WidthScale * scaling; + GLfloat tex_v=-0.5 + texcoord[1] * mostDetailedImage->HeightScale * scaling; + + GLfloat ux = dudx * scaling; + GLfloat vx = dvdx * scaling; + GLfloat uy = dudy * scaling; + GLfloat vy = dvdy * scaling; + + /* compute ellipse coefficients to bound the region: + * A*x*x + B*x*y + C*y*y = F. + */ + GLfloat A = vx*vx+vy*vy+1; + GLfloat B = -2*(ux*vx+uy*vy); + GLfloat C = ux*ux+uy*uy+1; + GLfloat F = A*C-B*B/4.0; + + /* check if it is an ellipse */ + /* ASSERT(F > 0.0); */ + + /* Compute the ellipse's (u,v) bounding box in texture space */ + GLfloat d = -B*B+4.0*C*A; + GLfloat box_u = 2.0 / d * sqrt(d*C*F); /* box_u -> half of bbox with */ + GLfloat box_v = 2.0 / d * sqrt(A*d*F); /* box_v -> half of bbox height */ + + GLint u0 = floor(tex_u - box_u); + GLint u1 = ceil (tex_u + box_u); + GLint v0 = floor(tex_v - box_v); + GLint v1 = ceil (tex_v + box_v); + + GLfloat num[4] = {0.0F, 0.0F, 0.0F, 0.0F}; + GLfloat newCoord[2]; + GLfloat den = 0.0F; + GLfloat ddq; + GLfloat U = u0 - tex_u; + GLint v; + + /* Scale ellipse formula to directly index the Filter Lookup Table. + * i.e. scale so that F = WEIGHT_LUT_SIZE-1 + */ + double formScale = (double) (WEIGHT_LUT_SIZE - 1) / F; + A *= formScale; + B *= formScale; + C *= formScale; + /* F *= formScale; */ /* no need to scale F as we don't use it below here */ + + /* Heckbert MS thesis, p. 59; scan over the bounding box of the ellipse + * and incrementally update the value of Ax^2+Bxy*Cy^2; when this + * value, q, is less than F, we're inside the ellipse + */ + ddq = 2 * A; + for (v = v0; v <= v1; ++v) { + GLfloat V = v - tex_v; + GLfloat dq = A * (2 * U + 1) + B * V; + GLfloat q = (C * V + B * U) * V + A * U * U; + + GLint u; + for (u = u0; u <= u1; ++u) { + /* Note that the ellipse has been pre-scaled so F = WEIGHT_LUT_SIZE - 1 */ + if (q < WEIGHT_LUT_SIZE) { + /* as a LUT is used, q must never be negative; + * should not happen, though + */ + const GLint qClamped = q >= 0.0F ? q : 0; + GLfloat weight = weightLut[qClamped]; + + newCoord[0] = u / ((GLfloat) img->Width2); + newCoord[1] = v / ((GLfloat) img->Height2); + + sample_2d_nearest(ctx, tObj, img, newCoord, rgba); + num[0] += weight * rgba[0]; + num[1] += weight * rgba[1]; + num[2] += weight * rgba[2]; + num[3] += weight * rgba[3]; + + den += weight; + } + q += dq; + dq += ddq; + } + } + + if (den <= 0.0F) { + /* Reaching this place would mean + * that no pixels intersected the ellipse. + * This should never happen because + * the filter we use always + * intersects at least one pixel. + */ + + /*rgba[0]=0; + rgba[1]=0; + rgba[2]=0; + rgba[3]=0;*/ + /* not enough pixels in resampling, resort to direct interpolation */ + sample_2d_linear(ctx, tObj, img, texcoord, rgba); + return; + } + + rgba[0] = num[0] / den; + rgba[1] = num[1] / den; + rgba[2] = num[2] / den; + rgba[3] = num[3] / den; +} + + +/** + * Anisotropic filtering using footprint assembly as outlined in the + * EXT_texture_filter_anisotropic spec: + * http://www.opengl.org/registry/specs/EXT/texture_filter_anisotropic.txt + * Faster than EWA but has less quality (more aliasing effects) + */ +static void +sample_2d_footprint(struct gl_context *ctx, + const struct gl_texture_object *tObj, + const GLfloat texcoord[4], + const GLfloat dudx, const GLfloat dvdx, + const GLfloat dudy, const GLfloat dvdy, const GLint lod, + GLfloat rgba[]) +{ + GLint level = lod > 0 ? lod : 0; + GLfloat scaling = 1.0F / (1 << level); + const struct gl_texture_image *img = tObj->Image[0][level]; + + GLfloat ux = dudx * scaling; + GLfloat vx = dvdx * scaling; + GLfloat uy = dudy * scaling; + GLfloat vy = dvdy * scaling; + + GLfloat Px2 = ux * ux + vx * vx; /* squared length of dx */ + GLfloat Py2 = uy * uy + vy * vy; /* squared length of dy */ + + GLint numSamples; + GLfloat ds; + GLfloat dt; + + GLfloat num[4] = {0.0F, 0.0F, 0.0F, 0.0F}; + GLfloat newCoord[2]; + GLint s; + + /* Calculate the per anisotropic sample offsets in s,t space. */ + if (Px2 > Py2) { + numSamples = ceil(SQRTF(Px2)); + ds = ux / ((GLfloat) img->Width2); + dt = vx / ((GLfloat) img->Height2); + } + else { + numSamples = ceil(SQRTF(Py2)); + ds = uy / ((GLfloat) img->Width2); + dt = vy / ((GLfloat) img->Height2); + } + + for (s = 0; sTexture._EnabledCoordUnits > 1) ? ctx->Const.MaxTextureUnits : 1; + GLuint u; + + /* XXX CoordUnits vs. ImageUnits */ + for (u = 0; u < maxUnit; u++) { + if (ctx->Texture.Unit[u]._Current == tObj) + break; /* found */ + } + if (u >= maxUnit) + u = 0; /* not found, use 1st one; should never happen */ + + return u; +} + + +/** + * Sample 2D texture using an anisotropic filter. + * NOTE: the const GLfloat lambda_iso[] parameter does *NOT* contain + * the lambda float array but a "hidden" SWspan struct which is required + * by this function but is not available in the texture_sample_func signature. + * See _swrast_texture_span( struct gl_context *ctx, SWspan *span ) on how + * this function is called. + */ +static void +sample_lambda_2d_aniso(struct gl_context *ctx, + const struct gl_texture_object *tObj, + GLuint n, const GLfloat texcoords[][4], + const GLfloat lambda_iso[], GLfloat rgba[][4]) +{ + const struct gl_texture_image *tImg = tObj->Image[0][tObj->BaseLevel]; + const GLfloat maxEccentricity = + tObj->Sampler.MaxAnisotropy * tObj->Sampler.MaxAnisotropy; + + /* re-calculate the lambda values so that they are usable with anisotropic + * filtering + */ + SWspan *span = (SWspan *)lambda_iso; /* access the "hidden" SWspan struct */ + + /* based on interpolate_texcoords(struct gl_context *ctx, SWspan *span) + * in swrast/s_span.c + */ + + /* find the texture unit index by looking up the current texture object + * from the context list of available texture objects. + */ + const GLuint u = texture_unit_index(ctx, tObj); + const GLuint attr = FRAG_ATTRIB_TEX0 + u; + GLfloat texW, texH; + + const GLfloat dsdx = span->attrStepX[attr][0]; + const GLfloat dsdy = span->attrStepY[attr][0]; + const GLfloat dtdx = span->attrStepX[attr][1]; + const GLfloat dtdy = span->attrStepY[attr][1]; + const GLfloat dqdx = span->attrStepX[attr][3]; + const GLfloat dqdy = span->attrStepY[attr][3]; + GLfloat s = span->attrStart[attr][0] + span->leftClip * dsdx; + GLfloat t = span->attrStart[attr][1] + span->leftClip * dtdx; + GLfloat q = span->attrStart[attr][3] + span->leftClip * dqdx; + + /* from swrast/s_texcombine.c _swrast_texture_span */ + const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u]; + const GLboolean adjustLOD = + (texUnit->LodBias + tObj->Sampler.LodBias != 0.0F) + || (tObj->Sampler.MinLod != -1000.0 || tObj->Sampler.MaxLod != 1000.0); + + GLuint i; + + /* on first access create the lookup table containing the filter weights. */ + if (!weightLut) { + create_filter_table(); + } + + texW = tImg->WidthScale; + texH = tImg->HeightScale; + + for (i = 0; i < n; i++) { + const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q); + + GLfloat dudx = texW * ((s + dsdx) / (q + dqdx) - s * invQ); + GLfloat dvdx = texH * ((t + dtdx) / (q + dqdx) - t * invQ); + GLfloat dudy = texW * ((s + dsdy) / (q + dqdy) - s * invQ); + GLfloat dvdy = texH * ((t + dtdy) / (q + dqdy) - t * invQ); + + /* note: instead of working with Px and Py, we will use the + * squared length instead, to avoid sqrt. + */ + GLfloat Px2 = dudx * dudx + dvdx * dvdx; + GLfloat Py2 = dudy * dudy + dvdy * dvdy; + + GLfloat Pmax2; + GLfloat Pmin2; + GLfloat e; + GLfloat lod; + + s += dsdx; + t += dtdx; + q += dqdx; + + if (Px2 < Py2) { + Pmax2 = Py2; + Pmin2 = Px2; + } + else { + Pmax2 = Px2; + Pmin2 = Py2; + } + + /* if the eccentricity of the ellipse is too big, scale up the shorter + * of the two vectors to limit the maximum amount of work per pixel + */ + e = Pmax2 / Pmin2; + if (e > maxEccentricity) { + /* GLfloat s=e / maxEccentricity; + minor[0] *= s; + minor[1] *= s; + Pmin2 *= s; */ + Pmin2 = Pmax2 / maxEccentricity; + } + + /* note: we need to have Pmin=sqrt(Pmin2) here, but we can avoid + * this since 0.5*log(x) = log(sqrt(x)) + */ + lod = 0.5 * LOG2(Pmin2); + + if (adjustLOD) { + /* from swrast/s_texcombine.c _swrast_texture_span */ + if (texUnit->LodBias + tObj->Sampler.LodBias != 0.0F) { + /* apply LOD bias, but don't clamp yet */ + const GLfloat bias = + CLAMP(texUnit->LodBias + tObj->Sampler.LodBias, + -ctx->Const.MaxTextureLodBias, + ctx->Const.MaxTextureLodBias); + lod += bias; + + if (tObj->Sampler.MinLod != -1000.0 || + tObj->Sampler.MaxLod != 1000.0) { + /* apply LOD clamping to lambda */ + lod = CLAMP(lod, tObj->Sampler.MinLod, tObj->Sampler.MaxLod); + } + } + } + + /* If the ellipse covers the whole image, we can + * simply return the average of the whole image. + */ + if (lod >= tObj->_MaxLevel) { + sample_2d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel], + texcoords[i], rgba[i]); + } + else { + /* don't bother interpolating between multiple LODs; it doesn't + * seem to be worth the extra running time. + */ + sample_2d_ewa(ctx, tObj, texcoords[i], + dudx, dvdx, dudy, dvdy, floor(lod), rgba[i]); + + /* unused: */ + (void) sample_2d_footprint; + /* + sample_2d_footprint(ctx, tObj, texcoords[i], + dudx, dvdx, dudy, dvdy, floor(lod), rgba[i]); + */ + } + } +} + + /**********************************************************************/ /* 3-D Texture Sampling Functions */ @@ -1523,7 +1930,7 @@ sample_lambda_2d(GLcontext *ctx, * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter. */ static INLINE void -sample_3d_nearest(GLcontext *ctx, +sample_3d_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -1535,9 +1942,9 @@ sample_3d_nearest(GLcontext *ctx, GLint i, j, k; (void) ctx; - i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]); - j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]); - k = nearest_texel_location(tObj->WrapR, img, depth, texcoord[2]); + i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]); + j = nearest_texel_location(tObj->Sampler.WrapT, img, height, texcoord[1]); + k = nearest_texel_location(tObj->Sampler.WrapR, img, depth, texcoord[2]); if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height || @@ -1555,7 +1962,7 @@ sample_3d_nearest(GLcontext *ctx, * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter. */ static void -sample_3d_linear(GLcontext *ctx, +sample_3d_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -1570,9 +1977,9 @@ sample_3d_linear(GLcontext *ctx, GLfloat t000[4], t010[4], t001[4], t011[4]; GLfloat t100[4], t110[4], t101[4], t111[4]; - linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a); - linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b); - linear_texel_locations(tObj->WrapR, img, depth, texcoord[2], &k0, &k1, &c); + linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a); + linear_texel_locations(tObj->Sampler.WrapT, img, height, texcoord[1], &j0, &j1, &b); + linear_texel_locations(tObj->Sampler.WrapR, img, depth, texcoord[2], &k0, &k1, &c); if (img->Border) { i0 += img->Border; @@ -1649,7 +2056,7 @@ sample_3d_linear(GLcontext *ctx, static void -sample_3d_nearest_mipmap_nearest(GLcontext *ctx, +sample_3d_nearest_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4] ) @@ -1663,7 +2070,7 @@ sample_3d_nearest_mipmap_nearest(GLcontext *ctx, static void -sample_3d_linear_mipmap_nearest(GLcontext *ctx, +sample_3d_linear_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1678,7 +2085,7 @@ sample_3d_linear_mipmap_nearest(GLcontext *ctx, static void -sample_3d_nearest_mipmap_linear(GLcontext *ctx, +sample_3d_nearest_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1703,7 +2110,7 @@ sample_3d_nearest_mipmap_linear(GLcontext *ctx, static void -sample_3d_linear_mipmap_linear(GLcontext *ctx, +sample_3d_linear_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1729,7 +2136,7 @@ sample_3d_linear_mipmap_linear(GLcontext *ctx, /** Sample 3D texture, nearest filtering for both min/magnification */ static void -sample_nearest_3d(GLcontext *ctx, +sample_nearest_3d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1745,7 +2152,7 @@ sample_nearest_3d(GLcontext *ctx, /** Sample 3D texture, linear filtering for both min/magnification */ static void -sample_linear_3d(GLcontext *ctx, +sample_linear_3d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1761,7 +2168,7 @@ sample_linear_3d(GLcontext *ctx, /** Sample 3D texture, using lambda to choose between min/magnification */ static void -sample_lambda_3d(GLcontext *ctx, +sample_lambda_3d(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1777,7 +2184,7 @@ sample_lambda_3d(GLcontext *ctx, if (minStart < minEnd) { /* do the minified texels */ GLuint m = minEnd - minStart; - switch (tObj->MinFilter) { + switch (tObj->Sampler.MinFilter) { case GL_NEAREST: for (i = minStart; i < minEnd; i++) sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -1812,7 +2219,7 @@ sample_lambda_3d(GLcontext *ctx, if (magStart < magEnd) { /* do the magnified texels */ - switch (tObj->MagFilter) { + switch (tObj->Sampler.MagFilter) { case GL_NEAREST: for (i = magStart; i < magEnd; i++) sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -1905,14 +2312,18 @@ choose_cube_face(const struct gl_texture_object *texObj, } } - newCoord[0] = ( sc / ma + 1.0F ) * 0.5F; - newCoord[1] = ( tc / ma + 1.0F ) * 0.5F; + { + const float ima = 1.0F / ma; + newCoord[0] = ( sc * ima + 1.0F ) * 0.5F; + newCoord[1] = ( tc * ima + 1.0F ) * 0.5F; + } + return (const struct gl_texture_image **) texObj->Image[face]; } static void -sample_nearest_cube(GLcontext *ctx, +sample_nearest_cube(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1930,7 +2341,7 @@ sample_nearest_cube(GLcontext *ctx, static void -sample_linear_cube(GLcontext *ctx, +sample_linear_cube(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1948,7 +2359,7 @@ sample_linear_cube(GLcontext *ctx, static void -sample_cube_nearest_mipmap_nearest(GLcontext *ctx, +sample_cube_nearest_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1977,7 +2388,7 @@ sample_cube_nearest_mipmap_nearest(GLcontext *ctx, static void -sample_cube_linear_mipmap_nearest(GLcontext *ctx, +sample_cube_linear_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -1996,7 +2407,7 @@ sample_cube_linear_mipmap_nearest(GLcontext *ctx, static void -sample_cube_nearest_mipmap_linear(GLcontext *ctx, +sample_cube_nearest_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2025,7 +2436,7 @@ sample_cube_nearest_mipmap_linear(GLcontext *ctx, static void -sample_cube_linear_mipmap_linear(GLcontext *ctx, +sample_cube_linear_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2055,7 +2466,7 @@ sample_cube_linear_mipmap_linear(GLcontext *ctx, /** Sample cube texture, using lambda to choose between min/magnification */ static void -sample_lambda_cube(GLcontext *ctx, +sample_lambda_cube(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2070,7 +2481,7 @@ sample_lambda_cube(GLcontext *ctx, if (minStart < minEnd) { /* do the minified texels */ const GLuint m = minEnd - minStart; - switch (tObj->MinFilter) { + switch (tObj->Sampler.MinFilter) { case GL_NEAREST: sample_nearest_cube(ctx, tObj, m, texcoords + minStart, lambda + minStart, rgba + minStart); @@ -2107,7 +2518,7 @@ sample_lambda_cube(GLcontext *ctx, if (magStart < magEnd) { /* do the magnified texels */ const GLuint m = magEnd - magStart; - switch (tObj->MagFilter) { + switch (tObj->Sampler.MagFilter) { case GL_NEAREST: sample_nearest_cube(ctx, tObj, m, texcoords + magStart, lambda + magStart, rgba + magStart); @@ -2129,7 +2540,7 @@ sample_lambda_cube(GLcontext *ctx, static void -sample_nearest_rect(GLcontext *ctx, +sample_nearest_rect(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2142,18 +2553,18 @@ sample_nearest_rect(GLcontext *ctx, (void) ctx; (void) lambda; - ASSERT(tObj->WrapS == GL_CLAMP || - tObj->WrapS == GL_CLAMP_TO_EDGE || - tObj->WrapS == GL_CLAMP_TO_BORDER); - ASSERT(tObj->WrapT == GL_CLAMP || - tObj->WrapT == GL_CLAMP_TO_EDGE || - tObj->WrapT == GL_CLAMP_TO_BORDER); - ASSERT(img->TexFormat->BaseFormat != GL_COLOR_INDEX); + ASSERT(tObj->Sampler.WrapS == GL_CLAMP || + tObj->Sampler.WrapS == GL_CLAMP_TO_EDGE || + tObj->Sampler.WrapS == GL_CLAMP_TO_BORDER); + ASSERT(tObj->Sampler.WrapT == GL_CLAMP || + tObj->Sampler.WrapT == GL_CLAMP_TO_EDGE || + tObj->Sampler.WrapT == GL_CLAMP_TO_BORDER); + ASSERT(img->_BaseFormat != GL_COLOR_INDEX); for (i = 0; i < n; i++) { GLint row, col; - col = clamp_rect_coord_nearest(tObj->WrapS, texcoords[i][0], width); - row = clamp_rect_coord_nearest(tObj->WrapT, texcoords[i][1], height); + col = clamp_rect_coord_nearest(tObj->Sampler.WrapS, texcoords[i][0], width); + row = clamp_rect_coord_nearest(tObj->Sampler.WrapT, texcoords[i][1], height); if (col < 0 || col >= width || row < 0 || row >= height) get_border_color(tObj, img, rgba[i]); else @@ -2163,7 +2574,7 @@ sample_nearest_rect(GLcontext *ctx, static void -sample_linear_rect(GLcontext *ctx, +sample_linear_rect(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2176,13 +2587,13 @@ sample_linear_rect(GLcontext *ctx, (void) ctx; (void) lambda; - ASSERT(tObj->WrapS == GL_CLAMP || - tObj->WrapS == GL_CLAMP_TO_EDGE || - tObj->WrapS == GL_CLAMP_TO_BORDER); - ASSERT(tObj->WrapT == GL_CLAMP || - tObj->WrapT == GL_CLAMP_TO_EDGE || - tObj->WrapT == GL_CLAMP_TO_BORDER); - ASSERT(img->TexFormat->BaseFormat != GL_COLOR_INDEX); + ASSERT(tObj->Sampler.WrapS == GL_CLAMP || + tObj->Sampler.WrapS == GL_CLAMP_TO_EDGE || + tObj->Sampler.WrapS == GL_CLAMP_TO_BORDER); + ASSERT(tObj->Sampler.WrapT == GL_CLAMP || + tObj->Sampler.WrapT == GL_CLAMP_TO_EDGE || + tObj->Sampler.WrapT == GL_CLAMP_TO_BORDER); + ASSERT(img->_BaseFormat != GL_COLOR_INDEX); for (i = 0; i < n; i++) { GLint i0, j0, i1, j1; @@ -2190,9 +2601,9 @@ sample_linear_rect(GLcontext *ctx, GLfloat a, b; GLbitfield useBorderColor = 0x0; - clamp_rect_coord_linear(tObj->WrapS, texcoords[i][0], width, + clamp_rect_coord_linear(tObj->Sampler.WrapS, texcoords[i][0], width, &i0, &i1, &a); - clamp_rect_coord_linear(tObj->WrapT, texcoords[i][1], height, + clamp_rect_coord_linear(tObj->Sampler.WrapT, texcoords[i][1], height, &j0, &j1, &b); /* compute integer rows/columns */ @@ -2229,7 +2640,7 @@ sample_linear_rect(GLcontext *ctx, /** Sample Rect texture, using lambda to choose between min/magnification */ static void -sample_lambda_rect(GLcontext *ctx, +sample_lambda_rect(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2243,7 +2654,7 @@ sample_lambda_rect(GLcontext *ctx, &minStart, &minEnd, &magStart, &magEnd); if (minStart < minEnd) { - if (tObj->MinFilter == GL_NEAREST) { + if (tObj->Sampler.MinFilter == GL_NEAREST) { sample_nearest_rect(ctx, tObj, minEnd - minStart, texcoords + minStart, NULL, rgba + minStart); } @@ -2253,7 +2664,7 @@ sample_lambda_rect(GLcontext *ctx, } } if (magStart < magEnd) { - if (tObj->MagFilter == GL_NEAREST) { + if (tObj->Sampler.MagFilter == GL_NEAREST) { sample_nearest_rect(ctx, tObj, magEnd - magStart, texcoords + magStart, NULL, rgba + magStart); } @@ -2265,7 +2676,6 @@ sample_lambda_rect(GLcontext *ctx, } - /**********************************************************************/ /* 2D Texture Array Sampling Functions */ /**********************************************************************/ @@ -2274,7 +2684,7 @@ sample_lambda_rect(GLcontext *ctx, * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter. */ static void -sample_2d_array_nearest(GLcontext *ctx, +sample_2d_array_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -2287,9 +2697,9 @@ sample_2d_array_nearest(GLcontext *ctx, GLint array; (void) ctx; - i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]); - j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]); - array = clamp_rect_coord_nearest(tObj->WrapR, texcoord[2], depth); + i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]); + j = nearest_texel_location(tObj->Sampler.WrapT, img, height, texcoord[1]); + array = tex_array_slice(texcoord[2], depth); if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height || @@ -2307,7 +2717,7 @@ sample_2d_array_nearest(GLcontext *ctx, * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter. */ static void -sample_2d_array_linear(GLcontext *ctx, +sample_2d_array_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -2322,12 +2732,12 @@ sample_2d_array_linear(GLcontext *ctx, GLfloat a, b; GLfloat t00[4], t01[4], t10[4], t11[4]; - linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a); - linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b); - array = clamp_rect_coord_nearest(tObj->WrapR, texcoord[2], depth); + linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a); + linear_texel_locations(tObj->Sampler.WrapT, img, height, texcoord[1], &j0, &j1, &b); + array = tex_array_slice(texcoord[2], depth); if (array < 0 || array >= depth) { - COPY_4V(rgba, tObj->BorderColor); + COPY_4V(rgba, tObj->Sampler.BorderColor.f); } else { if (img->Border) { @@ -2377,7 +2787,7 @@ sample_2d_array_linear(GLcontext *ctx, static void -sample_2d_array_nearest_mipmap_nearest(GLcontext *ctx, +sample_2d_array_nearest_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2392,7 +2802,7 @@ sample_2d_array_nearest_mipmap_nearest(GLcontext *ctx, static void -sample_2d_array_linear_mipmap_nearest(GLcontext *ctx, +sample_2d_array_linear_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2408,7 +2818,7 @@ sample_2d_array_linear_mipmap_nearest(GLcontext *ctx, static void -sample_2d_array_nearest_mipmap_linear(GLcontext *ctx, +sample_2d_array_nearest_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2435,7 +2845,7 @@ sample_2d_array_nearest_mipmap_linear(GLcontext *ctx, static void -sample_2d_array_linear_mipmap_linear(GLcontext *ctx, +sample_2d_array_linear_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2463,7 +2873,7 @@ sample_2d_array_linear_mipmap_linear(GLcontext *ctx, /** Sample 2D Array texture, nearest filtering for both min/magnification */ static void -sample_nearest_2d_array(GLcontext *ctx, +sample_nearest_2d_array(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2480,7 +2890,7 @@ sample_nearest_2d_array(GLcontext *ctx, /** Sample 2D Array texture, linear filtering for both min/magnification */ static void -sample_linear_2d_array(GLcontext *ctx, +sample_linear_2d_array(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2496,7 +2906,7 @@ sample_linear_2d_array(GLcontext *ctx, /** Sample 2D Array texture, using lambda to choose between min/magnification */ static void -sample_lambda_2d_array(GLcontext *ctx, +sample_lambda_2d_array(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2512,7 +2922,7 @@ sample_lambda_2d_array(GLcontext *ctx, if (minStart < minEnd) { /* do the minified texels */ GLuint m = minEnd - minStart; - switch (tObj->MinFilter) { + switch (tObj->Sampler.MinFilter) { case GL_NEAREST: for (i = minStart; i < minEnd; i++) sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -2555,7 +2965,7 @@ sample_lambda_2d_array(GLcontext *ctx, if (magStart < magEnd) { /* do the magnified texels */ - switch (tObj->MagFilter) { + switch (tObj->Sampler.MagFilter) { case GL_NEAREST: for (i = magStart; i < magEnd; i++) sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -2584,7 +2994,7 @@ sample_lambda_2d_array(GLcontext *ctx, * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter. */ static void -sample_1d_array_nearest(GLcontext *ctx, +sample_1d_array_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -2596,8 +3006,8 @@ sample_1d_array_nearest(GLcontext *ctx, GLint array; (void) ctx; - i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]); - array = clamp_rect_coord_nearest(tObj->WrapT, texcoord[1], height); + i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]); + array = tex_array_slice(texcoord[1], height); if (i < 0 || i >= (GLint) img->Width || array < 0 || array >= (GLint) img->Height) { @@ -2614,7 +3024,7 @@ sample_1d_array_nearest(GLcontext *ctx, * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter. */ static void -sample_1d_array_linear(GLcontext *ctx, +sample_1d_array_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, const struct gl_texture_image *img, const GLfloat texcoord[4], @@ -2628,8 +3038,8 @@ sample_1d_array_linear(GLcontext *ctx, GLfloat a; GLfloat t0[4], t1[4]; - linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a); - array = clamp_rect_coord_nearest(tObj->WrapT, texcoord[1], height); + linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a); + array = tex_array_slice(texcoord[1], height); if (img->Border) { i0 += img->Border; @@ -2663,7 +3073,7 @@ sample_1d_array_linear(GLcontext *ctx, static void -sample_1d_array_nearest_mipmap_nearest(GLcontext *ctx, +sample_1d_array_nearest_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2678,7 +3088,7 @@ sample_1d_array_nearest_mipmap_nearest(GLcontext *ctx, static void -sample_1d_array_linear_mipmap_nearest(GLcontext *ctx, +sample_1d_array_linear_mipmap_nearest(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2694,7 +3104,7 @@ sample_1d_array_linear_mipmap_nearest(GLcontext *ctx, static void -sample_1d_array_nearest_mipmap_linear(GLcontext *ctx, +sample_1d_array_nearest_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2719,7 +3129,7 @@ sample_1d_array_nearest_mipmap_linear(GLcontext *ctx, static void -sample_1d_array_linear_mipmap_linear(GLcontext *ctx, +sample_1d_array_linear_mipmap_linear(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoord[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2745,7 +3155,7 @@ sample_1d_array_linear_mipmap_linear(GLcontext *ctx, /** Sample 1D Array texture, nearest filtering for both min/magnification */ static void -sample_nearest_1d_array(GLcontext *ctx, +sample_nearest_1d_array(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2761,7 +3171,7 @@ sample_nearest_1d_array(GLcontext *ctx, /** Sample 1D Array texture, linear filtering for both min/magnification */ static void -sample_linear_1d_array(GLcontext *ctx, +sample_linear_1d_array(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2777,7 +3187,7 @@ sample_linear_1d_array(GLcontext *ctx, /** Sample 1D Array texture, using lambda to choose between min/magnification */ static void -sample_lambda_1d_array(GLcontext *ctx, +sample_lambda_1d_array(struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -2793,7 +3203,7 @@ sample_lambda_1d_array(GLcontext *ctx, if (minStart < minEnd) { /* do the minified texels */ GLuint m = minEnd - minStart; - switch (tObj->MinFilter) { + switch (tObj->Sampler.MinFilter) { case GL_NEAREST: for (i = minStart; i < minEnd; i++) sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -2832,7 +3242,7 @@ sample_lambda_1d_array(GLcontext *ctx, if (magStart < magEnd) { /* do the magnified texels */ - switch (tObj->MagFilter) { + switch (tObj->Sampler.MagFilter) { case GL_NEAREST: for (i = magStart; i < magEnd; i++) sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel], @@ -2898,66 +3308,90 @@ shadow_compare4(GLenum function, GLfloat coord, switch (function) { case GL_LEQUAL: - if (depth00 <= coord) luminance -= d; - if (depth01 <= coord) luminance -= d; - if (depth10 <= coord) luminance -= d; - if (depth11 <= coord) luminance -= d; + if (coord > depth00) luminance -= d; + if (coord > depth01) luminance -= d; + if (coord > depth10) luminance -= d; + if (coord > depth11) luminance -= d; return luminance; case GL_GEQUAL: - if (depth00 >= coord) luminance -= d; - if (depth01 >= coord) luminance -= d; - if (depth10 >= coord) luminance -= d; - if (depth11 >= coord) luminance -= d; + if (coord < depth00) luminance -= d; + if (coord < depth01) luminance -= d; + if (coord < depth10) luminance -= d; + if (coord < depth11) luminance -= d; return luminance; case GL_LESS: - if (depth00 < coord) luminance -= d; - if (depth01 < coord) luminance -= d; - if (depth10 < coord) luminance -= d; - if (depth11 < coord) luminance -= d; + if (coord >= depth00) luminance -= d; + if (coord >= depth01) luminance -= d; + if (coord >= depth10) luminance -= d; + if (coord >= depth11) luminance -= d; return luminance; case GL_GREATER: - if (depth00 > coord) luminance -= d; - if (depth01 > coord) luminance -= d; - if (depth10 > coord) luminance -= d; - if (depth11 > coord) luminance -= d; + if (coord <= depth00) luminance -= d; + if (coord <= depth01) luminance -= d; + if (coord <= depth10) luminance -= d; + if (coord <= depth11) luminance -= d; return luminance; case GL_EQUAL: - if (depth00 == coord) luminance -= d; - if (depth01 == coord) luminance -= d; - if (depth10 == coord) luminance -= d; - if (depth11 == coord) luminance -= d; + if (coord != depth00) luminance -= d; + if (coord != depth01) luminance -= d; + if (coord != depth10) luminance -= d; + if (coord != depth11) luminance -= d; return luminance; case GL_NOTEQUAL: - if (depth00 != coord) luminance -= d; - if (depth01 != coord) luminance -= d; - if (depth10 != coord) luminance -= d; - if (depth11 != coord) luminance -= d; + if (coord == depth00) luminance -= d; + if (coord == depth01) luminance -= d; + if (coord == depth10) luminance -= d; + if (coord == depth11) luminance -= d; return luminance; case GL_ALWAYS: - return 0.0; + return 1.0F; case GL_NEVER: return ambient; case GL_NONE: /* ordinary bilinear filtering */ return lerp_2d(wi, wj, depth00, depth10, depth01, depth11); default: - _mesa_problem(NULL, "Bad compare func in sample_depth_texture"); - return 0.0F; + _mesa_problem(NULL, "Bad compare func in sample_compare4"); + return ambient; + } +} + + +/** + * Choose the mipmap level to use when sampling from a depth texture. + */ +static int +choose_depth_texture_level(const struct gl_texture_object *tObj, GLfloat lambda) +{ + GLint level; + + if (tObj->Sampler.MinFilter == GL_NEAREST || tObj->Sampler.MinFilter == GL_LINEAR) { + /* no mipmapping - use base level */ + level = tObj->BaseLevel; + } + else { + /* choose mipmap level */ + lambda = CLAMP(lambda, tObj->Sampler.MinLod, tObj->Sampler.MaxLod); + level = (GLint) lambda; + level = CLAMP(level, tObj->BaseLevel, tObj->_MaxLevel); } + + return level; } /** - * Sample a shadow/depth texture. + * Sample a shadow/depth texture. This function is incomplete. It doesn't + * check for minification vs. magnification, etc. */ static void -sample_depth_texture( GLcontext *ctx, +sample_depth_texture( struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat texel[][4] ) { - const GLint baseLevel = tObj->BaseLevel; - const struct gl_texture_image *img = tObj->Image[0][baseLevel]; + const GLint level = choose_depth_texture_level(tObj, lambda[0]); + const struct gl_texture_image *img = tObj->Image[0][level]; const GLint width = img->Width; const GLint height = img->Height; const GLint depth = img->Depth; @@ -2967,10 +3401,8 @@ sample_depth_texture( GLcontext *ctx, GLenum function; GLfloat result; - (void) lambda; - - ASSERT(img->TexFormat->BaseFormat == GL_DEPTH_COMPONENT || - img->TexFormat->BaseFormat == GL_DEPTH_STENCIL_EXT); + ASSERT(img->_BaseFormat == GL_DEPTH_COMPONENT || + img->_BaseFormat == GL_DEPTH_STENCIL_EXT); ASSERT(tObj->Target == GL_TEXTURE_1D || tObj->Target == GL_TEXTURE_2D || @@ -2978,33 +3410,34 @@ sample_depth_texture( GLcontext *ctx, tObj->Target == GL_TEXTURE_1D_ARRAY_EXT || tObj->Target == GL_TEXTURE_2D_ARRAY_EXT); - ambient = tObj->CompareFailValue; + ambient = tObj->Sampler.CompareFailValue; - /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */ + /* XXXX if tObj->Sampler.MinFilter != tObj->Sampler.MagFilter, we're ignoring lambda */ - function = (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ? - tObj->CompareFunc : GL_NONE; + function = (tObj->Sampler.CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ? + tObj->Sampler.CompareFunc : GL_NONE; - if (tObj->MagFilter == GL_NEAREST) { + if (tObj->Sampler.MagFilter == GL_NEAREST) { GLuint i; for (i = 0; i < n; i++) { - GLfloat depthSample; + GLfloat depthSample, depthRef; GLint col, row, slice; - nearest_texcoord(tObj, texcoords[i], &col, &row, &slice); + nearest_texcoord(tObj, level, texcoords[i], &col, &row, &slice); if (col >= 0 && row >= 0 && col < width && row < height && slice >= 0 && slice < depth) { img->FetchTexelf(img, col, row, slice, &depthSample); } else { - depthSample = tObj->BorderColor[0]; + depthSample = tObj->Sampler.BorderColor.f[0]; } - result = shadow_compare(function, texcoords[i][compare_coord], - depthSample, ambient); + depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F); - switch (tObj->DepthMode) { + result = shadow_compare(function, depthRef, depthSample, ambient); + + switch (tObj->Sampler.DepthMode) { case GL_LUMINANCE: ASSIGN_4V(texel[i], result, result, result, 1.0F); break; @@ -3014,6 +3447,9 @@ sample_depth_texture( GLcontext *ctx, case GL_ALPHA: ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result); break; + case GL_RED: + ASSIGN_4V(texel[i], result, 0.0F, 0.0F, 1.0F); + break; default: _mesa_problem(ctx, "Bad depth texture mode"); } @@ -3021,15 +3457,15 @@ sample_depth_texture( GLcontext *ctx, } else { GLuint i; - ASSERT(tObj->MagFilter == GL_LINEAR); + ASSERT(tObj->Sampler.MagFilter == GL_LINEAR); for (i = 0; i < n; i++) { - GLfloat depth00, depth01, depth10, depth11; + GLfloat depth00, depth01, depth10, depth11, depthRef; GLint i0, i1, j0, j1; GLint slice; GLfloat wi, wj; GLuint useBorderTexel; - linear_texcoord(tObj, texcoords[i], &i0, &i1, &j0, &j1, &slice, + linear_texcoord(tObj, level, texcoords[i], &i0, &i1, &j0, &j1, &slice, &wi, &wj); useBorderTexel = 0; @@ -3049,21 +3485,21 @@ sample_depth_texture( GLcontext *ctx, } if (slice < 0 || slice >= (GLint) depth) { - depth00 = tObj->BorderColor[0]; - depth01 = tObj->BorderColor[0]; - depth10 = tObj->BorderColor[0]; - depth11 = tObj->BorderColor[0]; + depth00 = tObj->Sampler.BorderColor.f[0]; + depth01 = tObj->Sampler.BorderColor.f[0]; + depth10 = tObj->Sampler.BorderColor.f[0]; + depth11 = tObj->Sampler.BorderColor.f[0]; } else { /* get four depth samples from the texture */ if (useBorderTexel & (I0BIT | J0BIT)) { - depth00 = tObj->BorderColor[0]; + depth00 = tObj->Sampler.BorderColor.f[0]; } else { img->FetchTexelf(img, i0, j0, slice, &depth00); } if (useBorderTexel & (I1BIT | J0BIT)) { - depth10 = tObj->BorderColor[0]; + depth10 = tObj->Sampler.BorderColor.f[0]; } else { img->FetchTexelf(img, i1, j0, slice, &depth10); @@ -3071,13 +3507,13 @@ sample_depth_texture( GLcontext *ctx, if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) { if (useBorderTexel & (I0BIT | J1BIT)) { - depth01 = tObj->BorderColor[0]; + depth01 = tObj->Sampler.BorderColor.f[0]; } else { img->FetchTexelf(img, i0, j1, slice, &depth01); } if (useBorderTexel & (I1BIT | J1BIT)) { - depth11 = tObj->BorderColor[0]; + depth11 = tObj->Sampler.BorderColor.f[0]; } else { img->FetchTexelf(img, i1, j1, slice, &depth11); @@ -3089,11 +3525,13 @@ sample_depth_texture( GLcontext *ctx, } } - result = shadow_compare4(function, texcoords[i][compare_coord], + depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F); + + result = shadow_compare4(function, depthRef, depth00, depth01, depth10, depth11, ambient, wi, wj); - switch (tObj->DepthMode) { + switch (tObj->Sampler.DepthMode) { case GL_LUMINANCE: ASSIGN_4V(texel[i], result, result, result, 1.0F); break; @@ -3119,7 +3557,7 @@ sample_depth_texture( GLcontext *ctx, * Note: fragment programs don't observe the texture enable/disable flags. */ static void -null_sample_func( GLcontext *ctx, +null_sample_func( struct gl_context *ctx, const struct gl_texture_object *tObj, GLuint n, const GLfloat texcoords[][4], const GLfloat lambda[], GLfloat rgba[][4]) @@ -3133,7 +3571,7 @@ null_sample_func( GLcontext *ctx, rgba[i][RCOMP] = 0; rgba[i][GCOMP] = 0; rgba[i][BCOMP] = 0; - rgba[i][ACOMP] = CHAN_MAX; + rgba[i][ACOMP] = 1.0; } } @@ -3142,15 +3580,16 @@ null_sample_func( GLcontext *ctx, * Choose the texture sampling function for the given texture object. */ texture_sample_func -_swrast_choose_texture_sample_func( GLcontext *ctx, +_swrast_choose_texture_sample_func( struct gl_context *ctx, const struct gl_texture_object *t ) { if (!t || !t->_Complete) { return &null_sample_func; } else { - const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter); - const GLenum format = t->Image[0][t->BaseLevel]->TexFormat->BaseFormat; + const GLboolean needLambda = + (GLboolean) (t->Sampler.MinFilter != t->Sampler.MagFilter); + const GLenum format = t->Image[0][t->BaseLevel]->_BaseFormat; switch (t->Target) { case GL_TEXTURE_1D: @@ -3160,11 +3599,11 @@ _swrast_choose_texture_sample_func( GLcontext *ctx, else if (needLambda) { return &sample_lambda_1d; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_1d; } else { - ASSERT(t->MinFilter == GL_NEAREST); + ASSERT(t->Sampler.MinFilter == GL_NEAREST); return &sample_nearest_1d; } case GL_TEXTURE_2D: @@ -3172,27 +3611,32 @@ _swrast_choose_texture_sample_func( GLcontext *ctx, return &sample_depth_texture; } else if (needLambda) { + /* Anisotropic filtering extension. Activated only if mipmaps are used */ + if (t->Sampler.MaxAnisotropy > 1.0 && + t->Sampler.MinFilter == GL_LINEAR_MIPMAP_LINEAR) { + return &sample_lambda_2d_aniso; + } return &sample_lambda_2d; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_2d; } else { /* check for a few optimized cases */ const struct gl_texture_image *img = t->Image[0][t->BaseLevel]; - ASSERT(t->MinFilter == GL_NEAREST); - if (t->WrapS == GL_REPEAT && - t->WrapT == GL_REPEAT && + ASSERT(t->Sampler.MinFilter == GL_NEAREST); + if (t->Sampler.WrapS == GL_REPEAT && + t->Sampler.WrapT == GL_REPEAT && img->_IsPowerOfTwo && img->Border == 0 && - img->TexFormat->MesaFormat == MESA_FORMAT_RGB) { + img->TexFormat == MESA_FORMAT_RGB888) { return &opt_sample_rgb_2d; } - else if (t->WrapS == GL_REPEAT && - t->WrapT == GL_REPEAT && + else if (t->Sampler.WrapS == GL_REPEAT && + t->Sampler.WrapT == GL_REPEAT && img->_IsPowerOfTwo && img->Border == 0 && - img->TexFormat->MesaFormat == MESA_FORMAT_RGBA) { + img->TexFormat == MESA_FORMAT_RGBA8888) { return &opt_sample_rgba_2d; } else { @@ -3203,22 +3647,22 @@ _swrast_choose_texture_sample_func( GLcontext *ctx, if (needLambda) { return &sample_lambda_3d; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_3d; } else { - ASSERT(t->MinFilter == GL_NEAREST); + ASSERT(t->Sampler.MinFilter == GL_NEAREST); return &sample_nearest_3d; } case GL_TEXTURE_CUBE_MAP: if (needLambda) { return &sample_lambda_cube; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_cube; } else { - ASSERT(t->MinFilter == GL_NEAREST); + ASSERT(t->Sampler.MinFilter == GL_NEAREST); return &sample_nearest_cube; } case GL_TEXTURE_RECTANGLE_NV: @@ -3228,33 +3672,33 @@ _swrast_choose_texture_sample_func( GLcontext *ctx, else if (needLambda) { return &sample_lambda_rect; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_rect; } else { - ASSERT(t->MinFilter == GL_NEAREST); + ASSERT(t->Sampler.MinFilter == GL_NEAREST); return &sample_nearest_rect; } case GL_TEXTURE_1D_ARRAY_EXT: if (needLambda) { return &sample_lambda_1d_array; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_1d_array; } else { - ASSERT(t->MinFilter == GL_NEAREST); + ASSERT(t->Sampler.MinFilter == GL_NEAREST); return &sample_nearest_1d_array; } case GL_TEXTURE_2D_ARRAY_EXT: if (needLambda) { return &sample_lambda_2d_array; } - else if (t->MinFilter == GL_LINEAR) { + else if (t->Sampler.MinFilter == GL_LINEAR) { return &sample_linear_2d_array; } else { - ASSERT(t->MinFilter == GL_NEAREST); + ASSERT(t->Sampler.MinFilter == GL_NEAREST); return &sample_nearest_2d_array; } default: