Ignore:
Timestamp:
May 23, 2000, 10:41:28 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/pixel.c

    r2962 r3598  
    1 /* $Id: pixel.c,v 1.2 2000-03-01 18:49:33 jeroen Exp $ */
     1/* $Id: pixel.c,v 1.3 2000-05-23 20:40:45 jeroen Exp $ */
    22
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    3737#include "all.h"
    3838#else
    39 #ifndef XFree86Server
    40 #include <assert.h>
    41 #include <stdio.h>
    42 #include <stdlib.h>
    43 #else
    44 #include "GL/xf86glx.h"
    45 #endif
     39#include "glheader.h"
    4640#include "types.h"
    4741#include "context.h"
    4842#include "macros.h"
    4943#include "pixel.h"
     44#include "mem.h"
    5045#endif
    5146
    … …  
    5853
    5954
    60 void gl_PixelZoom( GLcontext *ctx, GLfloat xfactor, GLfloat yfactor )
    61 {
     55void
     56_mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
     57{
     58   GET_CURRENT_CONTEXT(ctx);
    6259   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelZoom");
    6360
    … …  
    7370
    7471
    75 void gl_PixelStorei( GLcontext *ctx, GLenum pname, GLint param )
     72void
     73_mesa_PixelStorei( GLenum pname, GLint param )
    7674{
    7775   /* NOTE: this call can't be compiled into the display list */
    78 
     76   GET_CURRENT_CONTEXT(ctx);
    7977   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelStore");
    80 
    8178
    8279   switch (pname) {
    8380      case GL_PACK_SWAP_BYTES:
    8481         ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
    85         break;
     82        break;
    8683      case GL_PACK_LSB_FIRST:
    8784         ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
    88         break;
     85        break;
    8986      case GL_PACK_ROW_LENGTH:
    90         if (param<0) {
    91             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    92         }
    93         else {
    94             ctx->Pack.RowLength = param;
    95         }
    96         break;
     87        if (param<0) {
     88            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     89        }
     90        else {
     91            ctx->Pack.RowLength = param;
     92        }
     93        break;
    9794      case GL_PACK_IMAGE_HEIGHT:
    9895         if (param<0)
    … …  
    10299         break;
    103100      case GL_PACK_SKIP_PIXELS:
    104         if (param<0) {
    105             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    106         }
    107         else {
    108             ctx->Pack.SkipPixels = param;
    109         }
    110         break;
     101        if (param<0) {
     102            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     103        }
     104        else {
     105            ctx->Pack.SkipPixels = param;
     106        }
     107        break;
    111108      case GL_PACK_SKIP_ROWS:
    112         if (param<0) {
    113             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    114         }
    115         else {
    116             ctx->Pack.SkipRows = param;
    117         }
    118         break;
     109        if (param<0) {
     110            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     111        }
     112        else {
     113            ctx->Pack.SkipRows = param;
     114        }
     115        break;
    119116      case GL_PACK_ALIGNMENT:
    120117         if (param==1 || param==2 || param==4 || param==8) {
    121             ctx->Pack.Alignment = param;
    122         }
    123         else {
    124             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    125         }
    126         break;
     118            ctx->Pack.Alignment = param;
     119        }
     120        else {
     121            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     122        }
     123        break;
    127124      case GL_UNPACK_SWAP_BYTES:
    128         ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
     125        ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
    129126         break;
    130127      case GL_UNPACK_LSB_FIRST:
    131         ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
    132         break;
     128        ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
     129        break;
    133130      case GL_UNPACK_ROW_LENGTH:
    134         if (param<0) {
    135             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    136         }
    137         else {
    138             ctx->Unpack.RowLength = param;
    139         }
    140         break;
     131        if (param<0) {
     132            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     133        }
     134        else {
     135            ctx->Unpack.RowLength = param;
     136        }
     137        break;
    141138      case GL_UNPACK_IMAGE_HEIGHT:
    142139         if (param<0)
    … …  
    146143         break;
    147144      case GL_UNPACK_SKIP_PIXELS:
    148         if (param<0) {
    149             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    150         }
    151         else {
    152             ctx->Unpack.SkipPixels = param;
    153         }
    154         break;
     145        if (param<0) {
     146            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     147        }
     148        else {
     149            ctx->Unpack.SkipPixels = param;
     150        }
     151        break;
    155152      case GL_UNPACK_SKIP_ROWS:
    156         if (param<0) {
    157             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
    158         }
    159         else {
    160             ctx->Unpack.SkipRows = param;
    161         }
    162         break;
     153        if (param<0) {
     154            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     155        }
     156        else {
     157            ctx->Unpack.SkipRows = param;
     158        }
     159        break;
    163160      case GL_UNPACK_ALIGNMENT:
    164161         if (param==1 || param==2 || param==4 || param==8) {
    165             ctx->Unpack.Alignment = param;
    166         }
    167         else {
    168             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
    169         }
    170         break;
     162            ctx->Unpack.Alignment = param;
     163        }
     164        else {
     165            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
     166        }
     167        break;
    171168      default:
    172          gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
    173    }
    174 }
    175 
    176 
     169         gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
     170   }
     171}
     172
     173
     174void
     175_mesa_PixelStoref( GLenum pname, GLfloat param )
     176{
     177   _mesa_PixelStorei( pname, (GLint) param );
     178}
    177179
    178180
    … …  
    184186
    185187
    186 void gl_PixelMapfv( GLcontext *ctx,
    187                     GLenum map, GLint mapsize, const GLfloat *values )
     188void
     189_mesa_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
    188190{
    189191   GLint i;
    190 
     192   GET_CURRENT_CONTEXT(ctx);
    191193   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelMapfv");
    192194
    … …  
    202204      GLboolean ok = GL_FALSE;
    203205      for (p=1; p<=MAX_PIXEL_MAP_TABLE; p=p<<1) {
    204         if ( (p&mapsize) == p ) {
    205             ok = GL_TRUE;
    206             break;
    207         }
     206        if ( (p&mapsize) == p ) {
     207            ok = GL_TRUE;
     208            break;
     209        }
    208210      }
    209211      if (!ok) {
    210         gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
     212        gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
    211213         return;
    212214      }
    … …  
    217219         ctx->Pixel.MapStoSsize = mapsize;
    218220         for (i=0;i<mapsize;i++) {
    219             ctx->Pixel.MapStoS[i] = (GLint) values[i];
    220         }
    221         break;
     221            ctx->Pixel.MapStoS[i] = (GLint) values[i];
     222        }
     223        break;
    222224      case GL_PIXEL_MAP_I_TO_I:
    223225         ctx->Pixel.MapItoIsize = mapsize;
    224226         for (i=0;i<mapsize;i++) {
    225             ctx->Pixel.MapItoI[i] = (GLint) values[i];
    226         }
    227         break;
     227            ctx->Pixel.MapItoI[i] = (GLint) values[i];
     228        }
     229        break;
    228230      case GL_PIXEL_MAP_I_TO_R:
    229231         ctx->Pixel.MapItoRsize = mapsize;
    230232         for (i=0;i<mapsize;i++) {
    231233            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
    232             ctx->Pixel.MapItoR[i] = val;
    233             ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
    234         }
    235         break;
     234            ctx->Pixel.MapItoR[i] = val;
     235            ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
     236        }
     237        break;
    236238      case GL_PIXEL_MAP_I_TO_G:
    237239         ctx->Pixel.MapItoGsize = mapsize;
    238240         for (i=0;i<mapsize;i++) {
    239241            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
    240             ctx->Pixel.MapItoG[i] = val;
    241             ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
    242         }
    243         break;
     242            ctx->Pixel.MapItoG[i] = val;
     243            ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
     244        }
     245        break;
    244246      case GL_PIXEL_MAP_I_TO_B:
    245247         ctx->Pixel.MapItoBsize = mapsize;
    246248         for (i=0;i<mapsize;i++) {
    247249            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
    248             ctx->Pixel.MapItoB[i] = val;
    249             ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
    250         }
    251         break;
     250            ctx->Pixel.MapItoB[i] = val;
     251            ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
     252        }
     253        break;
    252254      case GL_PIXEL_MAP_I_TO_A:
    253255         ctx->Pixel.MapItoAsize = mapsize;
    254256         for (i=0;i<mapsize;i++) {
    255257            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
    256             ctx->Pixel.MapItoA[i] = val;
    257             ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
    258         }
    259         break;
     258            ctx->Pixel.MapItoA[i] = val;
     259            ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
     260        }
     261        break;
    260262      case GL_PIXEL_MAP_R_TO_R:
    261263         ctx->Pixel.MapRtoRsize = mapsize;
    262264         for (i=0;i<mapsize;i++) {
    263             ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
    264         }
    265         break;
     265            ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
     266        }
     267        break;
    266268      case GL_PIXEL_MAP_G_TO_G:
    267269         ctx->Pixel.MapGtoGsize = mapsize;
    268270         for (i=0;i<mapsize;i++) {
    269             ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
    270         }
    271         break;
     271            ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
     272        }
     273        break;
    272274      case GL_PIXEL_MAP_B_TO_B:
    273275         ctx->Pixel.MapBtoBsize = mapsize;
    274276         for (i=0;i<mapsize;i++) {
    275             ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
    276         }
    277         break;
     277            ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
     278        }
     279        break;
    278280      case GL_PIXEL_MAP_A_TO_A:
    279281         ctx->Pixel.MapAtoAsize = mapsize;
    280282         for (i=0;i<mapsize;i++) {
    281             ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
    282         }
    283         break;
     283            ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
     284        }
     285        break;
    284286      default:
    285287         gl_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
    … …  
    288290
    289291
    290 
    291 
    292 
    293 void gl_GetPixelMapfv( GLcontext *ctx, GLenum map, GLfloat *values )
    294 {
     292void
     293_mesa_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
     294{
     295   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
     296   GLint i;
     297   if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
     298      for (i=0;i<mapsize;i++) {
     299         fvalues[i] = (GLfloat) values[i];
     300      }
     301   }
     302   else {
     303      for (i=0;i<mapsize;i++) {
     304         fvalues[i] = UINT_TO_FLOAT( values[i] );
     305      }
     306   }
     307   _mesa_PixelMapfv(map, mapsize, fvalues);
     308}
     309
     310
     311
     312void
     313_mesa_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values )
     314{
     315   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
     316   GLint i;
     317   if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
     318      for (i=0;i<mapsize;i++) {
     319         fvalues[i] = (GLfloat) values[i];
     320      }
     321   }
     322   else {
     323      for (i=0;i<mapsize;i++) {
     324         fvalues[i] = USHORT_TO_FLOAT( values[i] );
     325      }
     326   }
     327   _mesa_PixelMapfv(map, mapsize, fvalues);
     328}
     329
     330
     331
     332
     333
     334void
     335_mesa_GetPixelMapfv( GLenum map, GLfloat *values )
     336{
     337   GET_CURRENT_CONTEXT(ctx);
    295338   GLint i;
    296339
    … …  
    300343      case GL_PIXEL_MAP_I_TO_I:
    301344         for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
    302             values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
    303         }
    304         break;
     345            values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
     346        }
     347        break;
    305348      case GL_PIXEL_MAP_S_TO_S:
    306349         for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
    307             values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
    308         }
    309         break;
     350            values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
     351        }
     352        break;
    310353      case GL_PIXEL_MAP_I_TO_R:
    311354         MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
    312         break;
     355        break;
    313356      case GL_PIXEL_MAP_I_TO_G:
    314357         MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
    315         break;
     358        break;
    316359      case GL_PIXEL_MAP_I_TO_B:
    317360         MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
    318         break;
     361        break;
    319362      case GL_PIXEL_MAP_I_TO_A:
    320363         MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
    321         break;
     364        break;
    322365      case GL_PIXEL_MAP_R_TO_R:
    323366         MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
    324         break;
     367        break;
    325368      case GL_PIXEL_MAP_G_TO_G:
    326369         MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
    327         break;
     370        break;
    328371      case GL_PIXEL_MAP_B_TO_B:
    329372         MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
    330         break;
     373        break;
    331374      case GL_PIXEL_MAP_A_TO_A:
    332375         MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
    333         break;
     376        break;
    334377      default:
    335378         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
    … …  
    338381
    339382
    340 void gl_GetPixelMapuiv( GLcontext *ctx, GLenum map, GLuint *values )
    341 {
     383void
     384_mesa_GetPixelMapuiv( GLenum map, GLuint *values )
     385{
     386   GET_CURRENT_CONTEXT(ctx);
    342387   GLint i;
    343388
    … …  
    347392      case GL_PIXEL_MAP_I_TO_I:
    348393         MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
    349         break;
     394        break;
    350395      case GL_PIXEL_MAP_S_TO_S:
    351396         MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
    352         break;
     397        break;
    353398      case GL_PIXEL_MAP_I_TO_R:
    354         for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
    355             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
    356         }
    357         break;
     399        for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
     400            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
     401        }
     402        break;
    358403      case GL_PIXEL_MAP_I_TO_G:
    359         for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
    360             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
    361         }
    362         break;
     404        for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
     405            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
     406        }
     407        break;
    363408      case GL_PIXEL_MAP_I_TO_B:
    364         for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
    365             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
    366         }
    367         break;
     409        for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
     410            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
     411        }
     412        break;
    368413      case GL_PIXEL_MAP_I_TO_A:
    369         for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
    370             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
    371         }
    372         break;
     414        for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
     415            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
     416        }
     417        break;
    373418      case GL_PIXEL_MAP_R_TO_R:
    374         for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
    375             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
    376         }
    377         break;
     419        for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
     420            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
     421        }
     422        break;
    378423      case GL_PIXEL_MAP_G_TO_G:
    379         for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
    380             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
    381         }
    382         break;
     424        for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
     425            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
     426        }
     427        break;
    383428      case GL_PIXEL_MAP_B_TO_B:
    384         for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
    385             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
    386         }
    387         break;
     429        for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
     430            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
     431        }
     432        break;
    388433      case GL_PIXEL_MAP_A_TO_A:
    389         for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
    390             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
    391         }
    392         break;
     434        for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
     435            values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
     436        }
     437        break;
    393438      default:
    394439         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
    … …  
    397442
    398443
    399 void gl_GetPixelMapusv( GLcontext *ctx, GLenum map, GLushort *values )
    400 {
     444void
     445_mesa_GetPixelMapusv( GLenum map, GLushort *values )
     446{
     447   GET_CURRENT_CONTEXT(ctx);
    401448   GLint i;
    402449
    … …  
    405452   switch (map) {
    406453      case GL_PIXEL_MAP_I_TO_I:
    407         for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
    408             values[i] = (GLushort) ctx->Pixel.MapItoI[i];
    409         }
    410         break;
     454        for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
     455            values[i] = (GLushort) ctx->Pixel.MapItoI[i];
     456        }
     457        break;
    411458      case GL_PIXEL_MAP_S_TO_S:
    412         for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
    413             values[i] = (GLushort) ctx->Pixel.MapStoS[i];
    414         }
    415         break;
     459        for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
     460            values[i] = (GLushort) ctx->Pixel.MapStoS[i];
     461        }
     462        break;
    416463      case GL_PIXEL_MAP_I_TO_R:
    417         for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
    418             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
    419         }
    420         break;
     464        for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
     465            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
     466        }
     467        break;
    421468      case GL_PIXEL_MAP_I_TO_G:
    422         for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
    423             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
    424         }
    425         break;
     469        for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
     470            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
     471        }
     472        break;
    426473      case GL_PIXEL_MAP_I_TO_B:
    427         for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
    428             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
    429         }
    430         break;
     474        for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
     475            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
     476        }
     477        break;
    431478      case GL_PIXEL_MAP_I_TO_A:
    432         for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
    433             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
    434         }
    435         break;
     479        for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
     480            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
     481        }
     482        break;
    436483      case GL_PIXEL_MAP_R_TO_R:
    437         for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
    438             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
    439         }
    440         break;
     484        for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
     485            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
     486        }
     487        break;
    441488      case GL_PIXEL_MAP_G_TO_G:
    442         for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
    443             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
    444         }
    445         break;
     489        for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
     490            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
     491        }
     492        break;
    446493      case GL_PIXEL_MAP_B_TO_B:
    447         for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
    448             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
    449         }
    450         break;
     494        for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
     495            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
     496        }
     497        break;
    451498      case GL_PIXEL_MAP_A_TO_A:
    452         for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
    453             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
    454         }
    455         break;
     499        for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
     500            values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
     501        }
     502        break;
    456503      default:
    457504         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
    … …  
    470517 * display list.
    471518 */
    472 void gl_PixelTransferf( GLcontext *ctx, GLenum pname, GLfloat param )
    473 {
     519void
     520_mesa_PixelTransferf( GLenum pname, GLfloat param )
     521{
     522   GET_CURRENT_CONTEXT(ctx);
    474523   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelTransfer");
    475524
    … …  
    478527      case GL_MAP_COLOR:
    479528         ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
    480         break;
     529        break;
    481530      case GL_MAP_STENCIL:
    482531         ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
    483         break;
     532        break;
    484533      case GL_INDEX_SHIFT:
    485534         ctx->Pixel.IndexShift = (GLint) param;
    486         break;
     535        break;
    487536      case GL_INDEX_OFFSET:
    488537         ctx->Pixel.IndexOffset = (GLint) param;
    489         break;
     538        break;
    490539      case GL_RED_SCALE:
    491540         ctx->Pixel.RedScale = param;
    492         break;
     541        break;
    493542      case GL_RED_BIAS:
    494543         ctx->Pixel.RedBias = param;
    495         break;
     544        break;
    496545      case GL_GREEN_SCALE:
    497546         ctx->Pixel.GreenScale = param;
    498         break;
     547        break;
    499548      case GL_GREEN_BIAS:
    500549         ctx->Pixel.GreenBias = param;
    501         break;
     550        break;
    502551      case GL_BLUE_SCALE:
    503552         ctx->Pixel.BlueScale = param;
    504         break;
     553        break;
    505554      case GL_BLUE_BIAS:
    506555         ctx->Pixel.BlueBias = param;
    507         break;
     556        break;
    508557      case GL_ALPHA_SCALE:
    509558         ctx->Pixel.AlphaScale = param;
    510         break;
     559        break;
    511560      case GL_ALPHA_BIAS:
    512561         ctx->Pixel.AlphaBias = param;
    513         break;
     562        break;
    514563      case GL_DEPTH_SCALE:
    515564         ctx->Pixel.DepthScale = param;
    516         break;
     565        break;
    517566      case GL_DEPTH_BIAS:
    518567         ctx->Pixel.DepthBias = param;
    519         break;
     568        break;
    520569      default:
    521570         gl_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
    … …  
    532581      ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
    533582   }
     583}
     584
     585
     586void
     587_mesa_PixelTransferi( GLenum pname, GLint param )
     588{
     589   _mesa_PixelTransferf( pname, (GLfloat) param );
    534590}
    535591
Note: See TracChangeset for help on using the changeset viewer.