1 /* $Id: pixel.c,v 1.34 2002/04/24 20:11:20 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_UNPACK_SWAP_BYTES
:
150 if (param
== (GLint
)ctx
->Unpack
.SwapBytes
)
152 if ((GLint
)ctx
->Unpack
.SwapBytes
== param
)
154 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
155 ctx
->Unpack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
157 case GL_UNPACK_LSB_FIRST
:
158 if (param
== (GLint
)ctx
->Unpack
.LsbFirst
)
160 if ((GLint
)ctx
->Unpack
.LsbFirst
== param
)
162 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
163 ctx
->Unpack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
165 case GL_UNPACK_ROW_LENGTH
:
167 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
170 if (ctx
->Unpack
.RowLength
== param
)
172 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
173 ctx
->Unpack
.RowLength
= param
;
175 case GL_UNPACK_IMAGE_HEIGHT
:
177 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
180 if (ctx
->Unpack
.ImageHeight
== param
)
183 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
184 ctx
->Unpack
.ImageHeight
= param
;
186 case GL_UNPACK_SKIP_PIXELS
:
188 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
191 if (ctx
->Unpack
.SkipPixels
== param
)
193 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
194 ctx
->Unpack
.SkipPixels
= param
;
196 case GL_UNPACK_SKIP_ROWS
:
198 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
201 if (ctx
->Unpack
.SkipRows
== param
)
203 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
204 ctx
->Unpack
.SkipRows
= param
;
206 case GL_UNPACK_SKIP_IMAGES
:
208 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
211 if (ctx
->Unpack
.SkipImages
== param
)
213 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
214 ctx
->Unpack
.SkipImages
= param
;
216 case GL_UNPACK_ALIGNMENT
:
217 if (param
!=1 && param
!=2 && param
!=4 && param
!=8) {
218 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore" );
221 if (ctx
->Unpack
.Alignment
== param
)
223 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
224 ctx
->Unpack
.Alignment
= param
;
227 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelStore" );
234 _mesa_PixelStoref( GLenum pname
, GLfloat param
)
236 _mesa_PixelStorei( pname
, (GLint
) param
);
241 /**********************************************************************/
242 /***** glPixelMap *****/
243 /**********************************************************************/
248 _mesa_PixelMapfv( GLenum map
, GLint mapsize
, const GLfloat
*values
)
251 GET_CURRENT_CONTEXT(ctx
);
252 ASSERT_OUTSIDE_BEGIN_END(ctx
);
254 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
255 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
259 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
260 /* test that mapsize is a power of two */
261 if (_mesa_bitcount((GLuint
) mapsize
) != 1) {
262 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
267 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
270 case GL_PIXEL_MAP_S_TO_S
:
271 ctx
->Pixel
.MapStoSsize
= mapsize
;
272 for (i
=0;i
<mapsize
;i
++) {
273 ctx
->Pixel
.MapStoS
[i
] = (GLint
) values
[i
];
276 case GL_PIXEL_MAP_I_TO_I
:
277 ctx
->Pixel
.MapItoIsize
= mapsize
;
278 for (i
=0;i
<mapsize
;i
++) {
279 ctx
->Pixel
.MapItoI
[i
] = (GLint
) values
[i
];
282 case GL_PIXEL_MAP_I_TO_R
:
283 ctx
->Pixel
.MapItoRsize
= mapsize
;
284 for (i
=0;i
<mapsize
;i
++) {
285 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
286 ctx
->Pixel
.MapItoR
[i
] = val
;
287 ctx
->Pixel
.MapItoR8
[i
] = (GLint
) (val
* 255.0F
);
290 case GL_PIXEL_MAP_I_TO_G
:
291 ctx
->Pixel
.MapItoGsize
= mapsize
;
292 for (i
=0;i
<mapsize
;i
++) {
293 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
294 ctx
->Pixel
.MapItoG
[i
] = val
;
295 ctx
->Pixel
.MapItoG8
[i
] = (GLint
) (val
* 255.0F
);
298 case GL_PIXEL_MAP_I_TO_B
:
299 ctx
->Pixel
.MapItoBsize
= mapsize
;
300 for (i
=0;i
<mapsize
;i
++) {
301 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
302 ctx
->Pixel
.MapItoB
[i
] = val
;
303 ctx
->Pixel
.MapItoB8
[i
] = (GLint
) (val
* 255.0F
);
306 case GL_PIXEL_MAP_I_TO_A
:
307 ctx
->Pixel
.MapItoAsize
= mapsize
;
308 for (i
=0;i
<mapsize
;i
++) {
309 GLfloat val
= CLAMP( values
[i
], 0.0F
, 1.0F
);
310 ctx
->Pixel
.MapItoA
[i
] = val
;
311 ctx
->Pixel
.MapItoA8
[i
] = (GLint
) (val
* 255.0F
);
314 case GL_PIXEL_MAP_R_TO_R
:
315 ctx
->Pixel
.MapRtoRsize
= mapsize
;
316 for (i
=0;i
<mapsize
;i
++) {
317 ctx
->Pixel
.MapRtoR
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
320 case GL_PIXEL_MAP_G_TO_G
:
321 ctx
->Pixel
.MapGtoGsize
= mapsize
;
322 for (i
=0;i
<mapsize
;i
++) {
323 ctx
->Pixel
.MapGtoG
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
326 case GL_PIXEL_MAP_B_TO_B
:
327 ctx
->Pixel
.MapBtoBsize
= mapsize
;
328 for (i
=0;i
<mapsize
;i
++) {
329 ctx
->Pixel
.MapBtoB
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
332 case GL_PIXEL_MAP_A_TO_A
:
333 ctx
->Pixel
.MapAtoAsize
= mapsize
;
334 for (i
=0;i
<mapsize
;i
++) {
335 ctx
->Pixel
.MapAtoA
[i
] = CLAMP( values
[i
], 0.0F
, 1.0F
);
339 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelMapfv(map)" );
346 _mesa_PixelMapuiv(GLenum map
, GLint mapsize
, const GLuint
*values
)
348 const GLint n
= MIN2(mapsize
, MAX_PIXEL_MAP_TABLE
);
349 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
351 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
353 fvalues
[i
] = (GLfloat
) values
[i
];
358 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
361 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
367 _mesa_PixelMapusv(GLenum map
, GLint mapsize
, const GLushort
*values
)
369 const GLint n
= MIN2(mapsize
, MAX_PIXEL_MAP_TABLE
);
370 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
372 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
374 fvalues
[i
] = (GLfloat
) values
[i
];
379 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
382 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
388 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
390 GET_CURRENT_CONTEXT(ctx
);
392 ASSERT_OUTSIDE_BEGIN_END(ctx
);
395 case GL_PIXEL_MAP_I_TO_I
:
396 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
397 values
[i
] = (GLfloat
) ctx
->Pixel
.MapItoI
[i
];
400 case GL_PIXEL_MAP_S_TO_S
:
401 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
402 values
[i
] = (GLfloat
) ctx
->Pixel
.MapStoS
[i
];
405 case GL_PIXEL_MAP_I_TO_R
:
406 MEMCPY(values
,ctx
->Pixel
.MapItoR
,ctx
->Pixel
.MapItoRsize
*sizeof(GLfloat
));
408 case GL_PIXEL_MAP_I_TO_G
:
409 MEMCPY(values
,ctx
->Pixel
.MapItoG
,ctx
->Pixel
.MapItoGsize
*sizeof(GLfloat
));
411 case GL_PIXEL_MAP_I_TO_B
:
412 MEMCPY(values
,ctx
->Pixel
.MapItoB
,ctx
->Pixel
.MapItoBsize
*sizeof(GLfloat
));
414 case GL_PIXEL_MAP_I_TO_A
:
415 MEMCPY(values
,ctx
->Pixel
.MapItoA
,ctx
->Pixel
.MapItoAsize
*sizeof(GLfloat
));
417 case GL_PIXEL_MAP_R_TO_R
:
418 MEMCPY(values
,ctx
->Pixel
.MapRtoR
,ctx
->Pixel
.MapRtoRsize
*sizeof(GLfloat
));
420 case GL_PIXEL_MAP_G_TO_G
:
421 MEMCPY(values
,ctx
->Pixel
.MapGtoG
,ctx
->Pixel
.MapGtoGsize
*sizeof(GLfloat
));
423 case GL_PIXEL_MAP_B_TO_B
:
424 MEMCPY(values
,ctx
->Pixel
.MapBtoB
,ctx
->Pixel
.MapBtoBsize
*sizeof(GLfloat
));
426 case GL_PIXEL_MAP_A_TO_A
:
427 MEMCPY(values
,ctx
->Pixel
.MapAtoA
,ctx
->Pixel
.MapAtoAsize
*sizeof(GLfloat
));
430 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
436 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
438 GET_CURRENT_CONTEXT(ctx
);
440 ASSERT_OUTSIDE_BEGIN_END(ctx
);
443 case GL_PIXEL_MAP_I_TO_I
:
444 MEMCPY(values
, ctx
->Pixel
.MapItoI
, ctx
->Pixel
.MapItoIsize
*sizeof(GLint
));
446 case GL_PIXEL_MAP_S_TO_S
:
447 MEMCPY(values
, ctx
->Pixel
.MapStoS
, ctx
->Pixel
.MapStoSsize
*sizeof(GLint
));
449 case GL_PIXEL_MAP_I_TO_R
:
450 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
451 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoR
[i
] );
454 case GL_PIXEL_MAP_I_TO_G
:
455 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
456 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoG
[i
] );
459 case GL_PIXEL_MAP_I_TO_B
:
460 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
461 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoB
[i
] );
464 case GL_PIXEL_MAP_I_TO_A
:
465 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
466 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoA
[i
] );
469 case GL_PIXEL_MAP_R_TO_R
:
470 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
471 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapRtoR
[i
] );
474 case GL_PIXEL_MAP_G_TO_G
:
475 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
476 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapGtoG
[i
] );
479 case GL_PIXEL_MAP_B_TO_B
:
480 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
481 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapBtoB
[i
] );
484 case GL_PIXEL_MAP_A_TO_A
:
485 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
486 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapAtoA
[i
] );
490 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
496 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
498 GET_CURRENT_CONTEXT(ctx
);
500 ASSERT_OUTSIDE_BEGIN_END(ctx
);
503 case GL_PIXEL_MAP_I_TO_I
:
504 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
505 values
[i
] = (GLushort
) ctx
->Pixel
.MapItoI
[i
];
508 case GL_PIXEL_MAP_S_TO_S
:
509 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
510 values
[i
] = (GLushort
) ctx
->Pixel
.MapStoS
[i
];
513 case GL_PIXEL_MAP_I_TO_R
:
514 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
515 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoR
[i
] );
518 case GL_PIXEL_MAP_I_TO_G
:
519 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
520 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoG
[i
] );
523 case GL_PIXEL_MAP_I_TO_B
:
524 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
525 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoB
[i
] );
528 case GL_PIXEL_MAP_I_TO_A
:
529 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
530 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoA
[i
] );
533 case GL_PIXEL_MAP_R_TO_R
:
534 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
535 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapRtoR
[i
] );
538 case GL_PIXEL_MAP_G_TO_G
:
539 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
540 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapGtoG
[i
] );
543 case GL_PIXEL_MAP_B_TO_B
:
544 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
545 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapBtoB
[i
] );
548 case GL_PIXEL_MAP_A_TO_A
:
549 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
550 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapAtoA
[i
] );
554 _mesa_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
560 /**********************************************************************/
561 /***** glPixelTransfer *****/
562 /**********************************************************************/
566 * Implements glPixelTransfer[fi] whether called immediately or from a
570 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
572 GET_CURRENT_CONTEXT(ctx
);
573 ASSERT_OUTSIDE_BEGIN_END(ctx
);
577 if (ctx
->Pixel
.MapColorFlag
== (param
? GL_TRUE
: GL_FALSE
))
579 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
580 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
583 if (ctx
->Pixel
.MapStencilFlag
== (param
? GL_TRUE
: GL_FALSE
))
585 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
586 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
589 if (ctx
->Pixel
.IndexShift
== (GLint
) param
)
591 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
592 ctx
->Pixel
.IndexShift
= (GLint
) param
;
594 case GL_INDEX_OFFSET
:
595 if (ctx
->Pixel
.IndexOffset
== (GLint
) param
)
597 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
598 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
601 if (ctx
->Pixel
.RedScale
== param
)
603 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
604 ctx
->Pixel
.RedScale
= param
;
607 if (ctx
->Pixel
.RedBias
== param
)
609 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
610 ctx
->Pixel
.RedBias
= param
;
613 if (ctx
->Pixel
.GreenScale
== param
)
615 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
616 ctx
->Pixel
.GreenScale
= param
;
619 if (ctx
->Pixel
.GreenBias
== param
)
621 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
622 ctx
->Pixel
.GreenBias
= param
;
625 if (ctx
->Pixel
.BlueScale
== param
)
627 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
628 ctx
->Pixel
.BlueScale
= param
;
631 if (ctx
->Pixel
.BlueBias
== param
)
633 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
634 ctx
->Pixel
.BlueBias
= param
;
637 if (ctx
->Pixel
.AlphaScale
== param
)
639 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
640 ctx
->Pixel
.AlphaScale
= param
;
643 if (ctx
->Pixel
.AlphaBias
== param
)
645 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
646 ctx
->Pixel
.AlphaBias
= param
;
649 if (ctx
->Pixel
.DepthScale
== param
)
651 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
652 ctx
->Pixel
.DepthScale
= param
;
655 if (ctx
->Pixel
.DepthBias
== param
)
657 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
658 ctx
->Pixel
.DepthBias
= param
;
660 case GL_POST_COLOR_MATRIX_RED_SCALE
:
661 if (ctx
->Pixel
.PostColorMatrixScale
[0] == param
)
663 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
664 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
666 case GL_POST_COLOR_MATRIX_RED_BIAS
:
667 if (ctx
->Pixel
.PostColorMatrixBias
[0] == param
)
669 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
670 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
672 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
673 if (ctx
->Pixel
.PostColorMatrixScale
[1] == param
)
675 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
676 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
678 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
679 if (ctx
->Pixel
.PostColorMatrixBias
[1] == param
)
681 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
682 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
684 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
685 if (ctx
->Pixel
.PostColorMatrixScale
[2] == param
)
687 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
688 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
690 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
691 if (ctx
->Pixel
.PostColorMatrixBias
[2] == param
)
693 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
694 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
696 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
697 if (ctx
->Pixel
.PostColorMatrixScale
[3] == param
)
699 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
700 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
702 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
703 if (ctx
->Pixel
.PostColorMatrixBias
[3] == param
)
705 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
706 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
708 case GL_POST_CONVOLUTION_RED_SCALE
:
709 if (ctx
->Pixel
.PostConvolutionScale
[0] == param
)
711 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
712 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
714 case GL_POST_CONVOLUTION_RED_BIAS
:
715 if (ctx
->Pixel
.PostConvolutionBias
[0] == param
)
717 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
718 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
720 case GL_POST_CONVOLUTION_GREEN_SCALE
:
721 if (ctx
->Pixel
.PostConvolutionScale
[1] == param
)
723 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
724 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
726 case GL_POST_CONVOLUTION_GREEN_BIAS
:
727 if (ctx
->Pixel
.PostConvolutionBias
[1] == param
)
729 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
730 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
732 case GL_POST_CONVOLUTION_BLUE_SCALE
:
733 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
735 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
736 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
738 case GL_POST_CONVOLUTION_BLUE_BIAS
:
739 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
741 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
742 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
744 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
745 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
747 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
748 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
750 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
751 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
753 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
754 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
757 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
764 _mesa_PixelTransferi( GLenum pname
, GLint param
)
766 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
771 /**********************************************************************/
772 /***** Pixel processing functions ******/
773 /**********************************************************************/
777 * Apply scale and bias factors to an array of RGBA pixels.
780 _mesa_scale_and_bias_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4],
781 GLfloat rScale
, GLfloat gScale
,
782 GLfloat bScale
, GLfloat aScale
,
783 GLfloat rBias
, GLfloat gBias
,
784 GLfloat bBias
, GLfloat aBias
)
786 if (rScale
!= 1.0 || rBias
!= 0.0) {
788 for (i
= 0; i
< n
; i
++) {
789 rgba
[i
][RCOMP
] = rgba
[i
][RCOMP
] * rScale
+ rBias
;
792 if (gScale
!= 1.0 || gBias
!= 0.0) {
794 for (i
= 0; i
< n
; i
++) {
795 rgba
[i
][GCOMP
] = rgba
[i
][GCOMP
] * gScale
+ gBias
;
798 if (bScale
!= 1.0 || bBias
!= 0.0) {
800 for (i
= 0; i
< n
; i
++) {
801 rgba
[i
][BCOMP
] = rgba
[i
][BCOMP
] * bScale
+ bBias
;
804 if (aScale
!= 1.0 || aBias
!= 0.0) {
806 for (i
= 0; i
< n
; i
++) {
807 rgba
[i
][ACOMP
] = rgba
[i
][ACOMP
] * aScale
+ aBias
;
814 * Apply pixel mapping to an array of floating point RGBA pixels.
817 _mesa_map_rgba( const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4] )
819 const GLfloat rscale
= (GLfloat
) (ctx
->Pixel
.MapRtoRsize
- 1);
820 const GLfloat gscale
= (GLfloat
) (ctx
->Pixel
.MapGtoGsize
- 1);
821 const GLfloat bscale
= (GLfloat
) (ctx
->Pixel
.MapBtoBsize
- 1);
822 const GLfloat ascale
= (GLfloat
) (ctx
->Pixel
.MapAtoAsize
- 1);
823 const GLfloat
*rMap
= ctx
->Pixel
.MapRtoR
;
824 const GLfloat
*gMap
= ctx
->Pixel
.MapGtoG
;
825 const GLfloat
*bMap
= ctx
->Pixel
.MapBtoB
;
826 const GLfloat
*aMap
= ctx
->Pixel
.MapAtoA
;
829 GLfloat r
= CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
830 GLfloat g
= CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
831 GLfloat b
= CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
832 GLfloat a
= CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
833 rgba
[i
][RCOMP
] = rMap
[IROUND(r
* rscale
)];
834 rgba
[i
][GCOMP
] = gMap
[IROUND(g
* gscale
)];
835 rgba
[i
][BCOMP
] = bMap
[IROUND(b
* bscale
)];
836 rgba
[i
][ACOMP
] = aMap
[IROUND(a
* ascale
)];
842 * Apply the color matrix and post color matrix scaling and biasing.
845 _mesa_transform_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
847 const GLfloat rs
= ctx
->Pixel
.PostColorMatrixScale
[0];
848 const GLfloat rb
= ctx
->Pixel
.PostColorMatrixBias
[0];
849 const GLfloat gs
= ctx
->Pixel
.PostColorMatrixScale
[1];
850 const GLfloat gb
= ctx
->Pixel
.PostColorMatrixBias
[1];
851 const GLfloat bs
= ctx
->Pixel
.PostColorMatrixScale
[2];
852 const GLfloat bb
= ctx
->Pixel
.PostColorMatrixBias
[2];
853 const GLfloat as
= ctx
->Pixel
.PostColorMatrixScale
[3];
854 const GLfloat ab
= ctx
->Pixel
.PostColorMatrixBias
[3];
855 const GLfloat
*m
= ctx
->ColorMatrixStack
.Top
->m
;
857 for (i
= 0; i
< n
; i
++) {
858 const GLfloat r
= rgba
[i
][RCOMP
];
859 const GLfloat g
= rgba
[i
][GCOMP
];
860 const GLfloat b
= rgba
[i
][BCOMP
];
861 const GLfloat a
= rgba
[i
][ACOMP
];
862 rgba
[i
][RCOMP
] = (m
[0] * r
+ m
[4] * g
+ m
[ 8] * b
+ m
[12] * a
) * rs
+ rb
;
863 rgba
[i
][GCOMP
] = (m
[1] * r
+ m
[5] * g
+ m
[ 9] * b
+ m
[13] * a
) * gs
+ gb
;
864 rgba
[i
][BCOMP
] = (m
[2] * r
+ m
[6] * g
+ m
[10] * b
+ m
[14] * a
) * bs
+ bb
;
865 rgba
[i
][ACOMP
] = (m
[3] * r
+ m
[7] * g
+ m
[11] * b
+ m
[15] * a
) * as
+ ab
;
871 * Apply a color table lookup to an array of colors.
874 _mesa_lookup_rgba(const struct gl_color_table
*table
,
875 GLuint n
, GLfloat rgba
[][4])
877 ASSERT(table
->FloatTable
);
878 if (!table
->Table
|| table
->Size
== 0)
881 switch (table
->Format
) {
883 /* replace RGBA with I */
884 if (!table
->FloatTable
) {
885 const GLint max
= table
->Size
- 1;
886 const GLfloat scale
= (GLfloat
) max
;
887 const GLchan
*lut
= (const GLchan
*) table
->Table
;
889 for (i
= 0; i
< n
; i
++) {
890 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
891 GLfloat c
= CHAN_TO_FLOAT(lut
[CLAMP(j
, 0, 1)]);
892 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
893 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
898 const GLint max
= table
->Size
- 1;
899 const GLfloat scale
= (GLfloat
) max
;
900 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
902 for (i
= 0; i
< n
; i
++) {
903 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
904 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
905 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
906 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
911 /* replace RGB with L */
912 if (!table
->FloatTable
) {
913 const GLint max
= table
->Size
- 1;
914 const GLfloat scale
= (GLfloat
) max
;
915 const GLchan
*lut
= (const GLchan
*) table
->Table
;
917 for (i
= 0; i
< n
; i
++) {
918 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
919 GLfloat c
= CHAN_TO_FLOAT(lut
[CLAMP(j
, 0, max
)]);
920 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
924 const GLint max
= table
->Size
- 1;
925 const GLfloat scale
= (GLfloat
) max
;
926 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
928 for (i
= 0; i
< n
; i
++) {
929 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
930 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
931 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
936 /* replace A with A */
937 if (!table
->FloatTable
) {
938 const GLint max
= table
->Size
- 1;
939 const GLfloat scale
= (GLfloat
) max
;
940 const GLchan
*lut
= (const GLchan
*) table
->Table
;
942 for (i
= 0; i
< n
; i
++) {
943 GLint j
= IROUND(rgba
[i
][ACOMP
] * scale
);
944 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(lut
[CLAMP(j
, 0, max
)]);
948 const GLint max
= table
->Size
- 1;
949 const GLfloat scale
= (GLfloat
) max
;
950 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
952 for (i
= 0; i
< n
; i
++) {
953 GLint j
= IROUND(rgba
[i
][ACOMP
] * scale
);
954 rgba
[i
][ACOMP
] = lut
[CLAMP(j
, 0, max
)];
958 case GL_LUMINANCE_ALPHA
:
959 /* replace RGBA with LLLA */
960 if (!table
->FloatTable
) {
961 const GLint max
= table
->Size
- 1;
962 const GLfloat scale
= (GLfloat
) max
;
963 const GLchan
*lut
= (const GLchan
*) table
->Table
;
965 for (i
= 0; i
< n
; i
++) {
966 GLint jL
= IROUND(rgba
[i
][RCOMP
] * scale
);
967 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
968 GLfloat luminance
, alpha
;
969 jL
= CLAMP(jL
, 0, max
);
970 jA
= CLAMP(jA
, 0, max
);
971 luminance
= CHAN_TO_FLOAT(lut
[jL
* 2 + 0]);
972 alpha
= CHAN_TO_FLOAT(lut
[jA
* 2 + 1]);
973 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
974 rgba
[i
][ACOMP
] = alpha
;;
978 const GLint max
= table
->Size
- 1;
979 const GLfloat scale
= (GLfloat
) max
;
980 const GLfloat
*lut
= (const GLfloat
*) 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
= lut
[jL
* 2 + 0];
989 alpha
= lut
[jA
* 2 + 1];
990 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
991 rgba
[i
][ACOMP
] = alpha
;;
996 /* replace RGB with RGB */
997 if (!table
->FloatTable
) {
998 const GLint max
= table
->Size
- 1;
999 const GLfloat scale
= (GLfloat
) max
;
1000 const GLchan
*lut
= (const GLchan
*) table
->Table
;
1002 for (i
= 0; i
< n
; i
++) {
1003 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1004 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1005 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1006 jR
= CLAMP(jR
, 0, max
);
1007 jG
= CLAMP(jG
, 0, max
);
1008 jB
= CLAMP(jB
, 0, max
);
1009 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(lut
[jR
* 3 + 0]);
1010 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(lut
[jG
* 3 + 1]);
1011 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(lut
[jB
* 3 + 2]);
1015 const GLint max
= table
->Size
- 1;
1016 const GLfloat scale
= (GLfloat
) max
;
1017 const GLfloat
*lut
= (const GLfloat
*) 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
] = lut
[jR
* 3 + 0];
1027 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
1028 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
1033 /* replace RGBA with RGBA */
1034 if (!table
->FloatTable
) {
1035 const GLint max
= table
->Size
- 1;
1036 const GLfloat scale
= (GLfloat
) max
;
1037 const GLchan
*lut
= (const GLchan
*) table
->Table
;
1039 for (i
= 0; i
< n
; i
++) {
1040 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1041 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1042 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1043 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1044 jR
= CLAMP(jR
, 0, max
);
1045 jG
= CLAMP(jG
, 0, max
);
1046 jB
= CLAMP(jB
, 0, max
);
1047 jA
= CLAMP(jA
, 0, max
);
1048 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(lut
[jR
* 4 + 0]);
1049 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(lut
[jG
* 4 + 1]);
1050 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(lut
[jB
* 4 + 2]);
1051 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(lut
[jA
* 4 + 3]);
1055 const GLint max
= table
->Size
- 1;
1056 const GLfloat scale
= (GLfloat
) max
;
1057 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
1059 for (i
= 0; i
< n
; i
++) {
1060 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1061 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1062 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1063 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1064 jR
= CLAMP(jR
, 0, max
);
1065 jG
= CLAMP(jG
, 0, max
);
1066 jB
= CLAMP(jB
, 0, max
);
1067 jA
= CLAMP(jA
, 0, max
);
1068 rgba
[i
][RCOMP
] = lut
[jR
* 4 + 0];
1069 rgba
[i
][GCOMP
] = lut
[jG
* 4 + 1];
1070 rgba
[i
][BCOMP
] = lut
[jB
* 4 + 2];
1071 rgba
[i
][ACOMP
] = lut
[jA
* 4 + 3];
1076 _mesa_problem(NULL
, "Bad format in _mesa_lookup_rgba");
1084 * Apply color index shift and offset to an array of pixels.
1087 _mesa_shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
1089 GLint shift
= ctx
->Pixel
.IndexShift
;
1090 GLint offset
= ctx
->Pixel
.IndexOffset
;
1094 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
1097 else if (shift
< 0) {
1100 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
1105 indexes
[i
] = indexes
[i
] + offset
;
1112 * Apply color index mapping to color indexes.
1115 _mesa_map_ci( const GLcontext
*ctx
, GLuint n
, GLuint index
[] )
1117 GLuint mask
= ctx
->Pixel
.MapItoIsize
- 1;
1120 index
[i
] = ctx
->Pixel
.MapItoI
[ index
[i
] & mask
];
1126 * Map color indexes to rgba values.
1129 _mesa_map_ci_to_rgba_chan( const GLcontext
*ctx
, GLuint n
,
1130 const GLuint index
[], GLchan rgba
[][4] )
1133 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1134 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1135 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1136 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1137 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
1138 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
1139 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
1140 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
1143 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1144 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1145 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1146 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1149 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1150 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1151 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1152 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1153 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1154 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1155 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1156 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1159 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][RCOMP
], rMap
[index
[i
] & rmask
]);
1160 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][GCOMP
], gMap
[index
[i
] & gmask
]);
1161 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][BCOMP
], bMap
[index
[i
] & bmask
]);
1162 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][ACOMP
], aMap
[index
[i
] & amask
]);
1169 * Map color indexes to float rgba values.
1172 _mesa_map_ci_to_rgba( const GLcontext
*ctx
, GLuint n
,
1173 const GLuint index
[], GLfloat rgba
[][4] )
1175 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1176 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1177 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1178 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1179 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1180 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1181 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1182 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1185 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1186 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1187 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1188 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1194 * Map 8-bit color indexes to rgb values.
1197 _mesa_map_ci8_to_rgba( const GLcontext
*ctx
, GLuint n
, const GLubyte index
[],
1201 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1202 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1203 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1204 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1205 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
1206 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
1207 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
1208 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
1211 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1212 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1213 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1214 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1217 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1218 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1219 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1220 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1221 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1222 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1223 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1224 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1227 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][RCOMP
], rMap
[index
[i
] & rmask
]);
1228 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][GCOMP
], gMap
[index
[i
] & gmask
]);
1229 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][BCOMP
], bMap
[index
[i
] & bmask
]);
1230 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][ACOMP
], aMap
[index
[i
] & amask
]);
1237 _mesa_shift_and_offset_stencil( const GLcontext
*ctx
, GLuint n
,
1238 GLstencil stencil
[] )
1241 GLint shift
= ctx
->Pixel
.IndexShift
;
1242 GLint offset
= ctx
->Pixel
.IndexOffset
;
1245 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
1248 else if (shift
< 0) {
1251 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
1256 stencil
[i
] = stencil
[i
] + offset
;
1264 _mesa_map_stencil( const GLcontext
*ctx
, GLuint n
, GLstencil stencil
[] )
1266 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
1269 stencil
[i
] = ctx
->Pixel
.MapStoS
[ stencil
[i
] & mask
];
1276 * This function converts an array of GLchan colors to GLfloat colors.
1277 * Most importantly, it undoes the non-uniform quantization of pixel
1278 * values introduced when we convert shallow (< 8 bit) pixel values
1279 * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1280 * This fixes a number of OpenGL conformance failures when running on
1281 * 16bpp displays, for example.
1284 _mesa_chan_to_float_span(const GLcontext
*ctx
, GLuint n
,
1285 CONST GLchan rgba
[][4], GLfloat rgbaf
[][4])
1287 #if CHAN_TYPE == GL_FLOAT
1288 MEMCPY(rgbaf
, rgba
, n
* 4 * sizeof(GLfloat
));
1290 const GLuint rShift
= CHAN_BITS
- ctx
->Visual
.redBits
;
1291 const GLuint gShift
= CHAN_BITS
- ctx
->Visual
.greenBits
;
1292 const GLuint bShift
= CHAN_BITS
- ctx
->Visual
.blueBits
;
1294 const GLfloat rScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.redBits
) - 1);
1295 const GLfloat gScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.greenBits
) - 1);
1296 const GLfloat bScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.blueBits
) - 1);
1300 if (ctx
->Visual
.alphaBits
> 0) {
1301 aShift
= CHAN_BITS
- ctx
->Visual
.alphaBits
;
1302 aScale
= 1.0F
/ (GLfloat
) ((1 << ctx
->Visual
.alphaBits
) - 1);
1306 aScale
= 1.0F
/ CHAN_MAXF
;
1309 for (i
= 0; i
< n
; i
++) {
1310 const GLint r
= rgba
[i
][RCOMP
] >> rShift
;
1311 const GLint g
= rgba
[i
][GCOMP
] >> gShift
;
1312 const GLint b
= rgba
[i
][BCOMP
] >> bShift
;
1313 const GLint a
= rgba
[i
][ACOMP
] >> aShift
;
1314 rgbaf
[i
][RCOMP
] = (GLfloat
) r
* rScale
;
1315 rgbaf
[i
][GCOMP
] = (GLfloat
) g
* gScale
;
1316 rgbaf
[i
][BCOMP
] = (GLfloat
) b
* bScale
;
1317 rgbaf
[i
][ACOMP
] = (GLfloat
) a
* aScale
;