1 /* $Id: pixel.c,v 1.36 2002/09/21 17:34:56 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
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:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
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.
42 /**********************************************************************/
43 /***** glPixelZoom *****/
44 /**********************************************************************/
49 _mesa_PixelZoom( GLfloat xfactor
, GLfloat yfactor
)
51 GET_CURRENT_CONTEXT(ctx
);
53 if (ctx
->Pixel
.ZoomX
== xfactor
&&
54 ctx
->Pixel
.ZoomY
== yfactor
)
57 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
58 ctx
->Pixel
.ZoomX
= xfactor
;
59 ctx
->Pixel
.ZoomY
= yfactor
;
64 /**********************************************************************/
65 /***** glPixelStore *****/
66 /**********************************************************************/
70 _mesa_PixelStorei( GLenum pname
, GLint param
)
72 /* NOTE: this call can't be compiled into the display list */
73 GET_CURRENT_CONTEXT(ctx
);
74 ASSERT_OUTSIDE_BEGIN_END(ctx
);
77 case GL_PACK_SWAP_BYTES
:
78 if (param
== (GLint
)ctx
->Pack
.SwapBytes
)
80 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
81 ctx
->Pack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
83 case GL_PACK_LSB_FIRST
:
84 if (param
== (GLint
)ctx
->Pack
.LsbFirst
)
86 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
87 ctx
->Pack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
89 case GL_PACK_ROW_LENGTH
:
91 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
94 if (ctx
->Pack
.RowLength
== param
)
96 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
97 ctx
->Pack
.RowLength
= param
;
99 case GL_PACK_IMAGE_HEIGHT
:
101 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
104 if (ctx
->Pack
.ImageHeight
== param
)
106 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
107 ctx
->Pack
.ImageHeight
= param
;
109 case GL_PACK_SKIP_PIXELS
:
111 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
114 if (ctx
->Pack
.SkipPixels
== param
)
116 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
117 ctx
->Pack
.SkipPixels
= param
;
119 case GL_PACK_SKIP_ROWS
:
121 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
124 if (ctx
->Pack
.SkipRows
== param
)
126 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
127 ctx
->Pack
.SkipRows
= param
;
129 case GL_PACK_SKIP_IMAGES
:
131 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
134 if (ctx
->Pack
.SkipImages
== param
)
136 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
137 ctx
->Pack
.SkipImages
= param
;
139 case GL_PACK_ALIGNMENT
:
140 if (param
!=1 && param
!=2 && param
!=4 && param
!=8) {
141 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
144 if (ctx
->Pack
.Alignment
== param
)
146 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
147 ctx
->Pack
.Alignment
= param
;
149 case GL_PACK_INVERT_MESA
:
150 if (!ctx
->Extensions
.MESA_pack_invert
) {
151 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelstore(pname)" );
154 if (ctx
->Pack
.Invert
== param
)
156 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
157 ctx
->Pack
.Invert
= param
;
160 case GL_UNPACK_SWAP_BYTES
:
161 if (param
== (GLint
)ctx
->Unpack
.SwapBytes
)
163 if ((GLint
)ctx
->Unpack
.SwapBytes
== param
)
165 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
166 ctx
->Unpack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
168 case GL_UNPACK_LSB_FIRST
:
169 if (param
== (GLint
)ctx
->Unpack
.LsbFirst
)
171 if ((GLint
)ctx
->Unpack
.LsbFirst
== param
)
173 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
174 ctx
->Unpack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
176 case GL_UNPACK_ROW_LENGTH
:
178 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
181 if (ctx
->Unpack
.RowLength
== param
)
183 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
184 ctx
->Unpack
.RowLength
= param
;
186 case GL_UNPACK_IMAGE_HEIGHT
:
188 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
191 if (ctx
->Unpack
.ImageHeight
== param
)
194 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
195 ctx
->Unpack
.ImageHeight
= param
;
197 case GL_UNPACK_SKIP_PIXELS
:
199 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
202 if (ctx
->Unpack
.SkipPixels
== param
)
204 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
205 ctx
->Unpack
.SkipPixels
= param
;
207 case GL_UNPACK_SKIP_ROWS
:
209 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
212 if (ctx
->Unpack
.SkipRows
== param
)
214 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
215 ctx
->Unpack
.SkipRows
= param
;
217 case GL_UNPACK_SKIP_IMAGES
:
219 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
222 if (ctx
->Unpack
.SkipImages
== param
)
224 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
225 ctx
->Unpack
.SkipImages
= param
;
227 case GL_UNPACK_ALIGNMENT
:
228 if (param
!=1 && param
!=2 && param
!=4 && param
!=8) {
229 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore" );
232 if (ctx
->Unpack
.Alignment
== param
)
234 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
235 ctx
->Unpack
.Alignment
= param
;
237 case GL_UNPACK_CLIENT_STORAGE_APPLE
:
238 if (param
== (GLint
)ctx
->Unpack
.ClientStorage
)
240 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
241 ctx
->Unpack
.ClientStorage
= param
? GL_TRUE
: GL_FALSE
;
244 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelStore" );
251 _mesa_PixelStoref( GLenum pname
, GLfloat param
)
253 _mesa_PixelStorei( pname
, (GLint
) param
);
258 /**********************************************************************/
259 /***** glPixelMap *****/
260 /**********************************************************************/
265 _mesa_PixelMapfv( GLenum map
, GLint mapsize
, const GLfloat
*values
)
268 GET_CURRENT_CONTEXT(ctx
);
269 ASSERT_OUTSIDE_BEGIN_END(ctx
);
271 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
272 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
276 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
277 /* test that mapsize is a power of two */
278 if (_mesa_bitcount((GLuint
) mapsize
) != 1) {
279 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
284 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
287 case GL_PIXEL_MAP_S_TO_S
:
288 ctx
->Pixel
.MapStoSsize
= mapsize
;
289 for (i
=0;i
<mapsize
;i
++) {
290 ctx
->Pixel
.MapStoS
[i
] = (GLint
) values
[i
];
293 case GL_PIXEL_MAP_I_TO_I
:
294 ctx
->Pixel
.MapItoIsize
= mapsize
;
295 for (i
=0;i
<mapsize
;i
++) {
296 ctx
->Pixel
.MapItoI
[i
] = (GLint
) values
[i
];
299 case GL_PIXEL_MAP_I_TO_R
:
300 ctx
->Pixel
.MapItoRsize
= mapsize
;
301 for (i
=0;i
<mapsize
;i
++) {
302 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
303 ctx
->Pixel
.MapItoR
[i
] = val
;
304 ctx
->Pixel
.MapItoR8
[i
] = (GLint
) (val
* 255.0F
);
307 case GL_PIXEL_MAP_I_TO_G
:
308 ctx
->Pixel
.MapItoGsize
= mapsize
;
309 for (i
=0;i
<mapsize
;i
++) {
310 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
311 ctx
->Pixel
.MapItoG
[i
] = val
;
312 ctx
->Pixel
.MapItoG8
[i
] = (GLint
) (val
* 255.0F
);
315 case GL_PIXEL_MAP_I_TO_B
:
316 ctx
->Pixel
.MapItoBsize
= mapsize
;
317 for (i
=0;i
<mapsize
;i
++) {
318 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
319 ctx
->Pixel
.MapItoB
[i
] = val
;
320 ctx
->Pixel
.MapItoB8
[i
] = (GLint
) (val
* 255.0F
);
323 case GL_PIXEL_MAP_I_TO_A
:
324 ctx
->Pixel
.MapItoAsize
= mapsize
;
325 for (i
=0;i
<mapsize
;i
++) {
326 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
327 ctx
->Pixel
.MapItoA
[i
] = val
;
328 ctx
->Pixel
.MapItoA8
[i
] = (GLint
) (val
* 255.0F
);
331 case GL_PIXEL_MAP_R_TO_R
:
332 ctx
->Pixel
.MapRtoRsize
= mapsize
;
333 for (i
=0;i
<mapsize
;i
++) {
334 ctx
->Pixel
.MapRtoR
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
337 case GL_PIXEL_MAP_G_TO_G
:
338 ctx
->Pixel
.MapGtoGsize
= mapsize
;
339 for (i
=0;i
<mapsize
;i
++) {
340 ctx
->Pixel
.MapGtoG
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
343 case GL_PIXEL_MAP_B_TO_B
:
344 ctx
->Pixel
.MapBtoBsize
= mapsize
;
345 for (i
=0;i
<mapsize
;i
++) {
346 ctx
->Pixel
.MapBtoB
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
349 case GL_PIXEL_MAP_A_TO_A
:
350 ctx
->Pixel
.MapAtoAsize
= mapsize
;
351 for (i
=0;i
<mapsize
;i
++) {
352 ctx
->Pixel
.MapAtoA
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
356 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelMapfv(map)" );
363 _mesa_PixelMapuiv(GLenum map
, GLint mapsize
, const GLuint
*values
)
365 const GLint n
= MIN2(mapsize
, MAX_PIXEL_MAP_TABLE
);
366 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
368 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
370 fvalues
[i
] = (GLfloat
) values
[i
];
375 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
378 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
384 _mesa_PixelMapusv(GLenum map
, GLint mapsize
, const GLushort
*values
)
386 const GLint n
= MIN2(mapsize
, MAX_PIXEL_MAP_TABLE
);
387 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
389 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
391 fvalues
[i
] = (GLfloat
) values
[i
];
396 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
399 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
405 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
407 GET_CURRENT_CONTEXT(ctx
);
409 ASSERT_OUTSIDE_BEGIN_END(ctx
);
412 case GL_PIXEL_MAP_I_TO_I
:
413 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
414 values
[i
] = (GLfloat
) ctx
->Pixel
.MapItoI
[i
];
417 case GL_PIXEL_MAP_S_TO_S
:
418 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
419 values
[i
] = (GLfloat
) ctx
->Pixel
.MapStoS
[i
];
422 case GL_PIXEL_MAP_I_TO_R
:
423 MEMCPY(values
,ctx
->Pixel
.MapItoR
,ctx
->Pixel
.MapItoRsize
*sizeof(GLfloat
));
425 case GL_PIXEL_MAP_I_TO_G
:
426 MEMCPY(values
,ctx
->Pixel
.MapItoG
,ctx
->Pixel
.MapItoGsize
*sizeof(GLfloat
));
428 case GL_PIXEL_MAP_I_TO_B
:
429 MEMCPY(values
,ctx
->Pixel
.MapItoB
,ctx
->Pixel
.MapItoBsize
*sizeof(GLfloat
));
431 case GL_PIXEL_MAP_I_TO_A
:
432 MEMCPY(values
,ctx
->Pixel
.MapItoA
,ctx
->Pixel
.MapItoAsize
*sizeof(GLfloat
));
434 case GL_PIXEL_MAP_R_TO_R
:
435 MEMCPY(values
,ctx
->Pixel
.MapRtoR
,ctx
->Pixel
.MapRtoRsize
*sizeof(GLfloat
));
437 case GL_PIXEL_MAP_G_TO_G
:
438 MEMCPY(values
,ctx
->Pixel
.MapGtoG
,ctx
->Pixel
.MapGtoGsize
*sizeof(GLfloat
));
440 case GL_PIXEL_MAP_B_TO_B
:
441 MEMCPY(values
,ctx
->Pixel
.MapBtoB
,ctx
->Pixel
.MapBtoBsize
*sizeof(GLfloat
));
443 case GL_PIXEL_MAP_A_TO_A
:
444 MEMCPY(values
,ctx
->Pixel
.MapAtoA
,ctx
->Pixel
.MapAtoAsize
*sizeof(GLfloat
));
447 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
453 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
455 GET_CURRENT_CONTEXT(ctx
);
457 ASSERT_OUTSIDE_BEGIN_END(ctx
);
460 case GL_PIXEL_MAP_I_TO_I
:
461 MEMCPY(values
, ctx
->Pixel
.MapItoI
, ctx
->Pixel
.MapItoIsize
*sizeof(GLint
));
463 case GL_PIXEL_MAP_S_TO_S
:
464 MEMCPY(values
, ctx
->Pixel
.MapStoS
, ctx
->Pixel
.MapStoSsize
*sizeof(GLint
));
466 case GL_PIXEL_MAP_I_TO_R
:
467 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
468 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoR
[i
] );
471 case GL_PIXEL_MAP_I_TO_G
:
472 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
473 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoG
[i
] );
476 case GL_PIXEL_MAP_I_TO_B
:
477 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
478 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoB
[i
] );
481 case GL_PIXEL_MAP_I_TO_A
:
482 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
483 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoA
[i
] );
486 case GL_PIXEL_MAP_R_TO_R
:
487 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
488 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapRtoR
[i
] );
491 case GL_PIXEL_MAP_G_TO_G
:
492 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
493 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapGtoG
[i
] );
496 case GL_PIXEL_MAP_B_TO_B
:
497 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
498 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapBtoB
[i
] );
501 case GL_PIXEL_MAP_A_TO_A
:
502 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
503 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapAtoA
[i
] );
507 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
513 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
515 GET_CURRENT_CONTEXT(ctx
);
517 ASSERT_OUTSIDE_BEGIN_END(ctx
);
520 case GL_PIXEL_MAP_I_TO_I
:
521 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
522 values
[i
] = (GLushort
) ctx
->Pixel
.MapItoI
[i
];
525 case GL_PIXEL_MAP_S_TO_S
:
526 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
527 values
[i
] = (GLushort
) ctx
->Pixel
.MapStoS
[i
];
530 case GL_PIXEL_MAP_I_TO_R
:
531 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
532 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoR
[i
] );
535 case GL_PIXEL_MAP_I_TO_G
:
536 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
537 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoG
[i
] );
540 case GL_PIXEL_MAP_I_TO_B
:
541 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
542 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoB
[i
] );
545 case GL_PIXEL_MAP_I_TO_A
:
546 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
547 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoA
[i
] );
550 case GL_PIXEL_MAP_R_TO_R
:
551 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
552 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapRtoR
[i
] );
555 case GL_PIXEL_MAP_G_TO_G
:
556 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
557 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapGtoG
[i
] );
560 case GL_PIXEL_MAP_B_TO_B
:
561 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
562 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapBtoB
[i
] );
565 case GL_PIXEL_MAP_A_TO_A
:
566 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
567 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapAtoA
[i
] );
571 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
577 /**********************************************************************/
578 /***** glPixelTransfer *****/
579 /**********************************************************************/
583 * Implements glPixelTransfer[fi] whether called immediately or from a
587 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
589 GET_CURRENT_CONTEXT(ctx
);
590 ASSERT_OUTSIDE_BEGIN_END(ctx
);
594 if (ctx
->Pixel
.MapColorFlag
== (param
? GL_TRUE
: GL_FALSE
))
596 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
597 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
600 if (ctx
->Pixel
.MapStencilFlag
== (param
? GL_TRUE
: GL_FALSE
))
602 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
603 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
606 if (ctx
->Pixel
.IndexShift
== (GLint
) param
)
608 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
609 ctx
->Pixel
.IndexShift
= (GLint
) param
;
611 case GL_INDEX_OFFSET
:
612 if (ctx
->Pixel
.IndexOffset
== (GLint
) param
)
614 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
615 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
618 if (ctx
->Pixel
.RedScale
== param
)
620 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
621 ctx
->Pixel
.RedScale
= param
;
624 if (ctx
->Pixel
.RedBias
== param
)
626 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
627 ctx
->Pixel
.RedBias
= param
;
630 if (ctx
->Pixel
.GreenScale
== param
)
632 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
633 ctx
->Pixel
.GreenScale
= param
;
636 if (ctx
->Pixel
.GreenBias
== param
)
638 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
639 ctx
->Pixel
.GreenBias
= param
;
642 if (ctx
->Pixel
.BlueScale
== param
)
644 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
645 ctx
->Pixel
.BlueScale
= param
;
648 if (ctx
->Pixel
.BlueBias
== param
)
650 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
651 ctx
->Pixel
.BlueBias
= param
;
654 if (ctx
->Pixel
.AlphaScale
== param
)
656 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
657 ctx
->Pixel
.AlphaScale
= param
;
660 if (ctx
->Pixel
.AlphaBias
== param
)
662 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
663 ctx
->Pixel
.AlphaBias
= param
;
666 if (ctx
->Pixel
.DepthScale
== param
)
668 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
669 ctx
->Pixel
.DepthScale
= param
;
672 if (ctx
->Pixel
.DepthBias
== param
)
674 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
675 ctx
->Pixel
.DepthBias
= param
;
677 case GL_POST_COLOR_MATRIX_RED_SCALE
:
678 if (ctx
->Pixel
.PostColorMatrixScale
[0] == param
)
680 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
681 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
683 case GL_POST_COLOR_MATRIX_RED_BIAS
:
684 if (ctx
->Pixel
.PostColorMatrixBias
[0] == param
)
686 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
687 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
689 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
690 if (ctx
->Pixel
.PostColorMatrixScale
[1] == param
)
692 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
693 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
695 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
696 if (ctx
->Pixel
.PostColorMatrixBias
[1] == param
)
698 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
699 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
701 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
702 if (ctx
->Pixel
.PostColorMatrixScale
[2] == param
)
704 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
705 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
707 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
708 if (ctx
->Pixel
.PostColorMatrixBias
[2] == param
)
710 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
711 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
713 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
714 if (ctx
->Pixel
.PostColorMatrixScale
[3] == param
)
716 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
717 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
719 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
720 if (ctx
->Pixel
.PostColorMatrixBias
[3] == param
)
722 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
723 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
725 case GL_POST_CONVOLUTION_RED_SCALE
:
726 if (ctx
->Pixel
.PostConvolutionScale
[0] == param
)
728 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
729 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
731 case GL_POST_CONVOLUTION_RED_BIAS
:
732 if (ctx
->Pixel
.PostConvolutionBias
[0] == param
)
734 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
735 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
737 case GL_POST_CONVOLUTION_GREEN_SCALE
:
738 if (ctx
->Pixel
.PostConvolutionScale
[1] == param
)
740 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
741 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
743 case GL_POST_CONVOLUTION_GREEN_BIAS
:
744 if (ctx
->Pixel
.PostConvolutionBias
[1] == param
)
746 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
747 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
749 case GL_POST_CONVOLUTION_BLUE_SCALE
:
750 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
752 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
753 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
755 case GL_POST_CONVOLUTION_BLUE_BIAS
:
756 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
758 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
759 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
761 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
762 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
764 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
765 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
767 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
768 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
770 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
771 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
774 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
781 _mesa_PixelTransferi( GLenum pname
, GLint param
)
783 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
788 /**********************************************************************/
789 /***** Pixel processing functions ******/
790 /**********************************************************************/
794 * Apply scale and bias factors to an array of RGBA pixels.
797 _mesa_scale_and_bias_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4],
798 GLfloat rScale
, GLfloat gScale
,
799 GLfloat bScale
, GLfloat aScale
,
800 GLfloat rBias
, GLfloat gBias
,
801 GLfloat bBias
, GLfloat aBias
)
803 if (rScale
!= 1.0 || rBias
!= 0.0) {
805 for (i
= 0; i
< n
; i
++) {
806 rgba
[i
][RCOMP
] = rgba
[i
][RCOMP
] * rScale
+ rBias
;
809 if (gScale
!= 1.0 || gBias
!= 0.0) {
811 for (i
= 0; i
< n
; i
++) {
812 rgba
[i
][GCOMP
] = rgba
[i
][GCOMP
] * gScale
+ gBias
;
815 if (bScale
!= 1.0 || bBias
!= 0.0) {
817 for (i
= 0; i
< n
; i
++) {
818 rgba
[i
][BCOMP
] = rgba
[i
][BCOMP
] * bScale
+ bBias
;
821 if (aScale
!= 1.0 || aBias
!= 0.0) {
823 for (i
= 0; i
< n
; i
++) {
824 rgba
[i
][ACOMP
] = rgba
[i
][ACOMP
] * aScale
+ aBias
;
831 * Apply pixel mapping to an array of floating point RGBA pixels.
834 _mesa_map_rgba( const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4] )
836 const GLfloat rscale
= (GLfloat
) (ctx
->Pixel
.MapRtoRsize
- 1);
837 const GLfloat gscale
= (GLfloat
) (ctx
->Pixel
.MapGtoGsize
- 1);
838 const GLfloat bscale
= (GLfloat
) (ctx
->Pixel
.MapBtoBsize
- 1);
839 const GLfloat ascale
= (GLfloat
) (ctx
->Pixel
.MapAtoAsize
- 1);
840 const GLfloat
*rMap
= ctx
->Pixel
.MapRtoR
;
841 const GLfloat
*gMap
= ctx
->Pixel
.MapGtoG
;
842 const GLfloat
*bMap
= ctx
->Pixel
.MapBtoB
;
843 const GLfloat
*aMap
= ctx
->Pixel
.MapAtoA
;
846 GLfloat r
= CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
847 GLfloat g
= CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
848 GLfloat b
= CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
849 GLfloat a
= CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
850 rgba
[i
][RCOMP
] = rMap
[IROUND(r
* rscale
)];
851 rgba
[i
][GCOMP
] = gMap
[IROUND(g
* gscale
)];
852 rgba
[i
][BCOMP
] = bMap
[IROUND(b
* bscale
)];
853 rgba
[i
][ACOMP
] = aMap
[IROUND(a
* ascale
)];
859 * Apply the color matrix and post color matrix scaling and biasing.
862 _mesa_transform_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
864 const GLfloat rs
= ctx
->Pixel
.PostColorMatrixScale
[0];
865 const GLfloat rb
= ctx
->Pixel
.PostColorMatrixBias
[0];
866 const GLfloat gs
= ctx
->Pixel
.PostColorMatrixScale
[1];
867 const GLfloat gb
= ctx
->Pixel
.PostColorMatrixBias
[1];
868 const GLfloat bs
= ctx
->Pixel
.PostColorMatrixScale
[2];
869 const GLfloat bb
= ctx
->Pixel
.PostColorMatrixBias
[2];
870 const GLfloat as
= ctx
->Pixel
.PostColorMatrixScale
[3];
871 const GLfloat ab
= ctx
->Pixel
.PostColorMatrixBias
[3];
872 const GLfloat
*m
= ctx
->ColorMatrixStack
.Top
->m
;
874 for (i
= 0; i
< n
; i
++) {
875 const GLfloat r
= rgba
[i
][RCOMP
];
876 const GLfloat g
= rgba
[i
][GCOMP
];
877 const GLfloat b
= rgba
[i
][BCOMP
];
878 const GLfloat a
= rgba
[i
][ACOMP
];
879 rgba
[i
][RCOMP
] = (m
[0] * r
+ m
[4] * g
+ m
[ 8] * b
+ m
[12] * a
) * rs
+ rb
;
880 rgba
[i
][GCOMP
] = (m
[1] * r
+ m
[5] * g
+ m
[ 9] * b
+ m
[13] * a
) * gs
+ gb
;
881 rgba
[i
][BCOMP
] = (m
[2] * r
+ m
[6] * g
+ m
[10] * b
+ m
[14] * a
) * bs
+ bb
;
882 rgba
[i
][ACOMP
] = (m
[3] * r
+ m
[7] * g
+ m
[11] * b
+ m
[15] * a
) * as
+ ab
;
888 * Apply a color table lookup to an array of colors.
891 _mesa_lookup_rgba(const struct gl_color_table
*table
,
892 GLuint n
, GLfloat rgba
[][4])
894 ASSERT(table
->FloatTable
);
895 if (!table
->Table
|| table
->Size
== 0)
898 switch (table
->Format
) {
900 /* replace RGBA with I */
901 if (!table
->FloatTable
) {
902 const GLint max
= table
->Size
- 1;
903 const GLfloat scale
= (GLfloat
) max
;
904 const GLchan
*lut
= (const GLchan
*) table
->Table
;
906 for (i
= 0; i
< n
; i
++) {
907 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
908 GLfloat c
= CHAN_TO_FLOAT(lut
[CLAMP(j
, 0, 1)]);
909 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
910 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
915 const GLint max
= table
->Size
- 1;
916 const GLfloat scale
= (GLfloat
) max
;
917 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
919 for (i
= 0; i
< n
; i
++) {
920 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
921 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
922 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
923 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
928 /* replace RGB with L */
929 if (!table
->FloatTable
) {
930 const GLint max
= table
->Size
- 1;
931 const GLfloat scale
= (GLfloat
) max
;
932 const GLchan
*lut
= (const GLchan
*) table
->Table
;
934 for (i
= 0; i
< n
; i
++) {
935 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
936 GLfloat c
= CHAN_TO_FLOAT(lut
[CLAMP(j
, 0, max
)]);
937 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
941 const GLint max
= table
->Size
- 1;
942 const GLfloat scale
= (GLfloat
) max
;
943 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
945 for (i
= 0; i
< n
; i
++) {
946 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
947 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
948 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
953 /* replace A with A */
954 if (!table
->FloatTable
) {
955 const GLint max
= table
->Size
- 1;
956 const GLfloat scale
= (GLfloat
) max
;
957 const GLchan
*lut
= (const GLchan
*) table
->Table
;
959 for (i
= 0; i
< n
; i
++) {
960 GLint j
= IROUND(rgba
[i
][ACOMP
] * scale
);
961 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(lut
[CLAMP(j
, 0, max
)]);
965 const GLint max
= table
->Size
- 1;
966 const GLfloat scale
= (GLfloat
) max
;
967 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
969 for (i
= 0; i
< n
; i
++) {
970 GLint j
= IROUND(rgba
[i
][ACOMP
] * scale
);
971 rgba
[i
][ACOMP
] = lut
[CLAMP(j
, 0, max
)];
975 case GL_LUMINANCE_ALPHA
:
976 /* replace RGBA with LLLA */
977 if (!table
->FloatTable
) {
978 const GLint max
= table
->Size
- 1;
979 const GLfloat scale
= (GLfloat
) max
;
980 const GLchan
*lut
= (const GLchan
*) table
->Table
;
982 for (i
= 0; i
< n
; i
++) {
983 GLint jL
= IROUND(rgba
[i
][RCOMP
] * scale
);
984 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
985 GLfloat luminance
, alpha
;
986 jL
= CLAMP(jL
, 0, max
);
987 jA
= CLAMP(jA
, 0, max
);
988 luminance
= CHAN_TO_FLOAT(lut
[jL
* 2 + 0]);
989 alpha
= CHAN_TO_FLOAT(lut
[jA
* 2 + 1]);
990 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
991 rgba
[i
][ACOMP
] = alpha
;;
995 const GLint max
= table
->Size
- 1;
996 const GLfloat scale
= (GLfloat
) max
;
997 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
999 for (i
= 0; i
< n
; i
++) {
1000 GLint jL
= IROUND(rgba
[i
][RCOMP
] * scale
);
1001 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1002 GLfloat luminance
, alpha
;
1003 jL
= CLAMP(jL
, 0, max
);
1004 jA
= CLAMP(jA
, 0, max
);
1005 luminance
= lut
[jL
* 2 + 0];
1006 alpha
= lut
[jA
* 2 + 1];
1007 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
1008 rgba
[i
][ACOMP
] = alpha
;;
1013 /* replace RGB with RGB */
1014 if (!table
->FloatTable
) {
1015 const GLint max
= table
->Size
- 1;
1016 const GLfloat scale
= (GLfloat
) max
;
1017 const GLchan
*lut
= (const GLchan
*) table
->Table
;
1019 for (i
= 0; i
< n
; i
++) {
1020 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1021 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1022 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1023 jR
= CLAMP(jR
, 0, max
);
1024 jG
= CLAMP(jG
, 0, max
);
1025 jB
= CLAMP(jB
, 0, max
);
1026 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(lut
[jR
* 3 + 0]);
1027 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(lut
[jG
* 3 + 1]);
1028 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(lut
[jB
* 3 + 2]);
1032 const GLint max
= table
->Size
- 1;
1033 const GLfloat scale
= (GLfloat
) max
;
1034 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
1036 for (i
= 0; i
< n
; i
++) {
1037 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1038 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1039 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1040 jR
= CLAMP(jR
, 0, max
);
1041 jG
= CLAMP(jG
, 0, max
);
1042 jB
= CLAMP(jB
, 0, max
);
1043 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
1044 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
1045 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
1050 /* replace RGBA with RGBA */
1051 if (!table
->FloatTable
) {
1052 const GLint max
= table
->Size
- 1;
1053 const GLfloat scale
= (GLfloat
) max
;
1054 const GLchan
*lut
= (const GLchan
*) table
->Table
;
1056 for (i
= 0; i
< n
; i
++) {
1057 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1058 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1059 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1060 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1061 jR
= CLAMP(jR
, 0, max
);
1062 jG
= CLAMP(jG
, 0, max
);
1063 jB
= CLAMP(jB
, 0, max
);
1064 jA
= CLAMP(jA
, 0, max
);
1065 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(lut
[jR
* 4 + 0]);
1066 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(lut
[jG
* 4 + 1]);
1067 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(lut
[jB
* 4 + 2]);
1068 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(lut
[jA
* 4 + 3]);
1072 const GLint max
= table
->Size
- 1;
1073 const GLfloat scale
= (GLfloat
) max
;
1074 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
1076 for (i
= 0; i
< n
; i
++) {
1077 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1078 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1079 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1080 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1081 jR
= CLAMP(jR
, 0, max
);
1082 jG
= CLAMP(jG
, 0, max
);
1083 jB
= CLAMP(jB
, 0, max
);
1084 jA
= CLAMP(jA
, 0, max
);
1085 rgba
[i
][RCOMP
] = lut
[jR
* 4 + 0];
1086 rgba
[i
][GCOMP
] = lut
[jG
* 4 + 1];
1087 rgba
[i
][BCOMP
] = lut
[jB
* 4 + 2];
1088 rgba
[i
][ACOMP
] = lut
[jA
* 4 + 3];
1093 _mesa_problem(NULL
, "Bad format in _mesa_lookup_rgba");
1101 * Apply color index shift and offset to an array of pixels.
1104 _mesa_shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
1106 GLint shift
= ctx
->Pixel
.IndexShift
;
1107 GLint offset
= ctx
->Pixel
.IndexOffset
;
1111 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
1114 else if (shift
< 0) {
1117 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
1122 indexes
[i
] = indexes
[i
] + offset
;
1129 * Apply color index mapping to color indexes.
1132 _mesa_map_ci( const GLcontext
*ctx
, GLuint n
, GLuint index
[] )
1134 GLuint mask
= ctx
->Pixel
.MapItoIsize
- 1;
1137 index
[i
] = ctx
->Pixel
.MapItoI
[ index
[i
] & mask
];
1143 * Map color indexes to rgba values.
1146 _mesa_map_ci_to_rgba_chan( const GLcontext
*ctx
, GLuint n
,
1147 const GLuint index
[], GLchan rgba
[][4] )
1150 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1151 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1152 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1153 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1154 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
1155 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
1156 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
1157 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
1160 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1161 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1162 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1163 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1166 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1167 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1168 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1169 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1170 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1171 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1172 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1173 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1176 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][RCOMP
], rMap
[index
[i
] & rmask
]);
1177 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][GCOMP
], gMap
[index
[i
] & gmask
]);
1178 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][BCOMP
], bMap
[index
[i
] & bmask
]);
1179 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][ACOMP
], aMap
[index
[i
] & amask
]);
1186 * Map color indexes to float rgba values.
1189 _mesa_map_ci_to_rgba( const GLcontext
*ctx
, GLuint n
,
1190 const GLuint index
[], GLfloat rgba
[][4] )
1192 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1193 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1194 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1195 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1196 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1197 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1198 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1199 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1202 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1203 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1204 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1205 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1211 * Map 8-bit color indexes to rgb values.
1214 _mesa_map_ci8_to_rgba( const GLcontext
*ctx
, GLuint n
, const GLubyte index
[],
1218 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1219 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1220 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1221 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1222 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
1223 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
1224 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
1225 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
1228 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1229 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1230 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1231 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1234 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1235 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1236 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1237 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1238 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1239 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1240 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1241 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1244 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][RCOMP
], rMap
[index
[i
] & rmask
]);
1245 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][GCOMP
], gMap
[index
[i
] & gmask
]);
1246 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][BCOMP
], bMap
[index
[i
] & bmask
]);
1247 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][ACOMP
], aMap
[index
[i
] & amask
]);
1254 _mesa_shift_and_offset_stencil( const GLcontext
*ctx
, GLuint n
,
1255 GLstencil stencil
[] )
1258 GLint shift
= ctx
->Pixel
.IndexShift
;
1259 GLint offset
= ctx
->Pixel
.IndexOffset
;
1262 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
1265 else if (shift
< 0) {
1268 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
1273 stencil
[i
] = stencil
[i
] + offset
;
1281 _mesa_map_stencil( const GLcontext
*ctx
, GLuint n
, GLstencil stencil
[] )
1283 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
1286 stencil
[i
] = ctx
->Pixel
.MapStoS
[ stencil
[i
] & mask
];
1293 * This function converts an array of GLchan colors to GLfloat colors.
1294 * Most importantly, it undoes the non-uniform quantization of pixel
1295 * values introduced when we convert shallow (< 8 bit) pixel values
1296 * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1297 * This fixes a number of OpenGL conformance failures when running on
1298 * 16bpp displays, for example.
1301 _mesa_chan_to_float_span(const GLcontext
*ctx
, GLuint n
,
1302 CONST GLchan rgba
[][4], GLfloat rgbaf
[][4])
1304 #if CHAN_TYPE == GL_FLOAT
1305 MEMCPY(rgbaf
, rgba
, n
* 4 * sizeof(GLfloat
));
1307 const GLuint rShift
= CHAN_BITS
- ctx
->Visual
.redBits
;
1308 const GLuint gShift
= CHAN_BITS
- ctx
->Visual
.greenBits
;
1309 const GLuint bShift
= CHAN_BITS
- ctx
->Visual
.blueBits
;
1311 const GLfloat rScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.redBits
) - 1);
1312 const GLfloat gScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.greenBits
) - 1);
1313 const GLfloat bScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.blueBits
) - 1);
1317 if (ctx
->Visual
.alphaBits
> 0) {
1318 aShift
= CHAN_BITS
- ctx
->Visual
.alphaBits
;
1319 aScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.alphaBits
) - 1);
1323 aScale
= 1.0F
/ CHAN_MAXF
;
1326 for (i
= 0; i
< n
; i
++) {
1327 const GLint r
= rgba
[i
][RCOMP
] >> rShift
;
1328 const GLint g
= rgba
[i
][GCOMP
] >> gShift
;
1329 const GLint b
= rgba
[i
][BCOMP
] >> bShift
;
1330 const GLint a
= rgba
[i
][ACOMP
] >> aShift
;
1331 rgbaf
[i
][RCOMP
] = (GLfloat
) r
* rScale
;
1332 rgbaf
[i
][GCOMP
] = (GLfloat
) g
* gScale
;
1333 rgbaf
[i
][BCOMP
] = (GLfloat
) b
* bScale
;
1334 rgbaf
[i
][ACOMP
] = (GLfloat
) a
* aScale
;