X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Ftexstate.c;h=dfcfc4e8015f0d5d0e9a64aee3e72dcab0f3fdf6;hb=70847eb0a95f1e1b0fbd435aa0ef4091ae5bef88;hp=5cbf7914b62a26c076a8f32d0e697c1fed56bced;hpb=62d46332d8ed7a6270bc4e0520cf52668efd33b5;p=mesa.git diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c index 5cbf7914b62..dfcfc4e8015 100644 --- a/src/mesa/main/texstate.c +++ b/src/mesa/main/texstate.c @@ -22,25 +22,25 @@ * OTHER DEALINGS IN THE SOFTWARE. */ -/** +/** * \file texstate.c * * Texture state handling. */ +#include #include "glheader.h" #include "bufferobj.h" -#include "colormac.h" -#include "colortab.h" #include "context.h" #include "enums.h" #include "macros.h" -#include "shaderimage.h" #include "texobj.h" #include "teximage.h" #include "texstate.h" #include "mtypes.h" - +#include "state.h" +#include "util/bitscan.h" +#include "util/bitset.h" /** @@ -68,8 +68,8 @@ _mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst ) { GLuint u, tex; - ASSERT(src); - ASSERT(dst); + assert(src); + assert(dst); dst->Texture.CurrentUnit = src->Texture.CurrentUnit; dst->Texture._GenFlags = src->Texture._GenFlags; @@ -78,23 +78,8 @@ _mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst ) /* per-unit state */ for (u = 0; u < src->Const.MaxCombinedTextureImageUnits; u++) { - dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled; - dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode; - COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor); - dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled; - dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS; - dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT; - dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR; - dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ; dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias; - /* GL_EXT_texture_env_combine */ - dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine; - - /* GL_ATI_envmap_bumpmap - need this? */ - dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget; - COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix); - /* * XXX strictly speaking, we should compare texture names/ids and * bind textures in the dest context according to id. For now, only @@ -108,10 +93,29 @@ _mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst ) for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex], src->Texture.Unit[u].CurrentTex[tex]); + if (src->Texture.Unit[u].CurrentTex[tex]) { + dst->Texture.NumCurrentTexUsed = + MAX2(dst->Texture.NumCurrentTexUsed, u + 1); + } } + dst->Texture.Unit[u]._BoundTextures = src->Texture.Unit[u]._BoundTextures; _mesa_unlock_context_textures(dst); } } + + for (u = 0; u < src->Const.MaxTextureCoordUnits; u++) { + dst->Texture.FixedFuncUnit[u].Enabled = src->Texture.FixedFuncUnit[u].Enabled; + dst->Texture.FixedFuncUnit[u].EnvMode = src->Texture.FixedFuncUnit[u].EnvMode; + COPY_4V(dst->Texture.FixedFuncUnit[u].EnvColor, src->Texture.FixedFuncUnit[u].EnvColor); + dst->Texture.FixedFuncUnit[u].TexGenEnabled = src->Texture.FixedFuncUnit[u].TexGenEnabled; + dst->Texture.FixedFuncUnit[u].GenS = src->Texture.FixedFuncUnit[u].GenS; + dst->Texture.FixedFuncUnit[u].GenT = src->Texture.FixedFuncUnit[u].GenT; + dst->Texture.FixedFuncUnit[u].GenR = src->Texture.FixedFuncUnit[u].GenR; + dst->Texture.FixedFuncUnit[u].GenQ = src->Texture.FixedFuncUnit[u].GenQ; + + /* GL_EXT_texture_env_combine */ + dst->Texture.FixedFuncUnit[u].Combine = src->Texture.FixedFuncUnit[u].Combine; + } } @@ -121,23 +125,23 @@ _mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst ) void _mesa_print_texunit_state( struct gl_context *ctx, GLuint unit ) { - const struct gl_texture_unit *texUnit = ctx->Texture.Unit + unit; + const struct gl_fixedfunc_texture_unit *texUnit = ctx->Texture.FixedFuncUnit + unit; printf("Texture Unit %d\n", unit); - printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode)); - printf(" GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB)); - printf(" GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA)); - printf(" GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0])); - printf(" GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1])); - printf(" GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2])); - printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0])); - printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1])); - printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2])); - printf(" GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0])); - printf(" GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1])); - printf(" GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2])); - printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0])); - printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1])); - printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2])); + printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_enum_to_string(texUnit->EnvMode)); + printf(" GL_COMBINE_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.ModeRGB)); + printf(" GL_COMBINE_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.ModeA)); + printf(" GL_SOURCE0_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceRGB[0])); + printf(" GL_SOURCE1_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceRGB[1])); + printf(" GL_SOURCE2_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceRGB[2])); + printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceA[0])); + printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceA[1])); + printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceA[2])); + printf(" GL_OPERAND0_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandRGB[0])); + printf(" GL_OPERAND1_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandRGB[1])); + printf(" GL_OPERAND2_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandRGB[2])); + printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandA[0])); + printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandA[1])); + printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandA[2])); printf(" GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB); printf(" GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA); printf(" GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]); @@ -152,7 +156,7 @@ _mesa_print_texunit_state( struct gl_context *ctx, GLuint unit ) /** * Convert "classic" texture environment to ARB_texture_env_combine style * environments. - * + * * \param state texture_env_combine state vector to be filled-in. * \param mode Classic texture environment mode (i.e., \c GL_REPLACE, * \c GL_BLEND, \c GL_DECAL, etc.). @@ -183,10 +187,9 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, case GL_RG: case GL_RGB: case GL_YCBCR_MESA: - case GL_DUDV_ATI: state->SourceA[0] = GL_PREVIOUS; break; - + default: _mesa_problem(NULL, "Invalid texBaseFormat 0x%x in calculate_derived_texenv", @@ -203,7 +206,7 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : mode; mode_a = mode; break; - + case GL_DECAL: mode_rgb = GL_INTERPOLATE; mode_a = GL_REPLACE; @@ -225,7 +228,6 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, case GL_RG: case GL_RGB: case GL_YCBCR_MESA: - case GL_DUDV_ATI: mode_rgb = GL_REPLACE; break; case GL_RGBA: @@ -254,7 +256,6 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, case GL_LUMINANCE_ALPHA: case GL_RGBA: case GL_YCBCR_MESA: - case GL_DUDV_ATI: state->SourceRGB[2] = GL_TEXTURE; state->SourceA[2] = GL_TEXTURE; state->SourceRGB[0] = GL_CONSTANT; @@ -274,7 +275,7 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, mode); return; } - + state->ModeRGB = (state->SourceRGB[0] != GL_PREVIOUS) ? mode_rgb : GL_REPLACE; state->ModeA = (state->SourceA[0] != GL_PREVIOUS) @@ -282,36 +283,45 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, } - - /* GL_ARB_multitexture */ -void GLAPIENTRY -_mesa_ActiveTexture(GLenum texture) +static ALWAYS_INLINE void +active_texture(GLenum texture, bool no_error) { const GLuint texUnit = texture - GL_TEXTURE0; - GLuint k; - GET_CURRENT_CONTEXT(ctx); - /* See OpenGL spec for glActiveTexture: */ - k = MAX2(ctx->Const.MaxCombinedTextureImageUnits, - ctx->Const.MaxTextureCoordUnits); - - ASSERT(k <= Elements(ctx->Texture.Unit)); + GET_CURRENT_CONTEXT(ctx); if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) _mesa_debug(ctx, "glActiveTexture %s\n", - _mesa_lookup_enum_by_nr(texture)); + _mesa_enum_to_string(texture)); - if (texUnit >= k) { - _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)", - _mesa_lookup_enum_by_nr(texture)); + if (ctx->Texture.CurrentUnit == texUnit) return; + + if (!no_error) { + GLuint k = _mesa_max_tex_unit(ctx); + + assert(k <= ARRAY_SIZE(ctx->Texture.Unit)); + + if (texUnit >= k) { + _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)", + _mesa_enum_to_string(texture)); + return; + } } - if (ctx->Texture.CurrentUnit == texUnit) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); + /* The below flush call seems useless because + * gl_context::Texture::CurrentUnit is not used by + * _mesa_update_texture_state() and friends. + * + * However removing the flush + * introduced some blinking textures in UT2004. More investigation is + * needed to find the root cause. + * + * https://bugs.freedesktop.org/show_bug.cgi?id=105436 + */ + FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE); ctx->Texture.CurrentUnit = texUnit; if (ctx->Transform.MatrixMode == GL_TEXTURE) { @@ -321,6 +331,20 @@ _mesa_ActiveTexture(GLenum texture) } +void GLAPIENTRY +_mesa_ActiveTexture_no_error(GLenum texture) +{ + active_texture(texture, true); +} + + +void GLAPIENTRY +_mesa_ActiveTexture(GLenum texture) +{ + active_texture(texture, false); +} + + /* GL_ARB_multitexture */ void GLAPIENTRY _mesa_ClientActiveTexture(GLenum texture) @@ -330,17 +354,18 @@ _mesa_ClientActiveTexture(GLenum texture) if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE)) _mesa_debug(ctx, "glClientActiveTexture %s\n", - _mesa_lookup_enum_by_nr(texture)); + _mesa_enum_to_string(texture)); - if (texUnit >= ctx->Const.MaxTextureCoordUnits) { - _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture)"); + if (ctx->Array.ActiveTexture == texUnit) return; - } - if (ctx->Array.ActiveTexture == texUnit) + if (texUnit >= ctx->Const.MaxTextureCoordUnits) { + _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture=%s)", + _mesa_enum_to_string(texture)); return; + } - FLUSH_VERTICES(ctx, _NEW_ARRAY); + /* Don't flush vertices. This is a "latched" state. */ ctx->Array.ActiveTexture = texUnit; } @@ -354,24 +379,24 @@ _mesa_ClientActiveTexture(GLenum texture) /** * \note This routine refers to derived texture attribute values to * compute the ENABLE_TEXMAT flags, but is only called on - * _NEW_TEXTURE_MATRIX. On changes to _NEW_TEXTURE, the ENABLE_TEXMAT - * flags are updated by _mesa_update_textures(), below. + * _NEW_TEXTURE_MATRIX. On changes to _NEW_TEXTURE_OBJECT/STATE, + * the ENABLE_TEXMAT flags are updated by _mesa_update_textures(), below. * * \param ctx GL context. */ -static void -update_texture_matrices( struct gl_context *ctx ) +void +_mesa_update_texture_matrices(struct gl_context *ctx) { GLuint u; ctx->Texture._TexMatEnabled = 0x0; for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) { - ASSERT(u < Elements(ctx->TextureMatrixStack)); + assert(u < ARRAY_SIZE(ctx->TextureMatrixStack)); if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) { _math_matrix_analyse( ctx->TextureMatrixStack[u].Top ); - if (ctx->Texture.Unit[u]._ReallyEnabled && + if (ctx->Texture.Unit[u]._Current && ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY) ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u); } @@ -379,11 +404,114 @@ update_texture_matrices( struct gl_context *ctx ) } +/** + * Translate GL combiner state into a MODE_x value + */ +static uint32_t +tex_combine_translate_mode(GLenum envMode, GLenum mode) +{ + switch (mode) { + case GL_REPLACE: return TEXENV_MODE_REPLACE; + case GL_MODULATE: return TEXENV_MODE_MODULATE; + case GL_ADD: + if (envMode == GL_COMBINE4_NV) + return TEXENV_MODE_ADD_PRODUCTS_NV; + else + return TEXENV_MODE_ADD; + case GL_ADD_SIGNED: + if (envMode == GL_COMBINE4_NV) + return TEXENV_MODE_ADD_PRODUCTS_SIGNED_NV; + else + return TEXENV_MODE_ADD_SIGNED; + case GL_INTERPOLATE: return TEXENV_MODE_INTERPOLATE; + case GL_SUBTRACT: return TEXENV_MODE_SUBTRACT; + case GL_DOT3_RGB: return TEXENV_MODE_DOT3_RGB; + case GL_DOT3_RGB_EXT: return TEXENV_MODE_DOT3_RGB_EXT; + case GL_DOT3_RGBA: return TEXENV_MODE_DOT3_RGBA; + case GL_DOT3_RGBA_EXT: return TEXENV_MODE_DOT3_RGBA_EXT; + case GL_MODULATE_ADD_ATI: return TEXENV_MODE_MODULATE_ADD_ATI; + case GL_MODULATE_SIGNED_ADD_ATI: return TEXENV_MODE_MODULATE_SIGNED_ADD_ATI; + case GL_MODULATE_SUBTRACT_ATI: return TEXENV_MODE_MODULATE_SUBTRACT_ATI; + default: + unreachable("Invalid TexEnv Combine mode"); + } +} + + +static uint8_t +tex_combine_translate_source(GLenum src) +{ + switch (src) { + case GL_TEXTURE0: + case GL_TEXTURE1: + case GL_TEXTURE2: + case GL_TEXTURE3: + case GL_TEXTURE4: + case GL_TEXTURE5: + case GL_TEXTURE6: + case GL_TEXTURE7: return TEXENV_SRC_TEXTURE0 + (src - GL_TEXTURE0); + case GL_TEXTURE: return TEXENV_SRC_TEXTURE; + case GL_PREVIOUS: return TEXENV_SRC_PREVIOUS; + case GL_PRIMARY_COLOR: return TEXENV_SRC_PRIMARY_COLOR; + case GL_CONSTANT: return TEXENV_SRC_CONSTANT; + case GL_ZERO: return TEXENV_SRC_ZERO; + case GL_ONE: return TEXENV_SRC_ONE; + default: + unreachable("Invalid TexEnv Combine argument source"); + } +} + + +static uint8_t +tex_combine_translate_operand(GLenum operand) +{ + switch (operand) { + case GL_SRC_COLOR: return TEXENV_OPR_COLOR; + case GL_ONE_MINUS_SRC_COLOR: return TEXENV_OPR_ONE_MINUS_COLOR; + case GL_SRC_ALPHA: return TEXENV_OPR_ALPHA; + case GL_ONE_MINUS_SRC_ALPHA: return TEXENV_OPR_ONE_MINUS_ALPHA; + default: + unreachable("Invalid TexEnv Combine argument source"); + } +} + + +static void +pack_tex_combine(struct gl_fixedfunc_texture_unit *texUnit) +{ + struct gl_tex_env_combine_state *state = texUnit->_CurrentCombine; + struct gl_tex_env_combine_packed *packed = &texUnit->_CurrentCombinePacked; + + memset(packed, 0, sizeof *packed); + + packed->ModeRGB = tex_combine_translate_mode(texUnit->EnvMode, state->ModeRGB); + packed->ModeA = tex_combine_translate_mode(texUnit->EnvMode, state->ModeA); + packed->ScaleShiftRGB = state->ScaleShiftRGB; + packed->ScaleShiftA = state->ScaleShiftA; + packed->NumArgsRGB = state->_NumArgsRGB; + packed->NumArgsA = state->_NumArgsA; + + for (int i = 0; i < state->_NumArgsRGB; ++i) + { + packed->ArgsRGB[i].Source = tex_combine_translate_source(state->SourceRGB[i]); + packed->ArgsRGB[i].Operand = tex_combine_translate_operand(state->OperandRGB[i]); + } + + for (int i = 0; i < state->_NumArgsA; ++i) + { + packed->ArgsA[i].Source = tex_combine_translate_source(state->SourceA[i]); + packed->ArgsA[i].Operand = tex_combine_translate_operand(state->OperandA[i]); + } +} + + /** * Examine texture unit's combine/env state to update derived state. */ static void -update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) +update_tex_combine(struct gl_context *ctx, + struct gl_texture_unit *texUnit, + struct gl_fixedfunc_texture_unit *fftexUnit) { struct gl_tex_env_combine_state *combine; @@ -395,9 +523,9 @@ update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) * state, or the combiner state which is derived from traditional texenv * mode. */ - if (texUnit->EnvMode == GL_COMBINE || - texUnit->EnvMode == GL_COMBINE4_NV) { - texUnit->_CurrentCombine = & texUnit->Combine; + if (fftexUnit->EnvMode == GL_COMBINE || + fftexUnit->EnvMode == GL_COMBINE4_NV) { + fftexUnit->_CurrentCombine = & fftexUnit->Combine; } else { const struct gl_texture_object *texObj = texUnit->_Current; @@ -406,11 +534,11 @@ update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) { format = texObj->DepthMode; } - calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format); - texUnit->_CurrentCombine = & texUnit->_EnvMode; + calculate_derived_texenv(&fftexUnit->_EnvMode, fftexUnit->EnvMode, format); + fftexUnit->_CurrentCombine = & fftexUnit->_EnvMode; } - combine = texUnit->_CurrentCombine; + combine = fftexUnit->_CurrentCombine; /* Determine number of source RGB terms in the combiner function */ switch (combine->ModeRGB) { @@ -419,7 +547,7 @@ update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) break; case GL_ADD: case GL_ADD_SIGNED: - if (texUnit->EnvMode == GL_COMBINE4_NV) + if (fftexUnit->EnvMode == GL_COMBINE4_NV) combine->_NumArgsRGB = 4; else combine->_NumArgsRGB = 2; @@ -438,10 +566,6 @@ update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) case GL_MODULATE_SUBTRACT_ATI: combine->_NumArgsRGB = 3; break; - case GL_BUMP_ENVMAP_ATI: - /* no real arguments for this case */ - combine->_NumArgsRGB = 0; - break; default: combine->_NumArgsRGB = 0; _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state"); @@ -455,7 +579,7 @@ update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) break; case GL_ADD: case GL_ADD_SIGNED: - if (texUnit->EnvMode == GL_COMBINE4_NV) + if (fftexUnit->EnvMode == GL_COMBINE4_NV) combine->_NumArgsA = 4; else combine->_NumArgsA = 2; @@ -475,6 +599,8 @@ update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit) _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state"); break; } + + pack_tex_combine(fftexUnit); } static void @@ -484,7 +610,8 @@ update_texgen(struct gl_context *ctx) /* Setup texgen for those texture coordinate sets that are in use */ for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) { - struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + struct gl_fixedfunc_texture_unit *texUnit = + &ctx->Texture.FixedFuncUnit[unit]; texUnit->_GenFlags = 0x0; @@ -509,172 +636,298 @@ update_texgen(struct gl_context *ctx) ctx->Texture._GenFlags |= texUnit->_GenFlags; } - ASSERT(unit < Elements(ctx->TextureMatrixStack)); + assert(unit < ARRAY_SIZE(ctx->TextureMatrixStack)); if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY) ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(unit); } } -/** - * \note This routine refers to derived texture matrix values to - * compute the ENABLE_TEXMAT flags, but is only called on - * _NEW_TEXTURE. On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT - * flags are updated by _mesa_update_texture_matrices, above. - * - * \param ctx GL context. - */ +static struct gl_texture_object * +update_single_program_texture(struct gl_context *ctx, struct gl_program *prog, + int unit) +{ + gl_texture_index target_index; + struct gl_texture_unit *texUnit; + struct gl_texture_object *texObj; + struct gl_sampler_object *sampler; + + texUnit = &ctx->Texture.Unit[unit]; + + /* Note: If more than one bit was set in TexturesUsed[unit], then we should + * have had the draw call rejected already. From the GL 4.4 specification, + * section 7.10 ("Samplers"): + * + * "It is not allowed to have variables of different sampler types + * pointing to the same texture image unit within a program + * object. This situation can only be detected at the next rendering + * command issued which triggers shader invocations, and an + * INVALID_OPERATION error will then be generated." + */ + target_index = ffs(prog->TexturesUsed[unit]) - 1; + texObj = texUnit->CurrentTex[target_index]; + + sampler = texUnit->Sampler ? + texUnit->Sampler : &texObj->Sampler; + + if (likely(texObj)) { + if (_mesa_is_texture_complete(texObj, sampler)) + return texObj; + + _mesa_test_texobj_completeness(ctx, texObj); + if (_mesa_is_texture_complete(texObj, sampler)) + return texObj; + } + + /* If we've reached this point, we didn't find a complete texture of the + * shader's target. From the GL 4.4 core specification, section 11.1.3.5 + * ("Texture Access"): + * + * "If a sampler is used in a shader and the sampler’s associated + * texture is not complete, as defined in section 8.17, (0, 0, 0, 1) + * will be returned for a non-shadow sampler and 0 for a shadow + * sampler." + * + * Mesa implements this by creating a hidden texture object with a pixel of + * that value. + */ + texObj = _mesa_get_fallback_texture(ctx, target_index); + assert(texObj); + + return texObj; +} + +static inline void +update_single_program_texture_state(struct gl_context *ctx, + struct gl_program *prog, + int unit, + BITSET_WORD *enabled_texture_units) +{ + struct gl_texture_object *texObj; + + texObj = update_single_program_texture(ctx, prog, unit); + + _mesa_reference_texobj(&ctx->Texture.Unit[unit]._Current, texObj); + BITSET_SET(enabled_texture_units, unit); + ctx->Texture._MaxEnabledTexImageUnit = + MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit); +} + static void -update_texture_state( struct gl_context *ctx ) +update_program_texture_state(struct gl_context *ctx, struct gl_program **prog, + BITSET_WORD *enabled_texture_units) { - GLuint unit; - struct gl_program *prog[MESA_SHADER_STAGES]; - GLbitfield enabledFragUnits = 0x0; int i; for (i = 0; i < MESA_SHADER_STAGES; i++) { - if (ctx->_Shader->CurrentProgram[i] && - ctx->_Shader->CurrentProgram[i]->LinkStatus) { - prog[i] = ctx->_Shader->CurrentProgram[i]->_LinkedShaders[i]->Program; - } else { - if (i == MESA_SHADER_FRAGMENT && ctx->FragmentProgram._Enabled) - prog[i] = &ctx->FragmentProgram.Current->Base; - else - prog[i] = NULL; + GLbitfield mask; + GLuint s; + + if (!prog[i]) + continue; + + mask = prog[i]->SamplersUsed; + + while (mask) { + s = u_bit_scan(&mask); + + update_single_program_texture_state(ctx, prog[i], + prog[i]->SamplerUnits[s], + enabled_texture_units); + } + + if (unlikely(prog[i]->sh.HasBoundBindlessSampler)) { + /* Loop over bindless samplers bound to texture units. + */ + for (s = 0; s < prog[i]->sh.NumBindlessSamplers; s++) { + struct gl_bindless_sampler *sampler = + &prog[i]->sh.BindlessSamplers[s]; + + if (!sampler->bound) + continue; + + update_single_program_texture_state(ctx, prog[i], sampler->unit, + enabled_texture_units); + } } } - /* TODO: only set this if there are actual changes */ - ctx->NewState |= _NEW_TEXTURE; + if (prog[MESA_SHADER_FRAGMENT]) { + const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1; + ctx->Texture._EnabledCoordUnits |= + (prog[MESA_SHADER_FRAGMENT]->info.inputs_read >> VARYING_SLOT_TEX0) & + coordMask; + } +} - ctx->Texture._GenFlags = 0x0; - ctx->Texture._TexMatEnabled = 0x0; - ctx->Texture._TexGenEnabled = 0x0; - ctx->Texture._MaxEnabledTexImageUnit = -1; +static void +update_ff_texture_state(struct gl_context *ctx, + BITSET_WORD *enabled_texture_units) +{ + int unit; - /* - * Update texture unit state. - */ - for (unit = 0; unit < ctx->Const.MaxCombinedTextureImageUnits; unit++) { + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; - GLbitfield enabledTargetsByStage[MESA_SHADER_STAGES]; - GLbitfield enabledTargets = 0x0; - GLuint texIndex; - - /* Get the bitmask of texture target enables. - * enableBits will be a mask of the TEXTURE_*_BIT flags indicating - * which texture targets are enabled (fixed function) or referenced - * by a fragment program/program. When multiple flags are set, we'll - * settle on the one with highest priority (see below). - */ - for (i = 0; i < MESA_SHADER_STAGES; i++) { - if (prog[i]) - enabledTargetsByStage[i] = prog[i]->TexturesUsed[unit]; - else if (i == MESA_SHADER_FRAGMENT) - enabledTargetsByStage[i] = texUnit->Enabled; - else - enabledTargetsByStage[i] = 0; - enabledTargets |= enabledTargetsByStage[i]; - } + struct gl_fixedfunc_texture_unit *fftexUnit = + &ctx->Texture.FixedFuncUnit[unit]; + GLbitfield mask; + bool complete; - texUnit->_ReallyEnabled = 0x0; + if (fftexUnit->Enabled == 0x0) + continue; - if (enabledTargets == 0x0) { - _mesa_reference_texobj(&texUnit->_Current, NULL); - /* neither vertex nor fragment processing uses this unit */ + /* If a shader already dictated what texture target was used for this + * unit, just go along with it. + */ + if (BITSET_TEST(enabled_texture_units, unit)) continue; - } - /* Look for the highest priority texture target that's enabled (or used - * by the vert/frag shaders) and "complete". That's the one we'll use - * for texturing. + /* From the GL 4.4 compat specification, section 16.2 ("Texture Application"): + * + * "Texturing is enabled or disabled using the generic Enable and + * Disable commands, respectively, with the symbolic constants + * TEXTURE_1D, TEXTURE_2D, TEXTURE_RECTANGLE, TEXTURE_3D, or + * TEXTURE_CUBE_MAP to enable the one-, two-, rectangular, + * three-dimensional, or cube map texture, respectively. If more + * than one of these textures is enabled, the first one enabled + * from the following list is used: + * + * • cube map texture + * • three-dimensional texture + * • rectangular texture + * • two-dimensional texture + * • one-dimensional texture" * * Note that the TEXTURE_x_INDEX values are in high to low priority. + * Also: + * + * "If a texture unit is disabled or has an invalid or incomplete + * texture (as defined in section 8.17) bound to it, then blending + * is disabled for that texture unit. If the texture environment + * for a given enabled texture unit references a disabled texture + * unit, or an invalid or incomplete texture that is bound to + * another unit, then the results of texture blending are + * undefined." */ - for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) { - if (enabledTargets & (1 << texIndex)) { - struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex]; - struct gl_sampler_object *sampler = texUnit->Sampler ? - texUnit->Sampler : &texObj->Sampler; - - if (!_mesa_is_texture_complete(texObj, sampler)) { - _mesa_test_texobj_completeness(ctx, texObj); - } - if (_mesa_is_texture_complete(texObj, sampler)) { - texUnit->_ReallyEnabled = 1 << texIndex; - _mesa_reference_texobj(&texUnit->_Current, texObj); - break; - } + complete = false; + mask = fftexUnit->Enabled; + while (mask) { + const int texIndex = u_bit_scan(&mask); + struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex]; + struct gl_sampler_object *sampler = texUnit->Sampler ? + texUnit->Sampler : &texObj->Sampler; + + if (!_mesa_is_texture_complete(texObj, sampler)) { + _mesa_test_texobj_completeness(ctx, texObj); } - } - - if (!texUnit->_ReallyEnabled) { - if (prog[MESA_SHADER_FRAGMENT]) { - /* If we get here it means the shader is expecting a texture - * object, but there isn't one (or it's incomplete). Use the - * fallback texture. - */ - struct gl_texture_object *texObj; - gl_texture_index texTarget; - - texTarget = (gl_texture_index) (ffs(enabledTargets) - 1); - texObj = _mesa_get_fallback_texture(ctx, texTarget); - - assert(texObj); - if (!texObj) { - /* invalid fallback texture: don't enable the texture unit */ - continue; - } - + if (_mesa_is_texture_complete(texObj, sampler)) { _mesa_reference_texobj(&texUnit->_Current, texObj); - texUnit->_ReallyEnabled = 1 << texTarget; - } - else { - /* fixed-function: texture unit is really disabled */ - _mesa_reference_texobj(&texUnit->_Current, NULL); - continue; + complete = true; + break; } } + if (!complete) + continue; + /* if we get here, we know this texture unit is enabled */ - ctx->Texture._MaxEnabledTexImageUnit = unit; + BITSET_SET(enabled_texture_units, unit); + ctx->Texture._MaxEnabledTexImageUnit = + MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit); - if (enabledTargetsByStage[MESA_SHADER_FRAGMENT]) - enabledFragUnits |= (1 << unit); + ctx->Texture._EnabledCoordUnits |= 1 << unit; - if (!prog[MESA_SHADER_FRAGMENT]) - update_tex_combine(ctx, texUnit); + update_tex_combine(ctx, texUnit, fftexUnit); } +} - - /* Determine which texture coordinate sets are actually needed */ - if (prog[MESA_SHADER_FRAGMENT]) { - const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1; - ctx->Texture._EnabledCoordUnits - = (prog[MESA_SHADER_FRAGMENT]->InputsRead >> VARYING_SLOT_TEX0) & - coordMask; - } - else { - ctx->Texture._EnabledCoordUnits = enabledFragUnits; +static void +fix_missing_textures_for_atifs(struct gl_context *ctx, + struct gl_program *prog, + BITSET_WORD *enabled_texture_units) +{ + GLbitfield mask = prog->SamplersUsed; + + while (mask) { + const int s = u_bit_scan(&mask); + const int unit = prog->SamplerUnits[s]; + const gl_texture_index target_index = ffs(prog->TexturesUsed[unit]) - 1; + + if (!ctx->Texture.Unit[unit]._Current) { + struct gl_texture_object *texObj = + _mesa_get_fallback_texture(ctx, target_index); + _mesa_reference_texobj(&ctx->Texture.Unit[unit]._Current, texObj); + BITSET_SET(enabled_texture_units, unit); + ctx->Texture._MaxEnabledTexImageUnit = + MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit); + } } - - if (!prog[MESA_SHADER_FRAGMENT] || !prog[MESA_SHADER_VERTEX]) - update_texgen(ctx); - - _mesa_validate_image_units(ctx); } - /** - * Update texture-related derived state. + * \note This routine refers to derived texture matrix values to + * compute the ENABLE_TEXMAT flags, but is only called on + * _NEW_TEXTURE_OBJECT/STATE. On changes to _NEW_TEXTURE_MATRIX, + * the ENABLE_TEXMAT flags are updated by _mesa_update_texture_matrices, + * above. + * + * \param ctx GL context. */ void -_mesa_update_texture( struct gl_context *ctx, GLuint new_state ) +_mesa_update_texture_state(struct gl_context *ctx) { - if (new_state & _NEW_TEXTURE_MATRIX) - update_texture_matrices( ctx ); + struct gl_program *prog[MESA_SHADER_STAGES]; + int i; + int old_max_unit = ctx->Texture._MaxEnabledTexImageUnit; + BITSET_DECLARE(enabled_texture_units, MAX_COMBINED_TEXTURE_IMAGE_UNITS); - if (new_state & (_NEW_TEXTURE | _NEW_PROGRAM)) - update_texture_state( ctx ); + memcpy(prog, ctx->_Shader->CurrentProgram, sizeof(prog)); + + if (prog[MESA_SHADER_FRAGMENT] == NULL && + _mesa_arb_fragment_program_enabled(ctx)) { + prog[MESA_SHADER_FRAGMENT] = ctx->FragmentProgram.Current; + } + + /* TODO: only set this if there are actual changes */ + ctx->NewState |= _NEW_TEXTURE_OBJECT | _NEW_TEXTURE_STATE; + + ctx->Texture._GenFlags = 0x0; + ctx->Texture._TexMatEnabled = 0x0; + ctx->Texture._TexGenEnabled = 0x0; + ctx->Texture._MaxEnabledTexImageUnit = -1; + ctx->Texture._EnabledCoordUnits = 0x0; + + memset(&enabled_texture_units, 0, sizeof(enabled_texture_units)); + + /* First, walk over our programs pulling in all the textures for them. + * Programs dictate specific texture targets to be enabled, and for a draw + * call to be valid they can't conflict about which texture targets are + * used. + */ + update_program_texture_state(ctx, prog, enabled_texture_units); + + /* Also pull in any textures necessary for fixed function fragment shading. + */ + if (!prog[MESA_SHADER_FRAGMENT]) + update_ff_texture_state(ctx, enabled_texture_units); + + /* Now, clear out the _Current of any disabled texture units. */ + for (i = 0; i <= ctx->Texture._MaxEnabledTexImageUnit; i++) { + if (!BITSET_TEST(enabled_texture_units, i)) + _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL); + } + for (i = ctx->Texture._MaxEnabledTexImageUnit + 1; i <= old_max_unit; i++) { + _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL); + } + + /* add fallback texture for SampleMapATI if there is nothing */ + if (_mesa_ati_fragment_shader_enabled(ctx) && + ctx->ATIFragmentShader.Current->Program) + fix_missing_textures_for_atifs(ctx, + ctx->ATIFragmentShader.Current->Program, + enabled_texture_units); + + if (!prog[MESA_SHADER_FRAGMENT] || !prog[MESA_SHADER_VERTEX]) + update_texgen(ctx); } @@ -684,11 +937,11 @@ _mesa_update_texture( struct gl_context *ctx, GLuint new_state ) /** * Allocate the proxy textures for the given context. - * + * * \param ctx the context to allocate proxies for. - * + * * \return GL_TRUE on success, or GL_FALSE on failure - * + * * If run out of memory part way through the allocations, clean up and return * GL_FALSE. */ @@ -706,7 +959,7 @@ alloc_proxy_textures( struct gl_context *ctx ) GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_1D_ARRAY_EXT, GL_TEXTURE_EXTERNAL_OES, - GL_TEXTURE_CUBE_MAP_ARB, + GL_TEXTURE_CUBE_MAP, GL_TEXTURE_3D, GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_2D, @@ -714,7 +967,7 @@ alloc_proxy_textures( struct gl_context *ctx ) }; GLint tgt; - STATIC_ASSERT(Elements(targets) == NUM_TEXTURE_TARGETS); + STATIC_ASSERT(ARRAY_SIZE(targets) == NUM_TEXTURE_TARGETS); assert(targets[TEXTURE_2D_INDEX] == GL_TEXTURE_2D); assert(targets[TEXTURE_CUBE_INDEX] == GL_TEXTURE_CUBE_MAP); @@ -734,57 +987,6 @@ alloc_proxy_textures( struct gl_context *ctx ) } -/** - * Initialize a texture unit. - * - * \param ctx GL context. - * \param unit texture unit number to be initialized. - */ -static void -init_texture_unit( struct gl_context *ctx, GLuint unit ) -{ - struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; - GLuint tex; - - texUnit->EnvMode = GL_MODULATE; - ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 ); - - texUnit->Combine = default_combine_state; - texUnit->_EnvMode = default_combine_state; - texUnit->_CurrentCombine = & texUnit->_EnvMode; - texUnit->BumpTarget = GL_TEXTURE0; - - texUnit->TexGenEnabled = 0x0; - texUnit->GenS.Mode = GL_EYE_LINEAR; - texUnit->GenT.Mode = GL_EYE_LINEAR; - texUnit->GenR.Mode = GL_EYE_LINEAR; - texUnit->GenQ.Mode = GL_EYE_LINEAR; - texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR; - texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR; - texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR; - texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR; - - /* Yes, these plane coefficients are correct! */ - ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 ); - - /* no mention of this in spec, but maybe id matrix expected? */ - ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 ); - - /* initialize current texture object ptrs to the shared default objects */ - for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { - _mesa_reference_texobj(&texUnit->CurrentTex[tex], - ctx->Shared->DefaultTex[tex]); - } -} - - /** * Initialize texture state for the given context. */ @@ -801,11 +1003,62 @@ _mesa_init_texture(struct gl_context *ctx) * "OpenGL ES 3.0 requires that all cube map filtering be * seamless. OpenGL ES 2.0 specified that a single cube map face be * selected and used for filtering." + * + * Unfortunatley, a call to _mesa_is_gles3 below will only work if + * the driver has already computed and set ctx->Version, however drivers + * seem to call _mesa_initialize_context (which calls this) early + * in the CreateContext hook and _mesa_compute_version much later (since + * it needs information about available extensions). So, we will + * enable seamless cubemaps by default since GLES2. This should work + * for most implementations and drivers that don't support seamless + * cubemaps for GLES2 can still disable it. */ - ctx->Texture.CubeMapSeamless = _mesa_is_gles3(ctx); + ctx->Texture.CubeMapSeamless = ctx->API == API_OPENGLES2; + + for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) { + struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u]; + GLuint tex; - for (u = 0; u < Elements(ctx->Texture.Unit); u++) - init_texture_unit(ctx, u); + /* initialize current texture object ptrs to the shared default objects */ + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + _mesa_reference_texobj(&texUnit->CurrentTex[tex], + ctx->Shared->DefaultTex[tex]); + } + + texUnit->_BoundTextures = 0; + } + + for (u = 0; u < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); u++) { + struct gl_fixedfunc_texture_unit *texUnit = + &ctx->Texture.FixedFuncUnit[u]; + + texUnit->EnvMode = GL_MODULATE; + ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 ); + + texUnit->Combine = default_combine_state; + texUnit->_EnvMode = default_combine_state; + texUnit->_CurrentCombine = & texUnit->_EnvMode; + + texUnit->TexGenEnabled = 0x0; + texUnit->GenS.Mode = GL_EYE_LINEAR; + texUnit->GenT.Mode = GL_EYE_LINEAR; + texUnit->GenR.Mode = GL_EYE_LINEAR; + texUnit->GenQ.Mode = GL_EYE_LINEAR; + texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR; + texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR; + texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR; + texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR; + + /* Yes, these plane coefficients are correct! */ + ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + } /* After we're done initializing the context's texture state the default * texture objects' refcounts should be at least @@ -819,8 +1072,9 @@ _mesa_init_texture(struct gl_context *ctx) return GL_FALSE; /* GL_ARB_texture_buffer_object */ - _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, - ctx->Shared->NullBufferObj); + _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL); + + ctx->Texture.NumCurrentTexUsed = 0; return GL_TRUE; } @@ -835,7 +1089,7 @@ _mesa_free_texture_data(struct gl_context *ctx) GLuint u, tgt; /* unreference current textures */ - for (u = 0; u < Elements(ctx->Texture.Unit); u++) { + for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) { /* The _Current texture could account for another reference */ _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL); @@ -851,7 +1105,7 @@ _mesa_free_texture_data(struct gl_context *ctx) /* GL_ARB_texture_buffer_object */ _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL); - for (u = 0; u < Elements(ctx->Texture.Unit); u++) { + for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) { _mesa_reference_sampler_object(ctx, &ctx->Texture.Unit[u].Sampler, NULL); } } @@ -859,7 +1113,7 @@ _mesa_free_texture_data(struct gl_context *ctx) /** * Update the default texture objects in the given context to reference those - * specified in the shared state and release those referencing the old + * specified in the shared state and release those referencing the old * shared state. */ void @@ -867,7 +1121,7 @@ _mesa_update_default_objects_texture(struct gl_context *ctx) { GLuint u, tex; - for (u = 0; u < Elements(ctx->Texture.Unit); u++) { + for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u]; for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { _mesa_reference_texobj(&texUnit->CurrentTex[tex],