Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the "Software"),
  8.  * to deal in the Software without restriction, including without limitation
  9.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10.  * and/or sell copies of the Software, and to permit persons to whom the
  11.  * Software is furnished to do so, subject to the following conditions:
  12.  *
  13.  * The above copyright notice and this permission notice shall be included
  14.  * in all copies or substantial portions of the Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22.  * OTHER DEALINGS IN THE SOFTWARE.
  23.  */
  24.  
  25. /**
  26.  * \file texstate.c
  27.  *
  28.  * Texture state handling.
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include "glheader.h"
  33. #include "bufferobj.h"
  34. #include "context.h"
  35. #include "enums.h"
  36. #include "macros.h"
  37. #include "shaderimage.h"
  38. #include "texobj.h"
  39. #include "teximage.h"
  40. #include "texstate.h"
  41. #include "mtypes.h"
  42. #include "util/bitset.h"
  43.  
  44.  
  45. /**
  46.  * Default texture combine environment state.  This is used to initialize
  47.  * a context's texture units and as the basis for converting "classic"
  48.  * texture environmnets to ARB_texture_env_combine style values.
  49.  */
  50. static const struct gl_tex_env_combine_state default_combine_state = {
  51.    GL_MODULATE, GL_MODULATE,
  52.    { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
  53.    { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
  54.    { GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_ALPHA },
  55.    { GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA },
  56.    0, 0,
  57.    2, 2
  58. };
  59.  
  60.  
  61.  
  62. /**
  63.  * Used by glXCopyContext to copy texture state from one context to another.
  64.  */
  65. void
  66. _mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst )
  67. {
  68.    GLuint u, tex;
  69.  
  70.    assert(src);
  71.    assert(dst);
  72.  
  73.    dst->Texture.CurrentUnit = src->Texture.CurrentUnit;
  74.    dst->Texture._GenFlags = src->Texture._GenFlags;
  75.    dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;
  76.    dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;
  77.  
  78.    /* per-unit state */
  79.    for (u = 0; u < src->Const.MaxCombinedTextureImageUnits; u++) {
  80.       dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled;
  81.       dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode;
  82.       COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor);
  83.       dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled;
  84.       dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS;
  85.       dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT;
  86.       dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR;
  87.       dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ;
  88.       dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias;
  89.  
  90.       /* GL_EXT_texture_env_combine */
  91.       dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine;
  92.  
  93.       /*
  94.        * XXX strictly speaking, we should compare texture names/ids and
  95.        * bind textures in the dest context according to id.  For now, only
  96.        * copy bindings if the contexts share the same pool of textures to
  97.        * avoid refcounting bugs.
  98.        */
  99.       if (dst->Shared == src->Shared) {
  100.          /* copy texture object bindings, not contents of texture objects */
  101.          _mesa_lock_context_textures(dst);
  102.  
  103.          for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
  104.             _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex],
  105.                                    src->Texture.Unit[u].CurrentTex[tex]);
  106.             if (src->Texture.Unit[u].CurrentTex[tex]) {
  107.                dst->Texture.NumCurrentTexUsed =
  108.                   MAX2(dst->Texture.NumCurrentTexUsed, u + 1);
  109.             }
  110.          }
  111.          dst->Texture.Unit[u]._BoundTextures = src->Texture.Unit[u]._BoundTextures;
  112.          _mesa_unlock_context_textures(dst);
  113.       }
  114.    }
  115. }
  116.  
  117.  
  118. /*
  119.  * For debugging
  120.  */
  121. void
  122. _mesa_print_texunit_state( struct gl_context *ctx, GLuint unit )
  123. {
  124.    const struct gl_texture_unit *texUnit = ctx->Texture.Unit + unit;
  125.    printf("Texture Unit %d\n", unit);
  126.    printf("  GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode));
  127.    printf("  GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB));
  128.    printf("  GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA));
  129.    printf("  GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0]));
  130.    printf("  GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1]));
  131.    printf("  GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2]));
  132.    printf("  GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0]));
  133.    printf("  GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1]));
  134.    printf("  GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2]));
  135.    printf("  GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0]));
  136.    printf("  GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1]));
  137.    printf("  GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2]));
  138.    printf("  GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0]));
  139.    printf("  GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1]));
  140.    printf("  GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2]));
  141.    printf("  GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);
  142.    printf("  GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);
  143.    printf("  GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);
  144. }
  145.  
  146.  
  147.  
  148. /**********************************************************************/
  149. /*                       Texture Environment                          */
  150. /**********************************************************************/
  151.  
  152. /**
  153.  * Convert "classic" texture environment to ARB_texture_env_combine style
  154.  * environments.
  155.  *
  156.  * \param state  texture_env_combine state vector to be filled-in.
  157.  * \param mode   Classic texture environment mode (i.e., \c GL_REPLACE,
  158.  *               \c GL_BLEND, \c GL_DECAL, etc.).
  159.  * \param texBaseFormat  Base format of the texture associated with the
  160.  *               texture unit.
  161.  */
  162. static void
  163. calculate_derived_texenv( struct gl_tex_env_combine_state *state,
  164.                           GLenum mode, GLenum texBaseFormat )
  165. {
  166.    GLenum mode_rgb;
  167.    GLenum mode_a;
  168.  
  169.    *state = default_combine_state;
  170.  
  171.    switch (texBaseFormat) {
  172.    case GL_ALPHA:
  173.       state->SourceRGB[0] = GL_PREVIOUS;
  174.       break;
  175.  
  176.    case GL_LUMINANCE_ALPHA:
  177.    case GL_INTENSITY:
  178.    case GL_RGBA:
  179.       break;
  180.  
  181.    case GL_LUMINANCE:
  182.    case GL_RED:
  183.    case GL_RG:
  184.    case GL_RGB:
  185.    case GL_YCBCR_MESA:
  186.       state->SourceA[0] = GL_PREVIOUS;
  187.       break;
  188.  
  189.    default:
  190.       _mesa_problem(NULL,
  191.                     "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
  192.                     texBaseFormat);
  193.       return;
  194.    }
  195.  
  196.    if (mode == GL_REPLACE_EXT)
  197.       mode = GL_REPLACE;
  198.  
  199.    switch (mode) {
  200.    case GL_REPLACE:
  201.    case GL_MODULATE:
  202.       mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : mode;
  203.       mode_a   = mode;
  204.       break;
  205.  
  206.    case GL_DECAL:
  207.       mode_rgb = GL_INTERPOLATE;
  208.       mode_a   = GL_REPLACE;
  209.  
  210.       state->SourceA[0] = GL_PREVIOUS;
  211.  
  212.       /* Having alpha / luminance / intensity textures replace using the
  213.        * incoming fragment color matches the definition in NV_texture_shader.
  214.        * The 1.5 spec simply marks these as "undefined".
  215.        */
  216.       switch (texBaseFormat) {
  217.       case GL_ALPHA:
  218.       case GL_LUMINANCE:
  219.       case GL_LUMINANCE_ALPHA:
  220.       case GL_INTENSITY:
  221.          state->SourceRGB[0] = GL_PREVIOUS;
  222.          break;
  223.       case GL_RED:
  224.       case GL_RG:
  225.       case GL_RGB:
  226.       case GL_YCBCR_MESA:
  227.          mode_rgb = GL_REPLACE;
  228.          break;
  229.       case GL_RGBA:
  230.          state->SourceRGB[2] = GL_TEXTURE;
  231.          break;
  232.       }
  233.       break;
  234.  
  235.    case GL_BLEND:
  236.       mode_rgb = GL_INTERPOLATE;
  237.       mode_a   = GL_MODULATE;
  238.  
  239.       switch (texBaseFormat) {
  240.       case GL_ALPHA:
  241.          mode_rgb = GL_REPLACE;
  242.          break;
  243.       case GL_INTENSITY:
  244.          mode_a = GL_INTERPOLATE;
  245.          state->SourceA[0] = GL_CONSTANT;
  246.          state->OperandA[2] = GL_SRC_ALPHA;
  247.          /* FALLTHROUGH */
  248.       case GL_LUMINANCE:
  249.       case GL_RED:
  250.       case GL_RG:
  251.       case GL_RGB:
  252.       case GL_LUMINANCE_ALPHA:
  253.       case GL_RGBA:
  254.       case GL_YCBCR_MESA:
  255.          state->SourceRGB[2] = GL_TEXTURE;
  256.          state->SourceA[2]   = GL_TEXTURE;
  257.          state->SourceRGB[0] = GL_CONSTANT;
  258.          state->OperandRGB[2] = GL_SRC_COLOR;
  259.          break;
  260.       }
  261.       break;
  262.  
  263.    case GL_ADD:
  264.       mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : GL_ADD;
  265.       mode_a   = (texBaseFormat == GL_INTENSITY) ? GL_ADD : GL_MODULATE;
  266.       break;
  267.  
  268.    default:
  269.       _mesa_problem(NULL,
  270.                     "Invalid texture env mode 0x%x in calculate_derived_texenv",
  271.                     mode);
  272.       return;
  273.    }
  274.  
  275.    state->ModeRGB = (state->SourceRGB[0] != GL_PREVIOUS)
  276.        ? mode_rgb : GL_REPLACE;
  277.    state->ModeA   = (state->SourceA[0]   != GL_PREVIOUS)
  278.        ? mode_a   : GL_REPLACE;
  279. }
  280.  
  281.  
  282.  
  283.  
  284. /* GL_ARB_multitexture */
  285. void GLAPIENTRY
  286. _mesa_ActiveTexture(GLenum texture)
  287. {
  288.    const GLuint texUnit = texture - GL_TEXTURE0;
  289.    GLuint k;
  290.    GET_CURRENT_CONTEXT(ctx);
  291.  
  292.    k = _mesa_max_tex_unit(ctx);
  293.  
  294.    assert(k <= ARRAY_SIZE(ctx->Texture.Unit));
  295.  
  296.    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
  297.       _mesa_debug(ctx, "glActiveTexture %s\n",
  298.                   _mesa_lookup_enum_by_nr(texture));
  299.  
  300.    if (texUnit >= k) {
  301.       _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)",
  302.                   _mesa_lookup_enum_by_nr(texture));
  303.       return;
  304.    }
  305.  
  306.    if (ctx->Texture.CurrentUnit == texUnit)
  307.       return;
  308.  
  309.    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  310.  
  311.    ctx->Texture.CurrentUnit = texUnit;
  312.    if (ctx->Transform.MatrixMode == GL_TEXTURE) {
  313.       /* update current stack pointer */
  314.       ctx->CurrentStack = &ctx->TextureMatrixStack[texUnit];
  315.    }
  316. }
  317.  
  318.  
  319. /* GL_ARB_multitexture */
  320. void GLAPIENTRY
  321. _mesa_ClientActiveTexture(GLenum texture)
  322. {
  323.    GET_CURRENT_CONTEXT(ctx);
  324.    GLuint texUnit = texture - GL_TEXTURE0;
  325.  
  326.    if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE))
  327.       _mesa_debug(ctx, "glClientActiveTexture %s\n",
  328.                   _mesa_lookup_enum_by_nr(texture));
  329.  
  330.    if (texUnit >= ctx->Const.MaxTextureCoordUnits) {
  331.       _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture)");
  332.       return;
  333.    }
  334.  
  335.    if (ctx->Array.ActiveTexture == texUnit)
  336.       return;
  337.  
  338.    FLUSH_VERTICES(ctx, _NEW_ARRAY);
  339.    ctx->Array.ActiveTexture = texUnit;
  340. }
  341.  
  342.  
  343.  
  344. /**********************************************************************/
  345. /*****                    State management                        *****/
  346. /**********************************************************************/
  347.  
  348.  
  349. /**
  350.  * \note This routine refers to derived texture attribute values to
  351.  * compute the ENABLE_TEXMAT flags, but is only called on
  352.  * _NEW_TEXTURE_MATRIX.  On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
  353.  * flags are updated by _mesa_update_textures(), below.
  354.  *
  355.  * \param ctx GL context.
  356.  */
  357. static void
  358. update_texture_matrices( struct gl_context *ctx )
  359. {
  360.    GLuint u;
  361.  
  362.    ctx->Texture._TexMatEnabled = 0x0;
  363.  
  364.    for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) {
  365.       assert(u < ARRAY_SIZE(ctx->TextureMatrixStack));
  366.       if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) {
  367.          _math_matrix_analyse( ctx->TextureMatrixStack[u].Top );
  368.  
  369.          if (ctx->Texture.Unit[u]._Current &&
  370.              ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY)
  371.             ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u);
  372.       }
  373.    }
  374. }
  375.  
  376.  
  377. /**
  378.  * Examine texture unit's combine/env state to update derived state.
  379.  */
  380. static void
  381. update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit)
  382. {
  383.    struct gl_tex_env_combine_state *combine;
  384.  
  385.    /* No combiners will apply to this. */
  386.    if (texUnit->_Current->Target == GL_TEXTURE_BUFFER)
  387.       return;
  388.  
  389.    /* Set the texUnit->_CurrentCombine field to point to the user's combiner
  390.     * state, or the combiner state which is derived from traditional texenv
  391.     * mode.
  392.     */
  393.    if (texUnit->EnvMode == GL_COMBINE ||
  394.        texUnit->EnvMode == GL_COMBINE4_NV) {
  395.       texUnit->_CurrentCombine = & texUnit->Combine;
  396.    }
  397.    else {
  398.       const struct gl_texture_object *texObj = texUnit->_Current;
  399.       GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
  400.  
  401.       if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
  402.          format = texObj->DepthMode;
  403.       }
  404.       calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);
  405.       texUnit->_CurrentCombine = & texUnit->_EnvMode;
  406.    }
  407.  
  408.    combine = texUnit->_CurrentCombine;
  409.  
  410.    /* Determine number of source RGB terms in the combiner function */
  411.    switch (combine->ModeRGB) {
  412.    case GL_REPLACE:
  413.       combine->_NumArgsRGB = 1;
  414.       break;
  415.    case GL_ADD:
  416.    case GL_ADD_SIGNED:
  417.       if (texUnit->EnvMode == GL_COMBINE4_NV)
  418.          combine->_NumArgsRGB = 4;
  419.       else
  420.          combine->_NumArgsRGB = 2;
  421.       break;
  422.    case GL_MODULATE:
  423.    case GL_SUBTRACT:
  424.    case GL_DOT3_RGB:
  425.    case GL_DOT3_RGBA:
  426.    case GL_DOT3_RGB_EXT:
  427.    case GL_DOT3_RGBA_EXT:
  428.       combine->_NumArgsRGB = 2;
  429.       break;
  430.    case GL_INTERPOLATE:
  431.    case GL_MODULATE_ADD_ATI:
  432.    case GL_MODULATE_SIGNED_ADD_ATI:
  433.    case GL_MODULATE_SUBTRACT_ATI:
  434.       combine->_NumArgsRGB = 3;
  435.       break;
  436.    default:
  437.       combine->_NumArgsRGB = 0;
  438.       _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");
  439.       return;
  440.    }
  441.  
  442.    /* Determine number of source Alpha terms in the combiner function */
  443.    switch (combine->ModeA) {
  444.    case GL_REPLACE:
  445.       combine->_NumArgsA = 1;
  446.       break;
  447.    case GL_ADD:
  448.    case GL_ADD_SIGNED:
  449.       if (texUnit->EnvMode == GL_COMBINE4_NV)
  450.          combine->_NumArgsA = 4;
  451.       else
  452.          combine->_NumArgsA = 2;
  453.       break;
  454.    case GL_MODULATE:
  455.    case GL_SUBTRACT:
  456.       combine->_NumArgsA = 2;
  457.       break;
  458.    case GL_INTERPOLATE:
  459.    case GL_MODULATE_ADD_ATI:
  460.    case GL_MODULATE_SIGNED_ADD_ATI:
  461.    case GL_MODULATE_SUBTRACT_ATI:
  462.       combine->_NumArgsA = 3;
  463.       break;
  464.    default:
  465.       combine->_NumArgsA = 0;
  466.       _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");
  467.       break;
  468.    }
  469. }
  470.  
  471. static void
  472. update_texgen(struct gl_context *ctx)
  473. {
  474.    GLuint unit;
  475.  
  476.    /* Setup texgen for those texture coordinate sets that are in use */
  477.    for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) {
  478.       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
  479.  
  480.       texUnit->_GenFlags = 0x0;
  481.  
  482.       if (!(ctx->Texture._EnabledCoordUnits & (1 << unit)))
  483.          continue;
  484.  
  485.       if (texUnit->TexGenEnabled) {
  486.          if (texUnit->TexGenEnabled & S_BIT) {
  487.             texUnit->_GenFlags |= texUnit->GenS._ModeBit;
  488.          }
  489.          if (texUnit->TexGenEnabled & T_BIT) {
  490.             texUnit->_GenFlags |= texUnit->GenT._ModeBit;
  491.          }
  492.          if (texUnit->TexGenEnabled & R_BIT) {
  493.             texUnit->_GenFlags |= texUnit->GenR._ModeBit;
  494.          }
  495.          if (texUnit->TexGenEnabled & Q_BIT) {
  496.             texUnit->_GenFlags |= texUnit->GenQ._ModeBit;
  497.          }
  498.  
  499.          ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit);
  500.          ctx->Texture._GenFlags |= texUnit->_GenFlags;
  501.       }
  502.  
  503.       assert(unit < ARRAY_SIZE(ctx->TextureMatrixStack));
  504.       if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY)
  505.          ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(unit);
  506.    }
  507. }
  508.  
  509. static struct gl_texture_object *
  510. update_single_program_texture(struct gl_context *ctx, struct gl_program *prog,
  511.                               int s)
  512. {
  513.    gl_texture_index target_index;
  514.    struct gl_texture_unit *texUnit;
  515.    struct gl_texture_object *texObj;
  516.    struct gl_sampler_object *sampler;
  517.    int unit;
  518.  
  519.    if (!(prog->SamplersUsed & (1 << s)))
  520.       return NULL;
  521.  
  522.    unit = prog->SamplerUnits[s];
  523.    texUnit = &ctx->Texture.Unit[unit];
  524.  
  525.    /* Note: If more than one bit was set in TexturesUsed[unit], then we should
  526.     * have had the draw call rejected already.  From the GL 4.4 specification,
  527.     * section 7.10 ("Samplers"):
  528.     *
  529.     *     "It is not allowed to have variables of different sampler types
  530.     *      pointing to the same texture image unit within a program
  531.     *      object. This situation can only be detected at the next rendering
  532.     *      command issued which triggers shader invocations, and an
  533.     *      INVALID_OPERATION error will then be generated."
  534.     */
  535.    target_index = ffs(prog->TexturesUsed[unit]) - 1;
  536.    texObj = texUnit->CurrentTex[target_index];
  537.  
  538.    sampler = texUnit->Sampler ?
  539.       texUnit->Sampler : &texObj->Sampler;
  540.  
  541.    if (likely(texObj)) {
  542.       if (_mesa_is_texture_complete(texObj, sampler))
  543.          return texObj;
  544.  
  545.       _mesa_test_texobj_completeness(ctx, texObj);
  546.       if (_mesa_is_texture_complete(texObj, sampler))
  547.          return texObj;
  548.    }
  549.  
  550.    /* If we've reached this point, we didn't find a complete texture of the
  551.     * shader's target.  From the GL 4.4 core specification, section 11.1.3.5
  552.     * ("Texture Access"):
  553.     *
  554.     *     "If a sampler is used in a shader and the sampler’s associated
  555.     *      texture is not complete, as defined in section 8.17, (0, 0, 0, 1)
  556.     *      will be returned for a non-shadow sampler and 0 for a shadow
  557.     *      sampler."
  558.     *
  559.     * Mesa implements this by creating a hidden texture object with a pixel of
  560.     * that value.
  561.     */
  562.    texObj = _mesa_get_fallback_texture(ctx, target_index);
  563.    assert(texObj);
  564.  
  565.    return texObj;
  566. }
  567.  
  568. static void
  569. update_program_texture_state(struct gl_context *ctx, struct gl_program **prog,
  570.                              BITSET_WORD *enabled_texture_units)
  571. {
  572.    int i;
  573.  
  574.    for (i = 0; i < MESA_SHADER_STAGES; i++) {
  575.       int s;
  576.  
  577.       if (!prog[i])
  578.          continue;
  579.  
  580.       /* We can't only do the shifting trick as the loop condition because if
  581.        * sampler 31 is active, the next iteration tries to shift by 32, which is
  582.        * undefined.
  583.        */
  584.       for (s = 0; s < MAX_SAMPLERS && (1 << s) <= prog[i]->SamplersUsed; s++) {
  585.          struct gl_texture_object *texObj;
  586.  
  587.          texObj = update_single_program_texture(ctx, prog[i], s);
  588.          if (texObj) {
  589.             int unit = prog[i]->SamplerUnits[s];
  590.             _mesa_reference_texobj(&ctx->Texture.Unit[unit]._Current, texObj);
  591.             BITSET_SET(enabled_texture_units, unit);
  592.             ctx->Texture._MaxEnabledTexImageUnit =
  593.                MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit);
  594.          }
  595.       }
  596.    }
  597.  
  598.    if (prog[MESA_SHADER_FRAGMENT]) {
  599.       const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
  600.       ctx->Texture._EnabledCoordUnits |=
  601.          (prog[MESA_SHADER_FRAGMENT]->InputsRead >> VARYING_SLOT_TEX0) &
  602.          coordMask;
  603.    }
  604. }
  605.  
  606. static void
  607. update_ff_texture_state(struct gl_context *ctx,
  608.                         BITSET_WORD *enabled_texture_units)
  609. {
  610.    int unit;
  611.  
  612.    for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
  613.       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
  614.       GLuint texIndex;
  615.  
  616.       if (texUnit->Enabled == 0x0)
  617.          continue;
  618.  
  619.       /* If a shader already dictated what texture target was used for this
  620.        * unit, just go along with it.
  621.        */
  622.       if (BITSET_TEST(enabled_texture_units, unit))
  623.          continue;
  624.  
  625.       /* From the GL 4.4 compat specification, section 16.2 ("Texture Application"):
  626.        *
  627.        *     "Texturing is enabled or disabled using the generic Enable and
  628.        *      Disable commands, respectively, with the symbolic constants
  629.        *      TEXTURE_1D, TEXTURE_2D, TEXTURE_RECTANGLE, TEXTURE_3D, or
  630.        *      TEXTURE_CUBE_MAP to enable the one-, two-, rectangular,
  631.        *      three-dimensional, or cube map texture, respectively. If more
  632.        *      than one of these textures is enabled, the first one enabled
  633.        *      from the following list is used:
  634.        *
  635.        *      • cube map texture
  636.        *      • three-dimensional texture
  637.        *      • rectangular texture
  638.        *      • two-dimensional texture
  639.        *      • one-dimensional texture"
  640.        *
  641.        * Note that the TEXTURE_x_INDEX values are in high to low priority.
  642.        * Also:
  643.        *
  644.        *     "If a texture unit is disabled or has an invalid or incomplete
  645.        *      texture (as defined in section 8.17) bound to it, then blending
  646.        *      is disabled for that texture unit. If the texture environment
  647.        *      for a given enabled texture unit references a disabled texture
  648.        *      unit, or an invalid or incomplete texture that is bound to
  649.        *      another unit, then the results of texture blending are
  650.        *      undefined."
  651.        */
  652.       for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) {
  653.          if (texUnit->Enabled & (1 << texIndex)) {
  654.             struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];
  655.             struct gl_sampler_object *sampler = texUnit->Sampler ?
  656.                texUnit->Sampler : &texObj->Sampler;
  657.  
  658.             if (!_mesa_is_texture_complete(texObj, sampler)) {
  659.                _mesa_test_texobj_completeness(ctx, texObj);
  660.             }
  661.             if (_mesa_is_texture_complete(texObj, sampler)) {
  662.                _mesa_reference_texobj(&texUnit->_Current, texObj);
  663.                break;
  664.             }
  665.          }
  666.       }
  667.  
  668.       if (texIndex == NUM_TEXTURE_TARGETS)
  669.          continue;
  670.  
  671.       /* if we get here, we know this texture unit is enabled */
  672.       BITSET_SET(enabled_texture_units, unit);
  673.       ctx->Texture._MaxEnabledTexImageUnit =
  674.          MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit);
  675.  
  676.       ctx->Texture._EnabledCoordUnits |= 1 << unit;
  677.  
  678.       update_tex_combine(ctx, texUnit);
  679.    }
  680. }
  681.  
  682. /**
  683.  * \note This routine refers to derived texture matrix values to
  684.  * compute the ENABLE_TEXMAT flags, but is only called on
  685.  * _NEW_TEXTURE.  On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
  686.  * flags are updated by _mesa_update_texture_matrices, above.
  687.  *
  688.  * \param ctx GL context.
  689.  */
  690. static void
  691. update_texture_state( struct gl_context *ctx )
  692. {
  693.    struct gl_program *prog[MESA_SHADER_STAGES];
  694.    int i;
  695.    int old_max_unit = ctx->Texture._MaxEnabledTexImageUnit;
  696.    BITSET_DECLARE(enabled_texture_units, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
  697.  
  698.    for (i = 0; i < MESA_SHADER_STAGES; i++) {
  699.       if (ctx->_Shader->CurrentProgram[i] &&
  700.           ctx->_Shader->CurrentProgram[i]->LinkStatus) {
  701.          prog[i] = ctx->_Shader->CurrentProgram[i]->_LinkedShaders[i]->Program;
  702.       } else {
  703.          if (i == MESA_SHADER_FRAGMENT && ctx->FragmentProgram._Enabled)
  704.             prog[i] = &ctx->FragmentProgram.Current->Base;
  705.          else
  706.             prog[i] = NULL;
  707.       }
  708.    }
  709.  
  710.    /* TODO: only set this if there are actual changes */
  711.    ctx->NewState |= _NEW_TEXTURE;
  712.  
  713.    ctx->Texture._GenFlags = 0x0;
  714.    ctx->Texture._TexMatEnabled = 0x0;
  715.    ctx->Texture._TexGenEnabled = 0x0;
  716.    ctx->Texture._MaxEnabledTexImageUnit = -1;
  717.    ctx->Texture._EnabledCoordUnits = 0x0;
  718.  
  719.    memset(&enabled_texture_units, 0, sizeof(enabled_texture_units));
  720.  
  721.    /* First, walk over our programs pulling in all the textures for them.
  722.     * Programs dictate specific texture targets to be enabled, and for a draw
  723.     * call to be valid they can't conflict about which texture targets are
  724.     * used.
  725.     */
  726.    update_program_texture_state(ctx, prog, enabled_texture_units);
  727.  
  728.    /* Also pull in any textures necessary for fixed function fragment shading.
  729.     */
  730.    if (!prog[MESA_SHADER_FRAGMENT])
  731.       update_ff_texture_state(ctx, enabled_texture_units);
  732.  
  733.    /* Now, clear out the _Current of any disabled texture units. */
  734.    for (i = 0; i <= ctx->Texture._MaxEnabledTexImageUnit; i++) {
  735.       if (!BITSET_TEST(enabled_texture_units, i))
  736.          _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL);
  737.    }
  738.    for (i = ctx->Texture._MaxEnabledTexImageUnit + 1; i <= old_max_unit; i++) {
  739.       _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL);
  740.    }
  741.  
  742.    if (!prog[MESA_SHADER_FRAGMENT] || !prog[MESA_SHADER_VERTEX])
  743.       update_texgen(ctx);
  744.  
  745.    _mesa_validate_image_units(ctx);
  746. }
  747.  
  748.  
  749. /**
  750.  * Update texture-related derived state.
  751.  */
  752. void
  753. _mesa_update_texture( struct gl_context *ctx, GLuint new_state )
  754. {
  755.    if (new_state & _NEW_TEXTURE_MATRIX)
  756.       update_texture_matrices( ctx );
  757.  
  758.    if (new_state & (_NEW_TEXTURE | _NEW_PROGRAM))
  759.       update_texture_state( ctx );
  760. }
  761.  
  762.  
  763. /**********************************************************************/
  764. /*****                      Initialization                        *****/
  765. /**********************************************************************/
  766.  
  767. /**
  768.  * Allocate the proxy textures for the given context.
  769.  *
  770.  * \param ctx the context to allocate proxies for.
  771.  *
  772.  * \return GL_TRUE on success, or GL_FALSE on failure
  773.  *
  774.  * If run out of memory part way through the allocations, clean up and return
  775.  * GL_FALSE.
  776.  */
  777. static GLboolean
  778. alloc_proxy_textures( struct gl_context *ctx )
  779. {
  780.    /* NOTE: these values must be in the same order as the TEXTURE_x_INDEX
  781.     * values!
  782.     */
  783.    static const GLenum targets[] = {
  784.       GL_TEXTURE_2D_MULTISAMPLE,
  785.       GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
  786.       GL_TEXTURE_CUBE_MAP_ARRAY,
  787.       GL_TEXTURE_BUFFER,
  788.       GL_TEXTURE_2D_ARRAY_EXT,
  789.       GL_TEXTURE_1D_ARRAY_EXT,
  790.       GL_TEXTURE_EXTERNAL_OES,
  791.       GL_TEXTURE_CUBE_MAP_ARB,
  792.       GL_TEXTURE_3D,
  793.       GL_TEXTURE_RECTANGLE_NV,
  794.       GL_TEXTURE_2D,
  795.       GL_TEXTURE_1D,
  796.    };
  797.    GLint tgt;
  798.  
  799.    STATIC_ASSERT(ARRAY_SIZE(targets) == NUM_TEXTURE_TARGETS);
  800.    assert(targets[TEXTURE_2D_INDEX] == GL_TEXTURE_2D);
  801.    assert(targets[TEXTURE_CUBE_INDEX] == GL_TEXTURE_CUBE_MAP);
  802.  
  803.    for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
  804.       if (!(ctx->Texture.ProxyTex[tgt]
  805.             = ctx->Driver.NewTextureObject(ctx, 0, targets[tgt]))) {
  806.          /* out of memory, free what we did allocate */
  807.          while (--tgt >= 0) {
  808.             ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
  809.          }
  810.          return GL_FALSE;
  811.       }
  812.    }
  813.  
  814.    assert(ctx->Texture.ProxyTex[0]->RefCount == 1); /* sanity check */
  815.    return GL_TRUE;
  816. }
  817.  
  818.  
  819. /**
  820.  * Initialize a texture unit.
  821.  *
  822.  * \param ctx GL context.
  823.  * \param unit texture unit number to be initialized.
  824.  */
  825. static void
  826. init_texture_unit( struct gl_context *ctx, GLuint unit )
  827. {
  828.    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
  829.    GLuint tex;
  830.  
  831.    texUnit->EnvMode = GL_MODULATE;
  832.    ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
  833.  
  834.    texUnit->Combine = default_combine_state;
  835.    texUnit->_EnvMode = default_combine_state;
  836.    texUnit->_CurrentCombine = & texUnit->_EnvMode;
  837.  
  838.    texUnit->TexGenEnabled = 0x0;
  839.    texUnit->GenS.Mode = GL_EYE_LINEAR;
  840.    texUnit->GenT.Mode = GL_EYE_LINEAR;
  841.    texUnit->GenR.Mode = GL_EYE_LINEAR;
  842.    texUnit->GenQ.Mode = GL_EYE_LINEAR;
  843.    texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR;
  844.    texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR;
  845.    texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR;
  846.    texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR;
  847.  
  848.    /* Yes, these plane coefficients are correct! */
  849.    ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 );
  850.    ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 );
  851.    ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
  852.    ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
  853.    ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 );
  854.    ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 );
  855.    ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 );
  856.    ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 );
  857.  
  858.    /* initialize current texture object ptrs to the shared default objects */
  859.    for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
  860.       _mesa_reference_texobj(&texUnit->CurrentTex[tex],
  861.                              ctx->Shared->DefaultTex[tex]);
  862.    }
  863.  
  864.    texUnit->_BoundTextures = 0;
  865. }
  866.  
  867.  
  868. /**
  869.  * Initialize texture state for the given context.
  870.  */
  871. GLboolean
  872. _mesa_init_texture(struct gl_context *ctx)
  873. {
  874.    GLuint u;
  875.  
  876.    /* Texture group */
  877.    ctx->Texture.CurrentUnit = 0;      /* multitexture */
  878.  
  879.    /* Appendix F.2 of the OpenGL ES 3.0 spec says:
  880.     *
  881.     *     "OpenGL ES 3.0 requires that all cube map filtering be
  882.     *     seamless. OpenGL ES 2.0 specified that a single cube map face be
  883.     *     selected and used for filtering."
  884.     *
  885.     * Unfortunatley, a call to _mesa_is_gles3 below will only work if
  886.     * the driver has already computed and set ctx->Version, however drivers
  887.     * seem to call _mesa_initialize_context (which calls this) early
  888.     * in the CreateContext hook and _mesa_compute_version much later (since
  889.     * it needs information about available extensions). So, we will
  890.     * enable seamless cubemaps by default since GLES2. This should work
  891.     * for most implementations and drivers that don't support seamless
  892.     * cubemaps for GLES2 can still disable it.
  893.     */
  894.    ctx->Texture.CubeMapSeamless = ctx->API == API_OPENGLES2;
  895.  
  896.    for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++)
  897.       init_texture_unit(ctx, u);
  898.  
  899.    /* After we're done initializing the context's texture state the default
  900.     * texture objects' refcounts should be at least
  901.     * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.
  902.     */
  903.    assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount
  904.           >= MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1);
  905.  
  906.    /* Allocate proxy textures */
  907.    if (!alloc_proxy_textures( ctx ))
  908.       return GL_FALSE;
  909.  
  910.    /* GL_ARB_texture_buffer_object */
  911.    _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject,
  912.                                  ctx->Shared->NullBufferObj);
  913.  
  914.    ctx->Texture.NumCurrentTexUsed = 0;
  915.  
  916.    return GL_TRUE;
  917. }
  918.  
  919.  
  920. /**
  921.  * Free dynamically-allocted texture data attached to the given context.
  922.  */
  923. void
  924. _mesa_free_texture_data(struct gl_context *ctx)
  925. {
  926.    GLuint u, tgt;
  927.  
  928.    /* unreference current textures */
  929.    for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
  930.       /* The _Current texture could account for another reference */
  931.       _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL);
  932.  
  933.       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
  934.          _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL);
  935.       }
  936.    }
  937.  
  938.    /* Free proxy texture objects */
  939.    for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++)
  940.       ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
  941.  
  942.    /* GL_ARB_texture_buffer_object */
  943.    _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL);
  944.  
  945.    for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
  946.       _mesa_reference_sampler_object(ctx, &ctx->Texture.Unit[u].Sampler, NULL);
  947.    }
  948. }
  949.  
  950.  
  951. /**
  952.  * Update the default texture objects in the given context to reference those
  953.  * specified in the shared state and release those referencing the old
  954.  * shared state.
  955.  */
  956. void
  957. _mesa_update_default_objects_texture(struct gl_context *ctx)
  958. {
  959.    GLuint u, tex;
  960.  
  961.    for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
  962.       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
  963.       for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
  964.          _mesa_reference_texobj(&texUnit->CurrentTex[tex],
  965.                                 ctx->Shared->DefaultTex[tex]);
  966.       }
  967.    }
  968. }
  969.