ReactOS Development > Doxygen

00001 /*
00002  * Mesa 3-D graphics library
00003  * Version:  6.3
00004  *
00005  * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
00006  *
00007  * Permission is hereby granted, free of charge, to any person obtaining a
00008  * copy of this software and associated documentation files (the "Software"),
00009  * to deal in the Software without restriction, including without limitation
00010  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
00011  * and/or sell copies of the Software, and to permit persons to whom the
00012  * Software is furnished to do so, subject to the following conditions:
00013  *
00014  * The above copyright notice and this permission notice shall be included
00015  * in all copies or substantial portions of the Software.
00016  *
00017  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
00018  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00019  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
00020  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
00021  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
00022  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00023  */
00024 
00025 
00026 #include "glheader.h"
00027 #include "bufferobj.h"
00028 #include "colormac.h"
00029 #include "context.h"
00030 #include "image.h"
00031 #include "histogram.h"
00032 
00033 
00034 
00035 /*
00036  * XXX the packed pixel formats haven't been tested.
00037  */
00038 static void
00039 pack_histogram( GLcontext *ctx,
00040                 GLuint n, CONST GLuint rgba[][4],
00041                 GLenum format, GLenum type, GLvoid *destination,
00042                 const struct gl_pixelstore_attrib *packing )
00043 {
00044    const GLint comps = _mesa_components_in_format(format);
00045    GLuint luminance[MAX_WIDTH];
00046 
00047    if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) {
00048       GLuint i;
00049       for (i = 0; i < n; i++) {
00050          luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
00051       }
00052    }
00053 
00054 #define PACK_MACRO(TYPE)                    \
00055    {                                \
00056       GLuint i;                         \
00057       switch (format) {                     \
00058          case GL_RED:                       \
00059             for (i=0;i<n;i++)                   \
00060                dst[i] = (TYPE) rgba[i][RCOMP];          \
00061             break;                      \
00062          case GL_GREEN:                     \
00063             for (i=0;i<n;i++)                   \
00064                dst[i] = (TYPE) rgba[i][GCOMP];          \
00065             break;                      \
00066          case GL_BLUE:                      \
00067             for (i=0;i<n;i++)                   \
00068                dst[i] = (TYPE) rgba[i][BCOMP];          \
00069             break;                      \
00070          case GL_ALPHA:                     \
00071             for (i=0;i<n;i++)                   \
00072                dst[i] = (TYPE) rgba[i][ACOMP];          \
00073             break;                      \
00074          case GL_LUMINANCE:                 \
00075             for (i=0;i<n;i++)                   \
00076                dst[i] = (TYPE) luminance[i];            \
00077             break;                      \
00078          case GL_LUMINANCE_ALPHA:               \
00079             for (i=0;i<n;i++) {                 \
00080                dst[i*2+0] = (TYPE) luminance[i];        \
00081                dst[i*2+1] = (TYPE) rgba[i][ACOMP];      \
00082             }                           \
00083             break;                      \
00084          case GL_RGB:                       \
00085             for (i=0;i<n;i++) {                 \
00086                dst[i*3+0] = (TYPE) rgba[i][RCOMP];      \
00087                dst[i*3+1] = (TYPE) rgba[i][GCOMP];      \
00088                dst[i*3+2] = (TYPE) rgba[i][BCOMP];      \
00089             }                           \
00090             break;                      \
00091          case GL_RGBA:                      \
00092             for (i=0;i<n;i++) {                 \
00093                dst[i*4+0] = (TYPE) rgba[i][RCOMP];      \
00094                dst[i*4+1] = (TYPE) rgba[i][GCOMP];      \
00095                dst[i*4+2] = (TYPE) rgba[i][BCOMP];      \
00096                dst[i*4+3] = (TYPE) rgba[i][ACOMP];      \
00097             }                           \
00098             break;                      \
00099          case GL_BGR:                       \
00100             for (i=0;i<n;i++) {                 \
00101                dst[i*3+0] = (TYPE) rgba[i][BCOMP];      \
00102                dst[i*3+1] = (TYPE) rgba[i][GCOMP];      \
00103                dst[i*3+2] = (TYPE) rgba[i][RCOMP];      \
00104             }                           \
00105             break;                      \
00106          case GL_BGRA:                      \
00107             for (i=0;i<n;i++) {                 \
00108                dst[i*4+0] = (TYPE) rgba[i][BCOMP];      \
00109                dst[i*4+1] = (TYPE) rgba[i][GCOMP];      \
00110                dst[i*4+2] = (TYPE) rgba[i][RCOMP];      \
00111                dst[i*4+3] = (TYPE) rgba[i][ACOMP];      \
00112             }                           \
00113             break;                      \
00114          case GL_ABGR_EXT:                  \
00115             for (i=0;i<n;i++) {                 \
00116                dst[i*4+0] = (TYPE) rgba[i][ACOMP];      \
00117                dst[i*4+1] = (TYPE) rgba[i][BCOMP];      \
00118                dst[i*4+2] = (TYPE) rgba[i][GCOMP];      \
00119                dst[i*4+3] = (TYPE) rgba[i][RCOMP];      \
00120             }                           \
00121             break;                      \
00122          default:                       \
00123             _mesa_problem(ctx, "bad format in pack_histogram"); \
00124       }                             \
00125    }
00126 
00127    switch (type) {
00128       case GL_UNSIGNED_BYTE:
00129          {
00130             GLubyte *dst = (GLubyte *) destination;
00131             PACK_MACRO(GLubyte);
00132          }
00133          break;
00134       case GL_BYTE:
00135          {
00136             GLbyte *dst = (GLbyte *) destination;
00137             PACK_MACRO(GLbyte);
00138          }
00139          break;
00140       case GL_UNSIGNED_SHORT:
00141          {
00142             GLushort *dst = (GLushort *) destination;
00143             PACK_MACRO(GLushort);
00144             if (packing->SwapBytes) {
00145                _mesa_swap2(dst, n * comps);
00146             }
00147          }
00148          break;
00149       case GL_SHORT:
00150          {
00151             GLshort *dst = (GLshort *) destination;
00152             PACK_MACRO(GLshort);
00153             if (packing->SwapBytes) {
00154                _mesa_swap2((GLushort *) dst, n * comps);
00155             }
00156          }
00157          break;
00158       case GL_UNSIGNED_INT:
00159          {
00160             GLuint *dst = (GLuint *) destination;
00161             PACK_MACRO(GLuint);
00162             if (packing->SwapBytes) {
00163                _mesa_swap4(dst, n * comps);
00164             }
00165          }
00166          break;
00167       case GL_INT:
00168          {
00169             GLint *dst = (GLint *) destination;
00170             PACK_MACRO(GLint);
00171             if (packing->SwapBytes) {
00172                _mesa_swap4((GLuint *) dst, n * comps);
00173             }
00174          }
00175          break;
00176       case GL_FLOAT:
00177          {
00178             GLfloat *dst = (GLfloat *) destination;
00179             PACK_MACRO(GLfloat);
00180             if (packing->SwapBytes) {
00181                _mesa_swap4((GLuint *) dst, n * comps);
00182             }
00183          }
00184          break;
00185       case GL_HALF_FLOAT_ARB:
00186          {
00187             /* temporarily store as GLuints */
00188             GLuint temp[4*HISTOGRAM_TABLE_SIZE];
00189             GLhalfARB *dst = (GLhalfARB *) destination;
00190             GLuint i;
00191             /* get GLuint values */
00192             PACK_MACRO(GLuint);
00193             /* convert to GLhalf */
00194             for (i = 0; i < n * comps; i++) {
00195                dst[i] = _mesa_float_to_half((GLfloat) temp[i]);
00196             }
00197             if (packing->SwapBytes) {
00198                _mesa_swap2((GLushort *) dst, n * comps);
00199             }
00200          }
00201          break;
00202       case GL_UNSIGNED_BYTE_3_3_2:
00203          if (format == GL_RGB) {
00204             GLubyte *dst = (GLubyte *) destination;
00205             GLuint i;
00206             for (i = 0; i < n; i++) {
00207                dst[i] = ((rgba[i][RCOMP] & 0x7) << 5)
00208                       | ((rgba[i][GCOMP] & 0x7) << 2)
00209                       | ((rgba[i][BCOMP] & 0x3)     );
00210             }
00211          }
00212          else {
00213             GLubyte *dst = (GLubyte *) destination;
00214             GLuint i;
00215             ASSERT(format == GL_BGR);
00216             for (i = 0; i < n; i++) {
00217                dst[i] = ((rgba[i][BCOMP] & 0x7) << 5)
00218                       | ((rgba[i][GCOMP] & 0x7) << 2)
00219                       | ((rgba[i][RCOMP] & 0x3)     );
00220             }
00221          }
00222          break;
00223       case GL_UNSIGNED_BYTE_2_3_3_REV:
00224          if (format == GL_RGB) {
00225             GLubyte *dst = (GLubyte *) destination;
00226             GLuint i;
00227             for (i = 0; i < n; i++) {
00228                dst[i] = ((rgba[i][RCOMP] & 0x3) << 6)
00229                       | ((rgba[i][GCOMP] & 0x7) << 3)
00230                       | ((rgba[i][BCOMP] & 0x7)     );
00231             }
00232          }
00233          else {
00234             GLubyte *dst = (GLubyte *) destination;
00235             GLuint i;
00236             ASSERT(format == GL_BGR);
00237             for (i = 0; i < n; i++) {
00238                dst[i] = ((rgba[i][BCOMP] & 0x3) << 6)
00239                       | ((rgba[i][GCOMP] & 0x7) << 3)
00240                       | ((rgba[i][RCOMP] & 0x7)     );
00241             }
00242          }
00243          break;
00244       case GL_UNSIGNED_SHORT_5_6_5:
00245          if (format == GL_RGB) {
00246             GLushort *dst = (GLushort *) destination;
00247             GLuint i;
00248             for (i = 0; i < n; i++) {
00249                dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
00250                       | ((rgba[i][GCOMP] & 0x3f) <<  5)
00251                       | ((rgba[i][BCOMP] & 0x1f)      );
00252             }
00253          }
00254          else {
00255             GLushort *dst = (GLushort *) destination;
00256             GLuint i;
00257             ASSERT(format == GL_BGR);
00258             for (i = 0; i < n; i++) {
00259                dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11)
00260                       | ((rgba[i][GCOMP] & 0x3f) <<  5)
00261                       | ((rgba[i][RCOMP] & 0x1f)      );
00262             }
00263          }
00264          break;
00265       case GL_UNSIGNED_SHORT_5_6_5_REV:
00266          if (format == GL_RGB) {
00267             GLushort *dst = (GLushort *) destination;
00268             GLuint i;
00269             for (i = 0; i < n; i++) {
00270                dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11)
00271                       | ((rgba[i][GCOMP] & 0x3f) <<  5)
00272                       | ((rgba[i][RCOMP] & 0x1f)      );
00273             }
00274          }
00275          else {
00276             GLushort *dst = (GLushort *) destination;
00277             GLuint i;
00278             ASSERT(format == GL_BGR);
00279             for (i = 0; i < n; i++) {
00280                dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
00281                       | ((rgba[i][GCOMP] & 0x3f) <<  5)
00282                       | ((rgba[i][BCOMP] & 0x1f)      );
00283             }
00284          }
00285          break;
00286       case GL_UNSIGNED_SHORT_4_4_4_4:
00287          if (format == GL_RGBA) {
00288             GLushort *dst = (GLushort *) destination;
00289             GLuint i;
00290             for (i = 0; i < n; i++) {
00291                dst[i] = ((rgba[i][RCOMP] & 0xf) << 12)
00292                       | ((rgba[i][GCOMP] & 0xf) <<  8)
00293                       | ((rgba[i][BCOMP] & 0xf) <<  4)
00294                       | ((rgba[i][ACOMP] & 0xf)      );
00295             }
00296          }
00297          else if (format == GL_BGRA) {
00298             GLushort *dst = (GLushort *) destination;
00299             GLuint i;
00300             for (i = 0; i < n; i++) {
00301                dst[i] = ((rgba[i][BCOMP] & 0xf) << 12)
00302                       | ((rgba[i][GCOMP] & 0xf) <<  8)
00303                       | ((rgba[i][RCOMP] & 0xf) <<  4)
00304                       | ((rgba[i][ACOMP] & 0xf)      );
00305             }
00306          }
00307          else {
00308             GLushort *dst = (GLushort *) destination;
00309             GLuint i;
00310             ASSERT(format == GL_ABGR_EXT);
00311             for (i = 0; i < n; i++) {
00312                dst[i] = ((rgba[i][ACOMP] & 0xf) << 12)
00313                       | ((rgba[i][BCOMP] & 0xf) <<  8)
00314                       | ((rgba[i][GCOMP] & 0xf) <<  4)
00315                       | ((rgba[i][RCOMP] & 0xf)      );
00316             }
00317          }
00318          break;
00319       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
00320          if (format == GL_RGBA) {
00321             GLushort *dst = (GLushort *) destination;
00322             GLuint i;
00323             for (i = 0; i < n; i++) {
00324                dst[i] = ((rgba[i][ACOMP] & 0xf) << 12)
00325                       | ((rgba[i][BCOMP] & 0xf) <<  8)
00326                       | ((rgba[i][GCOMP] & 0xf) <<  4)
00327                       | ((rgba[i][RCOMP] & 0xf)      );
00328             }
00329          }
00330          else if (format == GL_BGRA) {
00331             GLushort *dst = (GLushort *) destination;
00332             GLuint i;
00333             for (i = 0; i < n; i++) {
00334                dst[i] = ((rgba[i][ACOMP] & 0xf) << 12)
00335                       | ((rgba[i][RCOMP] & 0xf) <<  8)
00336                       | ((rgba[i][GCOMP] & 0xf) <<  4)
00337                       | ((rgba[i][BCOMP] & 0xf)      );
00338             }
00339          }
00340          else {
00341             GLushort *dst = (GLushort *) destination;
00342             GLuint i;
00343             ASSERT(format == GL_ABGR_EXT);
00344             for (i = 0; i < n; i++) {
00345                dst[i] = ((rgba[i][RCOMP] & 0xf) << 12)
00346                       | ((rgba[i][GCOMP] & 0xf) <<  8)
00347                       | ((rgba[i][BCOMP] & 0xf) <<  4)
00348                       | ((rgba[i][ACOMP] & 0xf)      );
00349             }
00350          }
00351          break;
00352       case GL_UNSIGNED_SHORT_5_5_5_1:
00353          if (format == GL_RGBA) {
00354             GLushort *dst = (GLushort *) destination;
00355             GLuint i;
00356             for (i = 0; i < n; i++) {
00357                dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
00358                       | ((rgba[i][GCOMP] & 0x1f) <<  6)
00359                       | ((rgba[i][BCOMP] & 0x1f) <<  1)
00360                       | ((rgba[i][ACOMP] & 0x1)       );
00361             }
00362          }
00363          else if (format == GL_BGRA) {
00364             GLushort *dst = (GLushort *) destination;
00365             GLuint i;
00366             for (i = 0; i < n; i++) {
00367                dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11)
00368                       | ((rgba[i][GCOMP] & 0x1f) <<  6)
00369                       | ((rgba[i][RCOMP] & 0x1f) <<  1)
00370                       | ((rgba[i][ACOMP] & 0x1)       );
00371             }
00372          }
00373          else {
00374             GLushort *dst = (GLushort *) destination;
00375             GLuint i;
00376             ASSERT(format == GL_ABGR_EXT);
00377             for (i = 0; i < n; i++) {
00378                dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11)
00379                       | ((rgba[i][BCOMP] & 0x1f) <<  6)
00380                       | ((rgba[i][GCOMP] & 0x1f) <<  1)
00381                       | ((rgba[i][RCOMP] & 0x1)       );
00382             }
00383          }
00384          break;
00385       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
00386          if (format == GL_RGBA) {
00387             GLushort *dst = (GLushort *) destination;
00388             GLuint i;
00389             for (i = 0; i < n; i++) {
00390                dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11)
00391                       | ((rgba[i][BCOMP] & 0x1f) <<  6)
00392                       | ((rgba[i][GCOMP] & 0x1f) <<  1)
00393                       | ((rgba[i][RCOMP] & 0x1)       );
00394             }
00395          }
00396          else if (format == GL_BGRA) {
00397             GLushort *dst = (GLushort *) destination;
00398             GLuint i;
00399             for (i = 0; i < n; i++) {
00400                dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11)
00401                       | ((rgba[i][RCOMP] & 0x1f) <<  6)
00402                       | ((rgba[i][GCOMP] & 0x1f) <<  1)
00403                       | ((rgba[i][BCOMP] & 0x1)       );
00404             }
00405          }
00406          else {
00407             GLushort *dst = (GLushort *) destination;
00408             GLuint i;
00409             ASSERT(format == GL_ABGR_EXT);
00410             for (i = 0; i < n; i++) {
00411                dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
00412                       | ((rgba[i][GCOMP] & 0x1f) <<  6)
00413                       | ((rgba[i][BCOMP] & 0x1f) <<  1)
00414                       | ((rgba[i][ACOMP] & 0x1)       );
00415             }
00416          }
00417          break;
00418       case GL_UNSIGNED_INT_8_8_8_8:
00419          if (format == GL_RGBA) {
00420             GLuint *dst = (GLuint *) destination;
00421             GLuint i;
00422             for (i = 0; i < n; i++) {
00423                dst[i] = ((rgba[i][RCOMP] & 0xff) << 24)
00424                       | ((rgba[i][GCOMP] & 0xff) << 16)
00425                       | ((rgba[i][BCOMP] & 0xff) <<  8)
00426                       | ((rgba[i][ACOMP] & 0xff)      );
00427             }
00428          }
00429          else if (format == GL_BGRA) {
00430             GLuint *dst = (GLuint *) destination;
00431             GLuint i;
00432             for (i = 0; i < n; i++) {
00433                dst[i] = ((rgba[i][BCOMP] & 0xff) << 24)
00434                       | ((rgba[i][GCOMP] & 0xff) << 16)
00435                       | ((rgba[i][RCOMP] & 0xff) <<  8)
00436                       | ((rgba[i][ACOMP] & 0xff)      );
00437             }
00438          }
00439          else {
00440             GLuint *dst = (GLuint *) destination;
00441             GLuint i;
00442             ASSERT(format == GL_ABGR_EXT);
00443             for (i = 0; i < n; i++) {
00444                dst[i] = ((rgba[i][ACOMP] & 0xff) << 24)
00445                       | ((rgba[i][BCOMP] & 0xff) << 16)
00446                       | ((rgba[i][GCOMP] & 0xff) <<  8)
00447                       | ((rgba[i][RCOMP] & 0xff)      );
00448             }
00449          }
00450          break;
00451       case GL_UNSIGNED_INT_8_8_8_8_REV:
00452          if (format == GL_RGBA) {
00453             GLuint *dst = (GLuint *) destination;
00454             GLuint i;
00455             for (i = 0; i < n; i++) {
00456                dst[i] = ((rgba[i][ACOMP] & 0xff) << 24)
00457                       | ((rgba[i][BCOMP] & 0xff) << 16)
00458                       | ((rgba[i][GCOMP] & 0xff) <<  8)
00459                       | ((rgba[i][RCOMP] & 0xff)      );
00460             }
00461          }
00462          else if (format == GL_BGRA) {
00463             GLuint *dst = (GLuint *) destination;
00464             GLuint i;
00465             for (i = 0; i < n; i++) {
00466                dst[i] = ((rgba[i][ACOMP] & 0xff) << 24)
00467                       | ((rgba[i][RCOMP] & 0xff) << 16)
00468                       | ((rgba[i][GCOMP] & 0xff) <<  8)
00469                       | ((rgba[i][BCOMP] & 0xff)      );
00470             }
00471          }
00472          else {
00473             GLuint *dst = (GLuint *) destination;
00474             GLuint i;
00475             ASSERT(format == GL_ABGR_EXT);
00476             for (i = 0; i < n; i++) {
00477                dst[i] = ((rgba[i][RCOMP] & 0xff) << 24)
00478                       | ((rgba[i][GCOMP] & 0xff) << 16)
00479                       | ((rgba[i][BCOMP] & 0xff) <<  8)
00480                       | ((rgba[i][ACOMP] & 0xff)      );
00481             }
00482          }
00483          break;
00484       case GL_UNSIGNED_INT_10_10_10_2:
00485          if (format == GL_RGBA) {
00486             GLuint *dst = (GLuint *) destination;
00487             GLuint i;
00488             for (i = 0; i < n; i++) {
00489                dst[i] = ((rgba[i][RCOMP] & 0x3ff) << 22)
00490                       | ((rgba[i][GCOMP] & 0x3ff) << 12)
00491                       | ((rgba[i][BCOMP] & 0x3ff) <<  2)
00492                       | ((rgba[i][ACOMP] & 0x3)        );
00493             }
00494          }
00495          else if (format == GL_BGRA) {
00496             GLuint *dst = (GLuint *) destination;
00497             GLuint i;
00498             for (i = 0; i < n; i++) {
00499                dst[i] = ((rgba[i][BCOMP] & 0x3ff) << 22)
00500                       | ((rgba[i][GCOMP] & 0x3ff) << 12)
00501                       | ((rgba[i][RCOMP] & 0x3ff) <<  2)
00502                       | ((rgba[i][ACOMP] & 0x3)        );
00503             }
00504          }
00505          else {
00506             GLuint *dst = (GLuint *) destination;
00507             GLuint i;
00508             ASSERT(format == GL_ABGR_EXT);
00509             for (i = 0; i < n; i++) {
00510                dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22)
00511                       | ((rgba[i][BCOMP] & 0x3ff) << 12)
00512                       | ((rgba[i][GCOMP] & 0x3ff) <<  2)
00513                       | ((rgba[i][RCOMP] & 0x3)        );
00514             }
00515          }
00516          break;
00517       case GL_UNSIGNED_INT_2_10_10_10_REV:
00518          if (format == GL_RGBA) {
00519             GLuint *dst = (GLuint *) destination;
00520             GLuint i;
00521             for (i = 0; i < n; i++) {
00522                dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22)
00523                       | ((rgba[i][BCOMP] & 0x3ff) << 12)
00524                       | ((rgba[i][GCOMP] & 0x3ff) <<  2)
00525                       | ((rgba[i][RCOMP] & 0x3)        );
00526             }
00527          }
00528          else if (format == GL_BGRA) {
00529             GLuint *dst = (GLuint *) destination;
00530             GLuint i;
00531             for (i = 0; i < n; i++) {
00532                dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22)
00533                       | ((rgba[i][RCOMP] & 0x3ff) << 12)
00534                       | ((rgba[i][GCOMP] & 0x3ff) <<  2)
00535                       | ((rgba[i][BCOMP] & 0x3)        );
00536             }
00537          }
00538          else {
00539             GLuint *dst = (GLuint *) destination;
00540             GLuint i;
00541             ASSERT(format == GL_ABGR_EXT);
00542             for (i = 0; i < n; i++) {
00543                dst[i] = ((rgba[i][RCOMP] & 0x3ff) << 22)
00544                       | ((rgba[i][GCOMP] & 0x3ff) << 12)
00545                       | ((rgba[i][BCOMP] & 0x3ff) <<  2)
00546                       | ((rgba[i][ACOMP] & 0x3)        );
00547             }
00548          }
00549          break;
00550       default:
00551          _mesa_problem(ctx, "Bad type in pack_histogram");
00552    }
00553 
00554 #undef PACK_MACRO
00555 }
00556 
00557 
00558 /*
00559  * Given an internalFormat token passed to glHistogram or glMinMax,
00560  * return the corresponding base format.
00561  * Return -1 if invalid token.
00562  */
00563 static GLint
00564 base_histogram_format( GLenum format )
00565 {
00566    switch (format) {
00567       case GL_ALPHA:
00568       case GL_ALPHA4:
00569       case GL_ALPHA8:
00570       case GL_ALPHA12:
00571       case GL_ALPHA16:
00572          return GL_ALPHA;
00573       case GL_LUMINANCE:
00574       case GL_LUMINANCE4:
00575       case GL_LUMINANCE8:
00576       case GL_LUMINANCE12:
00577       case GL_LUMINANCE16:
00578          return GL_LUMINANCE;
00579       case GL_LUMINANCE_ALPHA:
00580       case GL_LUMINANCE4_ALPHA4:
00581       case GL_LUMINANCE6_ALPHA2:
00582       case GL_LUMINANCE8_ALPHA8:
00583       case GL_LUMINANCE12_ALPHA4:
00584       case GL_LUMINANCE12_ALPHA12:
00585       case GL_LUMINANCE16_ALPHA16:
00586          return GL_LUMINANCE_ALPHA;
00587       case GL_RGB:
00588       case GL_R3_G3_B2:
00589       case GL_RGB4:
00590       case GL_RGB5:
00591       case GL_RGB8:
00592       case GL_RGB10:
00593       case GL_RGB12:
00594       case GL_RGB16:
00595          return GL_RGB;
00596       case GL_RGBA:
00597       case GL_RGBA2:
00598       case GL_RGBA4:
00599       case GL_RGB5_A1:
00600       case GL_RGBA8:
00601       case GL_RGB10_A2:
00602       case GL_RGBA12:
00603       case GL_RGBA16:
00604          return GL_RGBA;
00605       default:
00606          return -1;  /* error */
00607    }
00608 }
00609 
00610 
00611 
00612 /**********************************************************************
00613  * API functions
00614  */
00615 
00616 
00617 void GLAPIENTRY
00618 _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
00619 {
00620    GET_CURRENT_CONTEXT(ctx);
00621    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
00622 
00623    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00624       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmax");
00625       return;
00626    }
00627 
00628    if (target != GL_MINMAX) {
00629       _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmax(target)");
00630       return;
00631    }
00632 
00633    if (format != GL_RED &&
00634        format != GL_GREEN &&
00635        format != GL_BLUE &&
00636        format != GL_ALPHA &&
00637        format != GL_RGB &&
00638        format != GL_BGR &&
00639        format != GL_RGBA &&
00640        format != GL_BGRA &&
00641        format != GL_ABGR_EXT &&
00642        format != GL_LUMINANCE &&
00643        format != GL_LUMINANCE_ALPHA) {
00644       _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMax(format)");
00645    }
00646 
00647    if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
00648       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmax(format or type)");
00649       return;
00650    }
00651 
00652    if (ctx->Pack.BufferObj->Name) {
00653       /* pack min/max values into a PBO */
00654       GLubyte *buf;
00655       if (!_mesa_validate_pbo_access(1, &ctx->Pack, 2, 1, 1,
00656                                      format, type, values)) {
00657          _mesa_error(ctx, GL_INVALID_OPERATION,
00658                      "glGetMinMax(invalid PBO access)");
00659          return;
00660       }
00661       buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
00662                                               GL_WRITE_ONLY_ARB,
00663                                               ctx->Pack.BufferObj);
00664       if (!buf) {
00665          /* buffer is already mapped - that's an error */
00666          _mesa_error(ctx, GL_INVALID_OPERATION,"glGetMinMax(PBO is mapped)");
00667          return;
00668       }
00669       values = ADD_POINTERS(buf, values);
00670    }
00671    else if (!values) {
00672       /* not an error */
00673       return;
00674    }
00675 
00676    {
00677       GLfloat minmax[2][4];
00678       minmax[0][RCOMP] = CLAMP(ctx->MinMax.Min[RCOMP], 0.0F, 1.0F);
00679       minmax[0][GCOMP] = CLAMP(ctx->MinMax.Min[GCOMP], 0.0F, 1.0F);
00680       minmax[0][BCOMP] = CLAMP(ctx->MinMax.Min[BCOMP], 0.0F, 1.0F);
00681       minmax[0][ACOMP] = CLAMP(ctx->MinMax.Min[ACOMP], 0.0F, 1.0F);
00682       minmax[1][RCOMP] = CLAMP(ctx->MinMax.Max[RCOMP], 0.0F, 1.0F);
00683       minmax[1][GCOMP] = CLAMP(ctx->MinMax.Max[GCOMP], 0.0F, 1.0F);
00684       minmax[1][BCOMP] = CLAMP(ctx->MinMax.Max[BCOMP], 0.0F, 1.0F);
00685       minmax[1][ACOMP] = CLAMP(ctx->MinMax.Max[ACOMP], 0.0F, 1.0F);
00686       _mesa_pack_rgba_span_float(ctx, 2, minmax,
00687                                  format, type, values, &ctx->Pack, 0x0);
00688    }
00689 
00690    if (ctx->Pack.BufferObj->Name) {
00691       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
00692                               ctx->Pack.BufferObj);
00693    }
00694 
00695    if (reset) {
00696       _mesa_ResetMinmax(GL_MINMAX);
00697    }
00698 }
00699 
00700 
00701 void GLAPIENTRY
00702 _mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
00703 {
00704    GET_CURRENT_CONTEXT(ctx);
00705    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
00706 
00707    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00708       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogram");
00709       return;
00710    }
00711 
00712    if (target != GL_HISTOGRAM) {
00713       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogram(target)");
00714       return;
00715    }
00716 
00717    if (format != GL_RED &&
00718        format != GL_GREEN &&
00719        format != GL_BLUE &&
00720        format != GL_ALPHA &&
00721        format != GL_RGB &&
00722        format != GL_BGR &&
00723        format != GL_RGBA &&
00724        format != GL_BGRA &&
00725        format != GL_ABGR_EXT &&
00726        format != GL_LUMINANCE &&
00727        format != GL_LUMINANCE_ALPHA) {
00728       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogram(format)");
00729    }
00730 
00731    if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
00732       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogram(format or type)");
00733       return;
00734    }
00735 
00736    if (ctx->Pack.BufferObj->Name) {
00737       /* pack min/max values into a PBO */
00738       GLubyte *buf;
00739       if (!_mesa_validate_pbo_access(1, &ctx->Pack, ctx->Histogram.Width, 1, 1,
00740                                      format, type, values)) {
00741          _mesa_error(ctx, GL_INVALID_OPERATION,
00742                      "glGetHistogram(invalid PBO access)");
00743          return;
00744       }
00745       buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
00746                                               GL_WRITE_ONLY_ARB,
00747                                               ctx->Pack.BufferObj);
00748       if (!buf) {
00749          /* buffer is already mapped - that's an error */
00750          _mesa_error(ctx,GL_INVALID_OPERATION,"glGetHistogram(PBO is mapped)");
00751          return;
00752       }
00753       values = ADD_POINTERS(buf, values);
00754    }
00755    else if (!values) {
00756       /* not an error */
00757       return;
00758    }
00759 
00760    pack_histogram(ctx, ctx->Histogram.Width,
00761                   (CONST GLuint (*)[4]) ctx->Histogram.Count,
00762                   format, type, values, &ctx->Pack);
00763 
00764    if (ctx->Pack.BufferObj->Name) {
00765       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
00766                               ctx->Pack.BufferObj);
00767    }
00768 
00769    if (reset) {
00770       GLuint i;
00771       for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
00772          ctx->Histogram.Count[i][0] = 0;
00773          ctx->Histogram.Count[i][1] = 0;
00774          ctx->Histogram.Count[i][2] = 0;
00775          ctx->Histogram.Count[i][3] = 0;
00776       }
00777    }
00778 }
00779 
00780 
00781 void GLAPIENTRY
00782 _mesa_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
00783 {
00784    GET_CURRENT_CONTEXT(ctx);
00785    ASSERT_OUTSIDE_BEGIN_END(ctx);
00786 
00787    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00788       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogramParameterfv");
00789       return;
00790    }
00791 
00792    if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
00793       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(target)");
00794       return;
00795    }
00796 
00797    switch (pname) {
00798       case GL_HISTOGRAM_WIDTH:
00799          *params = (GLfloat) ctx->Histogram.Width;
00800          break;
00801       case GL_HISTOGRAM_FORMAT:
00802          *params = (GLfloat) ctx->Histogram.Format;
00803          break;
00804       case GL_HISTOGRAM_RED_SIZE:
00805          *params = (GLfloat) ctx->Histogram.RedSize;
00806          break;
00807       case GL_HISTOGRAM_GREEN_SIZE:
00808          *params = (GLfloat) ctx->Histogram.GreenSize;
00809          break;
00810       case GL_HISTOGRAM_BLUE_SIZE:
00811          *params = (GLfloat) ctx->Histogram.BlueSize;
00812          break;
00813       case GL_HISTOGRAM_ALPHA_SIZE:
00814          *params = (GLfloat) ctx->Histogram.AlphaSize;
00815          break;
00816       case GL_HISTOGRAM_LUMINANCE_SIZE:
00817          *params = (GLfloat) ctx->Histogram.LuminanceSize;
00818          break;
00819       case GL_HISTOGRAM_SINK:
00820          *params = (GLfloat) ctx->Histogram.Sink;
00821          break;
00822       default:
00823          _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(pname)");
00824    }
00825 }
00826 
00827 
00828 void GLAPIENTRY
00829 _mesa_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
00830 {
00831    GET_CURRENT_CONTEXT(ctx);
00832    ASSERT_OUTSIDE_BEGIN_END(ctx);
00833 
00834    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00835       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogramParameteriv");
00836       return;
00837    }
00838 
00839    if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
00840       _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(target)");
00841       return;
00842    }
00843 
00844    switch (pname) {
00845       case GL_HISTOGRAM_WIDTH:
00846          *params = (GLint) ctx->Histogram.Width;
00847          break;
00848       case GL_HISTOGRAM_FORMAT:
00849          *params = (GLint) ctx->Histogram.Format;
00850          break;
00851       case GL_HISTOGRAM_RED_SIZE:
00852          *params = (GLint) ctx->Histogram.RedSize;
00853          break;
00854       case GL_HISTOGRAM_GREEN_SIZE:
00855          *params = (GLint) ctx->Histogram.GreenSize;
00856          break;
00857       case GL_HISTOGRAM_BLUE_SIZE:
00858          *params = (GLint) ctx->Histogram.BlueSize;
00859          break;
00860       case GL_HISTOGRAM_ALPHA_SIZE:
00861          *params = (GLint) ctx->Histogram.AlphaSize;
00862          break;
00863       case GL_HISTOGRAM_LUMINANCE_SIZE:
00864          *params = (GLint) ctx->Histogram.LuminanceSize;
00865          break;
00866       case GL_HISTOGRAM_SINK:
00867          *params = (GLint) ctx->Histogram.Sink;
00868          break;
00869       default:
00870          _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(pname)");
00871    }
00872 }
00873 
00874 
00875 void GLAPIENTRY
00876 _mesa_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
00877 {
00878    GET_CURRENT_CONTEXT(ctx);
00879    ASSERT_OUTSIDE_BEGIN_END(ctx);
00880 
00881    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00882       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmaxParameterfv");
00883       return;
00884    }
00885    if (target != GL_MINMAX) {
00886       _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameterfv(target)");
00887       return;
00888    }
00889    if (pname == GL_MINMAX_FORMAT) {
00890       *params = (GLfloat) ctx->MinMax.Format;
00891    }
00892    else if (pname == GL_MINMAX_SINK) {
00893       *params = (GLfloat) ctx->MinMax.Sink;
00894    }
00895    else {
00896       _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameterfv(pname)");
00897    }
00898 }
00899 
00900 
00901 void GLAPIENTRY
00902 _mesa_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
00903 {
00904    GET_CURRENT_CONTEXT(ctx);
00905    ASSERT_OUTSIDE_BEGIN_END(ctx);
00906 
00907    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00908       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmaxParameteriv");
00909       return;
00910    }
00911    if (target != GL_MINMAX) {
00912       _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameteriv(target)");
00913       return;
00914    }
00915    if (pname == GL_MINMAX_FORMAT) {
00916       *params = (GLint) ctx->MinMax.Format;
00917    }
00918    else if (pname == GL_MINMAX_SINK) {
00919       *params = (GLint) ctx->MinMax.Sink;
00920    }
00921    else {
00922       _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameteriv(pname)");
00923    }
00924 }
00925 
00926 
00927 void GLAPIENTRY
00928 _mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
00929 {
00930    GLuint i;
00931    GLboolean error = GL_FALSE;
00932    GET_CURRENT_CONTEXT(ctx);
00933    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */
00934 
00935    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
00936       _mesa_error(ctx, GL_INVALID_OPERATION, "glHistogram");
00937       return;
00938    }
00939 
00940    if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
00941       _mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(target)");
00942       return;
00943    }
00944 
00945    if (width < 0 || width > HISTOGRAM_TABLE_SIZE) {
00946       if (target == GL_PROXY_HISTOGRAM) {
00947          error = GL_TRUE;
00948       }
00949       else {
00950          if (width < 0)
00951             _mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
00952          else
00953             _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glHistogram(width)");
00954          return;
00955       }
00956    }
00957 
00958    if (width != 0 && !_mesa_is_pow_two(width)) {
00959       if (target == GL_PROXY_HISTOGRAM) {
00960          error = GL_TRUE;
00961       }
00962       else {
00963          _mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
00964          return;
00965       }
00966    }
00967 
00968    if (base_histogram_format(internalFormat) < 0) {
00969       if (target == GL_PROXY_HISTOGRAM) {
00970          error = GL_TRUE;
00971       }
00972       else {
00973          _mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(internalFormat)");
00974          return;
00975       }
00976    }
00977 
00978    /* reset histograms */
00979    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
00980       ctx->Histogram.Count[i][0] = 0;
00981       ctx->Histogram.Count[i][1] = 0;
00982       ctx->Histogram.Count[i][2] = 0;
00983       ctx->Histogram.Count[i][3] = 0;
00984    }
00985 
00986    if (error) {
00987       ctx->Histogram.Width = 0;
00988       ctx->Histogram.Format = 0;
00989       ctx->Histogram.RedSize       = 0;
00990       ctx->Histogram.GreenSize     = 0;
00991       ctx->Histogram.BlueSize      = 0;
00992       ctx->Histogram.AlphaSize     = 0;
00993       ctx->Histogram.LuminanceSize = 0;
00994    }
00995    else {
00996       ctx->Histogram.Width = width;
00997       ctx->Histogram.Format = internalFormat;
00998       ctx->Histogram.Sink = sink;
00999       ctx->Histogram.RedSize       = 8 * sizeof(GLuint);
01000       ctx->Histogram.GreenSize     = 8 * sizeof(GLuint);
01001       ctx->Histogram.BlueSize      = 8 * sizeof(GLuint);
01002       ctx->Histogram.AlphaSize     = 8 * sizeof(GLuint);
01003       ctx->Histogram.LuminanceSize = 8 * sizeof(GLuint);
01004    }
01005 
01006    ctx->NewState |= _NEW_PIXEL;
01007 }
01008 
01009 
01010 void GLAPIENTRY
01011 _mesa_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
01012 {
01013    GET_CURRENT_CONTEXT(ctx);
01014    ASSERT_OUTSIDE_BEGIN_END(ctx);
01015 
01016    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
01017       _mesa_error(ctx, GL_INVALID_OPERATION, "glMinmax");
01018       return;
01019    }
01020 
01021    if (target != GL_MINMAX) {
01022       _mesa_error(ctx, GL_INVALID_ENUM, "glMinMax(target)");
01023       return;
01024    }
01025 
01026    if (base_histogram_format(internalFormat) < 0) {
01027       _mesa_error(ctx, GL_INVALID_ENUM, "glMinMax(internalFormat)");
01028       return;
01029    }
01030 
01031    if (ctx->MinMax.Sink == sink)
01032       return;
01033    FLUSH_VERTICES(ctx, _NEW_PIXEL);
01034    ctx->MinMax.Sink = sink;
01035 }
01036 
01037 
01038 void GLAPIENTRY
01039 _mesa_ResetHistogram(GLenum target)
01040 {
01041    GLuint i;
01042    GET_CURRENT_CONTEXT(ctx);
01043    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */
01044 
01045    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
01046       _mesa_error(ctx, GL_INVALID_OPERATION, "glResetHistogram");
01047       return;
01048    }
01049 
01050    if (target != GL_HISTOGRAM) {
01051       _mesa_error(ctx, GL_INVALID_ENUM, "glResetHistogram(target)");
01052       return;
01053    }
01054 
01055    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
01056       ctx->Histogram.Count[i][0] = 0;
01057       ctx->Histogram.Count[i][1] = 0;
01058       ctx->Histogram.Count[i][2] = 0;
01059       ctx->Histogram.Count[i][3] = 0;
01060    }
01061 
01062    ctx->NewState |= _NEW_PIXEL;
01063 }
01064 
01065 
01066 void GLAPIENTRY
01067 _mesa_ResetMinmax(GLenum target)
01068 {
01069    GET_CURRENT_CONTEXT(ctx);
01070    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
01071 
01072    if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
01073       _mesa_error(ctx, GL_INVALID_OPERATION, "glResetMinmax");
01074       return;
01075    }
01076 
01077    if (target != GL_MINMAX) {
01078       _mesa_error(ctx, GL_INVALID_ENUM, "glResetMinMax(target)");
01079       return;
01080    }
01081 
01082    ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
01083    ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
01084    ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
01085    ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
01086    ctx->NewState |= _NEW_PIXEL;
01087 }
01088 
01089 
01090 
01091 /**********************************************************************/
01092 /*****                      Initialization                        *****/
01093 /**********************************************************************/
01094 
01095 void _mesa_init_histogram( GLcontext * ctx )
01096 {
01097    int i;
01098 
01099    /* Histogram group */
01100    ctx->Histogram.Width = 0;
01101    ctx->Histogram.Format = GL_RGBA;
01102    ctx->Histogram.Sink = GL_FALSE;
01103    ctx->Histogram.RedSize       = 0;
01104    ctx->Histogram.GreenSize     = 0;
01105    ctx->Histogram.BlueSize      = 0;
01106    ctx->Histogram.AlphaSize     = 0;
01107    ctx->Histogram.LuminanceSize = 0;
01108    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
01109       ctx->Histogram.Count[i][0] = 0;
01110       ctx->Histogram.Count[i][1] = 0;
01111       ctx->Histogram.Count[i][2] = 0;
01112       ctx->Histogram.Count[i][3] = 0;
01113    }
01114 
01115    /* Min/Max group */
01116    ctx->MinMax.Format = GL_RGBA;
01117    ctx->MinMax.Sink = GL_FALSE;
01118    ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
01119    ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
01120    ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
01121    ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
01122 }
Generated on Sun May 27 2012 04:20:18 for ReactOS by
1.7.6.1