X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_atom_sampler.c;h=94231cf1946f2975b4217f0314516d2f512cf003;hb=8498cb4a45e8ed53a2ee2b35d3c2cbb9963e1756;hp=06024ad2657ce0b632a6be6605f73db61dbc13ae;hpb=6bd8647b54054a59bdb4f0c170c4481eaadc81ff;p=mesa.git diff --git a/src/mesa/state_tracker/st_atom_sampler.c b/src/mesa/state_tracker/st_atom_sampler.c index 06024ad2657..94231cf1946 100644 --- a/src/mesa/state_tracker/st_atom_sampler.c +++ b/src/mesa/state_tracker/st_atom_sampler.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -18,7 +18,7 @@ * 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 + * IN NO EVENT SHALL VMWARE 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. @@ -27,14 +27,17 @@ /* * Authors: - * Keith Whitwell + * Keith Whitwell * Brian Paul */ #include "main/macros.h" #include "main/mtypes.h" +#include "main/glformats.h" #include "main/samplerobj.h" +#include "main/teximage.h" +#include "main/texobj.h" #include "st_context.h" #include "st_cb_texture.h" @@ -46,6 +49,8 @@ #include "cso_cache/cso_context.h" +#include "util/u_format.h" + /** * Convert GLenum texcoord wrap tokens to pipe tokens. @@ -120,147 +125,205 @@ gl_filter_to_img_filter(GLenum filter) } } -static void convert_sampler(struct st_context *st, - struct pipe_sampler_state *sampler, - GLuint texUnit) -{ - struct gl_texture_object *texobj; - struct gl_sampler_object *msamp; - - texobj = st->ctx->Texture.Unit[texUnit]._Current; - if (!texobj) { - texobj = st_get_default_texture(st); - } - - msamp = _mesa_get_samplerobj(st->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 = st->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 gl_texture_image *teximg; - - teximg = texobj->Image[0][texobj->BaseLevel]; - - st_translate_color(msamp->BorderColor.f, - teximg ? teximg->_BaseFormat : GL_RGBA, - sampler->border_color); - } - - 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 = - st->ctx->Texture.CubeMapSeamless || msamp->CubeMapSeamless; -} static void -update_vertex_samplers(struct st_context *st) +convert_sampler(struct st_context *st, + struct pipe_sampler_state *sampler, + GLuint texUnit) { - struct gl_vertex_program *vprog = st->ctx->VertexProgram._Current; - GLuint su; + const struct gl_texture_object *texobj; + struct gl_context *ctx = st->ctx; + struct gl_sampler_object *msamp; + GLenum texBaseFormat; + + texobj = ctx->Texture.Unit[texUnit]._Current; + if (!texobj) { + texobj = _mesa_get_fallback_texture(ctx, TEXTURE_2D_INDEX); + } - st->state.num_vertex_samplers = 0; + texBaseFormat = _mesa_texture_base_format(texobj); - /* loop over sampler units (aka tex image units) */ - for (su = 0; su < st->ctx->Const.MaxVertexTextureImageUnits; su++) { - struct pipe_sampler_state *sampler = st->state.vertex_samplers + su; + 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); - if (vprog->Base.SamplersUsed & (1 << su)) { - GLuint texUnit; + 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); - texUnit = vprog->Base.SamplerUnits[su]; + if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB) + sampler->normalized_coords = 1; - convert_sampler(st, sampler, texUnit); + sampler->lod_bias = ctx->Texture.Unit[texUnit].LodBias + msamp->LodBias; - st->state.num_vertex_samplers = su + 1; + sampler->min_lod = MAX2(msamp->MinLod, 0.0f); + sampler->max_lod = 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); + } - cso_single_vertex_sampler(st->cso_context, su, sampler); + /* For non-black borders... */ + if (msamp->BorderColor.ui[0] || + msamp->BorderColor.ui[1] || + msamp->BorderColor.ui[2] || + msamp->BorderColor.ui[3]) { + const struct st_texture_object *stobj = st_texture_object_const(texobj); + const GLboolean is_integer = texobj->_IsIntegerFormat; + const struct pipe_sampler_view *sv = NULL; + union pipe_color_union border_color; + GLuint i; + + /* Just search for the first used view. We can do this because the + swizzle is per-texture, not per context. */ + /* XXX: clean that up to not use the sampler view at all */ + for (i = 0; i < stobj->num_sampler_views; ++i) { + if (stobj->sampler_views[i]) { + sv = stobj->sampler_views[i]; + break; + } + } + + if (st->apply_texture_swizzle_to_border_color && sv) { + const unsigned char swz[4] = + { + sv->swizzle_r, + sv->swizzle_g, + sv->swizzle_b, + sv->swizzle_a, + }; + + st_translate_color(&msamp->BorderColor, + &border_color, + texBaseFormat, is_integer); + + util_format_apply_color_swizzle(&sampler->border_color, + &border_color, swz, is_integer); } else { - cso_single_vertex_sampler(st->cso_context, su, NULL); + st_translate_color(&msamp->BorderColor, + &sampler->border_color, + texBaseFormat, is_integer); } } - cso_single_vertex_sampler_done(st->cso_context); + + sampler->max_anisotropy = (msamp->MaxAnisotropy == 1.0 ? + 0 : (GLuint) msamp->MaxAnisotropy); + + /* If sampling a depth texture and using shadow comparison */ + if ((texBaseFormat == GL_DEPTH_COMPONENT || + texBaseFormat == GL_DEPTH_STENCIL) && + 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_fragment_samplers(struct st_context *st) +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) { - struct gl_fragment_program *fprog = st->ctx->FragmentProgram._Current; - GLuint su; + GLuint unit; + GLbitfield samplers_used; + const GLuint old_max = *num_samplers; + const struct pipe_sampler_state *states[PIPE_MAX_SAMPLERS]; - st->state.num_samplers = 0; + samplers_used = prog->SamplersUsed; - /* loop over sampler units (aka tex image units) */ - for (su = 0; su < st->ctx->Const.MaxTextureImageUnits; su++) { - struct pipe_sampler_state *sampler = st->state.samplers + su; + if (*num_samplers == 0 && samplers_used == 0x0) + return; + *num_samplers = 0; - if (fprog->Base.SamplersUsed & (1 << su)) { - GLuint texUnit; - - texUnit = fprog->Base.SamplerUnits[su]; - - convert_sampler(st, sampler, texUnit); + /* 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; - st->state.num_samplers = su + 1; + if (samplers_used & 1) { + const GLuint texUnit = prog->SamplerUnits[unit]; - /*printf("%s su=%u non-null\n", __FUNCTION__, su);*/ - cso_single_sampler(st->cso_context, su, sampler); + convert_sampler(st, sampler, texUnit); + states[unit] = sampler; + *num_samplers = unit + 1; + } + else if (samplers_used != 0 || unit < old_max) { + states[unit] = NULL; } else { - /*printf("%s su=%u null\n", __FUNCTION__, su);*/ - cso_single_sampler(st->cso_context, su, NULL); + /* if we've reset all the old samplers and we have no more new ones */ + break; } } - cso_single_sampler_done(st->cso_context); + cso_set_samplers(st->cso_context, shader_stage, *num_samplers, states); } + static void update_samplers(struct st_context *st) { - update_fragment_samplers(st); - update_vertex_samplers(st); + const struct gl_context *ctx = st->ctx; + + update_shader_samplers(st, + PIPE_SHADER_FRAGMENT, + &ctx->FragmentProgram._Current->Base, + ctx->Const.Program[MESA_SHADER_FRAGMENT].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.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits, + 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.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits, + st->state.samplers[PIPE_SHADER_GEOMETRY], + &st->state.num_samplers[PIPE_SHADER_GEOMETRY]); + } + if (ctx->TessCtrlProgram._Current) { + update_shader_samplers(st, + PIPE_SHADER_TESS_CTRL, + &ctx->TessCtrlProgram._Current->Base, + ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits, + st->state.samplers[PIPE_SHADER_TESS_CTRL], + &st->state.num_samplers[PIPE_SHADER_TESS_CTRL]); + } + if (ctx->TessEvalProgram._Current) { + update_shader_samplers(st, + PIPE_SHADER_TESS_EVAL, + &ctx->TessEvalProgram._Current->Base, + ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits, + st->state.samplers[PIPE_SHADER_TESS_EVAL], + &st->state.num_samplers[PIPE_SHADER_TESS_EVAL]); + } } + const struct st_tracked_state st_update_sampler = { "st_update_sampler", /* name */ { /* dirty */