/************************************************************************** * * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. * All Rights Reserved. * Copyright 2008 VMware, Inc. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ /** * Texture sampling * * Authors: * Brian Paul */ #include "lp_context.h" #include "lp_quad.h" #include "lp_surface.h" #include "lp_texture.h" #include "lp_tex_sample.h" #include "lp_tex_cache.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" #include "pipe/p_shader_tokens.h" #include "util/u_math.h" #include "util/u_memory.h" /* * Note, the FRAC macro has to work perfectly. Otherwise you'll sometimes * see 1-pixel bands of improperly weighted linear-filtered textures. * The tests/texwrap.c demo is a good test. * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0. * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x). */ #define FRAC(f) ((f) - util_ifloor(f)) /** * Linear interpolation macro */ static INLINE float lerp(float a, float v0, float v1) { return v0 + a * (v1 - v0); } /** * Do 2D/biliner interpolation of float values. * v00, v10, v01 and v11 are typically four texture samples in a square/box. * a and b are the horizontal and vertical interpolants. * It's important that this function is inlined when compiled with * optimization! If we find that's not true on some systems, convert * to a macro. */ static INLINE float lerp_2d(float a, float b, float v00, float v10, float v01, float v11) { const float temp0 = lerp(a, v00, v10); const float temp1 = lerp(a, v01, v11); return lerp(b, temp0, temp1); } /** * As above, but 3D interpolation of 8 values. */ static INLINE float lerp_3d(float a, float b, float c, float v000, float v100, float v010, float v110, float v001, float v101, float v011, float v111) { const float temp0 = lerp_2d(a, b, v000, v100, v010, v110); const float temp1 = lerp_2d(a, b, v001, v101, v011, v111); return lerp(c, temp0, temp1); } /** * 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. */ #define REMAINDER(A, B) ((unsigned) (A) % (unsigned) (B)) /** * Apply texture coord wrapping mode and return integer texture indexes * for a vector of four texcoords (S or T or P). * \param wrapMode PIPE_TEX_WRAP_x * \param s the incoming texcoords * \param size the texture image size * \param icoord returns the integer texcoords * \return integer texture index */ static INLINE void nearest_texcoord_4(unsigned wrapMode, const float s[4], unsigned size, int icoord[4]) { uint ch; switch (wrapMode) { case PIPE_TEX_WRAP_REPEAT: /* s limited to [0,1) */ /* i limited to [0,size-1] */ for (ch = 0; ch < 4; ch++) { int i = util_ifloor(s[ch] * size); icoord[ch] = REMAINDER(i, size); } return; case PIPE_TEX_WRAP_CLAMP: /* s limited to [0,1] */ /* i limited to [0,size-1] */ for (ch = 0; ch < 4; ch++) { if (s[ch] <= 0.0F) icoord[ch] = 0; else if (s[ch] >= 1.0F) icoord[ch] = size - 1; else icoord[ch] = util_ifloor(s[ch] * size); } return; case PIPE_TEX_WRAP_CLAMP_TO_EDGE: { /* s limited to [min,max] */ /* i limited to [0, size-1] */ const float min = 1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { if (s[ch] < min) icoord[ch] = 0; else if (s[ch] > max) icoord[ch] = size - 1; else icoord[ch] = util_ifloor(s[ch] * size); } } return; case PIPE_TEX_WRAP_CLAMP_TO_BORDER: { /* s limited to [min,max] */ /* i limited to [-1, size] */ const float min = -1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { if (s[ch] <= min) icoord[ch] = -1; else if (s[ch] >= max) icoord[ch] = size; else icoord[ch] = util_ifloor(s[ch] * size); } } return; case PIPE_TEX_WRAP_MIRROR_REPEAT: { const float min = 1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { const int flr = util_ifloor(s[ch]); float u; if (flr & 1) u = 1.0F - (s[ch] - (float) flr); else u = s[ch] - (float) flr; if (u < min) icoord[ch] = 0; else if (u > max) icoord[ch] = size - 1; else icoord[ch] = util_ifloor(u * size); } } return; case PIPE_TEX_WRAP_MIRROR_CLAMP: for (ch = 0; ch < 4; ch++) { /* s limited to [0,1] */ /* i limited to [0,size-1] */ const float u = fabsf(s[ch]); if (u <= 0.0F) icoord[ch] = 0; else if (u >= 1.0F) icoord[ch] = size - 1; else icoord[ch] = util_ifloor(u * size); } return; case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE: { /* s limited to [min,max] */ /* i limited to [0, size-1] */ const float min = 1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { const float u = fabsf(s[ch]); if (u < min) icoord[ch] = 0; else if (u > max) icoord[ch] = size - 1; else icoord[ch] = util_ifloor(u * size); } } return; case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER: { /* s limited to [min,max] */ /* i limited to [0, size-1] */ const float min = -1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { const float u = fabsf(s[ch]); if (u < min) icoord[ch] = -1; else if (u > max) icoord[ch] = size; else icoord[ch] = util_ifloor(u * size); } } return; default: assert(0); } } /** * Used to compute texel locations for linear sampling for four texcoords. * \param wrapMode PIPE_TEX_WRAP_x * \param s the texcoords * \param size the texture image size * \param icoord0 returns first texture indexes * \param icoord1 returns second texture indexes (usually icoord0 + 1) * \param w returns blend factor/weight between texture indexes * \param icoord returns the computed integer texture coords */ static INLINE void linear_texcoord_4(unsigned wrapMode, const float s[4], unsigned size, int icoord0[4], int icoord1[4], float w[4]) { uint ch; switch (wrapMode) { case PIPE_TEX_WRAP_REPEAT: for (ch = 0; ch < 4; ch++) { float u = s[ch] * size - 0.5F; icoord0[ch] = REMAINDER(util_ifloor(u), size); icoord1[ch] = REMAINDER(icoord0[ch] + 1, size); w[ch] = FRAC(u); } break;; case PIPE_TEX_WRAP_CLAMP: for (ch = 0; ch < 4; ch++) { float u = CLAMP(s[ch], 0.0F, 1.0F); u = u * size - 0.5f; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; w[ch] = FRAC(u); } break;; case PIPE_TEX_WRAP_CLAMP_TO_EDGE: for (ch = 0; ch < 4; ch++) { float u = CLAMP(s[ch], 0.0F, 1.0F); u = u * size - 0.5f; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; if (icoord0[ch] < 0) icoord0[ch] = 0; if (icoord1[ch] >= (int) size) icoord1[ch] = size - 1; w[ch] = FRAC(u); } break;; case PIPE_TEX_WRAP_CLAMP_TO_BORDER: { const float min = -1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { float u = CLAMP(s[ch], min, max); u = u * size - 0.5f; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; w[ch] = FRAC(u); } } break;; case PIPE_TEX_WRAP_MIRROR_REPEAT: for (ch = 0; ch < 4; ch++) { const int flr = util_ifloor(s[ch]); float u; if (flr & 1) u = 1.0F - (s[ch] - (float) flr); else u = s[ch] - (float) flr; u = u * size - 0.5F; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; if (icoord0[ch] < 0) icoord0[ch] = 0; if (icoord1[ch] >= (int) size) icoord1[ch] = size - 1; w[ch] = FRAC(u); } break;; case PIPE_TEX_WRAP_MIRROR_CLAMP: for (ch = 0; ch < 4; ch++) { float u = fabsf(s[ch]); if (u >= 1.0F) u = (float) size; else u *= size; u -= 0.5F; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; w[ch] = FRAC(u); } break;; case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE: for (ch = 0; ch < 4; ch++) { float u = fabsf(s[ch]); if (u >= 1.0F) u = (float) size; else u *= size; u -= 0.5F; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; if (icoord0[ch] < 0) icoord0[ch] = 0; if (icoord1[ch] >= (int) size) icoord1[ch] = size - 1; w[ch] = FRAC(u); } break;; case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER: { const float min = -1.0F / (2.0F * size); const float max = 1.0F - min; for (ch = 0; ch < 4; ch++) { float u = fabsf(s[ch]); if (u <= min) u = min * size; else if (u >= max) u = max * size; else u *= size; u -= 0.5F; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; w[ch] = FRAC(u); } } break;; default: assert(0); } } /** * For RECT textures / unnormalized texcoords * Only a subset of wrap modes supported. */ static INLINE void nearest_texcoord_unnorm_4(unsigned wrapMode, const float s[4], unsigned size, int icoord[4]) { uint ch; switch (wrapMode) { case PIPE_TEX_WRAP_CLAMP: for (ch = 0; ch < 4; ch++) { int i = util_ifloor(s[ch]); icoord[ch]= CLAMP(i, 0, (int) size-1); } return; case PIPE_TEX_WRAP_CLAMP_TO_EDGE: /* fall-through */ case PIPE_TEX_WRAP_CLAMP_TO_BORDER: for (ch = 0; ch < 4; ch++) { icoord[ch]= util_ifloor( CLAMP(s[ch], 0.5F, (float) size - 0.5F) ); } return; default: assert(0); } } /** * For RECT textures / unnormalized texcoords. * Only a subset of wrap modes supported. */ static INLINE void linear_texcoord_unnorm_4(unsigned wrapMode, const float s[4], unsigned size, int icoord0[4], int icoord1[4], float w[4]) { uint ch; switch (wrapMode) { case PIPE_TEX_WRAP_CLAMP: for (ch = 0; ch < 4; ch++) { /* Not exactly what the spec says, but it matches NVIDIA output */ float u = CLAMP(s[ch] - 0.5F, 0.0f, (float) size - 1.0f); icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; w[ch] = FRAC(u); } return; case PIPE_TEX_WRAP_CLAMP_TO_EDGE: /* fall-through */ case PIPE_TEX_WRAP_CLAMP_TO_BORDER: for (ch = 0; ch < 4; ch++) { float u = CLAMP(s[ch], 0.5F, (float) size - 0.5F); u -= 0.5F; icoord0[ch] = util_ifloor(u); icoord1[ch] = icoord0[ch] + 1; if (icoord1[ch] > (int) size - 1) icoord1[ch] = size - 1; w[ch] = FRAC(u); } break; default: assert(0); } } static unsigned choose_cube_face(float rx, float ry, float rz, float *newS, float *newT) { /* major axis direction target sc tc ma ---------- ------------------------------- --- --- --- +rx TEXTURE_CUBE_MAP_POSITIVE_X_EXT -rz -ry rx -rx TEXTURE_CUBE_MAP_NEGATIVE_X_EXT +rz -ry rx +ry TEXTURE_CUBE_MAP_POSITIVE_Y_EXT +rx +rz ry -ry TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT +rx -rz ry +rz TEXTURE_CUBE_MAP_POSITIVE_Z_EXT +rx -ry rz -rz TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT -rx -ry rz */ const float arx = fabsf(rx), ary = fabsf(ry), arz = fabsf(rz); unsigned face; float sc, tc, ma; if (arx > ary && arx > arz) { if (rx >= 0.0F) { face = PIPE_TEX_FACE_POS_X; sc = -rz; tc = -ry; ma = arx; } else { face = PIPE_TEX_FACE_NEG_X; sc = rz; tc = -ry; ma = arx; } } else if (ary > arx && ary > arz) { if (ry >= 0.0F) { face = PIPE_TEX_FACE_POS_Y; sc = rx; tc = rz; ma = ary; } else { face = PIPE_TEX_FACE_NEG_Y; sc = rx; tc = -rz; ma = ary; } } else { if (rz > 0.0F) { face = PIPE_TEX_FACE_POS_Z; sc = rx; tc = -ry; ma = arz; } else { face = PIPE_TEX_FACE_NEG_Z; sc = -rx; tc = -ry; ma = arz; } } *newS = ( sc / ma + 1.0F ) * 0.5F; *newT = ( tc / ma + 1.0F ) * 0.5F; return face; } /** * Examine the quad's texture coordinates to compute the partial * derivatives w.r.t X and Y, then compute lambda (level of detail). * * This is only done for fragment shaders, not vertex shaders. */ static float compute_lambda(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; float rho, lambda; if (samp->processor == TGSI_PROCESSOR_VERTEX) return lodbias; assert(sampler->normalized_coords); assert(s); { float dsdx = s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT]; float dsdy = s[QUAD_TOP_LEFT] - s[QUAD_BOTTOM_LEFT]; dsdx = fabsf(dsdx); dsdy = fabsf(dsdy); rho = MAX2(dsdx, dsdy) * texture->width0; } if (t) { float dtdx = t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT]; float dtdy = t[QUAD_TOP_LEFT] - t[QUAD_BOTTOM_LEFT]; float max; dtdx = fabsf(dtdx); dtdy = fabsf(dtdy); max = MAX2(dtdx, dtdy) * texture->height0; rho = MAX2(rho, max); } if (p) { float dpdx = p[QUAD_BOTTOM_RIGHT] - p[QUAD_BOTTOM_LEFT]; float dpdy = p[QUAD_TOP_LEFT] - p[QUAD_BOTTOM_LEFT]; float max; dpdx = fabsf(dpdx); dpdy = fabsf(dpdy); max = MAX2(dpdx, dpdy) * texture->depth0; rho = MAX2(rho, max); } lambda = util_fast_log2(rho); lambda += lodbias + sampler->lod_bias; lambda = CLAMP(lambda, sampler->min_lod, sampler->max_lod); return lambda; } /** * Do several things here: * 1. Compute lambda from the texcoords, if needed * 2. Determine if we're minifying or magnifying * 3. If minifying, choose mipmap levels * 4. Return image filter to use within mipmap images * \param level0 Returns first mipmap level to sample from * \param level1 Returns second mipmap level to sample from * \param levelBlend Returns blend factor between levels, in [0,1] * \param imgFilter Returns either the min or mag filter, depending on lambda */ static void choose_mipmap_levels(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, unsigned *level0, unsigned *level1, float *levelBlend, unsigned *imgFilter) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) { /* no mipmap selection needed */ *level0 = *level1 = CLAMP((int) sampler->min_lod, 0, (int) texture->last_level); if (sampler->min_img_filter != sampler->mag_img_filter) { /* non-mipmapped texture, but still need to determine if doing * minification or magnification. */ float lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias); if (lambda <= 0.0) { *imgFilter = sampler->mag_img_filter; } else { *imgFilter = sampler->min_img_filter; } } else { *imgFilter = sampler->mag_img_filter; } } else { float lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias); if (lambda <= 0.0) { /* XXX threshold depends on the filter */ /* magnifying */ *imgFilter = sampler->mag_img_filter; *level0 = *level1 = 0; } else { /* minifying */ *imgFilter = sampler->min_img_filter; /* choose mipmap level(s) and compute the blend factor between them */ if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NEAREST) { /* Nearest mipmap level */ const int lvl = (int) (lambda + 0.5); *level0 = *level1 = CLAMP(lvl, 0, (int) texture->last_level); } else { /* Linear interpolation between mipmap levels */ const int lvl = (int) lambda; *level0 = CLAMP(lvl, 0, (int) texture->last_level); *level1 = CLAMP(lvl + 1, 0, (int) texture->last_level); *levelBlend = FRAC(lambda); /* blending weight between levels */ } } } } /** * Get a texel from a texture, using the texture tile cache. * * \param face the cube face in 0..5 * \param level the mipmap level * \param x the x coord of texel within 2D image * \param y the y coord of texel within 2D image * \param z which slice of a 3D texture * \param rgba the quad to put the texel/color into * \param j which element of the rgba quad to write to * * XXX maybe move this into lp_tile_cache.c and merge with the * lp_get_cached_tile_tex() function. Also, get 4 texels instead of 1... */ static void get_texel_quad_2d(const struct tgsi_sampler *tgsi_sampler, unsigned face, unsigned level, int x, int y, const uint8_t *out[4]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct llvmpipe_cached_tex_tile *tile = lp_get_cached_tex_tile(samp->cache, tex_tile_address(x, y, 0, face, level)); y %= TEX_TILE_SIZE; x %= TEX_TILE_SIZE; out[0] = &tile->color[y ][x ][0]; out[1] = &tile->color[y ][x+1][0]; out[2] = &tile->color[y+1][x ][0]; out[3] = &tile->color[y+1][x+1][0]; } static INLINE const uint8_t * get_texel_2d_ptr(const struct tgsi_sampler *tgsi_sampler, unsigned face, unsigned level, int x, int y) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct llvmpipe_cached_tex_tile *tile = lp_get_cached_tex_tile(samp->cache, tex_tile_address(x, y, 0, face, level)); y %= TEX_TILE_SIZE; x %= TEX_TILE_SIZE; return &tile->color[y][x][0]; } static void get_texel_quad_2d_mt(const struct tgsi_sampler *tgsi_sampler, unsigned face, unsigned level, int x0, int y0, int x1, int y1, const uint8_t *out[4]) { unsigned i; for (i = 0; i < 4; i++) { unsigned tx = (i & 1) ? x1 : x0; unsigned ty = (i >> 1) ? y1 : y0; out[i] = get_texel_2d_ptr( tgsi_sampler, face, level, tx, ty ); } } static void get_texel(const struct tgsi_sampler *tgsi_sampler, unsigned face, unsigned level, int x, int y, int z, float rgba[NUM_CHANNELS][QUAD_SIZE], unsigned j) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; if (x < 0 || x >= (int) u_minify(texture->width0, level) || y < 0 || y >= (int) u_minify(texture->height0, level) || z < 0 || z >= (int) u_minify(texture->depth0, level)) { rgba[0][j] = sampler->border_color[0]; rgba[1][j] = sampler->border_color[1]; rgba[2][j] = sampler->border_color[2]; rgba[3][j] = sampler->border_color[3]; } else { const unsigned tx = x % TEX_TILE_SIZE; const unsigned ty = y % TEX_TILE_SIZE; const struct llvmpipe_cached_tex_tile *tile; tile = lp_get_cached_tex_tile(samp->cache, tex_tile_address(x, y, z, face, level)); rgba[0][j] = ubyte_to_float(tile->color[ty][tx][0]); rgba[1][j] = ubyte_to_float(tile->color[ty][tx][1]); rgba[2][j] = ubyte_to_float(tile->color[ty][tx][2]); rgba[3][j] = ubyte_to_float(tile->color[ty][tx][3]); if (0) { debug_printf("Get texel %f %f %f %f from %s\n", rgba[0][j], rgba[1][j], rgba[2][j], rgba[3][j], pf_name(texture->format)); } } } /** * Compare texcoord 'p' (aka R) against texture value 'rgba[0]' * When we sampled the depth texture, the depth value was put into all * RGBA channels. We look at the red channel here. * \param rgba quad of (depth) texel values * \param p texture 'P' components for four pixels in quad * \param j which pixel in the quad to test [0..3] */ static INLINE void shadow_compare(const struct pipe_sampler_state *sampler, float rgba[NUM_CHANNELS][QUAD_SIZE], const float p[QUAD_SIZE], uint j) { int k; switch (sampler->compare_func) { case PIPE_FUNC_LESS: k = p[j] < rgba[0][j]; break; case PIPE_FUNC_LEQUAL: k = p[j] <= rgba[0][j]; break; case PIPE_FUNC_GREATER: k = p[j] > rgba[0][j]; break; case PIPE_FUNC_GEQUAL: k = p[j] >= rgba[0][j]; break; case PIPE_FUNC_EQUAL: k = p[j] == rgba[0][j]; break; case PIPE_FUNC_NOTEQUAL: k = p[j] != rgba[0][j]; break; case PIPE_FUNC_ALWAYS: k = 1; break; case PIPE_FUNC_NEVER: k = 0; break; default: k = 0; assert(0); break; } /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */ rgba[0][j] = rgba[1][j] = rgba[2][j] = (float) k; rgba[3][j] = 1.0F; } /** * As above, but do four z/texture comparisons. */ static INLINE void shadow_compare4(const struct pipe_sampler_state *sampler, float rgba[NUM_CHANNELS][QUAD_SIZE], const float p[QUAD_SIZE]) { int j, k0, k1, k2, k3; float val; /* compare four texcoords vs. four texture samples */ switch (sampler->compare_func) { case PIPE_FUNC_LESS: k0 = p[0] < rgba[0][0]; k1 = p[1] < rgba[0][1]; k2 = p[2] < rgba[0][2]; k3 = p[3] < rgba[0][3]; break; case PIPE_FUNC_LEQUAL: k0 = p[0] <= rgba[0][0]; k1 = p[1] <= rgba[0][1]; k2 = p[2] <= rgba[0][2]; k3 = p[3] <= rgba[0][3]; break; case PIPE_FUNC_GREATER: k0 = p[0] > rgba[0][0]; k1 = p[1] > rgba[0][1]; k2 = p[2] > rgba[0][2]; k3 = p[3] > rgba[0][3]; break; case PIPE_FUNC_GEQUAL: k0 = p[0] >= rgba[0][0]; k1 = p[1] >= rgba[0][1]; k2 = p[2] >= rgba[0][2]; k3 = p[3] >= rgba[0][3]; break; case PIPE_FUNC_EQUAL: k0 = p[0] == rgba[0][0]; k1 = p[1] == rgba[0][1]; k2 = p[2] == rgba[0][2]; k3 = p[3] == rgba[0][3]; break; case PIPE_FUNC_NOTEQUAL: k0 = p[0] != rgba[0][0]; k1 = p[1] != rgba[0][1]; k2 = p[2] != rgba[0][2]; k3 = p[3] != rgba[0][3]; break; case PIPE_FUNC_ALWAYS: k0 = k1 = k2 = k3 = 1; break; case PIPE_FUNC_NEVER: k0 = k1 = k2 = k3 = 0; break; default: k0 = k1 = k2 = k3 = 0; assert(0); break; } /* convert four pass/fail values to an intensity in [0,1] */ val = 0.25F * (k0 + k1 + k2 + k3); /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */ for (j = 0; j < 4; j++) { rgba[0][j] = rgba[1][j] = rgba[2][j] = val; rgba[3][j] = 1.0F; } } static void lp_get_samples_2d_linear_repeat_POT(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); unsigned j; unsigned level = samp->level; unsigned xpot = 1 << (samp->xpot - level); unsigned ypot = 1 << (samp->ypot - level); unsigned xmax = (xpot - 1) & (TEX_TILE_SIZE - 1); /* MIN2(TEX_TILE_SIZE, xpot) - 1; */ unsigned ymax = (ypot - 1) & (TEX_TILE_SIZE - 1); /* MIN2(TEX_TILE_SIZE, ypot) - 1; */ for (j = 0; j < QUAD_SIZE; j++) { int c; float u = s[j] * xpot - 0.5F; float v = t[j] * ypot - 0.5F; int uflr = util_ifloor(u); int vflr = util_ifloor(v); float xw = u - (float)uflr; float yw = v - (float)vflr; int x0 = uflr & (xpot - 1); int y0 = vflr & (ypot - 1); const uint8_t *tx[4]; /* Can we fetch all four at once: */ if (x0 < xmax && y0 < ymax) { get_texel_quad_2d(tgsi_sampler, 0, level, x0, y0, tx); } else { unsigned x1 = (x0 + 1) & (xpot - 1); unsigned y1 = (y0 + 1) & (ypot - 1); get_texel_quad_2d_mt(tgsi_sampler, 0, level, x0, y0, x1, y1, tx); } /* interpolate R, G, B, A */ for (c = 0; c < 4; c++) { rgba[c][j] = lerp_2d(xw, yw, ubyte_to_float(tx[0][c]), ubyte_to_float(tx[1][c]), ubyte_to_float(tx[2][c]), ubyte_to_float(tx[3][c])); } } } static void lp_get_samples_2d_nearest_repeat_POT(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); unsigned j; unsigned level = samp->level; unsigned xpot = 1 << (samp->xpot - level); unsigned ypot = 1 << (samp->ypot - level); for (j = 0; j < QUAD_SIZE; j++) { int c; float u = s[j] * xpot; float v = t[j] * ypot; int uflr = util_ifloor(u); int vflr = util_ifloor(v); int x0 = uflr & (xpot - 1); int y0 = vflr & (ypot - 1); const uint8_t *out = get_texel_2d_ptr(tgsi_sampler, 0, level, x0, y0); for (c = 0; c < 4; c++) { rgba[c][j] = ubyte_to_float(out[c]); } } } static void lp_get_samples_2d_nearest_clamp_POT(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); unsigned j; unsigned level = samp->level; unsigned xpot = 1 << (samp->xpot - level); unsigned ypot = 1 << (samp->ypot - level); for (j = 0; j < QUAD_SIZE; j++) { int c; float u = s[j] * xpot; float v = t[j] * ypot; int x0, y0; const uint8_t *out; x0 = util_ifloor(u); if (x0 < 0) x0 = 0; else if (x0 > xpot - 1) x0 = xpot - 1; y0 = util_ifloor(v); if (y0 < 0) y0 = 0; else if (y0 > ypot - 1) y0 = ypot - 1; out = get_texel_2d_ptr(tgsi_sampler, 0, level, x0, y0); for (c = 0; c < 4; c++) { rgba[c][j] = ubyte_to_float(out[c]); } } } static void lp_get_samples_2d_linear_mip_linear_repeat_POT(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; int level0; float lambda; lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias); level0 = (int)lambda; if (lambda < 0.0) { samp->level = 0; lp_get_samples_2d_linear_repeat_POT( tgsi_sampler, s, t, p, 0, rgba ); } else if (level0 >= texture->last_level) { samp->level = texture->last_level; lp_get_samples_2d_linear_repeat_POT( tgsi_sampler, s, t, p, 0, rgba ); } else { float levelBlend = lambda - level0; float rgba0[4][4]; float rgba1[4][4]; int c,j; samp->level = level0; lp_get_samples_2d_linear_repeat_POT( tgsi_sampler, s, t, p, 0, rgba0 ); samp->level = level0+1; lp_get_samples_2d_linear_repeat_POT( tgsi_sampler, s, t, p, 0, rgba1 ); for (j = 0; j < QUAD_SIZE; j++) { for (c = 0; c < 4; c++) { rgba[c][j] = lerp(levelBlend, rgba0[c][j], rgba1[c][j]); } } } } /** * Common code for sampling 1D/2D/cube textures. * Could probably extend for 3D... */ static void lp_get_samples_2d_common(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE], const unsigned faces[4]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; unsigned level0, level1, j, imgFilter; int width, height; float levelBlend; choose_mipmap_levels(tgsi_sampler, s, t, p, lodbias, &level0, &level1, &levelBlend, &imgFilter); assert(sampler->normalized_coords); width = u_minify(texture->width0, level0); height = u_minify(texture->height0, level0); assert(width > 0); switch (imgFilter) { case PIPE_TEX_FILTER_NEAREST: { int x[4], y[4]; nearest_texcoord_4(sampler->wrap_s, s, width, x); nearest_texcoord_4(sampler->wrap_t, t, height, y); for (j = 0; j < QUAD_SIZE; j++) { get_texel(tgsi_sampler, faces[j], level0, x[j], y[j], 0, rgba, j); if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { shadow_compare(sampler, rgba, p, j); } if (level0 != level1) { /* get texels from second mipmap level and blend */ float rgba2[4][4]; unsigned c; x[j] /= 2; y[j] /= 2; get_texel(tgsi_sampler, faces[j], level1, x[j], y[j], 0, rgba2, j); if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE){ shadow_compare(sampler, rgba2, p, j); } for (c = 0; c < NUM_CHANNELS; c++) { rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]); } } } } break; case PIPE_TEX_FILTER_LINEAR: case PIPE_TEX_FILTER_ANISO: { int x0[4], y0[4], x1[4], y1[4]; float xw[4], yw[4]; /* weights */ linear_texcoord_4(sampler->wrap_s, s, width, x0, x1, xw); linear_texcoord_4(sampler->wrap_t, t, height, y0, y1, yw); for (j = 0; j < QUAD_SIZE; j++) { float tx[4][4]; /* texels */ int c; get_texel(tgsi_sampler, faces[j], level0, x0[j], y0[j], 0, tx, 0); get_texel(tgsi_sampler, faces[j], level0, x1[j], y0[j], 0, tx, 1); get_texel(tgsi_sampler, faces[j], level0, x0[j], y1[j], 0, tx, 2); get_texel(tgsi_sampler, faces[j], level0, x1[j], y1[j], 0, tx, 3); if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { shadow_compare4(sampler, tx, p); } /* interpolate R, G, B, A */ for (c = 0; c < 4; c++) { rgba[c][j] = lerp_2d(xw[j], yw[j], tx[c][0], tx[c][1], tx[c][2], tx[c][3]); } if (level0 != level1) { /* get texels from second mipmap level and blend */ float rgba2[4][4]; /* XXX: This is incorrect -- will often end up with (x0 * == x1 && y0 == y1), meaning that we fetch the same * texel four times and linearly interpolate between * identical values. The correct approach would be to * call linear_texcoord again for the second level. */ x0[j] /= 2; y0[j] /= 2; x1[j] /= 2; y1[j] /= 2; get_texel(tgsi_sampler, faces[j], level1, x0[j], y0[j], 0, tx, 0); get_texel(tgsi_sampler, faces[j], level1, x1[j], y0[j], 0, tx, 1); get_texel(tgsi_sampler, faces[j], level1, x0[j], y1[j], 0, tx, 2); get_texel(tgsi_sampler, faces[j], level1, x1[j], y1[j], 0, tx, 3); if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE){ shadow_compare4(sampler, tx, p); } /* interpolate R, G, B, A */ for (c = 0; c < 4; c++) { rgba2[c][j] = lerp_2d(xw[j], yw[j], tx[c][0], tx[c][1], tx[c][2], tx[c][3]); } for (c = 0; c < NUM_CHANNELS; c++) { rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]); } } } } break; default: assert(0); } } static INLINE void lp_get_samples_1d(struct tgsi_sampler *sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { static const unsigned faces[4] = {0, 0, 0, 0}; static const float tzero[4] = {0, 0, 0, 0}; lp_get_samples_2d_common(sampler, s, tzero, NULL, lodbias, rgba, faces); } static INLINE void lp_get_samples_2d(struct tgsi_sampler *sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { static const unsigned faces[4] = {0, 0, 0, 0}; lp_get_samples_2d_common(sampler, s, t, p, lodbias, rgba, faces); } static INLINE void lp_get_samples_3d(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; /* get/map pipe_surfaces corresponding to 3D tex slices */ unsigned level0, level1, j, imgFilter; int width, height, depth; float levelBlend; const uint face = 0; choose_mipmap_levels(tgsi_sampler, s, t, p, lodbias, &level0, &level1, &levelBlend, &imgFilter); assert(sampler->normalized_coords); width = u_minify(texture->width0, level0); height = u_minify(texture->height0, level0); depth = u_minify(texture->depth0, level0); assert(width > 0); assert(height > 0); assert(depth > 0); switch (imgFilter) { case PIPE_TEX_FILTER_NEAREST: { int x[4], y[4], z[4]; nearest_texcoord_4(sampler->wrap_s, s, width, x); nearest_texcoord_4(sampler->wrap_t, t, height, y); nearest_texcoord_4(sampler->wrap_r, p, depth, z); for (j = 0; j < QUAD_SIZE; j++) { get_texel(tgsi_sampler, face, level0, x[j], y[j], z[j], rgba, j); if (level0 != level1) { /* get texels from second mipmap level and blend */ float rgba2[4][4]; unsigned c; x[j] /= 2; y[j] /= 2; z[j] /= 2; get_texel(tgsi_sampler, face, level1, x[j], y[j], z[j], rgba2, j); for (c = 0; c < NUM_CHANNELS; c++) { rgba[c][j] = lerp(levelBlend, rgba2[c][j], rgba[c][j]); } } } } break; case PIPE_TEX_FILTER_LINEAR: case PIPE_TEX_FILTER_ANISO: { int x0[4], x1[4], y0[4], y1[4], z0[4], z1[4]; float xw[4], yw[4], zw[4]; /* interpolation weights */ linear_texcoord_4(sampler->wrap_s, s, width, x0, x1, xw); linear_texcoord_4(sampler->wrap_t, t, height, y0, y1, yw); linear_texcoord_4(sampler->wrap_r, p, depth, z0, z1, zw); for (j = 0; j < QUAD_SIZE; j++) { int c; float tx0[4][4], tx1[4][4]; get_texel(tgsi_sampler, face, level0, x0[j], y0[j], z0[j], tx0, 0); get_texel(tgsi_sampler, face, level0, x1[j], y0[j], z0[j], tx0, 1); get_texel(tgsi_sampler, face, level0, x0[j], y1[j], z0[j], tx0, 2); get_texel(tgsi_sampler, face, level0, x1[j], y1[j], z0[j], tx0, 3); get_texel(tgsi_sampler, face, level0, x0[j], y0[j], z1[j], tx1, 0); get_texel(tgsi_sampler, face, level0, x1[j], y0[j], z1[j], tx1, 1); get_texel(tgsi_sampler, face, level0, x0[j], y1[j], z1[j], tx1, 2); get_texel(tgsi_sampler, face, level0, x1[j], y1[j], z1[j], tx1, 3); /* interpolate R, G, B, A */ for (c = 0; c < 4; c++) { rgba[c][j] = lerp_3d(xw[j], yw[j], zw[j], tx0[c][0], tx0[c][1], tx0[c][2], tx0[c][3], tx1[c][0], tx1[c][1], tx1[c][2], tx1[c][3]); } if (level0 != level1) { /* get texels from second mipmap level and blend */ float rgba2[4][4]; x0[j] /= 2; y0[j] /= 2; z0[j] /= 2; x1[j] /= 2; y1[j] /= 2; z1[j] /= 2; get_texel(tgsi_sampler, face, level1, x0[j], y0[j], z0[j], tx0, 0); get_texel(tgsi_sampler, face, level1, x1[j], y0[j], z0[j], tx0, 1); get_texel(tgsi_sampler, face, level1, x0[j], y1[j], z0[j], tx0, 2); get_texel(tgsi_sampler, face, level1, x1[j], y1[j], z0[j], tx0, 3); get_texel(tgsi_sampler, face, level1, x0[j], y0[j], z1[j], tx1, 0); get_texel(tgsi_sampler, face, level1, x1[j], y0[j], z1[j], tx1, 1); get_texel(tgsi_sampler, face, level1, x0[j], y1[j], z1[j], tx1, 2); get_texel(tgsi_sampler, face, level1, x1[j], y1[j], z1[j], tx1, 3); /* interpolate R, G, B, A */ for (c = 0; c < 4; c++) { rgba2[c][j] = lerp_3d(xw[j], yw[j], zw[j], tx0[c][0], tx0[c][1], tx0[c][2], tx0[c][3], tx1[c][0], tx1[c][1], tx1[c][2], tx1[c][3]); } /* blend mipmap levels */ for (c = 0; c < NUM_CHANNELS; c++) { rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]); } } } } break; default: assert(0); } } static void lp_get_samples_cube(struct tgsi_sampler *sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { unsigned faces[QUAD_SIZE], j; float ssss[4], tttt[4]; for (j = 0; j < QUAD_SIZE; j++) { faces[j] = choose_cube_face(s[j], t[j], p[j], ssss + j, tttt + j); } lp_get_samples_2d_common(sampler, ssss, tttt, NULL, lodbias, rgba, faces); } static void lp_get_samples_rect(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; const uint face = 0; unsigned level0, level1, j, imgFilter; int width, height; float levelBlend; choose_mipmap_levels(tgsi_sampler, s, t, p, lodbias, &level0, &level1, &levelBlend, &imgFilter); /* texture RECTS cannot be mipmapped */ assert(level0 == level1); width = u_minify(texture->width0, level0); height = u_minify(texture->height0, level0); assert(width > 0); switch (imgFilter) { case PIPE_TEX_FILTER_NEAREST: { int x[4], y[4]; nearest_texcoord_unnorm_4(sampler->wrap_s, s, width, x); nearest_texcoord_unnorm_4(sampler->wrap_t, t, height, y); for (j = 0; j < QUAD_SIZE; j++) { get_texel(tgsi_sampler, face, level0, x[j], y[j], 0, rgba, j); if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { shadow_compare(sampler, rgba, p, j); } } } break; case PIPE_TEX_FILTER_LINEAR: case PIPE_TEX_FILTER_ANISO: { int x0[4], y0[4], x1[4], y1[4]; float xw[4], yw[4]; /* weights */ linear_texcoord_unnorm_4(sampler->wrap_s, s, width, x0, x1, xw); linear_texcoord_unnorm_4(sampler->wrap_t, t, height, y0, y1, yw); for (j = 0; j < QUAD_SIZE; j++) { float tx[4][4]; /* texels */ int c; get_texel(tgsi_sampler, face, level0, x0[j], y0[j], 0, tx, 0); get_texel(tgsi_sampler, face, level0, x1[j], y0[j], 0, tx, 1); get_texel(tgsi_sampler, face, level0, x0[j], y1[j], 0, tx, 2); get_texel(tgsi_sampler, face, level0, x1[j], y1[j], 0, tx, 3); if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { shadow_compare4(sampler, tx, p); } for (c = 0; c < 4; c++) { rgba[c][j] = lerp_2d(xw[j], yw[j], tx[c][0], tx[c][1], tx[c][2], tx[c][3]); } } } break; default: assert(0); } } /** * Error condition handler */ static INLINE void lp_get_samples_null(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { int i,j; for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) rgba[i][j] = 1.0; } /** * Called via tgsi_sampler::get_samples() when using a sampler for the * first time. Determine the actual sampler function, link it in and * call it. */ void lp_get_samples(struct tgsi_sampler *tgsi_sampler, const float s[QUAD_SIZE], const float t[QUAD_SIZE], const float p[QUAD_SIZE], float lodbias, float rgba[NUM_CHANNELS][QUAD_SIZE]) { struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler); const struct pipe_texture *texture = samp->texture; const struct pipe_sampler_state *sampler = samp->sampler; /* Default to the 'undefined' case: */ tgsi_sampler->get_samples = lp_get_samples_null; if (!texture) { assert(0); /* is this legal?? */ goto out; } if (!sampler->normalized_coords) { assert (texture->target == PIPE_TEXTURE_2D); tgsi_sampler->get_samples = lp_get_samples_rect; goto out; } switch (texture->target) { case PIPE_TEXTURE_1D: tgsi_sampler->get_samples = lp_get_samples_1d; break; case PIPE_TEXTURE_2D: tgsi_sampler->get_samples = lp_get_samples_2d; break; case PIPE_TEXTURE_3D: tgsi_sampler->get_samples = lp_get_samples_3d; break; case PIPE_TEXTURE_CUBE: tgsi_sampler->get_samples = lp_get_samples_cube; break; default: assert(0); break; } /* Do this elsewhere: */ samp->xpot = util_unsigned_logbase2( samp->texture->width0 ); samp->ypot = util_unsigned_logbase2( samp->texture->height0 ); /* Try to hook in a faster sampler. Ultimately we'll have to * code-generate these. Luckily most of this looks like it is * orthogonal state within the sampler. */ if (texture->target == PIPE_TEXTURE_2D && sampler->min_img_filter == sampler->mag_img_filter && sampler->wrap_s == sampler->wrap_t && sampler->compare_mode == FALSE && sampler->normalized_coords) { if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) { samp->level = CLAMP((int) sampler->min_lod, 0, (int) texture->last_level); if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT) { switch (sampler->min_img_filter) { case PIPE_TEX_FILTER_NEAREST: tgsi_sampler->get_samples = lp_get_samples_2d_nearest_repeat_POT; break; case PIPE_TEX_FILTER_LINEAR: tgsi_sampler->get_samples = lp_get_samples_2d_linear_repeat_POT; break; default: break; } } else if (sampler->wrap_s == PIPE_TEX_WRAP_CLAMP) { switch (sampler->min_img_filter) { case PIPE_TEX_FILTER_NEAREST: tgsi_sampler->get_samples = lp_get_samples_2d_nearest_clamp_POT; break; default: break; } } } else if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_LINEAR) { if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT) { switch (sampler->min_img_filter) { case PIPE_TEX_FILTER_LINEAR: tgsi_sampler->get_samples = lp_get_samples_2d_linear_mip_linear_repeat_POT; break; default: break; } } } } else if (0) { _debug_printf("target %d/%d min_mip %d/%d min_img %d/%d wrap %d/%d compare %d/%d norm %d/%d\n", texture->target, PIPE_TEXTURE_2D, sampler->min_mip_filter, PIPE_TEX_MIPFILTER_NONE, sampler->min_img_filter, sampler->mag_img_filter, sampler->wrap_s, sampler->wrap_t, sampler->compare_mode, FALSE, sampler->normalized_coords, TRUE); } out: tgsi_sampler->get_samples( tgsi_sampler, s, t, p, lodbias, rgba ); } void PIPE_CDECL lp_fetch_texel_soa( struct tgsi_sampler **samplers, uint32_t unit, float *store ) { struct tgsi_sampler *sampler = samplers[unit]; #if 0 uint j; debug_printf("%s sampler: %p (%p) store: %p\n", __FUNCTION__, sampler, *sampler, store ); debug_printf("lodbias %f\n", store[12]); for (j = 0; j < 4; j++) debug_printf("sample %d texcoord %f %f\n", j, store[0+j], store[4+j]); #endif { float rgba[NUM_CHANNELS][QUAD_SIZE]; sampler->get_samples(sampler, &store[0], &store[4], &store[8], 0.0f, /*store[12], lodbias */ rgba); memcpy(store, rgba, sizeof rgba); } #if 0 for (j = 0; j < 4; j++) debug_printf("sample %d result %f %f %f %f\n", j, store[0+j], store[4+j], store[8+j], store[12+j]); #endif } #include "lp_bld_type.h" #include "lp_bld_intr.h" #include "lp_bld_tgsi.h" struct lp_c_sampler_soa { struct lp_build_sampler_soa base; LLVMValueRef context_ptr; LLVMValueRef samplers_ptr; /** Coords/texels store */ LLVMValueRef store_ptr; }; static void lp_c_sampler_soa_destroy(struct lp_build_sampler_soa *sampler) { FREE(sampler); } static void lp_c_sampler_soa_emit_fetch_texel(struct lp_build_sampler_soa *_sampler, LLVMBuilderRef builder, struct lp_type type, unsigned unit, unsigned num_coords, const LLVMValueRef *coords, LLVMValueRef lodbias, LLVMValueRef *texel) { struct lp_c_sampler_soa *sampler = (struct lp_c_sampler_soa *)_sampler; LLVMTypeRef vec_type = LLVMTypeOf(coords[0]); LLVMValueRef args[3]; unsigned i; if(!sampler->samplers_ptr) sampler->samplers_ptr = lp_jit_context_samplers(builder, sampler->context_ptr); if(!sampler->store_ptr) sampler->store_ptr = LLVMBuildArrayAlloca(builder, vec_type, LLVMConstInt(LLVMInt32Type(), 4, 0), "texel_store"); for (i = 0; i < num_coords; i++) { LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0); LLVMValueRef coord_ptr = LLVMBuildGEP(builder, sampler->store_ptr, &index, 1, ""); LLVMBuildStore(builder, coords[i], coord_ptr); } args[0] = sampler->samplers_ptr; args[1] = LLVMConstInt(LLVMInt32Type(), unit, 0); args[2] = sampler->store_ptr; lp_build_intrinsic(builder, "fetch_texel", LLVMVoidType(), args, 3); for (i = 0; i < NUM_CHANNELS; ++i) { LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0); LLVMValueRef texel_ptr = LLVMBuildGEP(builder, sampler->store_ptr, &index, 1, ""); texel[i] = LLVMBuildLoad(builder, texel_ptr, ""); } } struct lp_build_sampler_soa * lp_c_sampler_soa_create(LLVMValueRef context_ptr) { struct lp_c_sampler_soa *sampler; sampler = CALLOC_STRUCT(lp_c_sampler_soa); if(!sampler) return NULL; sampler->base.destroy = lp_c_sampler_soa_destroy; sampler->base.emit_fetch_texel = lp_c_sampler_soa_emit_fetch_texel; sampler->context_ptr = context_ptr; return &sampler->base; }