/************************************************************************** * * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. * 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. * **************************************************************************/ /* * Authors: * Keith Whitwell * Brian Paul */ #include "main/macros.h" #include "main/mtypes.h" #include "main/glformats.h" #include "main/samplerobj.h" #include "main/texobj.h" #include "st_context.h" #include "st_cb_texture.h" #include "st_format.h" #include "st_atom.h" #include "st_texture.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" #include "cso_cache/cso_context.h" #include "util/u_format.h" /** * Convert GLenum texcoord wrap tokens to pipe tokens. */ static GLuint gl_wrap_xlate(GLenum wrap) { switch (wrap) { case GL_REPEAT: return PIPE_TEX_WRAP_REPEAT; case GL_CLAMP: return PIPE_TEX_WRAP_CLAMP; case GL_CLAMP_TO_EDGE: return PIPE_TEX_WRAP_CLAMP_TO_EDGE; case GL_CLAMP_TO_BORDER: return PIPE_TEX_WRAP_CLAMP_TO_BORDER; case GL_MIRRORED_REPEAT: return PIPE_TEX_WRAP_MIRROR_REPEAT; case GL_MIRROR_CLAMP_EXT: return PIPE_TEX_WRAP_MIRROR_CLAMP; case GL_MIRROR_CLAMP_TO_EDGE_EXT: return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE; case GL_MIRROR_CLAMP_TO_BORDER_EXT: return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER; default: assert(0); return 0; } } static GLuint gl_filter_to_mip_filter(GLenum filter) { switch (filter) { case GL_NEAREST: case GL_LINEAR: return PIPE_TEX_MIPFILTER_NONE; case GL_NEAREST_MIPMAP_NEAREST: case GL_LINEAR_MIPMAP_NEAREST: return PIPE_TEX_MIPFILTER_NEAREST; case GL_NEAREST_MIPMAP_LINEAR: case GL_LINEAR_MIPMAP_LINEAR: return PIPE_TEX_MIPFILTER_LINEAR; default: assert(0); return PIPE_TEX_MIPFILTER_NONE; } } static GLuint gl_filter_to_img_filter(GLenum filter) { switch (filter) { case GL_NEAREST: case GL_NEAREST_MIPMAP_NEAREST: case GL_NEAREST_MIPMAP_LINEAR: return PIPE_TEX_FILTER_NEAREST; case GL_LINEAR: case GL_LINEAR_MIPMAP_NEAREST: case GL_LINEAR_MIPMAP_LINEAR: return PIPE_TEX_FILTER_LINEAR; default: assert(0); return PIPE_TEX_FILTER_NEAREST; } } static void convert_sampler(struct st_context *st, struct pipe_sampler_state *sampler, GLuint texUnit) { struct gl_texture_object *texobj; struct gl_context *ctx = st->ctx; struct gl_sampler_object *msamp; texobj = ctx->Texture.Unit[texUnit]._Current; if (!texobj) { texobj = _mesa_get_fallback_texture(ctx, TEXTURE_2D_INDEX); } msamp = _mesa_get_samplerobj(ctx, texUnit); memset(sampler, 0, sizeof(*sampler)); sampler->wrap_s = gl_wrap_xlate(msamp->WrapS); sampler->wrap_t = gl_wrap_xlate(msamp->WrapT); sampler->wrap_r = gl_wrap_xlate(msamp->WrapR); sampler->min_img_filter = gl_filter_to_img_filter(msamp->MinFilter); sampler->min_mip_filter = gl_filter_to_mip_filter(msamp->MinFilter); sampler->mag_img_filter = gl_filter_to_img_filter(msamp->MagFilter); if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB) sampler->normalized_coords = 1; sampler->lod_bias = ctx->Texture.Unit[texUnit].LodBias + msamp->LodBias; sampler->min_lod = CLAMP(msamp->MinLod, 0.0f, (GLfloat) texobj->MaxLevel - texobj->BaseLevel); sampler->max_lod = MIN2((GLfloat) texobj->MaxLevel - texobj->BaseLevel, msamp->MaxLod); if (sampler->max_lod < sampler->min_lod) { /* The GL spec doesn't seem to specify what to do in this case. * Swap the values. */ float tmp = sampler->max_lod; sampler->max_lod = sampler->min_lod; sampler->min_lod = tmp; assert(sampler->min_lod <= sampler->max_lod); } if (msamp->BorderColor.ui[0] || msamp->BorderColor.ui[1] || msamp->BorderColor.ui[2] || msamp->BorderColor.ui[3]) { struct st_texture_object *stobj = st_texture_object(texobj); struct gl_texture_image *teximg; GLboolean is_integer = GL_FALSE; union pipe_color_union border_color; teximg = texobj->Image[0][texobj->BaseLevel]; if (teximg) { is_integer = _mesa_is_enum_format_integer(teximg->InternalFormat); } if (st->apply_texture_swizzle_to_border_color && stobj->sampler_view) { const unsigned char swz[4] = { stobj->sampler_view->swizzle_r, stobj->sampler_view->swizzle_g, stobj->sampler_view->swizzle_b, stobj->sampler_view->swizzle_a, }; st_translate_color(&msamp->BorderColor, &border_color, teximg ? teximg->_BaseFormat : GL_RGBA, is_integer); util_format_apply_color_swizzle(&sampler->border_color, &border_color, swz, is_integer); } else { st_translate_color(&msamp->BorderColor, &sampler->border_color, teximg ? teximg->_BaseFormat : GL_RGBA, is_integer); } } sampler->max_anisotropy = (msamp->MaxAnisotropy == 1.0 ? 0 : (GLuint) msamp->MaxAnisotropy); /* only care about ARB_shadow, not SGI shadow */ if (msamp->CompareMode == GL_COMPARE_R_TO_TEXTURE) { sampler->compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE; sampler->compare_func = st_compare_func_to_pipe(msamp->CompareFunc); } sampler->seamless_cube_map = ctx->Texture.CubeMapSeamless || msamp->CubeMapSeamless; } /** * Update the gallium driver's sampler state for fragment, vertex or * geometry shader stage. */ static void update_shader_samplers(struct st_context *st, unsigned shader_stage, const struct gl_program *prog, unsigned max_units, struct pipe_sampler_state *samplers, unsigned *num_samplers) { GLuint unit; GLbitfield samplers_used; const GLuint old_max = *num_samplers; samplers_used = prog->SamplersUsed; if (*num_samplers == 0 && samplers_used == 0x0) return; *num_samplers = 0; /* loop over sampler units (aka tex image units) */ for (unit = 0; unit < max_units; unit++, samplers_used >>= 1) { struct pipe_sampler_state *sampler = samplers + unit; if (samplers_used & 1) { const GLuint texUnit = prog->SamplerUnits[unit]; convert_sampler(st, sampler, texUnit); *num_samplers = unit + 1; cso_single_sampler(st->cso_context, shader_stage, unit, sampler); } else if (samplers_used != 0 || unit < old_max) { cso_single_sampler(st->cso_context, shader_stage, unit, NULL); } else { /* if we've reset all the old samplers and we have no more new ones */ break; } } cso_single_sampler_done(st->cso_context, shader_stage); } static void update_samplers(struct st_context *st) { const struct gl_context *ctx = st->ctx; update_shader_samplers(st, PIPE_SHADER_FRAGMENT, &ctx->FragmentProgram._Current->Base, ctx->Const.MaxTextureImageUnits, st->state.samplers[PIPE_SHADER_FRAGMENT], &st->state.num_samplers[PIPE_SHADER_FRAGMENT]); update_shader_samplers(st, PIPE_SHADER_VERTEX, &ctx->VertexProgram._Current->Base, ctx->Const.MaxVertexTextureImageUnits, st->state.samplers[PIPE_SHADER_VERTEX], &st->state.num_samplers[PIPE_SHADER_VERTEX]); if (ctx->GeometryProgram._Current) { update_shader_samplers(st, PIPE_SHADER_GEOMETRY, &ctx->GeometryProgram._Current->Base, ctx->Const.MaxGeometryTextureImageUnits, st->state.samplers[PIPE_SHADER_GEOMETRY], &st->state.num_samplers[PIPE_SHADER_GEOMETRY]); } } const struct st_tracked_state st_update_sampler = { "st_update_sampler", /* name */ { /* dirty */ _NEW_TEXTURE, /* mesa */ 0, /* st */ }, update_samplers /* update */ };