home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / swrast / s_texture.cpp < prev    next >
C/C++ Source or Header  |  2002-11-12  |  135KB  |  3,744 lines
  1. /* $Id: s_texture.c,v 1.75 2002/11/12 19:27:24 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  5.0
  6.  *
  7.  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  8.  *
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  *
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27.  
  28. #include "glheader.h"
  29. #include "context.h"
  30. #include "colormac.h"
  31. #include "macros.h"
  32. #include "mmath.h"
  33. #include "imports.h"
  34. #include "texformat.h"
  35. #include "teximage.h"
  36.  
  37. #include "s_context.h"
  38. #include "s_texture.h"
  39.  
  40.  
  41. /*
  42.  * These values are used in the fixed-point arithmetic used
  43.  * for linear filtering.
  44.  */
  45. #define WEIGHT_SCALE 65536.0F
  46. #define WEIGHT_SHIFT 16
  47.  
  48.  
  49. /*
  50.  * Used to compute texel locations for linear sampling.
  51.  * Input:
  52.  *    wrapMode = GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER_ARB
  53.  *    S = texcoord in [0,1]
  54.  *    SIZE = width (or height or depth) of texture
  55.  * Output:
  56.  *    U = texcoord in [0, width]
  57.  *    I0, I1 = two nearest texel indexes
  58.  */
  59. #define COMPUTE_LINEAR_TEXEL_LOCATIONS(wrapMode, S, U, SIZE, I0, I1)    \
  60. {                                    \
  61.    if (wrapMode == GL_REPEAT) {                        \
  62.       U = S * SIZE - 0.5F;                        \
  63.       I0 = IFLOOR(U) & (SIZE - 1);                    \
  64.       I1 = (I0 + 1) & (SIZE - 1);                    \
  65.    }                                    \
  66.    else if (wrapMode == GL_CLAMP_TO_EDGE) {                \
  67.       if (S <= 0.0F)                            \
  68.          U = 0.0F;                            \
  69.       else if (S >= 1.0F)                        \
  70.          U = (GLfloat) SIZE;                        \
  71.       else                                \
  72.          U = S * SIZE;                            \
  73.       U -= 0.5F;                            \
  74.       I0 = IFLOOR(U);                            \
  75.       I1 = I0 + 1;                            \
  76.       if (I0 < 0)                            \
  77.          I0 = 0;                            \
  78.       if (I1 >= (GLint) SIZE)                        \
  79.          I1 = SIZE - 1;                            \
  80.    }                                    \
  81.    else  if (wrapMode == GL_CLAMP_TO_BORDER_ARB) {            \
  82.       const GLfloat min = -1.0F / (2.0F * SIZE);            \
  83.       const GLfloat max = 1.0F - min;                    \
  84.       if (S <= min)                            \
  85.          U = min * SIZE;                        \
  86.       else if (S >= max)                        \
  87.          U = max * SIZE;                        \
  88.       else                                \
  89.          U = S * SIZE;                            \
  90.       U -= 0.5F;                            \
  91.       I0 = IFLOOR(U);                            \
  92.       I1 = I0 + 1;                            \
  93.    }                                    \
  94.    else if (wrapMode == GL_MIRRORED_REPEAT_ARB) {            \
  95.       const GLint flr = IFLOOR(S);                    \
  96.       if (flr & 1)                            \
  97.          U = 1.0F - (S - (GLfloat) flr);    /* flr is odd */    \
  98.       else                                \
  99.          U = S - (GLfloat) flr;        /* flr is even */        \
  100.       U = (U * SIZE) - 0.5F;                        \
  101.       I0 = IFLOOR(U);                            \
  102.       I1 = I0 + 1;                            \
  103.       if (I0 < 0)                            \
  104.          I0 = 0;                            \
  105.       if (I1 >= (GLint) SIZE)                        \
  106.          I1 = SIZE - 1;                            \
  107.    }                                    \
  108.    else if (wrapMode == GL_MIRROR_CLAMP_ATI) {                \
  109.       U = (GLfloat) fabs(S);                        \
  110.       if (U >= 1.0F)                            \
  111.          U = (GLfloat) SIZE;                        \
  112.       else                                \
  113.          U *= SIZE;                            \
  114.       U -= 0.5F;                            \
  115.       I0 = IFLOOR(U);                            \
  116.       I1 = I0 + 1;                            \
  117.    }                                    \
  118.    else if (wrapMode == GL_MIRROR_CLAMP_TO_EDGE_ATI) {            \
  119.       U = (GLfloat) fabs(S);                        \
  120.       if (U >= 1.0F)                            \
  121.          U = (GLfloat) SIZE;                        \
  122.       else                                \
  123.          U *= SIZE;                            \
  124.       U -= 0.5F;                            \
  125.       I0 = IFLOOR(U);                            \
  126.       I1 = I0 + 1;                            \
  127.       if (I0 < 0)                            \
  128.          I0 = 0;                            \
  129.       if (I1 >= (GLint) SIZE)                        \
  130.          I1 = SIZE - 1;                            \
  131.    }                                    \
  132.    else {                                \
  133.       ASSERT(wrapMode == GL_CLAMP);                    \
  134.       if (S <= 0.0F)                            \
  135.          U = 0.0F;                            \
  136.       else if (S >= 1.0F)                        \
  137.          U = (GLfloat) SIZE;                        \
  138.       else                                \
  139.          U = S * SIZE;                            \
  140.       U -= 0.5F;                            \
  141.       I0 = IFLOOR(U);                            \
  142.       I1 = I0 + 1;                            \
  143.    }                                    \
  144. }
  145.  
  146.  
  147. /*
  148.  * Used to compute texel location for nearest sampling.
  149.  */
  150. #define COMPUTE_NEAREST_TEXEL_LOCATION(wrapMode, S, SIZE, I)        \
  151. {                                    \
  152.    if (wrapMode == GL_REPEAT) {                        \
  153.       /* s limited to [0,1) */                        \
  154.       /* i limited to [0,size-1] */                    \
  155.       I = IFLOOR(S * SIZE);                        \
  156.       I &= (SIZE - 1);                            \
  157.    }                                    \
  158.    else if (wrapMode == GL_CLAMP_TO_EDGE) {                \
  159.       /* s limited to [min,max] */                    \
  160.       /* i limited to [0, size-1] */                    \
  161.       const GLfloat min = 1.0F / (2.0F * SIZE);                \
  162.       const GLfloat max = 1.0F - min;                    \
  163.       if (S < min)                            \
  164.          I = 0;                                \
  165.       else if (S > max)                            \
  166.          I = SIZE - 1;                            \
  167.       else                                \
  168.          I = IFLOOR(S * SIZE);                        \
  169.    }                                    \
  170.    else if (wrapMode == GL_CLAMP_TO_BORDER_ARB) {            \
  171.       /* s limited to [min,max] */                    \
  172.       /* i limited to [-1, size] */                    \
  173.       const GLfloat min = -1.0F / (2.0F * SIZE);            \
  174.       const GLfloat max = 1.0F - min;                    \
  175.       if (S <= min)                            \
  176.          I = -1;                            \
  177.       else if (S >= max)                        \
  178.          I = SIZE;                            \
  179.       else                                \
  180.          I = IFLOOR(S * SIZE);                        \
  181.    }                                    \
  182.    else if (wrapMode == GL_MIRRORED_REPEAT_ARB) {            \
  183.       const GLfloat min = 1.0F / (2.0F * SIZE);                \
  184.       const GLfloat max = 1.0F - min;                    \
  185.       const GLint flr = IFLOOR(S);                    \
  186.       GLfloat u;                            \
  187.       if (flr & 1)                            \
  188.          u = 1.0F - (S - (GLfloat) flr);    /* flr is odd */    \
  189.       else                                \
  190.          u = S - (GLfloat) flr;        /* flr is even */        \
  191.       if (u < min)                            \
  192.          I = 0;                                \
  193.       else if (u > max)                            \
  194.          I = SIZE - 1;                            \
  195.       else                                \
  196.          I = IFLOOR(u * SIZE);                        \
  197.    }                                    \
  198.    else if (wrapMode == GL_MIRROR_CLAMP_ATI) {                \
  199.       /* s limited to [0,1] */                        \
  200.       /* i limited to [0,size-1] */                    \
  201.       const GLfloat u = (GLfloat) fabs(S);                \
  202.       if (u <= 0.0F)                            \
  203.          I = 0;                                \
  204.       else if (u >= 1.0F)                        \
  205.          I = SIZE - 1;                            \
  206.       else                                \
  207.          I = IFLOOR(u * SIZE);                        \
  208.    }                                    \
  209.    else if (wrapMode == GL_MIRROR_CLAMP_TO_EDGE_ATI) {            \
  210.       /* s limited to [min,max] */                    \
  211.       /* i limited to [0, size-1] */                    \
  212.       const GLfloat min = 1.0F / (2.0F * SIZE);                \
  213.       const GLfloat max = 1.0F - min;                    \
  214.       const GLfloat u = (GLfloat) fabs(S);                \
  215.       if (u < min)                            \
  216.          I = 0;                                \
  217.       else if (u > max)                            \
  218.          I = SIZE - 1;                            \
  219.       else                                \
  220.          I = IFLOOR(u * SIZE);                        \
  221.    }                                    \
  222.    else {                                \
  223.       ASSERT(wrapMode == GL_CLAMP);                    \
  224.       /* s limited to [0,1] */                        \
  225.       /* i limited to [0,size-1] */                    \
  226.       if (S <= 0.0F)                            \
  227.          I = 0;                                \
  228.       else if (S >= 1.0F)                        \
  229.          I = SIZE - 1;                            \
  230.       else                                \
  231.          I = IFLOOR(S * SIZE);                        \
  232.    }                                    \
  233. }
  234.  
  235.  
  236. #define COMPUTE_LINEAR_REPEAT_TEXEL_LOCATION(S, U, SIZE, I0, I1)    \
  237. {                                    \
  238.    U = S * SIZE - 0.5F;                            \
  239.    I0 = IFLOOR(U) & (SIZE - 1);                        \
  240.    I1 = (I0 + 1) & (SIZE - 1);                        \
  241. }
  242.  
  243.  
  244. /*
  245.  * Compute linear mipmap levels for given lambda.
  246.  */
  247. #define COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level)    \
  248. {                                \
  249.    if (lambda < 0.0F)                        \
  250.       level = tObj->BaseLevel;                    \
  251.    else if (lambda > tObj->_MaxLambda)                \
  252.       level = (GLint) (tObj->BaseLevel + tObj->_MaxLambda);    \
  253.    else                                \
  254.       level = (GLint) (tObj->BaseLevel + lambda);        \
  255. }
  256.  
  257.  
  258. /*
  259.  * Compute nearest mipmap level for given lambda.
  260.  */
  261. #define COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level)    \
  262. {                                \
  263.    GLfloat l;                            \
  264.    if (lambda <= 0.5F)                        \
  265.       l = 0.0F;                            \
  266.    else if (lambda > tObj->_MaxLambda + 0.4999F)        \
  267.       l = tObj->_MaxLambda + 0.4999F;                \
  268.    else                                \
  269.       l = lambda;                        \
  270.    level = (GLint) (tObj->BaseLevel + l + 0.5F);        \
  271.    if (level > tObj->_MaxLevel)                    \
  272.       level = tObj->_MaxLevel;                    \
  273. }
  274.  
  275.  
  276.  
  277. /*
  278.  * Note, the FRAC macro has to work perfectly.  Otherwise you'll sometimes
  279.  * see 1-pixel bands of improperly weighted linear-sampled texels.  The
  280.  * tests/texwrap.c demo is a good test.
  281.  * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
  282.  * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
  283.  */
  284. #define FRAC(f)  ((f) - IFLOOR(f))
  285.  
  286.  
  287.  
  288. /*
  289.  * Bitflags for texture border color sampling.
  290.  */
  291. #define I0BIT   1
  292. #define I1BIT   2
  293. #define J0BIT   4
  294. #define J1BIT   8
  295. #define K0BIT  16
  296. #define K1BIT  32
  297.  
  298.  
  299.  
  300. /*
  301.  * Get texture palette entry.
  302.  */
  303. static void
  304. palette_sample(const GLcontext *ctx,
  305.                const struct gl_texture_object *tObj,
  306.                GLint index, GLchan rgba[4] )
  307. {
  308.    const GLchan *palette;
  309.    GLenum format;
  310.  
  311.    if (ctx->Texture.SharedPalette) {
  312.       ASSERT(!ctx->Texture.Palette.FloatTable);
  313.       palette = (const GLchan *) ctx->Texture.Palette.Table;
  314.       format = ctx->Texture.Palette.Format;
  315.    }
  316.    else {
  317.       ASSERT(!tObj->Palette.FloatTable);
  318.       palette = (const GLchan *) tObj->Palette.Table;
  319.       format = tObj->Palette.Format;
  320.    }
  321.  
  322.    switch (format) {
  323.       case GL_ALPHA:
  324.          rgba[ACOMP] = palette[index];
  325.          return;
  326.       case GL_LUMINANCE:
  327.       case GL_INTENSITY:
  328.          rgba[RCOMP] = palette[index];
  329.          return;
  330.       case GL_LUMINANCE_ALPHA:
  331.          rgba[RCOMP] = palette[(index << 1) + 0];
  332.          rgba[ACOMP] = palette[(index << 1) + 1];
  333.          return;
  334.       case GL_RGB:
  335.          rgba[RCOMP] = palette[index * 3 + 0];
  336.          rgba[GCOMP] = palette[index * 3 + 1];
  337.          rgba[BCOMP] = palette[index * 3 + 2];
  338.          return;
  339.       case GL_RGBA:
  340.          rgba[RCOMP] = palette[(index << 2) + 0];
  341.          rgba[GCOMP] = palette[(index << 2) + 1];
  342.          rgba[BCOMP] = palette[(index << 2) + 2];
  343.          rgba[ACOMP] = palette[(index << 2) + 3];
  344.          return;
  345.       default:
  346.          _mesa_problem(ctx, "Bad palette format in palette_sample");
  347.    }
  348. }
  349.  
  350.  
  351. /*
  352.  * The lambda[] array values are always monotonic.  Either the whole span
  353.  * will be minified, magnified, or split between the two.  This function
  354.  * determines the subranges in [0, n-1] that are to be minified or magnified.
  355.  */
  356. static INLINE void
  357. compute_min_mag_ranges( GLfloat minMagThresh, GLuint n, const GLfloat lambda[],
  358.                         GLuint *minStart, GLuint *minEnd,
  359.                         GLuint *magStart, GLuint *magEnd )
  360. {
  361.    ASSERT(lambda != NULL);
  362. #if 0
  363.    /* Verify that lambda[] is monotonous.
  364.     * We can't really use this because the inaccuracy in the LOG2 function
  365.     * causes this test to fail, yet the resulting texturing is correct.
  366.     */
  367.    if (n > 1) {
  368.       GLuint i;
  369.       printf("lambda delta = %g\n", lambda[0] - lambda[n-1]);
  370.       if (lambda[0] >= lambda[n-1]) { /* decreasing */
  371.          for (i = 0; i < n - 1; i++) {
  372.             ASSERT((GLint) (lambda[i] * 10) >= (GLint) (lambda[i+1] * 10));
  373.          }
  374.       }
  375.       else { /* increasing */
  376.          for (i = 0; i < n - 1; i++) {
  377.             ASSERT((GLint) (lambda[i] * 10) <= (GLint) (lambda[i+1] * 10));
  378.          }
  379.       }
  380.    }
  381. #endif /* DEBUG */
  382.  
  383.    /* since lambda is monotonous-array use this check first */
  384.    if (lambda[0] <= minMagThresh && lambda[n-1] <= minMagThresh) {
  385.       /* magnification for whole span */
  386.       *magStart = 0;
  387.       *magEnd = n;
  388.       *minStart = *minEnd = 0;
  389.    }
  390.    else if (lambda[0] > minMagThresh && lambda[n-1] > minMagThresh) {
  391.       /* minification for whole span */
  392.       *minStart = 0;
  393.       *minEnd = n;
  394.       *magStart = *magEnd = 0;
  395.    }
  396.    else {
  397.       /* a mix of minification and magnification */
  398.       GLuint i;
  399.       if (lambda[0] > minMagThresh) {
  400.          /* start with minification */
  401.          for (i = 1; i < n; i++) {
  402.             if (lambda[i] <= minMagThresh)
  403.                break;
  404.          }
  405.          *minStart = 0;
  406.          *minEnd = i;
  407.          *magStart = i;
  408.          *magEnd = n;
  409.       }
  410.       else {
  411.          /* start with magnification */
  412.          for (i = 1; i < n; i++) {
  413.             if (lambda[i] > minMagThresh)
  414.                break;
  415.          }
  416.          *magStart = 0;
  417.          *magEnd = i;
  418.          *minStart = i;
  419.          *minEnd = n;
  420.       }
  421.    }
  422.  
  423. #if 0
  424.    /* Verify the min/mag Start/End values
  425.     * We don't use this either (see above)
  426.     */
  427.    {
  428.       GLint i;
  429.       for (i = 0; i < n; i++) {
  430.          if (lambda[i] > minMagThresh) {
  431.             /* minification */
  432.             ASSERT(i >= *minStart);
  433.             ASSERT(i < *minEnd);
  434.          }
  435.          else {
  436.             /* magnification */
  437.             ASSERT(i >= *magStart);
  438.             ASSERT(i < *magEnd);
  439.          }
  440.       }
  441.    }
  442. #endif
  443. }
  444.  
  445.  
  446. /**********************************************************************/
  447. /*                    1-D Texture Sampling Functions                  */
  448. /**********************************************************************/
  449.  
  450. /*
  451.  * Return the texture sample for coordinate (s) using GL_NEAREST filter.
  452.  */
  453. static void
  454. sample_1d_nearest(GLcontext *ctx,
  455.                   const struct gl_texture_object *tObj,
  456.                   const struct gl_texture_image *img,
  457.                   const GLfloat texcoord[4], GLchan rgba[4])
  458. {
  459.    const GLint width = img->Width2;  /* without border, power of two */
  460.    GLint i;
  461.  
  462.    COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, texcoord[0], width, i);
  463.  
  464.    /* skip over the border, if any */
  465.    i += img->Border;
  466.  
  467.    if (i < 0 || i >= (GLint) img->Width) {
  468.       /* Need this test for GL_CLAMP_TO_BORDER_ARB mode */
  469.       COPY_CHAN4(rgba, tObj->_BorderChan);
  470.    }
  471.    else {
  472.       (*img->FetchTexel)(img, i, 0, 0, (GLvoid *) rgba);
  473.       if (img->Format == GL_COLOR_INDEX) {
  474.          palette_sample(ctx, tObj, rgba[0], rgba);
  475.       }
  476.    }
  477. }
  478.  
  479.  
  480.  
  481. /*
  482.  * Return the texture sample for coordinate (s) using GL_LINEAR filter.
  483.  */
  484. static void
  485. sample_1d_linear(GLcontext *ctx,
  486.                  const struct gl_texture_object *tObj,
  487.                  const struct gl_texture_image *img,
  488.                  const GLfloat texcoord[4], GLchan rgba[4])
  489. {
  490.    const GLint width = img->Width2;
  491.    GLint i0, i1;
  492.    GLfloat u;
  493.    GLuint useBorderColor;
  494.  
  495.    COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, texcoord[0], u, width, i0, i1);
  496.  
  497.    useBorderColor = 0;
  498.    if (img->Border) {
  499.       i0 += img->Border;
  500.       i1 += img->Border;
  501.    }
  502.    else {
  503.       if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
  504.       if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
  505.    }
  506.  
  507.    {
  508.       const GLfloat a = FRAC(u);
  509.  
  510. #if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
  511.       const GLfloat w0 = (1.0F-a);
  512.       const GLfloat w1 =       a ;
  513. #else /* CHAN_BITS == 8 */
  514.       /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
  515.       const GLint w0 = IROUND_POS((1.0F - a) * WEIGHT_SCALE);
  516.       const GLint w1 = IROUND_POS(        a  * WEIGHT_SCALE);
  517. #endif
  518.       GLchan t0[4], t1[4];  /* texels */
  519.  
  520.       if (useBorderColor & I0BIT) {
  521.          COPY_CHAN4(t0, tObj->_BorderChan);
  522.       }
  523.       else {
  524.          (*img->FetchTexel)(img, i0, 0, 0, (GLvoid *) t0);
  525.          if (img->Format == GL_COLOR_INDEX) {
  526.             palette_sample(ctx, tObj, t0[0], t0);
  527.          }
  528.       }
  529.       if (useBorderColor & I1BIT) {
  530.          COPY_CHAN4(t1, tObj->_BorderChan);
  531.       }
  532.       else {
  533.          (*img->FetchTexel)(img, i1, 0, 0, (GLvoid *) t1);
  534.          if (img->Format == GL_COLOR_INDEX) {
  535.             palette_sample(ctx, tObj, t1[0], t1);
  536.          }
  537.       }
  538.  
  539. #if CHAN_TYPE == GL_FLOAT
  540.       rgba[0] = w0 * t0[0] + w1 * t1[0];
  541.       rgba[1] = w0 * t0[1] + w1 * t1[1];
  542.       rgba[2] = w0 * t0[2] + w1 * t1[2];
  543.       rgba[3] = w0 * t0[3] + w1 * t1[3];
  544. #elif CHAN_TYPE == GL_UNSIGNED_SHORT
  545.       rgba[0] = (GLchan) (w0 * t0[0] + w1 * t1[0] + 0.5);
  546.       rgba[1] = (GLchan) (w0 * t0[1] + w1 * t1[1] + 0.5);
  547.       rgba[2] = (GLchan) (w0 * t0[2] + w1 * t1[2] + 0.5);
  548.       rgba[3] = (GLchan) (w0 * t0[3] + w1 * t1[3] + 0.5);
  549. #else /* CHAN_BITS == 8 */
  550.       rgba[0] = (GLchan) ((w0 * t0[0] + w1 * t1[0]) >> WEIGHT_SHIFT);
  551.       rgba[1] = (GLchan) ((w0 * t0[1] + w1 * t1[1]) >> WEIGHT_SHIFT);
  552.       rgba[2] = (GLchan) ((w0 * t0[2] + w1 * t1[2]) >> WEIGHT_SHIFT);
  553.       rgba[3] = (GLchan) ((w0 * t0[3] + w1 * t1[3]) >> WEIGHT_SHIFT);
  554. #endif
  555.  
  556.    }
  557. }
  558.  
  559.  
  560. static void
  561. sample_1d_nearest_mipmap_nearest(GLcontext *ctx,
  562.                                  const struct gl_texture_object *tObj,
  563.                                  GLuint n, GLfloat texcoord[][4],
  564.                                  const GLfloat lambda[], GLchan rgba[][4])
  565. {
  566.    GLuint i;
  567.    ASSERT(lambda != NULL);
  568.    for (i = 0; i < n; i++) {
  569.       GLint level;
  570.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  571.       sample_1d_nearest(ctx, tObj, tObj->Image[level], texcoord[i], rgba[i]);
  572.    }
  573. }
  574.  
  575.  
  576. static void
  577. sample_1d_linear_mipmap_nearest(GLcontext *ctx,
  578.                                 const struct gl_texture_object *tObj,
  579.                                 GLuint n, GLfloat texcoord[][4],
  580.                                 const GLfloat lambda[], GLchan rgba[][4])
  581. {
  582.    GLuint i;
  583.    ASSERT(lambda != NULL);
  584.    for (i = 0; i < n; i++) {
  585.       GLint level;
  586.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  587.       sample_1d_linear(ctx, tObj, tObj->Image[level], texcoord[i], rgba[i]);
  588.    }
  589. }
  590.  
  591.  
  592.  
  593. /*
  594.  * This is really just needed in order to prevent warnings with some compilers.
  595.  */
  596. #if CHAN_TYPE == GL_FLOAT
  597. #define CHAN_CAST
  598. #else
  599. #define CHAN_CAST (GLchan) (GLint)
  600. #endif
  601.  
  602.  
  603. static void
  604. sample_1d_nearest_mipmap_linear(GLcontext *ctx,
  605.                                 const struct gl_texture_object *tObj,
  606.                                 GLuint n, GLfloat texcoord[][4],
  607.                                 const GLfloat lambda[], GLchan rgba[][4])
  608. {
  609.    GLuint i;
  610.    ASSERT(lambda != NULL);
  611.    for (i = 0; i < n; i++) {
  612.       GLint level;
  613.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  614.       if (level >= tObj->_MaxLevel) {
  615.          sample_1d_nearest(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  616.                            texcoord[i], rgba[i]);
  617.       }
  618.       else {
  619.          GLchan t0[4], t1[4];
  620.          const GLfloat f = FRAC(lambda[i]);
  621.          sample_1d_nearest(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  622.          sample_1d_nearest(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  623.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  624.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  625.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  626.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  627.       }
  628.    }
  629. }
  630.  
  631.  
  632.  
  633. static void
  634. sample_1d_linear_mipmap_linear(GLcontext *ctx,
  635.                                const struct gl_texture_object *tObj,
  636.                                GLuint n, GLfloat texcoord[][4],
  637.                                const GLfloat lambda[], GLchan rgba[][4])
  638. {
  639.    GLuint i;
  640.    ASSERT(lambda != NULL);
  641.    for (i = 0; i < n; i++) {
  642.       GLint level;
  643.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  644.       if (level >= tObj->_MaxLevel) {
  645.          sample_1d_linear(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  646.                           texcoord[i], rgba[i]);
  647.       }
  648.       else {
  649.          GLchan t0[4], t1[4];
  650.          const GLfloat f = FRAC(lambda[i]);
  651.          sample_1d_linear(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  652.          sample_1d_linear(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  653.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  654.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  655.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  656.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  657.       }
  658.    }
  659. }
  660.  
  661.  
  662.  
  663. static void
  664. sample_nearest_1d( GLcontext *ctx, GLuint texUnit,
  665.                    const struct gl_texture_object *tObj, GLuint n,
  666.                    GLfloat texcoords[][4], const GLfloat lambda[],
  667.                    GLchan rgba[][4] )
  668. {
  669.    GLuint i;
  670.    struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
  671.    (void) lambda;
  672.    for (i=0;i<n;i++) {
  673.       sample_1d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
  674.    }
  675. }
  676.  
  677.  
  678.  
  679. static void
  680. sample_linear_1d( GLcontext *ctx, GLuint texUnit,
  681.                   const struct gl_texture_object *tObj, GLuint n,
  682.                   GLfloat texcoords[][4], const GLfloat lambda[],
  683.                   GLchan rgba[][4] )
  684. {
  685.    GLuint i;
  686.    struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
  687.    (void) lambda;
  688.    for (i=0;i<n;i++) {
  689.       sample_1d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
  690.    }
  691. }
  692.  
  693.  
  694. /*
  695.  * Given an (s) texture coordinate and lambda (level of detail) value,
  696.  * return a texture sample.
  697.  *
  698.  */
  699. static void
  700. sample_lambda_1d( GLcontext *ctx, GLuint texUnit,
  701.                   const struct gl_texture_object *tObj, GLuint n,
  702.                   GLfloat texcoords[][4],
  703.                   const GLfloat lambda[], GLchan rgba[][4] )
  704. {
  705.    GLuint minStart, minEnd;  /* texels with minification */
  706.    GLuint magStart, magEnd;  /* texels with magnification */
  707.    GLuint i;
  708.  
  709.    ASSERT(lambda != NULL);
  710.    compute_min_mag_ranges(SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit],
  711.                           n, lambda, &minStart, &minEnd, &magStart, &magEnd);
  712.  
  713.    if (minStart < minEnd) {
  714.       /* do the minified texels */
  715.       const GLuint m = minEnd - minStart;
  716.       switch (tObj->MinFilter) {
  717.       case GL_NEAREST:
  718.          for (i = minStart; i < minEnd; i++)
  719.             sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
  720.                               texcoords[i], rgba[i]);
  721.          break;
  722.       case GL_LINEAR:
  723.          for (i = minStart; i < minEnd; i++)
  724.             sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
  725.                              texcoords[i], rgba[i]);
  726.          break;
  727.       case GL_NEAREST_MIPMAP_NEAREST:
  728.          sample_1d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  729.                                           lambda + minStart, rgba + minStart);
  730.          break;
  731.       case GL_LINEAR_MIPMAP_NEAREST:
  732.          sample_1d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  733.                                          lambda + minStart, rgba + minStart);
  734.          break;
  735.       case GL_NEAREST_MIPMAP_LINEAR:
  736.          sample_1d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  737.                                          lambda + minStart, rgba + minStart);
  738.          break;
  739.       case GL_LINEAR_MIPMAP_LINEAR:
  740.          sample_1d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  741.                                         lambda + minStart, rgba + minStart);
  742.          break;
  743.       default:
  744.          _mesa_problem(ctx, "Bad min filter in sample_1d_texture");
  745.          return;
  746.       }
  747.    }
  748.  
  749.    if (magStart < magEnd) {
  750.       /* do the magnified texels */
  751.       switch (tObj->MagFilter) {
  752.       case GL_NEAREST:
  753.          for (i = magStart; i < magEnd; i++)
  754.             sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
  755.                               texcoords[i], rgba[i]);
  756.          break;
  757.       case GL_LINEAR:
  758.          for (i = magStart; i < magEnd; i++)
  759.             sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
  760.                              texcoords[i], rgba[i]);
  761.          break;
  762.       default:
  763.          _mesa_problem(ctx, "Bad mag filter in sample_1d_texture");
  764.          return;
  765.       }
  766.    }
  767. }
  768.  
  769.  
  770. /**********************************************************************/
  771. /*                    2-D Texture Sampling Functions                  */
  772. /**********************************************************************/
  773.  
  774.  
  775. /*
  776.  * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.
  777.  */
  778. static INLINE void
  779. sample_2d_nearest(GLcontext *ctx,
  780.                   const struct gl_texture_object *tObj,
  781.                   const struct gl_texture_image *img,
  782.                   const GLfloat texcoord[4],
  783.                   GLchan rgba[])
  784. {
  785.    const GLint width = img->Width2;    /* without border, power of two */
  786.    const GLint height = img->Height2;  /* without border, power of two */
  787.    GLint i, j;
  788.  
  789.    COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, texcoord[0], width,  i);
  790.    COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, texcoord[1], height, j);
  791.  
  792.    /* skip over the border, if any */
  793.    i += img->Border;
  794.    j += img->Border;
  795.  
  796.    if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height) {
  797.       /* Need this test for GL_CLAMP_TO_BORDER_ARB mode */
  798.       COPY_CHAN4(rgba, tObj->_BorderChan);
  799.    }
  800.    else {
  801.       (*img->FetchTexel)(img, i, j, 0, (GLvoid *) rgba);
  802.       if (img->Format == GL_COLOR_INDEX) {
  803.          palette_sample(ctx, tObj, rgba[0], rgba);
  804.       }
  805.    }
  806. }
  807.  
  808.  
  809.  
  810. /*
  811.  * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.
  812.  * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.
  813.  */
  814. static INLINE void
  815. sample_2d_linear(GLcontext *ctx,
  816.                  const struct gl_texture_object *tObj,
  817.                  const struct gl_texture_image *img,
  818.                  const GLfloat texcoord[4],
  819.                  GLchan rgba[])
  820. {
  821.    const GLint width = img->Width2;
  822.    const GLint height = img->Height2;
  823.    GLint i0, j0, i1, j1;
  824.    GLuint useBorderColor;
  825.    GLfloat u, v;
  826.  
  827.    COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, texcoord[0], u, width,  i0, i1);
  828.    COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, texcoord[1], v, height, j0, j1);
  829.  
  830.    useBorderColor = 0;
  831.    if (img->Border) {
  832.       i0 += img->Border;
  833.       i1 += img->Border;
  834.       j0 += img->Border;
  835.       j1 += img->Border;
  836.    }
  837.    else {
  838.       if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
  839.       if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
  840.       if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
  841.       if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
  842.    }
  843.  
  844.    {
  845.       const GLfloat a = FRAC(u);
  846.       const GLfloat b = FRAC(v);
  847.  
  848. #if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
  849.       const GLfloat w00 = (1.0F-a) * (1.0F-b);
  850.       const GLfloat w10 =       a  * (1.0F-b);
  851.       const GLfloat w01 = (1.0F-a) *       b ;
  852.       const GLfloat w11 =       a  *       b ;
  853. #else /* CHAN_BITS == 8 */
  854.       /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
  855.       const GLint w00 = IROUND_POS((1.0F-a) * (1.0F-b) * WEIGHT_SCALE);
  856.       const GLint w10 = IROUND_POS(      a  * (1.0F-b) * WEIGHT_SCALE);
  857.       const GLint w01 = IROUND_POS((1.0F-a) *       b  * WEIGHT_SCALE);
  858.       const GLint w11 = IROUND_POS(      a  *       b  * WEIGHT_SCALE);
  859. #endif
  860.       GLchan t00[4];
  861.       GLchan t10[4];
  862.       GLchan t01[4];
  863.       GLchan t11[4];
  864.  
  865.       if (useBorderColor & (I0BIT | J0BIT)) {
  866.          COPY_CHAN4(t00, tObj->_BorderChan);
  867.       }
  868.       else {
  869.          (*img->FetchTexel)(img, i0, j0, 0, (GLvoid *) t00);
  870.          if (img->Format == GL_COLOR_INDEX) {
  871.             palette_sample(ctx, tObj, t00[0], t00);
  872.          }
  873.       }
  874.       if (useBorderColor & (I1BIT | J0BIT)) {
  875.          COPY_CHAN4(t10, tObj->_BorderChan);
  876.       }
  877.       else {
  878.          (*img->FetchTexel)(img, i1, j0, 0, (GLvoid *) t10);
  879.          if (img->Format == GL_COLOR_INDEX) {
  880.             palette_sample(ctx, tObj, t10[0], t10);
  881.          }
  882.       }
  883.       if (useBorderColor & (I0BIT | J1BIT)) {
  884.          COPY_CHAN4(t01, tObj->_BorderChan);
  885.       }
  886.       else {
  887.          (*img->FetchTexel)(img, i0, j1, 0, (GLvoid *) t01);
  888.          if (img->Format == GL_COLOR_INDEX) {
  889.             palette_sample(ctx, tObj, t01[0], t01);
  890.          }
  891.       }
  892.       if (useBorderColor & (I1BIT | J1BIT)) {
  893.          COPY_CHAN4(t11, tObj->_BorderChan);
  894.       }
  895.       else {
  896.          (*img->FetchTexel)(img, i1, j1, 0, (GLvoid *) t11);
  897.          if (img->Format == GL_COLOR_INDEX) {
  898.             palette_sample(ctx, tObj, t11[0], t11);
  899.          }
  900.       }
  901. #if CHAN_TYPE == GL_FLOAT
  902.       rgba[0] = w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0];
  903.       rgba[1] = w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1];
  904.       rgba[2] = w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2];
  905.       rgba[3] = w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3];
  906. #elif CHAN_TYPE == GL_UNSIGNED_SHORT
  907.       rgba[0] = (GLchan) (w00 * t00[0] + w10 * t10[0] +
  908.                           w01 * t01[0] + w11 * t11[0] + 0.5);
  909.       rgba[1] = (GLchan) (w00 * t00[1] + w10 * t10[1] +
  910.                           w01 * t01[1] + w11 * t11[1] + 0.5);
  911.       rgba[2] = (GLchan) (w00 * t00[2] + w10 * t10[2] +
  912.                           w01 * t01[2] + w11 * t11[2] + 0.5);
  913.       rgba[3] = (GLchan) (w00 * t00[3] + w10 * t10[3] +
  914.                           w01 * t01[3] + w11 * t11[3] + 0.5);
  915. #else /* CHAN_BITS == 8 */
  916.       rgba[0] = (GLchan) ((w00 * t00[0] + w10 * t10[0] +
  917.                            w01 * t01[0] + w11 * t11[0]) >> WEIGHT_SHIFT);
  918.       rgba[1] = (GLchan) ((w00 * t00[1] + w10 * t10[1] +
  919.                            w01 * t01[1] + w11 * t11[1]) >> WEIGHT_SHIFT);
  920.       rgba[2] = (GLchan) ((w00 * t00[2] + w10 * t10[2] +
  921.                            w01 * t01[2] + w11 * t11[2]) >> WEIGHT_SHIFT);
  922.       rgba[3] = (GLchan) ((w00 * t00[3] + w10 * t10[3] +
  923.                            w01 * t01[3] + w11 * t11[3]) >> WEIGHT_SHIFT);
  924. #endif
  925.  
  926.    }
  927.  
  928. }
  929.  
  930.  
  931. /*
  932.  * As above, but we know WRAP_S == REPEAT and WRAP_T == REPEAT
  933.  * and we're not using a paletted texture.
  934.  */
  935. static INLINE void
  936. sample_2d_linear_repeat(GLcontext *ctx,
  937.                         const struct gl_texture_object *tObj,
  938.                         const struct gl_texture_image *img,
  939.                         const GLfloat texcoord[4],
  940.                         GLchan rgba[])
  941. {
  942.    const GLint width = img->Width2;
  943.    const GLint height = img->Height2;
  944.    GLint i0, j0, i1, j1;
  945.    GLfloat u, v;
  946.  
  947.    ASSERT(tObj->WrapS == GL_REPEAT);
  948.    ASSERT(tObj->WrapT == GL_REPEAT);
  949.    ASSERT(img->Border == 0);
  950.    ASSERT(img->Format != GL_COLOR_INDEX);
  951.  
  952.    COMPUTE_LINEAR_REPEAT_TEXEL_LOCATION(texcoord[0], u, width,  i0, i1);
  953.    COMPUTE_LINEAR_REPEAT_TEXEL_LOCATION(texcoord[1], v, height, j0, j1);
  954.  
  955.    {
  956.       const GLfloat a = FRAC(u);
  957.       const GLfloat b = FRAC(v);
  958.  
  959. #if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
  960.       const GLfloat w00 = (1.0F-a) * (1.0F-b);
  961.       const GLfloat w10 =       a  * (1.0F-b);
  962.       const GLfloat w01 = (1.0F-a) *       b ;
  963.       const GLfloat w11 =       a  *       b ;
  964. #else /* CHAN_BITS == 8 */
  965.       /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
  966.       const GLint w00 = IROUND_POS((1.0F-a) * (1.0F-b) * WEIGHT_SCALE);
  967.       const GLint w10 = IROUND_POS(      a  * (1.0F-b) * WEIGHT_SCALE);
  968.       const GLint w01 = IROUND_POS((1.0F-a) *       b  * WEIGHT_SCALE);
  969.       const GLint w11 = IROUND_POS(      a  *       b  * WEIGHT_SCALE);
  970. #endif
  971.       GLchan t00[4];
  972.       GLchan t10[4];
  973.       GLchan t01[4];
  974.       GLchan t11[4];
  975.  
  976.       (*img->FetchTexel)(img, i0, j0, 0, (GLvoid *) t00);
  977.       (*img->FetchTexel)(img, i1, j0, 0, (GLvoid *) t10);
  978.       (*img->FetchTexel)(img, i0, j1, 0, (GLvoid *) t01);
  979.       (*img->FetchTexel)(img, i1, j1, 0, (GLvoid *) t11);
  980.  
  981. #if CHAN_TYPE == GL_FLOAT
  982.       rgba[0] = w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0];
  983.       rgba[1] = w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1];
  984.       rgba[2] = w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2];
  985.       rgba[3] = w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3];
  986. #elif CHAN_TYPE == GL_UNSIGNED_SHORT
  987.       rgba[0] = (GLchan) (w00 * t00[0] + w10 * t10[0] +
  988.                           w01 * t01[0] + w11 * t11[0] + 0.5);
  989.       rgba[1] = (GLchan) (w00 * t00[1] + w10 * t10[1] +
  990.                           w01 * t01[1] + w11 * t11[1] + 0.5);
  991.       rgba[2] = (GLchan) (w00 * t00[2] + w10 * t10[2] +
  992.                           w01 * t01[2] + w11 * t11[2] + 0.5);
  993.       rgba[3] = (GLchan) (w00 * t00[3] + w10 * t10[3] +
  994.                           w01 * t01[3] + w11 * t11[3] + 0.5);
  995. #else /* CHAN_BITS == 8 */
  996.       rgba[0] = (GLchan) ((w00 * t00[0] + w10 * t10[0] +
  997.                            w01 * t01[0] + w11 * t11[0]) >> WEIGHT_SHIFT);
  998.       rgba[1] = (GLchan) ((w00 * t00[1] + w10 * t10[1] +
  999.                            w01 * t01[1] + w11 * t11[1]) >> WEIGHT_SHIFT);
  1000.       rgba[2] = (GLchan) ((w00 * t00[2] + w10 * t10[2] +
  1001.                            w01 * t01[2] + w11 * t11[2]) >> WEIGHT_SHIFT);
  1002.       rgba[3] = (GLchan) ((w00 * t00[3] + w10 * t10[3] +
  1003.                            w01 * t01[3] + w11 * t11[3]) >> WEIGHT_SHIFT);
  1004. #endif
  1005.  
  1006.    }
  1007.  
  1008. }
  1009.  
  1010.  
  1011.  
  1012. static void
  1013. sample_2d_nearest_mipmap_nearest(GLcontext *ctx,
  1014.                                  const struct gl_texture_object *tObj,
  1015.                                  GLuint n, GLfloat texcoord[][4],
  1016.                                  const GLfloat lambda[], GLchan rgba[][4])
  1017. {
  1018.    GLuint i;
  1019.    for (i = 0; i < n; i++) {
  1020.       GLint level;
  1021.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  1022.       sample_2d_nearest(ctx, tObj, tObj->Image[level], texcoord[i], rgba[i]);
  1023.    }
  1024. }
  1025.  
  1026.  
  1027.  
  1028. static void
  1029. sample_2d_linear_mipmap_nearest(GLcontext *ctx,
  1030.                                 const struct gl_texture_object *tObj,
  1031.                                 GLuint n, GLfloat texcoord[][4],
  1032.                                 const GLfloat lambda[], GLchan rgba[][4])
  1033. {
  1034.    GLuint i;
  1035.    ASSERT(lambda != NULL);
  1036.    for (i = 0; i < n; i++) {
  1037.       GLint level;
  1038.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  1039.       sample_2d_linear(ctx, tObj, tObj->Image[level], texcoord[i], rgba[i]);
  1040.    }
  1041. }
  1042.  
  1043.  
  1044.  
  1045. static void
  1046. sample_2d_nearest_mipmap_linear(GLcontext *ctx,
  1047.                                 const struct gl_texture_object *tObj,
  1048.                                 GLuint n, GLfloat texcoord[][4],
  1049.                                 const GLfloat lambda[], GLchan rgba[][4])
  1050. {
  1051.    GLuint i;
  1052.    ASSERT(lambda != NULL);
  1053.    for (i = 0; i < n; i++) {
  1054.       GLint level;
  1055.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1056.       if (level >= tObj->_MaxLevel) {
  1057.          sample_2d_nearest(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  1058.                            texcoord[i], rgba[i]);
  1059.       }
  1060.       else {
  1061.          GLchan t0[4], t1[4];  /* texels */
  1062.          const GLfloat f = FRAC(lambda[i]);
  1063.          sample_2d_nearest(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  1064.          sample_2d_nearest(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  1065.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1066.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1067.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1068.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  1069.       }
  1070.    }
  1071. }
  1072.  
  1073.  
  1074.  
  1075. /* Trilinear filtering */
  1076. static void
  1077. sample_2d_linear_mipmap_linear( GLcontext *ctx,
  1078.                                 const struct gl_texture_object *tObj,
  1079.                                 GLuint n, GLfloat texcoord[][4],
  1080.                                 const GLfloat lambda[], GLchan rgba[][4] )
  1081. {
  1082.    GLuint i;
  1083.    ASSERT(lambda != NULL);
  1084.    for (i = 0; i < n; i++) {
  1085.       GLint level;
  1086.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1087.       if (level >= tObj->_MaxLevel) {
  1088.          sample_2d_linear(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  1089.                           texcoord[i], rgba[i]);
  1090.       }
  1091.       else {
  1092.          GLchan t0[4], t1[4];  /* texels */
  1093.          const GLfloat f = FRAC(lambda[i]);
  1094.          sample_2d_linear(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  1095.          sample_2d_linear(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  1096.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1097.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1098.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1099.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  1100.       }
  1101.    }
  1102. }
  1103.  
  1104.  
  1105. static void
  1106. sample_2d_linear_mipmap_linear_repeat( GLcontext *ctx,
  1107.                                        const struct gl_texture_object *tObj,
  1108.                                        GLuint n, GLfloat texcoord[][4],
  1109.                                        const GLfloat lambda[], GLchan rgba[][4] )
  1110. {
  1111.    GLuint i;
  1112.    ASSERT(lambda != NULL);
  1113.    ASSERT(tObj->WrapS == GL_REPEAT);
  1114.    ASSERT(tObj->WrapT == GL_REPEAT);
  1115.    for (i = 0; i < n; i++) {
  1116.       GLint level;
  1117.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1118.       if (level >= tObj->_MaxLevel) {
  1119.          sample_2d_linear_repeat(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  1120.                                  texcoord[i], rgba[i]);
  1121.       }
  1122.       else {
  1123.          GLchan t0[4], t1[4];  /* texels */
  1124.          const GLfloat f = FRAC(lambda[i]);
  1125.          sample_2d_linear_repeat(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  1126.          sample_2d_linear_repeat(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  1127.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1128.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1129.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1130.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  1131.       }
  1132.    }
  1133. }
  1134.  
  1135.  
  1136. static void
  1137. sample_nearest_2d( GLcontext *ctx, GLuint texUnit,
  1138.                    const struct gl_texture_object *tObj, GLuint n,
  1139.                    GLfloat texcoords[][4],
  1140.                    const GLfloat lambda[], GLchan rgba[][4] )
  1141. {
  1142.    GLuint i;
  1143.    struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
  1144.    (void) lambda;
  1145.    for (i=0;i<n;i++) {
  1146.       sample_2d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
  1147.    }
  1148. }
  1149.  
  1150.  
  1151.  
  1152. static void
  1153. sample_linear_2d( GLcontext *ctx, GLuint texUnit,
  1154.                   const struct gl_texture_object *tObj, GLuint n,
  1155.                   GLfloat texcoords[][4],
  1156.                   const GLfloat lambda[], GLchan rgba[][4] )
  1157. {
  1158.    GLuint i;
  1159.    struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
  1160.    (void) lambda;
  1161.    for (i=0;i<n;i++) {
  1162.       sample_2d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
  1163.    }
  1164. }
  1165.  
  1166.  
  1167. /*
  1168.  * Optimized 2-D texture sampling:
  1169.  *    S and T wrap mode == GL_REPEAT
  1170.  *    GL_NEAREST min/mag filter
  1171.  *    No border, 
  1172.  *    RowStride == Width,
  1173.  *    Format = GL_RGB
  1174.  */
  1175. static void
  1176. opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
  1177.                    const struct gl_texture_object *tObj,
  1178.                    GLuint n, GLfloat texcoords[][4],
  1179.                    const GLfloat lambda[], GLchan rgba[][4] )
  1180. {
  1181.    const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
  1182.    const GLfloat width = (GLfloat) img->Width;
  1183.    const GLfloat height = (GLfloat) img->Height;
  1184.    const GLint colMask = img->Width - 1;
  1185.    const GLint rowMask = img->Height - 1;
  1186.    const GLint shift = img->WidthLog2;
  1187.    GLuint k;
  1188.    (void) lambda;
  1189.    ASSERT(tObj->WrapS==GL_REPEAT);
  1190.    ASSERT(tObj->WrapT==GL_REPEAT);
  1191.    ASSERT(img->Border==0);
  1192.    ASSERT(img->Format==GL_RGB);
  1193.  
  1194.    for (k=0; k<n; k++) {
  1195.       GLint i = IFLOOR(texcoords[k][0] * width) & colMask;
  1196.       GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;
  1197.       GLint pos = (j << shift) | i;
  1198.       GLchan *texel = ((GLchan *) img->Data) + 3*pos;
  1199.       rgba[k][RCOMP] = texel[0];
  1200.       rgba[k][GCOMP] = texel[1];
  1201.       rgba[k][BCOMP] = texel[2];
  1202.    }
  1203. }
  1204.  
  1205.  
  1206. /*
  1207.  * Optimized 2-D texture sampling:
  1208.  *    S and T wrap mode == GL_REPEAT
  1209.  *    GL_NEAREST min/mag filter
  1210.  *    No border
  1211.  *    RowStride == Width,
  1212.  *    Format = GL_RGBA
  1213.  */
  1214. static void
  1215. opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit,
  1216.                     const struct gl_texture_object *tObj,
  1217.                     GLuint n, GLfloat texcoords[][4],
  1218.                     const GLfloat lambda[], GLchan rgba[][4] )
  1219. {
  1220.    const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
  1221.    const GLfloat width = (GLfloat) img->Width;
  1222.    const GLfloat height = (GLfloat) img->Height;
  1223.    const GLint colMask = img->Width - 1;
  1224.    const GLint rowMask = img->Height - 1;
  1225.    const GLint shift = img->WidthLog2;
  1226.    GLuint i;
  1227.    (void) lambda;
  1228.    ASSERT(tObj->WrapS==GL_REPEAT);
  1229.    ASSERT(tObj->WrapT==GL_REPEAT);
  1230.    ASSERT(img->Border==0);
  1231.    ASSERT(img->Format==GL_RGBA);
  1232.  
  1233.    for (i = 0; i < n; i++) {
  1234.       const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;
  1235.       const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;
  1236.       const GLint pos = (row << shift) | col;
  1237.       const GLchan *texel = ((GLchan *) img->Data) + (pos << 2);    /* pos*4 */
  1238.       COPY_CHAN4(rgba[i], texel);
  1239.    }
  1240. }
  1241.  
  1242.  
  1243. /*
  1244.  * Given an array of texture coordinate and lambda (level of detail)
  1245.  * values, return an array of texture sample.
  1246.  */
  1247. static void
  1248. sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
  1249.                   const struct gl_texture_object *tObj,
  1250.                   GLuint n, GLfloat texcoords[][4],
  1251.                   const GLfloat lambda[], GLchan rgba[][4] )
  1252. {
  1253.    const struct gl_texture_image *tImg = tObj->Image[tObj->BaseLevel];
  1254.    GLuint minStart, minEnd;  /* texels with minification */
  1255.    GLuint magStart, magEnd;  /* texels with magnification */
  1256.  
  1257.    const GLboolean repeatNoBorder = (tObj->WrapS == GL_REPEAT)
  1258.       && (tObj->WrapT == GL_REPEAT)
  1259.       && (tImg->Border == 0 && (tImg->Width == tImg->RowStride))
  1260.       && (tImg->Format != GL_COLOR_INDEX);
  1261.  
  1262.    ASSERT(lambda != NULL);
  1263.    compute_min_mag_ranges(SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit],
  1264.                           n, lambda, &minStart, &minEnd, &magStart, &magEnd);
  1265.  
  1266.    if (minStart < minEnd) {
  1267.       /* do the minified texels */
  1268.       const GLuint m = minEnd - minStart;
  1269.       switch (tObj->MinFilter) {
  1270.       case GL_NEAREST:
  1271.          if (repeatNoBorder) {
  1272.             switch (tImg->Format) {
  1273.             case GL_RGB:
  1274.                opt_sample_rgb_2d(ctx, texUnit, tObj, m, texcoords + minStart,
  1275.                                  NULL, rgba + minStart);
  1276.                break;
  1277.             case GL_RGBA:
  1278.            opt_sample_rgba_2d(ctx, texUnit, tObj, m, texcoords + minStart,
  1279.                                   NULL, rgba + minStart);
  1280.                break;
  1281.             default:
  1282.                sample_nearest_2d(ctx, texUnit, tObj, m, texcoords + minStart,
  1283.                                  NULL, rgba + minStart );
  1284.             }
  1285.          }
  1286.          else {
  1287.             sample_nearest_2d(ctx, texUnit, tObj, m, texcoords + minStart,
  1288.                               NULL, rgba + minStart);
  1289.          }
  1290.          break;
  1291.       case GL_LINEAR:
  1292.      sample_linear_2d(ctx, texUnit, tObj, m, texcoords + minStart,
  1293.               NULL, rgba + minStart);
  1294.          break;
  1295.       case GL_NEAREST_MIPMAP_NEAREST:
  1296.          sample_2d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  1297.                                           lambda + minStart, rgba + minStart);
  1298.          break;
  1299.       case GL_LINEAR_MIPMAP_NEAREST:
  1300.          sample_2d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  1301.                                          lambda + minStart, rgba + minStart);
  1302.          break;
  1303.       case GL_NEAREST_MIPMAP_LINEAR:
  1304.          sample_2d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  1305.                                          lambda + minStart, rgba + minStart);
  1306.          break;
  1307.       case GL_LINEAR_MIPMAP_LINEAR:
  1308.          if (repeatNoBorder)
  1309.             sample_2d_linear_mipmap_linear_repeat(ctx, tObj, m,
  1310.                   texcoords + minStart, lambda + minStart, rgba + minStart);
  1311.          else
  1312.             sample_2d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  1313.                                         lambda + minStart, rgba + minStart);
  1314.          break;
  1315.       default:
  1316.          _mesa_problem(ctx, "Bad min filter in sample_2d_texture");
  1317.          return;
  1318.       }
  1319.    }
  1320.  
  1321.    if (magStart < magEnd) {
  1322.       /* do the magnified texels */
  1323.       const GLuint m = magEnd - magStart;
  1324.  
  1325.       switch (tObj->MagFilter) {
  1326.       case GL_NEAREST:
  1327.          if (repeatNoBorder) {
  1328.             switch (tImg->Format) {
  1329.             case GL_RGB:
  1330.                opt_sample_rgb_2d(ctx, texUnit, tObj, m, texcoords + magStart,
  1331.                                  NULL, rgba + magStart);
  1332.                break;
  1333.             case GL_RGBA:
  1334.            opt_sample_rgba_2d(ctx, texUnit, tObj, m, texcoords + magStart,
  1335.                                   NULL, rgba + magStart);
  1336.                break;
  1337.             default:
  1338.                sample_nearest_2d(ctx, texUnit, tObj, m, texcoords + magStart,
  1339.                                  NULL, rgba + magStart );
  1340.             }
  1341.          }
  1342.          else {
  1343.             sample_nearest_2d(ctx, texUnit, tObj, m, texcoords + magStart,
  1344.                               NULL, rgba + magStart);
  1345.          }
  1346.          break;
  1347.       case GL_LINEAR:
  1348.      sample_linear_2d(ctx, texUnit, tObj, m, texcoords + magStart,
  1349.               NULL, rgba + magStart);
  1350.          break;
  1351.       default:
  1352.          _mesa_problem(ctx, "Bad mag filter in sample_lambda_2d");
  1353.       }
  1354.    }
  1355. }
  1356.  
  1357.  
  1358.  
  1359. /**********************************************************************/
  1360. /*                    3-D Texture Sampling Functions                  */
  1361. /**********************************************************************/
  1362.  
  1363. /*
  1364.  * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
  1365.  */
  1366. static void
  1367. sample_3d_nearest(GLcontext *ctx,
  1368.                   const struct gl_texture_object *tObj,
  1369.                   const struct gl_texture_image *img,
  1370.                   const GLfloat texcoord[4],
  1371.                   GLchan rgba[4])
  1372. {
  1373.    const GLint width = img->Width2;     /* without border, power of two */
  1374.    const GLint height = img->Height2;   /* without border, power of two */
  1375.    const GLint depth = img->Depth2;     /* without border, power of two */
  1376.    GLint i, j, k;
  1377.  
  1378.    COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, texcoord[0], width,  i);
  1379.    COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, texcoord[1], height, j);
  1380.    COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapR, texcoord[2], depth,  k);
  1381.  
  1382.    if (i < 0 || i >= (GLint) img->Width ||
  1383.        j < 0 || j >= (GLint) img->Height ||
  1384.        k < 0 || k >= (GLint) img->Depth) {
  1385.       /* Need this test for GL_CLAMP_TO_BORDER_ARB mode */
  1386.       COPY_CHAN4(rgba, tObj->_BorderChan);
  1387.    }
  1388.    else {
  1389.       (*img->FetchTexel)(img, i, j, k, (GLvoid *) rgba);
  1390.       if (img->Format == GL_COLOR_INDEX) {
  1391.          palette_sample(ctx, tObj, rgba[0], rgba);
  1392.       }
  1393.    }
  1394. }
  1395.  
  1396.  
  1397.  
  1398. /*
  1399.  * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
  1400.  */
  1401. static void
  1402. sample_3d_linear(GLcontext *ctx,
  1403.                  const struct gl_texture_object *tObj,
  1404.                  const struct gl_texture_image *img,
  1405.                  const GLfloat texcoord[4],
  1406.                  GLchan rgba[4])
  1407. {
  1408.    const GLint width = img->Width2;
  1409.    const GLint height = img->Height2;
  1410.    const GLint depth = img->Depth2;
  1411.    GLint i0, j0, k0, i1, j1, k1;
  1412.    GLuint useBorderColor;
  1413.    GLfloat u, v, w;
  1414.  
  1415.    COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, texcoord[0], u, width,  i0, i1);
  1416.    COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, texcoord[1], v, height, j0, j1);
  1417.    COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapR, texcoord[2], w, depth,  k0, k1);
  1418.  
  1419.    useBorderColor = 0;
  1420.    if (img->Border) {
  1421.       i0 += img->Border;
  1422.       i1 += img->Border;
  1423.       j0 += img->Border;
  1424.       j1 += img->Border;
  1425.       k0 += img->Border;
  1426.       k1 += img->Border;
  1427.    }
  1428.    else {
  1429.       /* check if sampling texture border color */
  1430.       if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
  1431.       if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
  1432.       if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
  1433.       if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
  1434.       if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;
  1435.       if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;
  1436.    }
  1437.  
  1438.    {
  1439.       const GLfloat a = FRAC(u);
  1440.       const GLfloat b = FRAC(v);
  1441.       const GLfloat c = FRAC(w);
  1442.  
  1443. #if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
  1444.       /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
  1445.       GLfloat w000 = (1.0F-a) * (1.0F-b) * (1.0F-c);
  1446.       GLfloat w100 =       a  * (1.0F-b) * (1.0F-c);
  1447.       GLfloat w010 = (1.0F-a) *       b  * (1.0F-c);
  1448.       GLfloat w110 =       a  *       b  * (1.0F-c);
  1449.       GLfloat w001 = (1.0F-a) * (1.0F-b) *       c ;
  1450.       GLfloat w101 =       a  * (1.0F-b) *       c ;
  1451.       GLfloat w011 = (1.0F-a) *       b  *       c ;
  1452.       GLfloat w111 =       a  *       b  *       c ;
  1453. #else /* CHAN_BITS == 8 */
  1454.       /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
  1455.       GLint w000 = IROUND_POS((1.0F-a) * (1.0F-b) * (1.0F-c) * WEIGHT_SCALE);
  1456.       GLint w100 = IROUND_POS(      a  * (1.0F-b) * (1.0F-c) * WEIGHT_SCALE);
  1457.       GLint w010 = IROUND_POS((1.0F-a) *       b  * (1.0F-c) * WEIGHT_SCALE);
  1458.       GLint w110 = IROUND_POS(      a  *       b  * (1.0F-c) * WEIGHT_SCALE);
  1459.       GLint w001 = IROUND_POS((1.0F-a) * (1.0F-b) *       c  * WEIGHT_SCALE);
  1460.       GLint w101 = IROUND_POS(      a  * (1.0F-b) *       c  * WEIGHT_SCALE);
  1461.       GLint w011 = IROUND_POS((1.0F-a) *       b  *       c  * WEIGHT_SCALE);
  1462.       GLint w111 = IROUND_POS(      a  *       b  *       c  * WEIGHT_SCALE);
  1463. #endif
  1464.  
  1465.       GLchan t000[4], t010[4], t001[4], t011[4];
  1466.       GLchan t100[4], t110[4], t101[4], t111[4];
  1467.  
  1468.       if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {
  1469.          COPY_CHAN4(t000, tObj->_BorderChan);
  1470.       }
  1471.       else {
  1472.          (*img->FetchTexel)(img, i0, j0, k0, (GLvoid *) t000);
  1473.          if (img->Format == GL_COLOR_INDEX) {
  1474.             palette_sample(ctx, tObj, t000[0], t000);
  1475.          }
  1476.       }
  1477.       if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {
  1478.          COPY_CHAN4(t100, tObj->_BorderChan);
  1479.       }
  1480.       else {
  1481.          (*img->FetchTexel)(img, i1, j0, k0, (GLvoid *) t100);
  1482.          if (img->Format == GL_COLOR_INDEX) {
  1483.             palette_sample(ctx, tObj, t100[0], t100);
  1484.          }
  1485.       }
  1486.       if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {
  1487.          COPY_CHAN4(t010, tObj->_BorderChan);
  1488.       }
  1489.       else {
  1490.          (*img->FetchTexel)(img, i0, j1, k0, (GLvoid *) t010);
  1491.          if (img->Format == GL_COLOR_INDEX) {
  1492.             palette_sample(ctx, tObj, t010[0], t010);
  1493.          }
  1494.       }
  1495.       if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {
  1496.          COPY_CHAN4(t110, tObj->_BorderChan);
  1497.       }
  1498.       else {
  1499.          (*img->FetchTexel)(img, i1, j1, k0, (GLvoid *) t110);
  1500.          if (img->Format == GL_COLOR_INDEX) {
  1501.             palette_sample(ctx, tObj, t110[0], t110);
  1502.          }
  1503.       }
  1504.  
  1505.       if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {
  1506.          COPY_CHAN4(t001, tObj->_BorderChan);
  1507.       }
  1508.       else {
  1509.          (*img->FetchTexel)(img, i0, j0, k1, (GLvoid *) t001);
  1510.          if (img->Format == GL_COLOR_INDEX) {
  1511.             palette_sample(ctx, tObj, t001[0], t001);
  1512.          }
  1513.       }
  1514.       if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {
  1515.          COPY_CHAN4(t101, tObj->_BorderChan);
  1516.       }
  1517.       else {
  1518.          (*img->FetchTexel)(img, i1, j0, k1, (GLvoid *) t101);
  1519.          if (img->Format == GL_COLOR_INDEX) {
  1520.             palette_sample(ctx, tObj, t101[0], t101);
  1521.          }
  1522.       }
  1523.       if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {
  1524.          COPY_CHAN4(t011, tObj->_BorderChan);
  1525.       }
  1526.       else {
  1527.          (*img->FetchTexel)(img, i0, j1, k1, (GLvoid *) t011);
  1528.          if (img->Format == GL_COLOR_INDEX) {
  1529.             palette_sample(ctx, tObj, t011[0], t011);
  1530.          }
  1531.       }
  1532.       if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {
  1533.          COPY_CHAN4(t111, tObj->_BorderChan);
  1534.       }
  1535.       else {
  1536.          (*img->FetchTexel)(img, i1, j1, k1, (GLvoid *) t111);
  1537.          if (img->Format == GL_COLOR_INDEX) {
  1538.             palette_sample(ctx, tObj, t111[0], t111);
  1539.          }
  1540.       }
  1541.  
  1542. #if CHAN_TYPE == GL_FLOAT
  1543.       rgba[0] = w000*t000[0] + w010*t010[0] + w001*t001[0] + w011*t011[0] +
  1544.                 w100*t100[0] + w110*t110[0] + w101*t101[0] + w111*t111[0];
  1545.       rgba[1] = w000*t000[1] + w010*t010[1] + w001*t001[1] + w011*t011[1] +
  1546.                 w100*t100[1] + w110*t110[1] + w101*t101[1] + w111*t111[1];
  1547.       rgba[2] = w000*t000[2] + w010*t010[2] + w001*t001[2] + w011*t011[2] +
  1548.                 w100*t100[2] + w110*t110[2] + w101*t101[2] + w111*t111[2];
  1549.       rgba[3] = w000*t000[3] + w010*t010[3] + w001*t001[3] + w011*t011[3] +
  1550.                 w100*t100[3] + w110*t110[3] + w101*t101[3] + w111*t111[3];
  1551. #elif CHAN_TYPE == GL_UNSIGNED_SHORT
  1552.       rgba[0] = (GLchan) (w000*t000[0] + w010*t010[0] +
  1553.                           w001*t001[0] + w011*t011[0] +
  1554.                           w100*t100[0] + w110*t110[0] +
  1555.                           w101*t101[0] + w111*t111[0] + 0.5);
  1556.       rgba[1] = (GLchan) (w000*t000[1] + w010*t010[1] +
  1557.                           w001*t001[1] + w011*t011[1] +
  1558.                           w100*t100[1] + w110*t110[1] +
  1559.                           w101*t101[1] + w111*t111[1] + 0.5);
  1560.       rgba[2] = (GLchan) (w000*t000[2] + w010*t010[2] +
  1561.                           w001*t001[2] + w011*t011[2] +
  1562.                           w100*t100[2] + w110*t110[2] +
  1563.                           w101*t101[2] + w111*t111[2] + 0.5);
  1564.       rgba[3] = (GLchan) (w000*t000[3] + w010*t010[3] +
  1565.                           w001*t001[3] + w011*t011[3] +
  1566.                           w100*t100[3] + w110*t110[3] +
  1567.                           w101*t101[3] + w111*t111[3] + 0.5);
  1568. #else /* CHAN_BITS == 8 */
  1569.       rgba[0] = (GLchan) (
  1570.                  (w000*t000[0] + w010*t010[0] + w001*t001[0] + w011*t011[0] +
  1571.                   w100*t100[0] + w110*t110[0] + w101*t101[0] + w111*t111[0] )
  1572.                  >> WEIGHT_SHIFT);
  1573.       rgba[1] = (GLchan) (
  1574.                  (w000*t000[1] + w010*t010[1] + w001*t001[1] + w011*t011[1] +
  1575.                   w100*t100[1] + w110*t110[1] + w101*t101[1] + w111*t111[1] )
  1576.                  >> WEIGHT_SHIFT);
  1577.       rgba[2] = (GLchan) (
  1578.                  (w000*t000[2] + w010*t010[2] + w001*t001[2] + w011*t011[2] +
  1579.                   w100*t100[2] + w110*t110[2] + w101*t101[2] + w111*t111[2] )
  1580.                  >> WEIGHT_SHIFT);
  1581.       rgba[3] = (GLchan) (
  1582.                  (w000*t000[3] + w010*t010[3] + w001*t001[3] + w011*t011[3] +
  1583.                   w100*t100[3] + w110*t110[3] + w101*t101[3] + w111*t111[3] )
  1584.                  >> WEIGHT_SHIFT);
  1585. #endif
  1586.  
  1587.    }
  1588. }
  1589.  
  1590.  
  1591.  
  1592. static void
  1593. sample_3d_nearest_mipmap_nearest(GLcontext *ctx,
  1594.                                  const struct gl_texture_object *tObj,
  1595.                                  GLuint n, GLfloat texcoord[][4],
  1596.                                  const GLfloat lambda[], GLchan rgba[][4] )
  1597. {
  1598.    GLuint i;
  1599.    for (i = 0; i < n; i++) {
  1600.       GLint level;
  1601.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  1602.       sample_3d_nearest(ctx, tObj, tObj->Image[level], texcoord[i], rgba[i]);
  1603.    }
  1604. }
  1605.  
  1606.  
  1607. static void
  1608. sample_3d_linear_mipmap_nearest(GLcontext *ctx,
  1609.                                 const struct gl_texture_object *tObj,
  1610.                                 GLuint n, GLfloat texcoord[][4],
  1611.                                 const GLfloat lambda[], GLchan rgba[][4])
  1612. {
  1613.    GLuint i;
  1614.    ASSERT(lambda != NULL);
  1615.    for (i = 0; i < n; i++) {
  1616.       GLint level;
  1617.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  1618.       sample_3d_linear(ctx, tObj, tObj->Image[level], texcoord[i], rgba[i]);
  1619.    }
  1620. }
  1621.  
  1622.  
  1623. static void
  1624. sample_3d_nearest_mipmap_linear(GLcontext *ctx,
  1625.                                 const struct gl_texture_object *tObj,
  1626.                                 GLuint n, GLfloat texcoord[][4],
  1627.                                 const GLfloat lambda[], GLchan rgba[][4])
  1628. {
  1629.    GLuint i;
  1630.    ASSERT(lambda != NULL);
  1631.    for (i = 0; i < n; i++) {
  1632.       GLint level;
  1633.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1634.       if (level >= tObj->_MaxLevel) {
  1635.          sample_3d_nearest(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  1636.                            texcoord[i], rgba[i]);
  1637.       }
  1638.       else {
  1639.          GLchan t0[4], t1[4];  /* texels */
  1640.          const GLfloat f = FRAC(lambda[i]);
  1641.          sample_3d_nearest(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  1642.          sample_3d_nearest(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  1643.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1644.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1645.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1646.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  1647.       }
  1648.    }
  1649. }
  1650.  
  1651.  
  1652. static void
  1653. sample_3d_linear_mipmap_linear(GLcontext *ctx,
  1654.                                const struct gl_texture_object *tObj,
  1655.                                GLuint n, GLfloat texcoord[][4],
  1656.                                const GLfloat lambda[], GLchan rgba[][4])
  1657. {
  1658.    GLuint i;
  1659.    ASSERT(lambda != NULL);
  1660.    for (i = 0; i < n; i++) {
  1661.       GLint level;
  1662.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1663.       if (level >= tObj->_MaxLevel) {
  1664.          sample_3d_linear(ctx, tObj, tObj->Image[tObj->_MaxLevel],
  1665.                           texcoord[i], rgba[i]);
  1666.       }
  1667.       else {
  1668.          GLchan t0[4], t1[4];  /* texels */
  1669.          const GLfloat f = FRAC(lambda[i]);
  1670.          sample_3d_linear(ctx, tObj, tObj->Image[level  ], texcoord[i], t0);
  1671.          sample_3d_linear(ctx, tObj, tObj->Image[level+1], texcoord[i], t1);
  1672.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1673.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1674.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1675.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  1676.       }
  1677.    }
  1678. }
  1679.  
  1680.  
  1681. static void
  1682. sample_nearest_3d(GLcontext *ctx, GLuint texUnit,
  1683.                   const struct gl_texture_object *tObj, GLuint n,
  1684.                   GLfloat texcoords[][4], const GLfloat lambda[],
  1685.                   GLchan rgba[][4])
  1686. {
  1687.    GLuint i;
  1688.    struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
  1689.    (void) lambda;
  1690.    for (i=0;i<n;i++) {
  1691.       sample_3d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
  1692.    }
  1693. }
  1694.  
  1695.  
  1696.  
  1697. static void
  1698. sample_linear_3d( GLcontext *ctx, GLuint texUnit,
  1699.                   const struct gl_texture_object *tObj, GLuint n,
  1700.                   GLfloat texcoords[][4],
  1701.           const GLfloat lambda[], GLchan rgba[][4] )
  1702. {
  1703.    GLuint i;
  1704.    struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
  1705.    (void) lambda;
  1706.    for (i=0;i<n;i++) {
  1707.       sample_3d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
  1708.    }
  1709. }
  1710.  
  1711.  
  1712. /*
  1713.  * Given an (s,t,r) texture coordinate and lambda (level of detail) value,
  1714.  * return a texture sample.
  1715.  */
  1716. static void
  1717. sample_lambda_3d( GLcontext *ctx, GLuint texUnit,
  1718.                   const struct gl_texture_object *tObj, GLuint n,
  1719.                   GLfloat texcoords[][4], const GLfloat lambda[],
  1720.                   GLchan rgba[][4] )
  1721. {
  1722.    GLuint minStart, minEnd;  /* texels with minification */
  1723.    GLuint magStart, magEnd;  /* texels with magnification */
  1724.    GLuint i;
  1725.  
  1726.    ASSERT(lambda != NULL);
  1727.    compute_min_mag_ranges(SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit],
  1728.                           n, lambda, &minStart, &minEnd, &magStart, &magEnd);
  1729.  
  1730.    if (minStart < minEnd) {
  1731.       /* do the minified texels */
  1732.       GLuint m = minEnd - minStart;
  1733.       switch (tObj->MinFilter) {
  1734.       case GL_NEAREST:
  1735.          for (i = minStart; i < minEnd; i++)
  1736.             sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
  1737.                               texcoords[i], rgba[i]);
  1738.          break;
  1739.       case GL_LINEAR:
  1740.          for (i = minStart; i < minEnd; i++)
  1741.             sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
  1742.                              texcoords[i], rgba[i]);
  1743.          break;
  1744.       case GL_NEAREST_MIPMAP_NEAREST:
  1745.          sample_3d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  1746.                                           lambda + minStart, rgba + minStart);
  1747.          break;
  1748.       case GL_LINEAR_MIPMAP_NEAREST:
  1749.          sample_3d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  1750.                                          lambda + minStart, rgba + minStart);
  1751.          break;
  1752.       case GL_NEAREST_MIPMAP_LINEAR:
  1753.          sample_3d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  1754.                                          lambda + minStart, rgba + minStart);
  1755.          break;
  1756.       case GL_LINEAR_MIPMAP_LINEAR:
  1757.          sample_3d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  1758.                                         lambda + minStart, rgba + minStart);
  1759.          break;
  1760.       default:
  1761.          _mesa_problem(ctx, "Bad min filter in sample_3d_texture");
  1762.          return;
  1763.       }
  1764.    }
  1765.  
  1766.    if (magStart < magEnd) {
  1767.       /* do the magnified texels */
  1768.       switch (tObj->MagFilter) {
  1769.       case GL_NEAREST:
  1770.          for (i = magStart; i < magEnd; i++)
  1771.             sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
  1772.                               texcoords[i], rgba[i]);
  1773.          break;
  1774.       case GL_LINEAR:
  1775.          for (i = magStart; i < magEnd; i++)
  1776.             sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
  1777.                              texcoords[i], rgba[i]);
  1778.          break;
  1779.       default:
  1780.          _mesa_problem(ctx, "Bad mag filter in sample_3d_texture");
  1781.          return;
  1782.       }
  1783.    }
  1784. }
  1785.  
  1786.  
  1787. /**********************************************************************/
  1788. /*                Texture Cube Map Sampling Functions                 */
  1789. /**********************************************************************/
  1790.  
  1791. /*
  1792.  * Choose one of six sides of a texture cube map given the texture
  1793.  * coord (rx,ry,rz).  Return pointer to corresponding array of texture
  1794.  * images.
  1795.  */
  1796. static const struct gl_texture_image **
  1797. choose_cube_face(const struct gl_texture_object *texObj,
  1798.                  const GLfloat texcoord[4], GLfloat newCoord[4])
  1799. {
  1800. /*
  1801.       major axis
  1802.       direction     target                             sc     tc    ma
  1803.       ----------    -------------------------------    ---    ---   ---
  1804.        +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx
  1805.        -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx
  1806.        +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry
  1807.        -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry
  1808.        +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz
  1809.        -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz
  1810. */
  1811.    const GLfloat rx = texcoord[0];
  1812.    const GLfloat ry = texcoord[1];
  1813.    const GLfloat rz = texcoord[2];
  1814.    const struct gl_texture_image **imgArray;
  1815.    const GLfloat arx = ABSF(rx),   ary = ABSF(ry),   arz = ABSF(rz);
  1816.    GLfloat sc, tc, ma;
  1817.  
  1818.    if (arx > ary && arx > arz) {
  1819.       if (rx >= 0.0F) {
  1820.          imgArray = (const struct gl_texture_image **) texObj->Image;
  1821.          sc = -rz;
  1822.          tc = -ry;
  1823.          ma = arx;
  1824.       }
  1825.       else {
  1826.          imgArray = (const struct gl_texture_image **) texObj->NegX;
  1827.          sc = rz;
  1828.          tc = -ry;
  1829.          ma = arx;
  1830.       }
  1831.    }
  1832.    else if (ary > arx && ary > arz) {
  1833.       if (ry >= 0.0F) {
  1834.          imgArray = (const struct gl_texture_image **) texObj->PosY;
  1835.          sc = rx;
  1836.          tc = rz;
  1837.          ma = ary;
  1838.       }
  1839.       else {
  1840.          imgArray = (const struct gl_texture_image **) texObj->NegY;
  1841.          sc = rx;
  1842.          tc = -rz;
  1843.          ma = ary;
  1844.       }
  1845.    }
  1846.    else {
  1847.       if (rz > 0.0F) {
  1848.          imgArray = (const struct gl_texture_image **) texObj->PosZ;
  1849.          sc = rx;
  1850.          tc = -ry;
  1851.          ma = arz;
  1852.       }
  1853.       else {
  1854.          imgArray = (const struct gl_texture_image **) texObj->NegZ;
  1855.          sc = -rx;
  1856.          tc = -ry;
  1857.          ma = arz;
  1858.       }
  1859.    }
  1860.  
  1861.    newCoord[0] = ( sc / ma + 1.0F ) * 0.5F;
  1862.    newCoord[1] = ( tc / ma + 1.0F ) * 0.5F;
  1863.    return imgArray;
  1864. }
  1865.  
  1866.  
  1867. static void
  1868. sample_nearest_cube(GLcontext *ctx, GLuint texUnit,
  1869.             const struct gl_texture_object *tObj, GLuint n,
  1870.                     GLfloat texcoords[][4], const GLfloat lambda[],
  1871.                     GLchan rgba[][4])
  1872. {
  1873.    GLuint i;
  1874.    (void) lambda;
  1875.    for (i = 0; i < n; i++) {
  1876.       const struct gl_texture_image **images;
  1877.       GLfloat newCoord[4];
  1878.       images = choose_cube_face(tObj, texcoords[i], newCoord);
  1879.       sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
  1880.                         newCoord, rgba[i]);
  1881.    }
  1882. }
  1883.  
  1884.  
  1885. static void
  1886. sample_linear_cube(GLcontext *ctx, GLuint texUnit,
  1887.            const struct gl_texture_object *tObj, GLuint n,
  1888.                    GLfloat texcoords[][4],
  1889.            const GLfloat lambda[], GLchan rgba[][4])
  1890. {
  1891.    GLuint i;
  1892.    (void) lambda;
  1893.    for (i = 0; i < n; i++) {
  1894.       const struct gl_texture_image **images;
  1895.       GLfloat newCoord[4];
  1896.       images = choose_cube_face(tObj, texcoords[i], newCoord);
  1897.       sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
  1898.                        newCoord, rgba[i]);
  1899.    }
  1900. }
  1901.  
  1902.  
  1903. static void
  1904. sample_cube_nearest_mipmap_nearest(GLcontext *ctx,
  1905.                                    const struct gl_texture_object *tObj,
  1906.                                    GLuint n, GLfloat texcoord[][4],
  1907.                                    const GLfloat lambda[], GLchan rgba[][4])
  1908. {
  1909.    GLuint i;
  1910.    ASSERT(lambda != NULL);
  1911.    for (i = 0; i < n; i++) {
  1912.       const struct gl_texture_image **images;
  1913.       GLfloat newCoord[4];
  1914.       GLint level;
  1915.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  1916.       images = choose_cube_face(tObj, texcoord[i], newCoord);
  1917.       sample_2d_nearest(ctx, tObj, images[level], newCoord, rgba[i]);
  1918.    }
  1919. }
  1920.  
  1921.  
  1922. static void
  1923. sample_cube_linear_mipmap_nearest(GLcontext *ctx,
  1924.                                   const struct gl_texture_object *tObj,
  1925.                                   GLuint n, GLfloat texcoord[][4],
  1926.                                   const GLfloat lambda[], GLchan rgba[][4])
  1927. {
  1928.    GLuint i;
  1929.    ASSERT(lambda != NULL);
  1930.    for (i = 0; i < n; i++) {
  1931.       const struct gl_texture_image **images;
  1932.       GLfloat newCoord[4];
  1933.       GLint level;
  1934.       COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda[i], level);
  1935.       images = choose_cube_face(tObj, texcoord[i], newCoord);
  1936.       sample_2d_linear(ctx, tObj, images[level], newCoord, rgba[i]);
  1937.    }
  1938. }
  1939.  
  1940.  
  1941. static void
  1942. sample_cube_nearest_mipmap_linear(GLcontext *ctx,
  1943.                                   const struct gl_texture_object *tObj,
  1944.                                   GLuint n, GLfloat texcoord[][4],
  1945.                                   const GLfloat lambda[], GLchan rgba[][4])
  1946. {
  1947.    GLuint i;
  1948.    ASSERT(lambda != NULL);
  1949.    for (i = 0; i < n; i++) {
  1950.       const struct gl_texture_image **images;
  1951.       GLfloat newCoord[4];
  1952.       GLint level;
  1953.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1954.       images = choose_cube_face(tObj, texcoord[i], newCoord);
  1955.       if (level >= tObj->_MaxLevel) {
  1956.          sample_2d_nearest(ctx, tObj, images[tObj->_MaxLevel],
  1957.                            newCoord, rgba[i]);
  1958.       }
  1959.       else {
  1960.          GLchan t0[4], t1[4];  /* texels */
  1961.          const GLfloat f = FRAC(lambda[i]);
  1962.          sample_2d_nearest(ctx, tObj, images[level  ], newCoord, t0);
  1963.          sample_2d_nearest(ctx, tObj, images[level+1], newCoord, t1);
  1964.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1965.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1966.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1967.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  1968.       }
  1969.    }
  1970. }
  1971.  
  1972.  
  1973. static void
  1974. sample_cube_linear_mipmap_linear(GLcontext *ctx,
  1975.                                  const struct gl_texture_object *tObj,
  1976.                                  GLuint n, GLfloat texcoord[][4],
  1977.                                  const GLfloat lambda[], GLchan rgba[][4])
  1978. {
  1979.    GLuint i;
  1980.    ASSERT(lambda != NULL);
  1981.    for (i = 0; i < n; i++) {
  1982.       const struct gl_texture_image **images;
  1983.       GLfloat newCoord[4];
  1984.       GLint level;
  1985.       COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda[i], level);
  1986.       images = choose_cube_face(tObj, texcoord[i], newCoord);
  1987.       if (level >= tObj->_MaxLevel) {
  1988.          sample_2d_linear(ctx, tObj, images[tObj->_MaxLevel],
  1989.                           newCoord, rgba[i]);
  1990.       }
  1991.       else {
  1992.          GLchan t0[4], t1[4];
  1993.          const GLfloat f = FRAC(lambda[i]);
  1994.          sample_2d_linear(ctx, tObj, images[level  ], newCoord, t0);
  1995.          sample_2d_linear(ctx, tObj, images[level+1], newCoord, t1);
  1996.          rgba[i][RCOMP] = CHAN_CAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
  1997.          rgba[i][GCOMP] = CHAN_CAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
  1998.          rgba[i][BCOMP] = CHAN_CAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
  1999.          rgba[i][ACOMP] = CHAN_CAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
  2000.       }
  2001.    }
  2002. }
  2003.  
  2004.  
  2005. static void
  2006. sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
  2007.             const struct gl_texture_object *tObj, GLuint n,
  2008.             GLfloat texcoords[][4], const GLfloat lambda[],
  2009.             GLchan rgba[][4])
  2010. {
  2011.    GLuint minStart, minEnd;  /* texels with minification */
  2012.    GLuint magStart, magEnd;  /* texels with magnification */
  2013.  
  2014.    ASSERT(lambda != NULL);
  2015.    compute_min_mag_ranges(SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit],
  2016.                           n, lambda, &minStart, &minEnd, &magStart, &magEnd);
  2017.  
  2018.    if (minStart < minEnd) {
  2019.       /* do the minified texels */
  2020.       const GLuint m = minEnd - minStart;
  2021.       switch (tObj->MinFilter) {
  2022.       case GL_NEAREST:
  2023.          sample_nearest_cube(ctx, texUnit, tObj, m, texcoords + minStart,
  2024.                              lambda + minStart, rgba + minStart);
  2025.          break;
  2026.       case GL_LINEAR:
  2027.          sample_linear_cube(ctx, texUnit, tObj, m, texcoords + minStart,
  2028.                             lambda + minStart, rgba + minStart);
  2029.          break;
  2030.       case GL_NEAREST_MIPMAP_NEAREST:
  2031.          sample_cube_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  2032.                                            lambda + minStart, rgba + minStart);
  2033.          break;
  2034.       case GL_LINEAR_MIPMAP_NEAREST:
  2035.          sample_cube_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
  2036.                                            lambda + minStart, rgba + minStart);
  2037.          break;
  2038.       case GL_NEAREST_MIPMAP_LINEAR:
  2039.          sample_cube_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  2040.                                            lambda + minStart, rgba + minStart);
  2041.          break;
  2042.       case GL_LINEAR_MIPMAP_LINEAR:
  2043.          sample_cube_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
  2044.                                           lambda + minStart, rgba + minStart);
  2045.          break;
  2046.       default:
  2047.          _mesa_problem(ctx, "Bad min filter in sample_lambda_cube");
  2048.       }
  2049.    }
  2050.  
  2051.    if (magStart < magEnd) {
  2052.       /* do the magnified texels */
  2053.       const GLuint m = magEnd - magStart;
  2054.       switch (tObj->MagFilter) {
  2055.       case GL_NEAREST:
  2056.          sample_nearest_cube(ctx, texUnit, tObj, m, texcoords + magStart,
  2057.                              lambda + magStart, rgba + magStart);
  2058.          break;
  2059.       case GL_LINEAR:
  2060.          sample_linear_cube(ctx, texUnit, tObj, m, texcoords + magStart,
  2061.                             lambda + magStart, rgba + magStart);
  2062.          break;
  2063.       default:
  2064.          _mesa_problem(ctx, "Bad mag filter in sample_lambda_cube");
  2065.       }
  2066.    }
  2067. }
  2068.  
  2069.  
  2070. /**********************************************************************/
  2071. /*               Texture Rectangle Sampling Functions                 */
  2072. /**********************************************************************/
  2073.  
  2074. static void
  2075. sample_nearest_rect(GLcontext *ctx, GLuint texUnit,
  2076.             const struct gl_texture_object *tObj, GLuint n,
  2077.                     GLfloat texcoords[][4], const GLfloat lambda[],
  2078.                     GLchan rgba[][4])
  2079. {
  2080.    const struct gl_texture_image *img = tObj->Image[0];
  2081.    const GLfloat width = (GLfloat) img->Width;
  2082.    const GLfloat height = (GLfloat) img->Height;
  2083.    const GLint width_minus_1 = img->Width - 1;
  2084.    const GLint height_minus_1 = img->Height - 1;
  2085.    GLuint i;
  2086.  
  2087.    (void) texUnit;
  2088.    (void) lambda;
  2089.  
  2090.    ASSERT(tObj->WrapS == GL_CLAMP ||
  2091.           tObj->WrapS == GL_CLAMP_TO_EDGE ||
  2092.           tObj->WrapS == GL_CLAMP_TO_BORDER_ARB);
  2093.    ASSERT(tObj->WrapT == GL_CLAMP ||
  2094.           tObj->WrapT == GL_CLAMP_TO_EDGE ||
  2095.           tObj->WrapT == GL_CLAMP_TO_BORDER_ARB);
  2096.    ASSERT(img->Format != GL_COLOR_INDEX);
  2097.  
  2098.    /* XXX move Wrap mode tests outside of loops for common cases */
  2099.    for (i = 0; i < n; i++) {
  2100.       GLint row, col;
  2101.       /* NOTE: we DO NOT use [0, 1] texture coordinates! */
  2102.       if (tObj->WrapS == GL_CLAMP) {
  2103.          col = IFLOOR( CLAMP(texcoords[i][0], 0.0F, width) );
  2104.       }
  2105.       else if (tObj->WrapS == GL_CLAMP_TO_EDGE) {
  2106.          col = IFLOOR( CLAMP(texcoords[i][0], 0.5F, width - 0.5F) );
  2107.       }
  2108.       else {
  2109.          col = IFLOOR( CLAMP(texcoords[i][0], -0.5F, width + 0.5F) );
  2110.       }
  2111.       if (tObj->WrapT == GL_CLAMP) {
  2112.          row = IFLOOR( CLAMP(texcoords[i][1], 0.0F, height) );
  2113.       }
  2114.       else if (tObj->WrapT == GL_CLAMP_TO_EDGE) {
  2115.          row = IFLOOR( CLAMP(texcoords[i][1], 0.5F, height - 0.5F) );
  2116.       }
  2117.       else {
  2118.          row = IFLOOR( CLAMP(texcoords[i][1], -0.5F, height + 0.5F) );
  2119.       }
  2120.  
  2121.       col = CLAMP(col, 0, width_minus_1);
  2122.       row = CLAMP(row, 0, height_minus_1);
  2123.  
  2124.       (*img->FetchTexel)(img, col, row, 0, (GLvoid *) rgba[i]);
  2125.    }
  2126. }
  2127.  
  2128.  
  2129. static void
  2130. sample_linear_rect(GLcontext *ctx, GLuint texUnit,
  2131.            const struct gl_texture_object *tObj, GLuint n,
  2132.                    GLfloat texcoords[][4],
  2133.            const GLfloat lambda[], GLchan rgba[][4])
  2134. {
  2135.    const struct gl_texture_image *img = tObj->Image[0];
  2136.    const GLfloat width = (GLfloat) img->Width;
  2137.    const GLfloat height = (GLfloat) img->Height;
  2138.    const GLint width_minus_1 = img->Width - 1;
  2139.    const GLint height_minus_1 = img->Height - 1;
  2140.    GLuint i;
  2141.  
  2142.    (void) texUnit;
  2143.    (void) lambda;
  2144.  
  2145.    ASSERT(tObj->WrapS == GL_CLAMP ||
  2146.           tObj->WrapS == GL_CLAMP_TO_EDGE ||
  2147.           tObj->WrapS == GL_CLAMP_TO_BORDER_ARB);
  2148.    ASSERT(tObj->WrapT == GL_CLAMP ||
  2149.           tObj->WrapT == GL_CLAMP_TO_EDGE ||
  2150.           tObj->WrapT == GL_CLAMP_TO_BORDER_ARB);
  2151.    ASSERT(img->Format != GL_COLOR_INDEX);
  2152.  
  2153.    /* XXX lots of opportunity for optimization in this loop */
  2154.    for (i = 0; i < n; i++) {
  2155.       GLfloat frow, fcol;
  2156.       GLint row0, col0, row1, col1;
  2157.       GLchan t00[4], t01[4], t10[4], t11[4];
  2158.       GLfloat a, b, w00, w01, w10, w11;
  2159.  
  2160.       /* NOTE: we DO NOT use [0, 1] texture coordinates! */
  2161.       if (tObj->WrapS == GL_CLAMP) {
  2162.          fcol = CLAMP(texcoords[i][0], 0.0F, width);
  2163.       }
  2164.       else if (tObj->WrapS == GL_CLAMP_TO_EDGE) {
  2165.          fcol = CLAMP(texcoords[i][0], 0.5F, width - 0.5F);
  2166.       }
  2167.       else {
  2168.          fcol = CLAMP(texcoords[i][0], -0.5F, width + 0.5F);
  2169.       }
  2170.       if (tObj->WrapT == GL_CLAMP) {
  2171.          frow = CLAMP(texcoords[i][1], 0.0F, height);
  2172.       }
  2173.       else if (tObj->WrapT == GL_CLAMP_TO_EDGE) {
  2174.          frow = CLAMP(texcoords[i][1], 0.5F, height - 0.5F);
  2175.       }
  2176.       else {
  2177.          frow = CLAMP(texcoords[i][1], -0.5F, height + 0.5F);
  2178.       }
  2179.  
  2180.       /* compute integer rows/columns */
  2181.       col0 = IFLOOR(fcol);
  2182.       col1 = col0 + 1;
  2183.       col0 = CLAMP(col0, 0, width_minus_1);
  2184.       col1 = CLAMP(col1, 0, width_minus_1);
  2185.       row0 = IFLOOR(frow);
  2186.       row1 = row0 + 1;
  2187.       row0 = CLAMP(row0, 0, height_minus_1);
  2188.       row1 = CLAMP(row1, 0, height_minus_1);
  2189.  
  2190.       /* get four texel samples */
  2191.       (*img->FetchTexel)(img, col0, row0, 0, (GLvoid *) t00);
  2192.       (*img->FetchTexel)(img, col1, row0, 0, (GLvoid *) t10);
  2193.       (*img->FetchTexel)(img, col0, row1, 0, (GLvoid *) t01);
  2194.       (*img->FetchTexel)(img, col1, row1, 0, (GLvoid *) t11);
  2195.  
  2196.       /* compute sample weights */
  2197.       a = FRAC(fcol);
  2198.       b = FRAC(frow);
  2199.       w00 = (1.0F-a) * (1.0F-b);
  2200.       w10 =       a  * (1.0F-b);
  2201.       w01 = (1.0F-a) *       b ;
  2202.       w11 =       a  *       b ;
  2203.  
  2204.       /* compute weighted average of samples */
  2205.       rgba[i][0] = 
  2206.       (GLchan) (w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0]);
  2207.       rgba[i][1] = 
  2208.       (GLchan) (w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1]);
  2209.       rgba[i][2] = 
  2210.       (GLchan) (w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2]);
  2211.       rgba[i][3] = 
  2212.       (GLchan) (w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3]);
  2213.    }
  2214. }
  2215.  
  2216.  
  2217. static void
  2218. sample_lambda_rect( GLcontext *ctx, GLuint texUnit,
  2219.             const struct gl_texture_object *tObj, GLuint n,
  2220.             GLfloat texcoords[][4], const GLfloat lambda[],
  2221.             GLchan rgba[][4])
  2222. {
  2223.    GLuint minStart, minEnd, magStart, magEnd;
  2224.  
  2225.    /* We only need lambda to decide between minification and magnification.
  2226.     * There is no mipmapping with rectangular textures.
  2227.     */
  2228.    compute_min_mag_ranges(SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit],
  2229.                           n, lambda, &minStart, &minEnd, &magStart, &magEnd);
  2230.  
  2231.    if (minStart < minEnd) {
  2232.       if (tObj->MinFilter == GL_NEAREST) {
  2233.          sample_nearest_rect( ctx, texUnit, tObj, minEnd - minStart,
  2234.                               texcoords + minStart, NULL, rgba + minStart);
  2235.       }
  2236.       else {
  2237.          sample_linear_rect( ctx, texUnit, tObj, minEnd - minStart,
  2238.                              texcoords + minStart, NULL, rgba + minStart);
  2239.       }
  2240.    }
  2241.    if (magStart < magEnd) {
  2242.       if (tObj->MagFilter == GL_NEAREST) {
  2243.          sample_nearest_rect( ctx, texUnit, tObj, magEnd - magStart,
  2244.                               texcoords + magStart, NULL, rgba + magStart);
  2245.       }
  2246.       else {
  2247.          sample_linear_rect( ctx, texUnit, tObj, magEnd - magStart,
  2248.                              texcoords + magStart, NULL, rgba + magStart);
  2249.       }
  2250.    }
  2251. }
  2252.  
  2253.  
  2254.  
  2255. /*
  2256.  * Sample a shadow/depth texture.
  2257.  */
  2258. static void
  2259. sample_depth_texture( GLcontext *ctx, GLuint unit,
  2260.                       const struct gl_texture_object *tObj, GLuint n,
  2261.                       GLfloat texcoords[][4], const GLfloat lambda[],
  2262.                       GLchan texel[][4] )
  2263. {
  2264.    const GLint baseLevel = tObj->BaseLevel;
  2265.    const struct gl_texture_image *texImage = tObj->Image[baseLevel];
  2266.    const GLuint width = texImage->Width;
  2267.    const GLuint height = texImage->Height;
  2268.    GLchan ambient;
  2269.    GLenum function;
  2270.    GLchan result;
  2271.  
  2272.    (void) unit;
  2273.  
  2274.    ASSERT(tObj->Image[tObj->BaseLevel]->Format == GL_DEPTH_COMPONENT);
  2275.    ASSERT(tObj->Target == GL_TEXTURE_1D ||
  2276.           tObj->Target == GL_TEXTURE_2D ||
  2277.           tObj->Target == GL_TEXTURE_RECTANGLE_NV);
  2278.  
  2279.    UNCLAMPED_FLOAT_TO_CHAN(ambient, tObj->ShadowAmbient);
  2280.  
  2281.    /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */
  2282.  
  2283.    /* XXX this could be precomputed and saved in the texture object */
  2284.    if (tObj->CompareFlag) {
  2285.       /* GL_SGIX_shadow */
  2286.       if (tObj->CompareOperator == GL_TEXTURE_LEQUAL_R_SGIX) {
  2287.          function = GL_LEQUAL;
  2288.       }
  2289.       else {
  2290.          ASSERT(tObj->CompareOperator == GL_TEXTURE_GEQUAL_R_SGIX);
  2291.          function = GL_GEQUAL;
  2292.       }
  2293.    }
  2294.    else if (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) {
  2295.       /* GL_ARB_shadow */
  2296.       function = tObj->CompareFunc;
  2297.    }
  2298.    else {
  2299.       function = GL_NONE;  /* pass depth through as grayscale */
  2300.    }
  2301.  
  2302.    if (tObj->MagFilter == GL_NEAREST) {
  2303.       GLuint i;
  2304.       for (i = 0; i < n; i++) {
  2305.          GLfloat depthSample;
  2306.          GLint col, row;
  2307.          /* XXX fix for texture rectangle! */
  2308.          COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, texcoords[i][0], width, col);
  2309.          COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, texcoords[i][1], height, row);
  2310.          depthSample = *((const GLfloat *) texImage->Data + row * width + col);
  2311.  
  2312.          switch (function) {
  2313.          case GL_LEQUAL:
  2314.             result = (texcoords[i][2] <= depthSample) ? CHAN_MAX : ambient;
  2315.             break;
  2316.          case GL_GEQUAL:
  2317.             result = (texcoords[i][2] >= depthSample) ? CHAN_MAX : ambient;
  2318.             break;
  2319.          case GL_LESS:
  2320.             result = (texcoords[i][2] < depthSample) ? CHAN_MAX : ambient;
  2321.             break;
  2322.          case GL_GREATER:
  2323.             result = (texcoords[i][2] > depthSample) ? CHAN_MAX : ambient;
  2324.             break;
  2325.          case GL_EQUAL:
  2326.             result = (texcoords[i][2] == depthSample) ? CHAN_MAX : ambient;
  2327.             break;
  2328.          case GL_NOTEQUAL:
  2329.             result = (texcoords[i][2] != depthSample) ? CHAN_MAX : ambient;
  2330.             break;
  2331.          case GL_ALWAYS:
  2332.             result = CHAN_MAX;
  2333.             break;
  2334.          case GL_NEVER:
  2335.             result = ambient;
  2336.             break;
  2337.          case GL_NONE:
  2338.             CLAMPED_FLOAT_TO_CHAN(result, depthSample);
  2339.             break;
  2340.          default:
  2341.             _mesa_problem(ctx, "Bad compare func in sample_depth_texture");
  2342.             return;
  2343.          }
  2344.  
  2345.          switch (tObj->DepthMode) {
  2346.          case GL_LUMINANCE:
  2347.             texel[i][RCOMP] = result;
  2348.             texel[i][GCOMP] = result;
  2349.             texel[i][BCOMP] = result;
  2350.             texel[i][ACOMP] = CHAN_MAX;
  2351.             break;
  2352.          case GL_INTENSITY:
  2353.             texel[i][RCOMP] = result;
  2354.             texel[i][GCOMP] = result;
  2355.             texel[i][BCOMP] = result;
  2356.             texel[i][ACOMP] = result;
  2357.             break;
  2358.          case GL_ALPHA:
  2359.             texel[i][RCOMP] = 0;
  2360.             texel[i][GCOMP] = 0;
  2361.             texel[i][BCOMP] = 0;
  2362.             texel[i][ACOMP] = result;
  2363.             break;
  2364.          default:
  2365.             _mesa_problem(ctx, "Bad depth texture mode");
  2366.          }
  2367.       }
  2368.    }
  2369.    else {
  2370.       GLuint i;
  2371.       ASSERT(tObj->MagFilter == GL_LINEAR);
  2372.       for (i = 0; i < n; i++) {
  2373.          GLfloat depth00, depth01, depth10, depth11;
  2374.          GLint i0, i1, j0, j1;
  2375.          GLfloat u, v;
  2376.          GLuint useBorderTexel;
  2377.  
  2378.          /* XXX fix for texture rectangle! */
  2379.          COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, texcoords[i][0], u, width, i0, i1);
  2380.          COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, texcoords[i][1], v, height,j0, j1);
  2381.  
  2382.          useBorderTexel = 0;
  2383.          if (texImage->Border) {
  2384.             i0 += texImage->Border;
  2385.             i1 += texImage->Border;
  2386.             j0 += texImage->Border;
  2387.             j1 += texImage->Border;
  2388.          }
  2389.          else {
  2390.             if (i0 < 0 || i0 >= (GLint) width)   useBorderTexel |= I0BIT;
  2391.             if (i1 < 0 || i1 >= (GLint) width)   useBorderTexel |= I1BIT;
  2392.             if (j0 < 0 || j0 >= (GLint) height)  useBorderTexel |= J0BIT;
  2393.             if (j1 < 0 || j1 >= (GLint) height)  useBorderTexel |= J1BIT;
  2394.          }
  2395.  
  2396.          /* get four depth samples from the texture */
  2397.          if (useBorderTexel & (I0BIT | J0BIT)) {
  2398.             depth00 = 1.0;
  2399.          }
  2400.          else {
  2401.             depth00 = *((const GLfloat *) texImage->Data + j0 * width + i0);
  2402.          }
  2403.          if (useBorderTexel & (I1BIT | J0BIT)) {
  2404.             depth10 = 1.0;
  2405.          }
  2406.          else {
  2407.             depth10 = *((const GLfloat *) texImage->Data + j0 * width + i1);
  2408.          }
  2409.          if (useBorderTexel & (I0BIT | J1BIT)) {
  2410.             depth01 = 1.0;
  2411.          }
  2412.          else {
  2413.             depth01 = *((const GLfloat *) texImage->Data + j1 * width + i0);
  2414.          }
  2415.          if (useBorderTexel & (I1BIT | J1BIT)) {
  2416.             depth11 = 1.0;
  2417.          }
  2418.          else {
  2419.             depth11 = *((const GLfloat *) texImage->Data + j1 * width + i1);
  2420.          }
  2421.  
  2422.          if (0) {
  2423.             /* compute a single weighted depth sample and do one comparison */
  2424.             const GLfloat a = FRAC(u + 1.0F);
  2425.             const GLfloat b = FRAC(v + 1.0F);
  2426.             const GLfloat w00 = (1.0F - a) * (1.0F - b);
  2427.             const GLfloat w10 = (       a) * (1.0F - b);
  2428.             const GLfloat w01 = (1.0F - a) * (       b);
  2429.             const GLfloat w11 = (       a) * (       b);
  2430.             const GLfloat depthSample = w00 * depth00 + w10 * depth10
  2431.                                       + w01 * depth01 + w11 * depth11;
  2432.             if ((depthSample <= texcoords[i][2] && function == GL_LEQUAL) ||
  2433.                 (depthSample >= texcoords[i][2] && function == GL_GEQUAL)) {
  2434.                result  = ambient;
  2435.             }
  2436.             else {
  2437.                result = CHAN_MAX;
  2438.             }
  2439.          }
  2440.          else {
  2441.             /* Do four depth/R comparisons and compute a weighted result.
  2442.              * If this touches on somebody's I.P., I'll remove this code
  2443.              * upon request.
  2444.              */
  2445.             const GLfloat d = (CHAN_MAXF - (GLfloat) ambient) * 0.25F;
  2446.             GLfloat luminance = CHAN_MAXF;
  2447.  
  2448.             switch (function) {
  2449.             case GL_LEQUAL:
  2450.                if (depth00 <= texcoords[i][2])  luminance -= d;
  2451.                if (depth01 <= texcoords[i][2])  luminance -= d;
  2452.                if (depth10 <= texcoords[i][2])  luminance -= d;
  2453.                if (depth11 <= texcoords[i][2])  luminance -= d;
  2454.                result = (GLchan) luminance;
  2455.                break;
  2456.             case GL_GEQUAL:
  2457.                if (depth00 >= texcoords[i][2])  luminance -= d;
  2458.                if (depth01 >= texcoords[i][2])  luminance -= d;
  2459.                if (depth10 >= texcoords[i][2])  luminance -= d;
  2460.                if (depth11 >= texcoords[i][2])  luminance -= d;
  2461.                result = (GLchan) luminance;
  2462.                break;
  2463.             case GL_LESS:
  2464.                if (depth00 < texcoords[i][2])  luminance -= d;
  2465.                if (depth01 < texcoords[i][2])  luminance -= d;
  2466.                if (depth10 < texcoords[i][2])  luminance -= d;
  2467.                if (depth11 < texcoords[i][2])  luminance -= d;
  2468.                result = (GLchan) luminance;
  2469.                break;
  2470.             case GL_GREATER:
  2471.                if (depth00 > texcoords[i][2])  luminance -= d;
  2472.                if (depth01 > texcoords[i][2])  luminance -= d;
  2473.                if (depth10 > texcoords[i][2])  luminance -= d;
  2474.                if (depth11 > texcoords[i][2])  luminance -= d;
  2475.                result = (GLchan) luminance;
  2476.                break;
  2477.             case GL_EQUAL:
  2478.                if (depth00 == texcoords[i][2])  luminance -= d;
  2479.                if (depth01 == texcoords[i][2])  luminance -= d;
  2480.                if (depth10 == texcoords[i][2])  luminance -= d;
  2481.                if (depth11 == texcoords[i][2])  luminance -= d;
  2482.                result = (GLchan) luminance;
  2483.                break;
  2484.             case GL_NOTEQUAL:
  2485.                if (depth00 != texcoords[i][2])  luminance -= d;
  2486.                if (depth01 != texcoords[i][2])  luminance -= d;
  2487.                if (depth10 != texcoords[i][2])  luminance -= d;
  2488.                if (depth11 != texcoords[i][2])  luminance -= d;
  2489.                result = (GLchan) luminance;
  2490.                break;
  2491.             case GL_ALWAYS:
  2492.                result = 0;
  2493.                break;
  2494.             case GL_NEVER:
  2495.                result = CHAN_MAX;
  2496.                break;
  2497.             case GL_NONE:
  2498.                /* ordinary bilinear filtering */
  2499.                {
  2500.                   const GLfloat a = FRAC(u + 1.0F);
  2501.                   const GLfloat b = FRAC(v + 1.0F);
  2502.                   const GLfloat w00 = (1.0F - a) * (1.0F - b);
  2503.                   const GLfloat w10 = (       a) * (1.0F - b);
  2504.                   const GLfloat w01 = (1.0F - a) * (       b);
  2505.                   const GLfloat w11 = (       a) * (       b);
  2506.                   const GLfloat depthSample = w00 * depth00 + w10 * depth10
  2507.                                             + w01 * depth01 + w11 * depth11;
  2508.                   CLAMPED_FLOAT_TO_CHAN(result, depthSample);
  2509.                }
  2510.                break;
  2511.             default:
  2512.                _mesa_problem(ctx, "Bad compare func in sample_depth_texture");
  2513.                return;
  2514.             }
  2515.          }
  2516.  
  2517.          switch (tObj->DepthMode) {
  2518.          case GL_LUMINANCE:
  2519.             texel[i][RCOMP] = result;
  2520.             texel[i][GCOMP] = result;
  2521.             texel[i][BCOMP] = result;
  2522.             texel[i][ACOMP] = CHAN_MAX;
  2523.             break;
  2524.          case GL_INTENSITY:
  2525.             texel[i][RCOMP] = result;
  2526.             texel[i][GCOMP] = result;
  2527.             texel[i][BCOMP] = result;
  2528.             texel[i][ACOMP] = result;
  2529.             break;
  2530.          case GL_ALPHA:
  2531.             texel[i][RCOMP] = 0;
  2532.             texel[i][GCOMP] = 0;
  2533.             texel[i][BCOMP] = 0;
  2534.             texel[i][ACOMP] = result;
  2535.             break;
  2536.          default:
  2537.             _mesa_problem(ctx, "Bad depth texture mode");
  2538.          }
  2539.       }  /* for */
  2540.    }  /* if filter */
  2541. }
  2542.  
  2543.  
  2544. #if 0
  2545. /*
  2546.  * Experimental depth texture sampling function.
  2547.  */
  2548. static void
  2549. sample_depth_texture2(const GLcontext *ctx,
  2550.                      const struct gl_texture_unit *texUnit,
  2551.                      GLuint n, GLfloat texcoords[][4],
  2552.                      GLchan texel[][4])
  2553. {
  2554.    const struct gl_texture_object *texObj = texUnit->_Current;
  2555.    const GLint baseLevel = texObj->BaseLevel;
  2556.    const struct gl_texture_image *texImage = texObj->Image[baseLevel];
  2557.    const GLuint width = texImage->Width;
  2558.    const GLuint height = texImage->Height;
  2559.    GLchan ambient;
  2560.    GLboolean lequal, gequal;
  2561.  
  2562.    if (texObj->Target != GL_TEXTURE_2D) {
  2563.       _mesa_problem(ctx, "only 2-D depth textures supported at this time");
  2564.       return;
  2565.    }
  2566.  
  2567.    if (texObj->MinFilter != texObj->MagFilter) {
  2568.       _mesa_problem(ctx, "mipmapped depth textures not supported at this time");
  2569.       return;
  2570.    }
  2571.  
  2572.    /* XXX the GL_SGIX_shadow extension spec doesn't say what to do if
  2573.     * GL_TEXTURE_COMPARE_SGIX == GL_TRUE but the current texture object
  2574.     * isn't a depth texture.
  2575.     */
  2576.    if (texImage->Format != GL_DEPTH_COMPONENT) {
  2577.       _mesa_problem(ctx,"GL_TEXTURE_COMPARE_SGIX enabled with non-depth texture");
  2578.       return;
  2579.    }
  2580.  
  2581.    UNCLAMPED_FLOAT_TO_CHAN(ambient, tObj->ShadowAmbient);
  2582.  
  2583.    if (texObj->CompareOperator == GL_TEXTURE_LEQUAL_R_SGIX) {
  2584.       lequal = GL_TRUE;
  2585.       gequal = GL_FALSE;
  2586.    }
  2587.    else {
  2588.       lequal = GL_FALSE;
  2589.       gequal = GL_TRUE;
  2590.    }
  2591.  
  2592.    {
  2593.       GLuint i;
  2594.       for (i = 0; i < n; i++) {
  2595.          const GLint K = 3;
  2596.          GLint col, row, ii, jj, imin, imax, jmin, jmax, samples, count;
  2597.          GLfloat w;
  2598.          GLchan lum;
  2599.          COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, texcoords[i][0],
  2600.                     width, col);
  2601.          COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, texcoords[i][1],
  2602.                     height, row);
  2603.  
  2604.          imin = col - K;
  2605.          imax = col + K;
  2606.          jmin = row - K;
  2607.          jmax = row + K;
  2608.  
  2609.          if (imin < 0)  imin = 0;
  2610.          if (imax >= width)  imax = width - 1;
  2611.          if (jmin < 0)  jmin = 0;
  2612.          if (jmax >= height) jmax = height - 1;
  2613.  
  2614.          samples = (imax - imin + 1) * (jmax - jmin + 1);
  2615.          count = 0;
  2616.          for (jj = jmin; jj <= jmax; jj++) {
  2617.             for (ii = imin; ii <= imax; ii++) {
  2618.                GLfloat depthSample = *((const GLfloat *) texImage->Data
  2619.                                        + jj * width + ii);
  2620.                if ((depthSample <= r[i] && lequal) ||
  2621.                    (depthSample >= r[i] && gequal)) {
  2622.                   count++;
  2623.                }
  2624.             }
  2625.          }
  2626.  
  2627.          w = (GLfloat) count / (GLfloat) samples;
  2628.          w = CHAN_MAXF - w * (CHAN_MAXF - (GLfloat) ambient);
  2629.          lum = (GLint) w;
  2630.  
  2631.          texel[i][RCOMP] = lum;
  2632.          texel[i][GCOMP] = lum;
  2633.          texel[i][BCOMP] = lum;
  2634.          texel[i][ACOMP] = CHAN_MAX;
  2635.       }
  2636.    }
  2637. }
  2638. #endif
  2639.  
  2640.  
  2641. /**
  2642.  * We use this function when a texture object is in an "incomplete" state.
  2643.  */
  2644. static void
  2645. null_sample_func( GLcontext *ctx, GLuint texUnit,
  2646.           const struct gl_texture_object *tObj, GLuint n,
  2647.           GLfloat texcoords[][4], const GLfloat lambda[],
  2648.           GLchan rgba[][4])
  2649. {
  2650. }
  2651.  
  2652.  
  2653.  
  2654. /**
  2655.  * Setup the texture sampling function for this texture object.
  2656.  */
  2657. void
  2658. _swrast_choose_texture_sample_func( GLcontext *ctx, GLuint texUnit,
  2659.                     const struct gl_texture_object *t )
  2660. {
  2661.    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  2662.  
  2663.    if (!t->Complete) {
  2664.       swrast->TextureSample[texUnit] = null_sample_func;
  2665.    }
  2666.    else {
  2667.       const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
  2668.       const GLenum format = t->Image[t->BaseLevel]->Format;
  2669.  
  2670.       if (needLambda) {
  2671.          /* Compute min/mag filter threshold */
  2672.          if (t->MagFilter == GL_LINEAR
  2673.              && (t->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
  2674.                  t->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
  2675.             swrast->_MinMagThresh[texUnit] = 0.5F;
  2676.          }
  2677.          else {
  2678.             swrast->_MinMagThresh[texUnit] = 0.0F;
  2679.          }
  2680.       }
  2681.  
  2682.       switch (t->Target) {
  2683.          case GL_TEXTURE_1D:
  2684.             if (format == GL_DEPTH_COMPONENT) {
  2685.                swrast->TextureSample[texUnit] = sample_depth_texture;
  2686.             }
  2687.             else if (needLambda) {
  2688.                swrast->TextureSample[texUnit] = sample_lambda_1d;
  2689.             }
  2690.             else if (t->MinFilter == GL_LINEAR) {
  2691.                swrast->TextureSample[texUnit] = sample_linear_1d;
  2692.             }
  2693.             else {
  2694.                ASSERT(t->MinFilter == GL_NEAREST);
  2695.                swrast->TextureSample[texUnit] = sample_nearest_1d;
  2696.             }
  2697.             break;
  2698.          case GL_TEXTURE_2D:
  2699.             if (format == GL_DEPTH_COMPONENT) {
  2700.                swrast->TextureSample[texUnit] = sample_depth_texture;
  2701.             }
  2702.             else if (needLambda) {
  2703.                swrast->TextureSample[texUnit] = sample_lambda_2d;
  2704.             }
  2705.             else if (t->MinFilter == GL_LINEAR) {
  2706.                swrast->TextureSample[texUnit] = sample_linear_2d;
  2707.             }
  2708.             else {
  2709.                GLint baseLevel = t->BaseLevel;
  2710.                ASSERT(t->MinFilter == GL_NEAREST);
  2711.                if (t->WrapS == GL_REPEAT &&
  2712.                    t->WrapT == GL_REPEAT &&
  2713.                    t->Image[baseLevel]->Border == 0 &&
  2714.                    t->Image[baseLevel]->TexFormat->MesaFormat == MESA_FORMAT_RGB) {
  2715.                   swrast->TextureSample[texUnit] = opt_sample_rgb_2d;
  2716.                }
  2717.                else if (t->WrapS == GL_REPEAT &&
  2718.                         t->WrapT == GL_REPEAT &&
  2719.                         t->Image[baseLevel]->Border == 0 &&
  2720.                         t->Image[baseLevel]->TexFormat->MesaFormat == MESA_FORMAT_RGBA) {
  2721.                   swrast->TextureSample[texUnit] = opt_sample_rgba_2d;
  2722.                }
  2723.                else
  2724.                   swrast->TextureSample[texUnit] = sample_nearest_2d;
  2725.             }
  2726.             break;
  2727.          case GL_TEXTURE_3D:
  2728.             if (needLambda) {
  2729.                swrast->TextureSample[texUnit] = sample_lambda_3d;
  2730.             }
  2731.             else if (t->MinFilter == GL_LINEAR) {
  2732.                swrast->TextureSample[texUnit] = sample_linear_3d;
  2733.             }
  2734.             else {
  2735.                ASSERT(t->MinFilter == GL_NEAREST);
  2736.                swrast->TextureSample[texUnit] = sample_nearest_3d;
  2737.             }
  2738.             break;
  2739.          case GL_TEXTURE_CUBE_MAP_ARB:
  2740.             if (needLambda) {
  2741.                swrast->TextureSample[texUnit] = sample_lambda_cube;
  2742.             }
  2743.             else if (t->MinFilter == GL_LINEAR) {
  2744.                swrast->TextureSample[texUnit] = sample_linear_cube;
  2745.             }
  2746.             else {
  2747.                ASSERT(t->MinFilter == GL_NEAREST);
  2748.                swrast->TextureSample[texUnit] = sample_nearest_cube;
  2749.             }
  2750.             break;
  2751.          case GL_TEXTURE_RECTANGLE_NV:
  2752.             if (needLambda) {
  2753.                swrast->TextureSample[texUnit] = sample_lambda_rect;
  2754.             }
  2755.             else if (t->MinFilter == GL_LINEAR) {
  2756.                swrast->TextureSample[texUnit] = sample_linear_rect;
  2757.             }
  2758.             else {
  2759.                ASSERT(t->MinFilter == GL_NEAREST);
  2760.                swrast->TextureSample[texUnit] = sample_nearest_rect;
  2761.             }
  2762.             break;
  2763.          default:
  2764.             _mesa_problem(ctx, "invalid target in _swrast_choose_texture_sample_func");
  2765.       }
  2766.    }
  2767. }
  2768.  
  2769.  
  2770. #define PROD(A,B)   ( (GLuint)(A) * ((GLuint)(B)+1) )
  2771. #define S_PROD(A,B) ( (GLint)(A) * ((GLint)(B)+1) )
  2772.  
  2773.  
  2774. /**
  2775.  * Do texture application for GL_ARB/EXT_texture_env_combine.
  2776.  * Input:
  2777.  *     ctx - rendering context
  2778.  *     textureUnit - the texture unit to apply
  2779.  *     n - number of fragments to process (span width)
  2780.  *     primary_rgba - incoming fragment color array
  2781.  *     texelBuffer - pointer to texel colors for all texture units
  2782.  * Input/Output:
  2783.  *     rgba - incoming colors, which get modified here
  2784.  */
  2785. static INLINE void
  2786. texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
  2787.                  CONST GLchan (*primary_rgba)[4],
  2788.                  CONST GLchan *texelBuffer,
  2789.                  GLchan (*rgba)[4] )
  2790. {
  2791.    const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);
  2792.    const GLchan (*argRGB [3])[4];
  2793.    const GLchan (*argA [3])[4];
  2794.    const GLuint RGBshift = textureUnit->CombineScaleShiftRGB;
  2795.    const GLuint Ashift   = textureUnit->CombineScaleShiftA;
  2796. #if CHAN_TYPE == GL_FLOAT
  2797.    const GLchan RGBmult = (GLfloat) (1 << RGBshift);
  2798.    const GLchan Amult = (GLfloat) (1 << Ashift);
  2799. #else
  2800.    const GLint half = (CHAN_MAX + 1) / 2;
  2801. #endif
  2802.    GLuint i, j;
  2803.  
  2804.    /* GLchan ccolor[3][4]; */
  2805.    DEFMNARRAY(GLchan, ccolor, 3, 3 * MAX_WIDTH, 4);  /* mac 32k limitation */
  2806.    CHECKARRAY(ccolor, return);  /* mac 32k limitation */
  2807.  
  2808.    ASSERT(ctx->Extensions.EXT_texture_env_combine ||
  2809.           ctx->Extensions.ARB_texture_env_combine);
  2810.    ASSERT(SWRAST_CONTEXT(ctx)->_AnyTextureCombine);
  2811.  
  2812.  
  2813.    /*
  2814.    printf("modeRGB 0x%x  modeA 0x%x  srcRGB1 0x%x  srcA1 0x%x  srcRGB2 0x%x  srcA2 0x%x\n",
  2815.           textureUnit->CombineModeRGB,
  2816.           textureUnit->CombineModeA,
  2817.           textureUnit->CombineSourceRGB[0],
  2818.           textureUnit->CombineSourceA[0],
  2819.           textureUnit->CombineSourceRGB[1],
  2820.           textureUnit->CombineSourceA[1]);
  2821.    */
  2822.  
  2823.    /*
  2824.     * Do operand setup for up to 3 operands.  Loop over the terms.
  2825.     */
  2826.    for (j = 0; j < 3; j++) {
  2827.       const GLenum srcA = textureUnit->CombineSourceA[j];
  2828.       const GLenum srcRGB = textureUnit->CombineSourceRGB[j];
  2829.  
  2830.       switch (srcA) {
  2831.          case GL_TEXTURE:
  2832.             argA[j] = (const GLchan (*)[4])
  2833.                (texelBuffer + unit * (n * 4 * sizeof(GLchan)));
  2834.             break;
  2835.          case GL_PRIMARY_COLOR_EXT:
  2836.             argA[j] = primary_rgba;
  2837.             break;
  2838.          case GL_PREVIOUS_EXT:
  2839.             argA[j] = (const GLchan (*)[4]) rgba;
  2840.             break;
  2841.          case GL_CONSTANT_EXT:
  2842.             {
  2843.                GLchan alpha, (*c)[4] = ccolor[j];
  2844.                UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
  2845.                for (i = 0; i < n; i++)
  2846.                   c[i][ACOMP] = alpha;
  2847.                argA[j] = (const GLchan (*)[4]) ccolor[j];
  2848.             }
  2849.             break;
  2850.          default:
  2851.             /* ARB_texture_env_crossbar source */
  2852.             {
  2853.                const GLuint srcUnit = srcA - GL_TEXTURE0_ARB;
  2854.                ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
  2855.                if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
  2856.                   return;
  2857.                argA[j] = (const GLchan (*)[4])
  2858.                   (texelBuffer + srcUnit * (n * 4 * sizeof(GLchan)));
  2859.             }
  2860.       }
  2861.  
  2862.       switch (srcRGB) {
  2863.          case GL_TEXTURE:
  2864.             argRGB[j] = (const GLchan (*)[4])
  2865.                (texelBuffer + unit * (n * 4 * sizeof(GLchan)));
  2866.             break;
  2867.          case GL_PRIMARY_COLOR_EXT:
  2868.             argRGB[j] = primary_rgba;
  2869.             break;
  2870.          case GL_PREVIOUS_EXT:
  2871.             argRGB[j] = (const GLchan (*)[4]) rgba;
  2872.             break;
  2873.          case GL_CONSTANT_EXT:
  2874.             {
  2875.                GLchan (*c)[4] = ccolor[j];
  2876.                GLchan red, green, blue, alpha;
  2877.                UNCLAMPED_FLOAT_TO_CHAN(red,   textureUnit->EnvColor[0]);
  2878.                UNCLAMPED_FLOAT_TO_CHAN(green, textureUnit->EnvColor[1]);
  2879.                UNCLAMPED_FLOAT_TO_CHAN(blue,  textureUnit->EnvColor[2]);
  2880.                UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
  2881.                for (i = 0; i < n; i++) {
  2882.                   c[i][RCOMP] = red;
  2883.                   c[i][GCOMP] = green;
  2884.                   c[i][BCOMP] = blue;
  2885.                   c[i][ACOMP] = alpha;
  2886.                }
  2887.                argRGB[j] = (const GLchan (*)[4]) ccolor[j];
  2888.             }
  2889.             break;
  2890.          default:
  2891.             /* ARB_texture_env_crossbar source */
  2892.             {
  2893.                const GLuint srcUnit = srcRGB - GL_TEXTURE0_ARB;
  2894.                ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
  2895.                if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
  2896.                   return;
  2897.                argRGB[j] = (const GLchan (*)[4])
  2898.                   (texelBuffer + srcUnit * (n * 4 * sizeof(GLchan)));
  2899.             }
  2900.       }
  2901.  
  2902.       if (textureUnit->CombineOperandRGB[j] != GL_SRC_COLOR) {
  2903.          const GLchan (*src)[4] = argRGB[j];
  2904.          GLchan (*dst)[4] = ccolor[j];
  2905.  
  2906.          /* point to new arg[j] storage */
  2907.          argRGB[j] = (const GLchan (*)[4]) ccolor[j];
  2908.  
  2909.          if (textureUnit->CombineOperandRGB[j] == GL_ONE_MINUS_SRC_COLOR) {
  2910.             for (i = 0; i < n; i++) {
  2911.                dst[i][RCOMP] = CHAN_MAX - src[i][RCOMP];
  2912.                dst[i][GCOMP] = CHAN_MAX - src[i][GCOMP];
  2913.                dst[i][BCOMP] = CHAN_MAX - src[i][BCOMP];
  2914.             }
  2915.          }
  2916.          else if (textureUnit->CombineOperandRGB[j] == GL_SRC_ALPHA) {
  2917.             for (i = 0; i < n; i++) {
  2918.                dst[i][RCOMP] = src[i][ACOMP];
  2919.                dst[i][GCOMP] = src[i][ACOMP];
  2920.                dst[i][BCOMP] = src[i][ACOMP];
  2921.             }
  2922.          }
  2923.          else {
  2924.             ASSERT(textureUnit->CombineOperandRGB[j] ==GL_ONE_MINUS_SRC_ALPHA);
  2925.             for (i = 0; i < n; i++) {
  2926.                dst[i][RCOMP] = CHAN_MAX - src[i][ACOMP];
  2927.                dst[i][GCOMP] = CHAN_MAX - src[i][ACOMP];
  2928.                dst[i][BCOMP] = CHAN_MAX - src[i][ACOMP];
  2929.             }
  2930.          }
  2931.       }
  2932.  
  2933.       if (textureUnit->CombineOperandA[j] == GL_ONE_MINUS_SRC_ALPHA) {
  2934.          const GLchan (*src)[4] = argA[j];
  2935.          GLchan (*dst)[4] = ccolor[j];
  2936.          argA[j] = (const GLchan (*)[4]) ccolor[j];
  2937.          for (i = 0; i < n; i++) {
  2938.             dst[i][ACOMP] = CHAN_MAX - src[i][ACOMP];
  2939.          }
  2940.       }
  2941.  
  2942.       if (textureUnit->CombineModeRGB == GL_REPLACE &&
  2943.           textureUnit->CombineModeA == GL_REPLACE) {
  2944.          break;      /*  done, we need only arg0  */
  2945.       }
  2946.  
  2947.       if (j == 1 &&
  2948.           textureUnit->CombineModeRGB != GL_INTERPOLATE_EXT &&
  2949.           textureUnit->CombineModeA != GL_INTERPOLATE_EXT) {
  2950.          break;      /*  arg0 and arg1 are done. we don't need arg2. */
  2951.       }
  2952.    }
  2953.  
  2954.    /*
  2955.     * Do the texture combine.
  2956.     */
  2957.    switch (textureUnit->CombineModeRGB) {
  2958.       case GL_REPLACE:
  2959.          {
  2960.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  2961.             if (RGBshift) {
  2962.                for (i = 0; i < n; i++) {
  2963. #if CHAN_TYPE == GL_FLOAT
  2964.                   rgba[i][RCOMP] = arg0[i][RCOMP] * RGBmult;
  2965.                   rgba[i][GCOMP] = arg0[i][GCOMP] * RGBmult;
  2966.                   rgba[i][BCOMP] = arg0[i][BCOMP] * RGBmult;
  2967. #else
  2968.                   GLuint r = (GLuint) arg0[i][RCOMP] << RGBshift;
  2969.                   GLuint g = (GLuint) arg0[i][GCOMP] << RGBshift;
  2970.                   GLuint b = (GLuint) arg0[i][BCOMP] << RGBshift;
  2971.                   rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
  2972.                   rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
  2973.                   rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
  2974. #endif
  2975.                }
  2976.             }
  2977.             else {
  2978.                for (i = 0; i < n; i++) {
  2979.                   rgba[i][RCOMP] = arg0[i][RCOMP];
  2980.                   rgba[i][GCOMP] = arg0[i][GCOMP];
  2981.                   rgba[i][BCOMP] = arg0[i][BCOMP];
  2982.                }
  2983.             }
  2984.          }
  2985.          break;
  2986.       case GL_MODULATE:
  2987.          {
  2988.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  2989.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  2990. #if CHAN_TYPE != GL_FLOAT
  2991.             const GLint shift = CHAN_BITS - RGBshift;
  2992. #endif
  2993.             for (i = 0; i < n; i++) {
  2994. #if CHAN_TYPE == GL_FLOAT
  2995.                rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * RGBmult;
  2996.                rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * RGBmult;
  2997.                rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * RGBmult;
  2998. #else
  2999.                GLuint r = PROD(arg0[i][RCOMP], arg1[i][RCOMP]) >> shift;
  3000.                GLuint g = PROD(arg0[i][GCOMP], arg1[i][GCOMP]) >> shift;
  3001.                GLuint b = PROD(arg0[i][BCOMP], arg1[i][BCOMP]) >> shift;
  3002.                rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
  3003.                rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
  3004.                rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
  3005. #endif
  3006.             }
  3007.          }
  3008.          break;
  3009.       case GL_ADD:
  3010.          {
  3011.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  3012.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  3013.             for (i = 0; i < n; i++) {
  3014. #if CHAN_TYPE == GL_FLOAT
  3015.                rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * RGBmult;
  3016.                rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * RGBmult;
  3017.                rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * RGBmult;
  3018. #else
  3019.                GLint r = ((GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP]) << RGBshift;
  3020.                GLint g = ((GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP]) << RGBshift;
  3021.                GLint b = ((GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP]) << RGBshift;
  3022.                rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
  3023.                rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
  3024.                rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
  3025. #endif
  3026.             }
  3027.          }
  3028.          break;
  3029.       case GL_ADD_SIGNED_EXT:
  3030.          {
  3031.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  3032.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  3033.             for (i = 0; i < n; i++) {
  3034. #if CHAN_TYPE == GL_FLOAT
  3035.                rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5) * RGBmult;
  3036.                rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5) * RGBmult;
  3037.                rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5) * RGBmult;
  3038. #else
  3039.                GLint r = (GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP] -half;
  3040.                GLint g = (GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP] -half;
  3041.                GLint b = (GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP] -half;
  3042.                r = (r < 0) ? 0 : r << RGBshift;
  3043.                g = (g < 0) ? 0 : g << RGBshift;
  3044.                b = (b < 0) ? 0 : b << RGBshift;
  3045.                rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
  3046.                rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
  3047.                rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
  3048. #endif
  3049.             }
  3050.          }
  3051.          break;
  3052.       case GL_INTERPOLATE_EXT:
  3053.          {
  3054.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  3055.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  3056.             const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
  3057. #if CHAN_TYPE != GL_FLOAT
  3058.             const GLint shift = CHAN_BITS - RGBshift;
  3059. #endif
  3060.             for (i = 0; i < n; i++) {
  3061. #if CHAN_TYPE == GL_FLOAT
  3062.                rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +
  3063.                       arg1[i][RCOMP] * (CHAN_MAXF - arg2[i][RCOMP])) * RGBmult;
  3064.                rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +
  3065.                       arg1[i][GCOMP] * (CHAN_MAXF - arg2[i][GCOMP])) * RGBmult;
  3066.                rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +
  3067.                       arg1[i][BCOMP] * (CHAN_MAXF - arg2[i][BCOMP])) * RGBmult;
  3068. #else
  3069.                GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
  3070.                            + PROD(arg1[i][RCOMP], CHAN_MAX - arg2[i][RCOMP]))
  3071.                               >> shift;
  3072.                GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
  3073.                            + PROD(arg1[i][GCOMP], CHAN_MAX - arg2[i][GCOMP]))
  3074.                               >> shift;
  3075.                GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
  3076.                            + PROD(arg1[i][BCOMP], CHAN_MAX - arg2[i][BCOMP]))
  3077.                               >> shift;
  3078.                rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
  3079.                rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
  3080.                rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
  3081. #endif
  3082.             }
  3083.          }
  3084.          break;
  3085.       case GL_SUBTRACT_ARB:
  3086.          {
  3087.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  3088.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  3089.             for (i = 0; i < n; i++) {
  3090. #if CHAN_TYPE == GL_FLOAT
  3091.                rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * RGBmult;
  3092.                rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * RGBmult;
  3093.                rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * RGBmult;
  3094. #else
  3095.                GLint r = ((GLint) arg0[i][RCOMP] - (GLint) arg1[i][RCOMP]) << RGBshift;
  3096.                GLint g = ((GLint) arg0[i][GCOMP] - (GLint) arg1[i][GCOMP]) << RGBshift;
  3097.                GLint b = ((GLint) arg0[i][BCOMP] - (GLint) arg1[i][BCOMP]) << RGBshift;
  3098.                rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
  3099.                rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
  3100.                rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
  3101. #endif
  3102.             }
  3103.          }
  3104.          break;
  3105.       case GL_DOT3_RGB_EXT:
  3106.       case GL_DOT3_RGBA_EXT:
  3107.          {
  3108.             /* Do not scale the result by 1 2 or 4 */
  3109.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  3110.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  3111.             for (i = 0; i < n; i++) {
  3112. #if CHAN_TYPE == GL_FLOAT
  3113.                GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
  3114.                              (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
  3115.                              (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
  3116.                             * 4.0F;
  3117.                dot = CLAMP(dot, 0.0F, CHAN_MAXF);
  3118. #else
  3119.                GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
  3120.                    (GLint)arg1[i][RCOMP] - half) +
  3121.                 S_PROD((GLint)arg0[i][GCOMP] - half,
  3122.                    (GLint)arg1[i][GCOMP] - half) +
  3123.                 S_PROD((GLint)arg0[i][BCOMP] - half,
  3124.                    (GLint)arg1[i][BCOMP] - half)) >> 6;
  3125.                dot = CLAMP(dot, 0, CHAN_MAX);
  3126. #endif
  3127.                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
  3128.             }
  3129.          }
  3130.          break;
  3131.       case GL_DOT3_RGB_ARB:
  3132.       case GL_DOT3_RGBA_ARB:
  3133.          {
  3134.             /* DO scale the result by 1 2 or 4 */
  3135.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
  3136.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
  3137.             for (i = 0; i < n; i++) {
  3138. #if CHAN_TYPE == GL_FLOAT
  3139.                GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
  3140.                              (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
  3141.                              (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
  3142.                             * 4.0F * RGBmult;
  3143.                dot = CLAMP(dot, 0.0, CHAN_MAXF);
  3144. #else
  3145.                GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
  3146.                    (GLint)arg1[i][RCOMP] - half) +
  3147.                 S_PROD((GLint)arg0[i][GCOMP] - half,
  3148.                    (GLint)arg1[i][GCOMP] - half) +
  3149.                 S_PROD((GLint)arg0[i][BCOMP] - half,
  3150.                    (GLint)arg1[i][BCOMP] - half)) >> 6;
  3151.                dot <<= RGBshift;
  3152.                dot = CLAMP(dot, 0, CHAN_MAX);
  3153. #endif
  3154.                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
  3155.             }
  3156.          }
  3157.          break;
  3158.       default:
  3159.          _mesa_problem(ctx, "invalid combine mode");
  3160.    }
  3161.  
  3162.    switch (textureUnit->CombineModeA) {
  3163.       case GL_REPLACE:
  3164.          {
  3165.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
  3166.             if (Ashift) {
  3167.                for (i = 0; i < n; i++) {
  3168. #if CHAN_TYPE == GL_FLOAT
  3169.                   GLchan a = arg0[i][ACOMP] * Amult;
  3170. #else
  3171.                   GLuint a = (GLuint) arg0[i][ACOMP] << Ashift;
  3172. #endif
  3173.                   rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
  3174.                }
  3175.             }
  3176.             else {
  3177.                for (i = 0; i < n; i++) {
  3178.                   rgba[i][ACOMP] = arg0[i][ACOMP];
  3179.                }
  3180.             }
  3181.          }
  3182.          break;
  3183.       case GL_MODULATE:
  3184.          {
  3185.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
  3186.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
  3187. #if CHAN_TYPE != GL_FLOAT
  3188.             const GLint shift = CHAN_BITS - Ashift;
  3189. #endif
  3190.             for (i = 0; i < n; i++) {
  3191. #if CHAN_TYPE == GL_FLOAT
  3192.                rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * Amult;
  3193. #else
  3194.                GLuint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift);
  3195.                rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
  3196. #endif
  3197.             }
  3198.          }
  3199.          break;
  3200.       case GL_ADD:
  3201.          {
  3202.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
  3203.             const GLchan  (*arg1)[4] = (const GLchan (*)[4]) argA[1];
  3204.             for (i = 0; i < n; i++) {
  3205. #if CHAN_TYPE == GL_FLOAT
  3206.                rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * Amult;
  3207. #else
  3208.                GLint a = ((GLint) arg0[i][ACOMP] + arg1[i][ACOMP]) << Ashift;
  3209.                rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
  3210. #endif
  3211.             }
  3212.          }
  3213.          break;
  3214.       case GL_ADD_SIGNED_EXT:
  3215.          {
  3216.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
  3217.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
  3218.             for (i = 0; i < n; i++) {
  3219. #if CHAN_TYPE == GL_FLOAT
  3220.                rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * Amult;
  3221. #else
  3222.                GLint a = (GLint) arg0[i][ACOMP] + (GLint) arg1[i][ACOMP] -half;
  3223.                a = (a < 0) ? 0 : a << Ashift;
  3224.                rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
  3225. #endif
  3226.             }
  3227.          }
  3228.          break;
  3229.       case GL_INTERPOLATE_EXT:
  3230.          {
  3231.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
  3232.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
  3233.             const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
  3234. #if CHAN_TYPE != GL_FLOAT
  3235.             const GLint shift = CHAN_BITS - Ashift;
  3236. #endif
  3237.             for (i=0; i<n; i++) {
  3238. #if CHAN_TYPE == GL_FLOAT
  3239.                rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +
  3240.                                  arg1[i][ACOMP] * (CHAN_MAXF - arg2[i][ACOMP]))
  3241.                                 * Amult;
  3242. #else
  3243.                GLuint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
  3244.                            + PROD(arg1[i][ACOMP], CHAN_MAX - arg2[i][ACOMP]))
  3245.                               >> shift;
  3246.                rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
  3247. #endif
  3248.             }
  3249.          }
  3250.          break;
  3251.       case GL_SUBTRACT_ARB:
  3252.          {
  3253.             const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
  3254.             const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
  3255.             for (i = 0; i < n; i++) {
  3256. #if CHAN_TYPE == GL_FLOAT
  3257.                rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * Amult;
  3258. #else
  3259.                GLint a = ((GLint) arg0[i][ACOMP] - (GLint) arg1[i][ACOMP]) << Ashift;
  3260.                rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
  3261. #endif
  3262.             }
  3263.          }
  3264.          break;
  3265.  
  3266.       default:
  3267.          _mesa_problem(ctx, "invalid combine mode");
  3268.    }
  3269.  
  3270.    /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.
  3271.     * This is kind of a kludge.  It would have been better if the spec
  3272.     * were written such that the GL_COMBINE_ALPHA value could be set to
  3273.     * GL_DOT3.
  3274.     */
  3275.    if (textureUnit->CombineModeRGB == GL_DOT3_RGBA_EXT ||
  3276.        textureUnit->CombineModeRGB == GL_DOT3_RGBA_ARB) {
  3277.       for (i = 0; i < n; i++) {
  3278.      rgba[i][ACOMP] = rgba[i][RCOMP];
  3279.       }
  3280.    }
  3281.    UNDEFARRAY(ccolor);  /* mac 32k limitation */
  3282. }
  3283. #undef PROD
  3284.  
  3285.  
  3286. /**
  3287.  * Implement NVIDIA's GL_NV_texture_env_combine4 extension when
  3288.  * texUnit->EnvMode == GL_COMBINE4_NV.
  3289.  */
  3290. static INLINE void
  3291. texture_combine4( const GLcontext *ctx, GLuint unit, GLuint n,
  3292.                   CONST GLchan (*primary_rgba)[4],
  3293.                   CONST GLchan *texelBuffer,
  3294.                   GLchan (*rgba)[4] )
  3295. {
  3296. }
  3297.  
  3298.  
  3299.  
  3300. /**
  3301.  * Apply a conventional OpenGL texture env mode (REPLACE, ADD, BLEND,
  3302.  * MODULATE, or DECAL) to an array of fragments.
  3303.  * Input:  textureUnit - pointer to texture unit to apply
  3304.  *         format - base internal texture format
  3305.  *         n - number of fragments
  3306.  *         primary_rgba - primary colors (may alias rgba for single texture)
  3307.  *         texels - array of texel colors
  3308.  * InOut:  rgba - incoming fragment colors modified by texel colors
  3309.  *                according to the texture environment mode.
  3310.  */
  3311. static void
  3312. texture_apply( const GLcontext *ctx,
  3313.                const struct gl_texture_unit *texUnit,
  3314.                GLuint n,
  3315.                CONST GLchan primary_rgba[][4], CONST GLchan texel[][4],
  3316.                GLchan rgba[][4] )
  3317. {
  3318.    GLint baseLevel;
  3319.    GLuint i;
  3320.    GLint Rc, Gc, Bc, Ac;
  3321.    GLenum format;
  3322.  
  3323.    ASSERT(texUnit);
  3324.    ASSERT(texUnit->_Current);
  3325.  
  3326.    baseLevel = texUnit->_Current->BaseLevel;
  3327.    ASSERT(texUnit->_Current->Image[baseLevel]);
  3328.  
  3329.    format = texUnit->_Current->Image[baseLevel]->Format;
  3330.  
  3331.    if (format == GL_COLOR_INDEX || format == GL_DEPTH_COMPONENT
  3332.        || format == GL_YCBCR_MESA) {
  3333.       format = GL_RGBA;  /* a bit of a hack */
  3334.    }
  3335.  
  3336.    switch (texUnit->EnvMode) {
  3337.       case GL_REPLACE:
  3338.      switch (format) {
  3339.         case GL_ALPHA:
  3340.            for (i=0;i<n;i++) {
  3341.           /* Cv = Cf */
  3342.                   /* Av = At */
  3343.                   rgba[i][ACOMP] = texel[i][ACOMP];
  3344.            }
  3345.            break;
  3346.         case GL_LUMINANCE:
  3347.            for (i=0;i<n;i++) {
  3348.           /* Cv = Lt */
  3349.                   GLchan Lt = texel[i][RCOMP];
  3350.                   rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
  3351.                   /* Av = Af */
  3352.            }
  3353.            break;
  3354.         case GL_LUMINANCE_ALPHA:
  3355.            for (i=0;i<n;i++) {
  3356.                   GLchan Lt = texel[i][RCOMP];
  3357.           /* Cv = Lt */
  3358.           rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
  3359.           /* Av = At */
  3360.           rgba[i][ACOMP] = texel[i][ACOMP];
  3361.            }
  3362.            break;
  3363.         case GL_INTENSITY:
  3364.            for (i=0;i<n;i++) {
  3365.           /* Cv = It */
  3366.                   GLchan It = texel[i][RCOMP];
  3367.                   rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = It;
  3368.                   /* Av = It */
  3369.                   rgba[i][ACOMP] = It;
  3370.            }
  3371.            break;
  3372.         case GL_RGB:
  3373.            for (i=0;i<n;i++) {
  3374.           /* Cv = Ct */
  3375.           rgba[i][RCOMP] = texel[i][RCOMP];
  3376.           rgba[i][GCOMP] = texel[i][GCOMP];
  3377.           rgba[i][BCOMP] = texel[i][BCOMP];
  3378.           /* Av = Af */
  3379.            }
  3380.            break;
  3381.         case GL_RGBA:
  3382.            for (i=0;i<n;i++) {
  3383.           /* Cv = Ct */
  3384.           rgba[i][RCOMP] = texel[i][RCOMP];
  3385.           rgba[i][GCOMP] = texel[i][GCOMP];
  3386.           rgba[i][BCOMP] = texel[i][BCOMP];
  3387.           /* Av = At */
  3388.           rgba[i][ACOMP] = texel[i][ACOMP];
  3389.            }
  3390.            break;
  3391.             default:
  3392.                _mesa_problem(ctx, "Bad format (GL_REPLACE) in texture_apply");
  3393.                return;
  3394.      }
  3395.      break;
  3396.  
  3397.       case GL_MODULATE:
  3398.          switch (format) {
  3399.         case GL_ALPHA:
  3400.            for (i=0;i<n;i++) {
  3401.           /* Cv = Cf */
  3402.           /* Av = AfAt */
  3403.           rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
  3404.            }
  3405.            break;
  3406.         case GL_LUMINANCE:
  3407.            for (i=0;i<n;i++) {
  3408.           /* Cv = LtCf */
  3409.                   GLchan Lt = texel[i][RCOMP];
  3410.           rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
  3411.           rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
  3412.           rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
  3413.           /* Av = Af */
  3414.            }
  3415.            break;
  3416.         case GL_LUMINANCE_ALPHA:
  3417.            for (i=0;i<n;i++) {
  3418.           /* Cv = CfLt */
  3419.                   GLchan Lt = texel[i][RCOMP];
  3420.           rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
  3421.           rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
  3422.           rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
  3423.           /* Av = AfAt */
  3424.           rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
  3425.            }
  3426.            break;
  3427.         case GL_INTENSITY:
  3428.            for (i=0;i<n;i++) {
  3429.           /* Cv = CfIt */
  3430.                   GLchan It = texel[i][RCOMP];
  3431.           rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], It );
  3432.           rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], It );
  3433.           rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], It );
  3434.           /* Av = AfIt */
  3435.           rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], It );
  3436.            }
  3437.            break;
  3438.         case GL_RGB:
  3439.            for (i=0;i<n;i++) {
  3440.           /* Cv = CfCt */
  3441.           rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
  3442.           rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
  3443.           rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
  3444.           /* Av = Af */
  3445.            }
  3446.            break;
  3447.         case GL_RGBA:
  3448.            for (i=0;i<n;i++) {
  3449.           /* Cv = CfCt */
  3450.           rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
  3451.           rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
  3452.           rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
  3453.           /* Av = AfAt */
  3454.           rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
  3455.            }
  3456.            break;
  3457.             default:
  3458.                _mesa_problem(ctx, "Bad format (GL_MODULATE) in texture_apply");
  3459.                return;
  3460.      }
  3461.      break;
  3462.  
  3463.       case GL_DECAL:
  3464.          switch (format) {
  3465.             case GL_ALPHA:
  3466.             case GL_LUMINANCE:
  3467.             case GL_LUMINANCE_ALPHA:
  3468.             case GL_INTENSITY:
  3469.                /* undefined */
  3470.                break;
  3471.         case GL_RGB:
  3472.            for (i=0;i<n;i++) {
  3473.           /* Cv = Ct */
  3474.           rgba[i][RCOMP] = texel[i][RCOMP];
  3475.           rgba[i][GCOMP] = texel[i][GCOMP];
  3476.           rgba[i][BCOMP] = texel[i][BCOMP];
  3477.           /* Av = Af */
  3478.            }
  3479.            break;
  3480.         case GL_RGBA:
  3481.            for (i=0;i<n;i++) {
  3482.           /* Cv = Cf(1-At) + CtAt */
  3483.           GLint t = texel[i][ACOMP], s = CHAN_MAX - t;
  3484.           rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(texel[i][RCOMP],t);
  3485.           rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(texel[i][GCOMP],t);
  3486.           rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(texel[i][BCOMP],t);
  3487.           /* Av = Af */
  3488.            }
  3489.            break;
  3490.             default:
  3491.                _mesa_problem(ctx, "Bad format (GL_DECAL) in texture_apply");
  3492.                return;
  3493.      }
  3494.      break;
  3495.  
  3496.       case GL_BLEND:
  3497.          Rc = (GLint) (texUnit->EnvColor[0] * CHAN_MAXF);
  3498.          Gc = (GLint) (texUnit->EnvColor[1] * CHAN_MAXF);
  3499.          Bc = (GLint) (texUnit->EnvColor[2] * CHAN_MAXF);
  3500.          Ac = (GLint) (texUnit->EnvColor[3] * CHAN_MAXF);
  3501.      switch (format) {
  3502.         case GL_ALPHA:
  3503.            for (i=0;i<n;i++) {
  3504.           /* Cv = Cf */
  3505.           /* Av = AfAt */
  3506.                   rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
  3507.            }
  3508.            break;
  3509.             case GL_LUMINANCE:
  3510.            for (i=0;i<n;i++) {
  3511.           /* Cv = Cf(1-Lt) + CcLt */
  3512.           GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
  3513.           rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
  3514.           rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
  3515.           rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
  3516.           /* Av = Af */
  3517.            }
  3518.            break;
  3519.         case GL_LUMINANCE_ALPHA:
  3520.            for (i=0;i<n;i++) {
  3521.           /* Cv = Cf(1-Lt) + CcLt */
  3522.           GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
  3523.           rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
  3524.           rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
  3525.           rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
  3526.           /* Av = AfAt */
  3527.           rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
  3528.            }
  3529.            break;
  3530.             case GL_INTENSITY:
  3531.            for (i=0;i<n;i++) {
  3532.           /* Cv = Cf(1-It) + CcLt */
  3533.           GLchan It = texel[i][RCOMP], s = CHAN_MAX - It;
  3534.           rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, It);
  3535.           rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, It);
  3536.           rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, It);
  3537.                   /* Av = Af(1-It) + Ac*It */
  3538.                   rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], s) + CHAN_PRODUCT(Ac, It);
  3539.                }
  3540.                break;
  3541.         case GL_RGB:
  3542.            for (i=0;i<n;i++) {
  3543.           /* Cv = Cf(1-Ct) + CcCt */
  3544.           rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
  3545.           rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
  3546.           rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
  3547.           /* Av = Af */
  3548.            }
  3549.            break;
  3550.         case GL_RGBA:
  3551.            for (i=0;i<n;i++) {
  3552.           /* Cv = Cf(1-Ct) + CcCt */
  3553.           rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
  3554.           rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
  3555.           rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
  3556.           /* Av = AfAt */
  3557.           rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
  3558.            }
  3559.            break;
  3560.             default:
  3561.                _mesa_problem(ctx, "Bad format (GL_BLEND) in texture_apply");
  3562.                return;
  3563.      }
  3564.      break;
  3565.  
  3566.      /* XXX don't clamp results if GLchan is float??? */
  3567.  
  3568.       case GL_ADD:  /* GL_EXT_texture_add_env */
  3569.          switch (format) {
  3570.             case GL_ALPHA:
  3571.                for (i=0;i<n;i++) {
  3572.                   /* Rv = Rf */
  3573.                   /* Gv = Gf */
  3574.                   /* Bv = Bf */
  3575.                   rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
  3576.                }
  3577.                break;
  3578.             case GL_LUMINANCE:
  3579.                for (i=0;i<n;i++) {
  3580.                   GLuint Lt = texel[i][RCOMP];
  3581.                   GLuint r = rgba[i][RCOMP] + Lt;
  3582.                   GLuint g = rgba[i][GCOMP] + Lt;
  3583.                   GLuint b = rgba[i][BCOMP] + Lt;
  3584.                   rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
  3585.                   rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
  3586.                   rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
  3587.                   /* Av = Af */
  3588.                }
  3589.                break;
  3590.             case GL_LUMINANCE_ALPHA:
  3591.                for (i=0;i<n;i++) {
  3592.                   GLuint Lt = texel[i][RCOMP];
  3593.                   GLuint r = rgba[i][RCOMP] + Lt;
  3594.                   GLuint g = rgba[i][GCOMP] + Lt;
  3595.                   GLuint b = rgba[i][BCOMP] + Lt;
  3596.                   rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
  3597.                   rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
  3598.                   rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
  3599.                   rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
  3600.                }
  3601.                break;
  3602.             case GL_INTENSITY:
  3603.                for (i=0;i<n;i++) {
  3604.                   GLchan It = texel[i][RCOMP];
  3605.                   GLuint r = rgba[i][RCOMP] + It;
  3606.                   GLuint g = rgba[i][GCOMP] + It;
  3607.                   GLuint b = rgba[i][BCOMP] + It;
  3608.                   GLuint a = rgba[i][ACOMP] + It;
  3609.                   rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
  3610.                   rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
  3611.                   rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
  3612.                   rgba[i][ACOMP] = MIN2(a, CHAN_MAX);
  3613.                }
  3614.                break;
  3615.         case GL_RGB:
  3616.            for (i=0;i<n;i++) {
  3617.                   GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
  3618.                   GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
  3619.                   GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
  3620.           rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
  3621.           rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
  3622.           rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
  3623.           /* Av = Af */
  3624.            }
  3625.            break;
  3626.         case GL_RGBA:
  3627.            for (i=0;i<n;i++) {
  3628.                   GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
  3629.                   GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
  3630.                   GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
  3631.           rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
  3632.           rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
  3633.           rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
  3634.                   rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
  3635.                }
  3636.                break;
  3637.             default:
  3638.                _mesa_problem(ctx, "Bad format (GL_ADD) in texture_apply");
  3639.                return;
  3640.      }
  3641.      break;
  3642.  
  3643.       default:
  3644.          _mesa_problem(ctx, "Bad env mode in texture_apply");
  3645.          return;
  3646.    }
  3647. }
  3648.  
  3649.  
  3650.  
  3651. /**
  3652.  * Apply texture mapping to a span of fragments.
  3653.  */
  3654. void
  3655. _swrast_texture_span( GLcontext *ctx, struct sw_span *span )
  3656. {
  3657.    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  3658.    GLchan primary_rgba[MAX_WIDTH][4];
  3659.    GLuint unit;
  3660.  
  3661.    ASSERT(span->end < MAX_WIDTH);
  3662.    ASSERT(span->arrayMask & SPAN_TEXTURE);
  3663.  
  3664.    /*
  3665.     * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)
  3666.     */
  3667.    if (swrast->_AnyTextureCombine)
  3668.       MEMCPY(primary_rgba, span->array->rgba, 4 * span->end * sizeof(GLchan));
  3669.  
  3670.    /*
  3671.     * Must do all texture sampling before combining in order to
  3672.     * accomodate GL_ARB_texture_env_crossbar.
  3673.     */
  3674.    for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
  3675.       if (ctx->Texture.Unit[unit]._ReallyEnabled) {
  3676.          const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
  3677.          const struct gl_texture_object *curObj = texUnit->_Current;
  3678.          GLfloat *lambda = span->array->lambda[unit];
  3679.          GLchan (*texels)[4] = (GLchan (*)[4])
  3680.             (swrast->TexelBuffer + unit * (span->end * 4 * sizeof(GLchan)));
  3681.  
  3682.          /* adjust texture lod (lambda) */
  3683.          if (span->arrayMask | SPAN_LAMBDA) {
  3684.             if (texUnit->LodBias != 0.0F) {
  3685.                /* apply LOD bias, but don't clamp yet */
  3686.                GLuint i;
  3687.                for (i = 0; i < span->end; i++) {
  3688.                   lambda[i] += texUnit->LodBias;
  3689.                }
  3690.             }
  3691.  
  3692.             if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
  3693.                /* apply LOD clamping to lambda */
  3694.                const GLfloat min = curObj->MinLod;
  3695.                const GLfloat max = curObj->MaxLod;
  3696.                GLuint i;
  3697.                for (i = 0; i < span->end; i++) {
  3698.                   GLfloat l = lambda[i];
  3699.                   lambda[i] = CLAMP(l, min, max);
  3700.                }
  3701.             }
  3702.          }
  3703.  
  3704.          /* Sample the texture (span->end fragments) */
  3705.          swrast->TextureSample[unit]( ctx, unit, texUnit->_Current,
  3706.                                       span->end, span->array->texcoords[unit],
  3707.                                       lambda, texels );
  3708.       }
  3709.    }
  3710.  
  3711.    /*
  3712.     * OK, now apply the texture (aka texture combine/blend).
  3713.     * We modify the span->color.rgba values.
  3714.     */
  3715.    for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
  3716.       if (ctx->Texture.Unit[unit]._ReallyEnabled) {
  3717.          const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
  3718.          if (texUnit->EnvMode == GL_COMBINE_EXT) {
  3719.             /* GL_ARB/EXT_texture_env_combine */
  3720.             texture_combine( ctx, unit, span->end,
  3721.                              (CONST GLchan (*)[4]) primary_rgba,
  3722.                              swrast->TexelBuffer,
  3723.                              span->array->rgba );
  3724.          }
  3725.          else if (texUnit->EnvMode == GL_COMBINE4_NV) {
  3726.             /* GL_NV_texture_env_combine4 */
  3727.             texture_combine4( ctx, unit, span->end,
  3728.                               (CONST GLchan (*)[4]) primary_rgba,
  3729.                               swrast->TexelBuffer,
  3730.                               span->array->rgba );
  3731.          }
  3732.          else {
  3733.             /* conventional texture blend */
  3734.             const GLchan (*texels)[4] = (const GLchan (*)[4])
  3735.                (swrast->TexelBuffer + unit *
  3736.                 (span->end * 4 * sizeof(GLchan)));
  3737.             texture_apply( ctx, texUnit, span->end,
  3738.                            (CONST GLchan (*)[4]) primary_rgba, texels,
  3739.                            span->array->rgba );
  3740.          }
  3741.       }
  3742.    }
  3743. }
  3744.