1 /* $Id: pixel.c,v 1.21 2000/12/13 00:46:21 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999-2000 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
);
52 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelZoom");
54 ctx
->Pixel
.ZoomX
= xfactor
;
55 ctx
->Pixel
.ZoomY
= yfactor
;
56 ctx
->NewState
|= _NEW_PIXEL
;
61 /**********************************************************************/
62 /***** glPixelStore *****/
63 /**********************************************************************/
67 _mesa_PixelStorei( GLenum pname
, GLint param
)
69 /* NOTE: this call can't be compiled into the display list */
70 GET_CURRENT_CONTEXT(ctx
);
71 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelStore");
74 case GL_PACK_SWAP_BYTES
:
75 ctx
->Pack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
77 case GL_PACK_LSB_FIRST
:
78 ctx
->Pack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
80 case GL_PACK_ROW_LENGTH
:
82 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
85 ctx
->Pack
.RowLength
= param
;
88 case GL_PACK_IMAGE_HEIGHT
:
90 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
92 ctx
->Pack
.ImageHeight
= param
;
94 case GL_PACK_SKIP_PIXELS
:
96 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
99 ctx
->Pack
.SkipPixels
= param
;
102 case GL_PACK_SKIP_ROWS
:
104 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
107 ctx
->Pack
.SkipRows
= param
;
110 case GL_PACK_SKIP_IMAGES
:
112 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
115 ctx
->Pack
.SkipImages
= param
;
118 case GL_PACK_ALIGNMENT
:
119 if (param
==1 || param
==2 || param
==4 || param
==8) {
120 ctx
->Pack
.Alignment
= param
;
123 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
126 case GL_UNPACK_SWAP_BYTES
:
127 ctx
->Unpack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
129 case GL_UNPACK_LSB_FIRST
:
130 ctx
->Unpack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
132 case GL_UNPACK_ROW_LENGTH
:
134 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
137 ctx
->Unpack
.RowLength
= param
;
140 case GL_UNPACK_IMAGE_HEIGHT
:
142 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
144 ctx
->Unpack
.ImageHeight
= param
;
146 case GL_UNPACK_SKIP_PIXELS
:
148 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
151 ctx
->Unpack
.SkipPixels
= param
;
154 case GL_UNPACK_SKIP_ROWS
:
156 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
159 ctx
->Unpack
.SkipRows
= param
;
162 case GL_UNPACK_SKIP_IMAGES
:
164 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
167 ctx
->Unpack
.SkipImages
= param
;
170 case GL_UNPACK_ALIGNMENT
:
171 if (param
==1 || param
==2 || param
==4 || param
==8) {
172 ctx
->Unpack
.Alignment
= param
;
175 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore" );
179 gl_error( ctx
, GL_INVALID_ENUM
, "glPixelStore" );
182 ctx
->NewState
|= _NEW_PACKUNPACK
;
187 _mesa_PixelStoref( GLenum pname
, GLfloat param
)
189 _mesa_PixelStorei( pname
, (GLint
) param
);
194 /**********************************************************************/
195 /***** glPixelMap *****/
196 /**********************************************************************/
201 _mesa_PixelMapfv( GLenum map
, GLint mapsize
, const GLfloat
*values
)
204 GET_CURRENT_CONTEXT(ctx
);
205 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelMapfv");
208 if (mapsize
<0 || mapsize
>MAX_PIXEL_MAP_TABLE
) {
209 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
213 if (map
>=GL_PIXEL_MAP_S_TO_S
&& map
<=GL_PIXEL_MAP_I_TO_A
) {
214 /* test that mapsize is a power of two */
216 GLboolean ok
= GL_FALSE
;
217 for (p
=1; p
<=MAX_PIXEL_MAP_TABLE
; p
=p
<<1) {
218 if ( (p
&mapsize
) == p
) {
224 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
230 case GL_PIXEL_MAP_S_TO_S
:
231 ctx
->Pixel
.MapStoSsize
= mapsize
;
232 for (i
=0;i
<mapsize
;i
++) {
233 ctx
->Pixel
.MapStoS
[i
] = (GLint
) values
[i
];
236 case GL_PIXEL_MAP_I_TO_I
:
237 ctx
->Pixel
.MapItoIsize
= mapsize
;
238 for (i
=0;i
<mapsize
;i
++) {
239 ctx
->Pixel
.MapItoI
[i
] = (GLint
) values
[i
];
242 case GL_PIXEL_MAP_I_TO_R
:
243 ctx
->Pixel
.MapItoRsize
= mapsize
;
244 for (i
=0;i
<mapsize
;i
++) {
245 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
246 ctx
->Pixel
.MapItoR
[i
] = val
;
247 ctx
->Pixel
.MapItoR8
[i
] = (GLint
) (val
* 255.0F
);
250 case GL_PIXEL_MAP_I_TO_G
:
251 ctx
->Pixel
.MapItoGsize
= mapsize
;
252 for (i
=0;i
<mapsize
;i
++) {
253 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
254 ctx
->Pixel
.MapItoG
[i
] = val
;
255 ctx
->Pixel
.MapItoG8
[i
] = (GLint
) (val
* 255.0F
);
258 case GL_PIXEL_MAP_I_TO_B
:
259 ctx
->Pixel
.MapItoBsize
= mapsize
;
260 for (i
=0;i
<mapsize
;i
++) {
261 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
262 ctx
->Pixel
.MapItoB
[i
] = val
;
263 ctx
->Pixel
.MapItoB8
[i
] = (GLint
) (val
* 255.0F
);
266 case GL_PIXEL_MAP_I_TO_A
:
267 ctx
->Pixel
.MapItoAsize
= mapsize
;
268 for (i
=0;i
<mapsize
;i
++) {
269 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
270 ctx
->Pixel
.MapItoA
[i
] = val
;
271 ctx
->Pixel
.MapItoA8
[i
] = (GLint
) (val
* 255.0F
);
274 case GL_PIXEL_MAP_R_TO_R
:
275 ctx
->Pixel
.MapRtoRsize
= mapsize
;
276 for (i
=0;i
<mapsize
;i
++) {
277 ctx
->Pixel
.MapRtoR
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
280 case GL_PIXEL_MAP_G_TO_G
:
281 ctx
->Pixel
.MapGtoGsize
= mapsize
;
282 for (i
=0;i
<mapsize
;i
++) {
283 ctx
->Pixel
.MapGtoG
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
286 case GL_PIXEL_MAP_B_TO_B
:
287 ctx
->Pixel
.MapBtoBsize
= mapsize
;
288 for (i
=0;i
<mapsize
;i
++) {
289 ctx
->Pixel
.MapBtoB
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
292 case GL_PIXEL_MAP_A_TO_A
:
293 ctx
->Pixel
.MapAtoAsize
= mapsize
;
294 for (i
=0;i
<mapsize
;i
++) {
295 ctx
->Pixel
.MapAtoA
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
299 gl_error( ctx
, GL_INVALID_ENUM
, "glPixelMapfv(map)" );
301 ctx
->NewState
|= _NEW_PIXEL
;
307 _mesa_PixelMapuiv(GLenum map
, GLint mapsize
, const GLuint
*values
)
309 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
311 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
312 for (i
=0;i
<mapsize
;i
++) {
313 fvalues
[i
] = (GLfloat
) values
[i
];
317 for (i
=0;i
<mapsize
;i
++) {
318 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
321 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
327 _mesa_PixelMapusv(GLenum map
, GLint mapsize
, const GLushort
*values
)
329 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
331 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
332 for (i
=0;i
<mapsize
;i
++) {
333 fvalues
[i
] = (GLfloat
) values
[i
];
337 for (i
=0;i
<mapsize
;i
++) {
338 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
341 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
347 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
349 GET_CURRENT_CONTEXT(ctx
);
352 ASSERT_OUTSIDE_BEGIN_END(ctx
, "glGetPixelMapfv");
355 case GL_PIXEL_MAP_I_TO_I
:
356 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
357 values
[i
] = (GLfloat
) ctx
->Pixel
.MapItoI
[i
];
360 case GL_PIXEL_MAP_S_TO_S
:
361 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
362 values
[i
] = (GLfloat
) ctx
->Pixel
.MapStoS
[i
];
365 case GL_PIXEL_MAP_I_TO_R
:
366 MEMCPY(values
,ctx
->Pixel
.MapItoR
,ctx
->Pixel
.MapItoRsize
*sizeof(GLfloat
));
368 case GL_PIXEL_MAP_I_TO_G
:
369 MEMCPY(values
,ctx
->Pixel
.MapItoG
,ctx
->Pixel
.MapItoGsize
*sizeof(GLfloat
));
371 case GL_PIXEL_MAP_I_TO_B
:
372 MEMCPY(values
,ctx
->Pixel
.MapItoB
,ctx
->Pixel
.MapItoBsize
*sizeof(GLfloat
));
374 case GL_PIXEL_MAP_I_TO_A
:
375 MEMCPY(values
,ctx
->Pixel
.MapItoA
,ctx
->Pixel
.MapItoAsize
*sizeof(GLfloat
));
377 case GL_PIXEL_MAP_R_TO_R
:
378 MEMCPY(values
,ctx
->Pixel
.MapRtoR
,ctx
->Pixel
.MapRtoRsize
*sizeof(GLfloat
));
380 case GL_PIXEL_MAP_G_TO_G
:
381 MEMCPY(values
,ctx
->Pixel
.MapGtoG
,ctx
->Pixel
.MapGtoGsize
*sizeof(GLfloat
));
383 case GL_PIXEL_MAP_B_TO_B
:
384 MEMCPY(values
,ctx
->Pixel
.MapBtoB
,ctx
->Pixel
.MapBtoBsize
*sizeof(GLfloat
));
386 case GL_PIXEL_MAP_A_TO_A
:
387 MEMCPY(values
,ctx
->Pixel
.MapAtoA
,ctx
->Pixel
.MapAtoAsize
*sizeof(GLfloat
));
390 gl_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
396 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
398 GET_CURRENT_CONTEXT(ctx
);
401 ASSERT_OUTSIDE_BEGIN_END(ctx
, "glGetPixelMapfv");
404 case GL_PIXEL_MAP_I_TO_I
:
405 MEMCPY(values
, ctx
->Pixel
.MapItoI
, ctx
->Pixel
.MapItoIsize
*sizeof(GLint
));
407 case GL_PIXEL_MAP_S_TO_S
:
408 MEMCPY(values
, ctx
->Pixel
.MapStoS
, ctx
->Pixel
.MapStoSsize
*sizeof(GLint
));
410 case GL_PIXEL_MAP_I_TO_R
:
411 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
412 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoR
[i
] );
415 case GL_PIXEL_MAP_I_TO_G
:
416 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
417 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoG
[i
] );
420 case GL_PIXEL_MAP_I_TO_B
:
421 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
422 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoB
[i
] );
425 case GL_PIXEL_MAP_I_TO_A
:
426 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
427 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoA
[i
] );
430 case GL_PIXEL_MAP_R_TO_R
:
431 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
432 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapRtoR
[i
] );
435 case GL_PIXEL_MAP_G_TO_G
:
436 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
437 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapGtoG
[i
] );
440 case GL_PIXEL_MAP_B_TO_B
:
441 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
442 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapBtoB
[i
] );
445 case GL_PIXEL_MAP_A_TO_A
:
446 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
447 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapAtoA
[i
] );
451 gl_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
457 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
459 GET_CURRENT_CONTEXT(ctx
);
462 ASSERT_OUTSIDE_BEGIN_END(ctx
, "glGetPixelMapfv");
465 case GL_PIXEL_MAP_I_TO_I
:
466 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
467 values
[i
] = (GLushort
) ctx
->Pixel
.MapItoI
[i
];
470 case GL_PIXEL_MAP_S_TO_S
:
471 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
472 values
[i
] = (GLushort
) ctx
->Pixel
.MapStoS
[i
];
475 case GL_PIXEL_MAP_I_TO_R
:
476 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
477 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoR
[i
] );
480 case GL_PIXEL_MAP_I_TO_G
:
481 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
482 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoG
[i
] );
485 case GL_PIXEL_MAP_I_TO_B
:
486 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
487 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoB
[i
] );
490 case GL_PIXEL_MAP_I_TO_A
:
491 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
492 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoA
[i
] );
495 case GL_PIXEL_MAP_R_TO_R
:
496 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
497 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapRtoR
[i
] );
500 case GL_PIXEL_MAP_G_TO_G
:
501 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
502 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapGtoG
[i
] );
505 case GL_PIXEL_MAP_B_TO_B
:
506 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
507 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapBtoB
[i
] );
510 case GL_PIXEL_MAP_A_TO_A
:
511 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
512 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapAtoA
[i
] );
516 gl_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
522 /**********************************************************************/
523 /***** glPixelTransfer *****/
524 /**********************************************************************/
528 * Implements glPixelTransfer[fi] whether called immediately or from a
532 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
534 GET_CURRENT_CONTEXT(ctx
);
535 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelTransfer");
540 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
543 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
546 ctx
->Pixel
.IndexShift
= (GLint
) param
;
548 case GL_INDEX_OFFSET
:
549 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
552 ctx
->Pixel
.RedScale
= param
;
555 ctx
->Pixel
.RedBias
= param
;
558 ctx
->Pixel
.GreenScale
= param
;
561 ctx
->Pixel
.GreenBias
= param
;
564 ctx
->Pixel
.BlueScale
= param
;
567 ctx
->Pixel
.BlueBias
= param
;
570 ctx
->Pixel
.AlphaScale
= param
;
573 ctx
->Pixel
.AlphaBias
= param
;
576 ctx
->Pixel
.DepthScale
= param
;
579 ctx
->Pixel
.DepthBias
= param
;
581 case GL_POST_COLOR_MATRIX_RED_SCALE
:
582 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
584 case GL_POST_COLOR_MATRIX_RED_BIAS
:
585 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
587 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
588 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
590 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
591 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
593 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
594 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
596 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
597 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
599 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
600 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
602 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
603 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
605 case GL_POST_CONVOLUTION_RED_SCALE
:
606 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
608 case GL_POST_CONVOLUTION_RED_BIAS
:
609 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
611 case GL_POST_CONVOLUTION_GREEN_SCALE
:
612 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
614 case GL_POST_CONVOLUTION_GREEN_BIAS
:
615 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
617 case GL_POST_CONVOLUTION_BLUE_SCALE
:
618 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
620 case GL_POST_CONVOLUTION_BLUE_BIAS
:
621 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
623 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
624 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
626 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
627 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
630 gl_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
634 /* signal to recompute the bitmask */
635 ctx
->NewState
|= _NEW_PIXEL
;
640 _mesa_PixelTransferi( GLenum pname
, GLint param
)
642 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
647 /**********************************************************************/
648 /***** Pixel processing functions ******/
649 /**********************************************************************/
653 * Apply scale and bias factors to an array of RGBA pixels.
656 _mesa_scale_and_bias_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4],
657 GLfloat rScale
, GLfloat gScale
,
658 GLfloat bScale
, GLfloat aScale
,
659 GLfloat rBias
, GLfloat gBias
,
660 GLfloat bBias
, GLfloat aBias
)
662 if (rScale
!= 1.0 || rBias
!= 0.0) {
664 for (i
= 0; i
< n
; i
++) {
665 rgba
[i
][RCOMP
] = rgba
[i
][RCOMP
] * rScale
+ rBias
;
668 if (gScale
!= 1.0 || gBias
!= 0.0) {
670 for (i
= 0; i
< n
; i
++) {
671 rgba
[i
][GCOMP
] = rgba
[i
][GCOMP
] * gScale
+ gBias
;
674 if (bScale
!= 1.0 || bBias
!= 0.0) {
676 for (i
= 0; i
< n
; i
++) {
677 rgba
[i
][BCOMP
] = rgba
[i
][BCOMP
] * bScale
+ bBias
;
680 if (aScale
!= 1.0 || aBias
!= 0.0) {
682 for (i
= 0; i
< n
; i
++) {
683 rgba
[i
][ACOMP
] = rgba
[i
][ACOMP
] * aScale
+ aBias
;
690 * Apply pixel mapping to an array of floating point RGBA pixels.
693 _mesa_map_rgba( const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4] )
695 const GLfloat rscale
= ctx
->Pixel
.MapRtoRsize
- 1;
696 const GLfloat gscale
= ctx
->Pixel
.MapGtoGsize
- 1;
697 const GLfloat bscale
= ctx
->Pixel
.MapBtoBsize
- 1;
698 const GLfloat ascale
= ctx
->Pixel
.MapAtoAsize
- 1;
699 const GLfloat
*rMap
= ctx
->Pixel
.MapRtoR
;
700 const GLfloat
*gMap
= ctx
->Pixel
.MapGtoG
;
701 const GLfloat
*bMap
= ctx
->Pixel
.MapBtoB
;
702 const GLfloat
*aMap
= ctx
->Pixel
.MapAtoA
;
705 rgba
[i
][RCOMP
] = rMap
[(GLint
) (rgba
[i
][RCOMP
] * rscale
+ 0.5F
)];
706 rgba
[i
][GCOMP
] = gMap
[(GLint
) (rgba
[i
][GCOMP
] * gscale
+ 0.5F
)];
707 rgba
[i
][BCOMP
] = bMap
[(GLint
) (rgba
[i
][BCOMP
] * bscale
+ 0.5F
)];
708 rgba
[i
][ACOMP
] = aMap
[(GLint
) (rgba
[i
][ACOMP
] * ascale
+ 0.5F
)];
714 * Apply the color matrix and post color matrix scaling and biasing.
717 _mesa_transform_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
719 const GLfloat rs
= ctx
->Pixel
.PostColorMatrixScale
[0];
720 const GLfloat rb
= ctx
->Pixel
.PostColorMatrixBias
[0];
721 const GLfloat gs
= ctx
->Pixel
.PostColorMatrixScale
[1];
722 const GLfloat gb
= ctx
->Pixel
.PostColorMatrixBias
[1];
723 const GLfloat bs
= ctx
->Pixel
.PostColorMatrixScale
[2];
724 const GLfloat bb
= ctx
->Pixel
.PostColorMatrixBias
[2];
725 const GLfloat as
= ctx
->Pixel
.PostColorMatrixScale
[3];
726 const GLfloat ab
= ctx
->Pixel
.PostColorMatrixBias
[3];
727 const GLfloat
*m
= ctx
->ColorMatrix
.m
;
729 for (i
= 0; i
< n
; i
++) {
730 const GLfloat r
= rgba
[i
][RCOMP
];
731 const GLfloat g
= rgba
[i
][GCOMP
];
732 const GLfloat b
= rgba
[i
][BCOMP
];
733 const GLfloat a
= rgba
[i
][ACOMP
];
734 rgba
[i
][RCOMP
] = (m
[0] * r
+ m
[4] * g
+ m
[ 8] * b
+ m
[12] * a
) * rs
+ rb
;
735 rgba
[i
][GCOMP
] = (m
[1] * r
+ m
[5] * g
+ m
[ 9] * b
+ m
[13] * a
) * gs
+ gb
;
736 rgba
[i
][BCOMP
] = (m
[2] * r
+ m
[6] * g
+ m
[10] * b
+ m
[14] * a
) * bs
+ bb
;
737 rgba
[i
][ACOMP
] = (m
[3] * r
+ m
[7] * g
+ m
[11] * b
+ m
[15] * a
) * as
+ ab
;
743 * Apply a color table lookup to an array of colors.
746 _mesa_lookup_rgba(const struct gl_color_table
*table
,
747 GLuint n
, GLfloat rgba
[][4])
749 ASSERT(table
->FloatTable
);
753 switch (table
->Format
) {
755 /* replace RGBA with I */
756 if (!table
->FloatTable
) {
757 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
758 const GLchan
*lut
= (const GLchan
*) table
->Table
;
760 for (i
= 0; i
< n
; i
++) {
761 GLint j
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
762 GLfloat c
= CHAN_TO_FLOAT(lut
[j
]);
763 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
764 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
769 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
770 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
772 for (i
= 0; i
< n
; i
++) {
773 GLint j
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
775 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
776 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
781 /* replace RGB with L */
782 if (!table
->FloatTable
) {
783 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
784 const GLchan
*lut
= (const GLchan
*) table
->Table
;
786 for (i
= 0; i
< n
; i
++) {
787 GLint j
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
788 GLfloat c
= CHAN_TO_FLOAT(lut
[j
]);
789 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
793 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
794 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
796 for (i
= 0; i
< n
; i
++) {
797 GLint j
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
799 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
804 /* replace A with A */
805 if (!table
->FloatTable
) {
806 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
807 const GLchan
*lut
= (const GLchan
*) table
->Table
;
809 for (i
= 0; i
< n
; i
++) {
810 GLint j
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
811 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(lut
[j
]);
815 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
816 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
818 for (i
= 0; i
< n
; i
++) {
819 GLint j
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
820 rgba
[i
][ACOMP
] = lut
[j
];
824 case GL_LUMINANCE_ALPHA
:
825 /* replace RGBA with LLLA */
826 if (!table
->FloatTable
) {
827 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
828 const GLchan
*lut
= (const GLchan
*) table
->Table
;
830 for (i
= 0; i
< n
; i
++) {
831 GLint jL
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
832 GLint jA
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
833 GLfloat luminance
= CHAN_TO_FLOAT(lut
[jL
* 2 + 0]);
834 GLfloat alpha
= CHAN_TO_FLOAT(lut
[jA
* 2 + 1]);
835 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
836 rgba
[i
][ACOMP
] = alpha
;;
840 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
841 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
843 for (i
= 0; i
< n
; i
++) {
844 GLint jL
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
845 GLint jA
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
846 GLfloat luminance
= lut
[jL
* 2 + 0];
847 GLfloat alpha
= lut
[jA
* 2 + 1];
848 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
849 rgba
[i
][ACOMP
] = alpha
;;
854 /* replace RGB with RGB */
855 if (!table
->FloatTable
) {
856 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
857 const GLchan
*lut
= (const GLchan
*) table
->Table
;
859 for (i
= 0; i
< n
; i
++) {
860 GLint jR
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
861 GLint jG
= (GLint
) (rgba
[i
][GCOMP
] * scale
+ 0.5F
);
862 GLint jB
= (GLint
) (rgba
[i
][BCOMP
] * scale
+ 0.5F
);
863 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(lut
[jR
* 3 + 0]);
864 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(lut
[jG
* 3 + 1]);
865 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(lut
[jB
* 3 + 2]);
869 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
870 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
872 for (i
= 0; i
< n
; i
++) {
873 GLint jR
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
874 GLint jG
= (GLint
) (rgba
[i
][GCOMP
] * scale
+ 0.5F
);
875 GLint jB
= (GLint
) (rgba
[i
][BCOMP
] * scale
+ 0.5F
);
876 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
877 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
878 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
883 /* replace RGBA with RGBA */
884 if (!table
->FloatTable
) {
885 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
886 const GLchan
*lut
= (const GLchan
*) table
->Table
;
888 for (i
= 0; i
< n
; i
++) {
889 GLint jR
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
890 GLint jG
= (GLint
) (rgba
[i
][GCOMP
] * scale
+ 0.5F
);
891 GLint jB
= (GLint
) (rgba
[i
][BCOMP
] * scale
+ 0.5F
);
892 GLint jA
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
893 rgba
[i
][RCOMP
] = CHAN_TO_FLOAT(lut
[jR
* 4 + 0]);
894 rgba
[i
][GCOMP
] = CHAN_TO_FLOAT(lut
[jG
* 4 + 1]);
895 rgba
[i
][BCOMP
] = CHAN_TO_FLOAT(lut
[jB
* 4 + 2]);
896 rgba
[i
][ACOMP
] = CHAN_TO_FLOAT(lut
[jA
* 4 + 3]);
900 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
901 const GLfloat
*lut
= (const GLfloat
*) table
->Table
;
903 for (i
= 0; i
< n
; i
++) {
904 GLint jR
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
905 GLint jG
= (GLint
) (rgba
[i
][GCOMP
] * scale
+ 0.5F
);
906 GLint jB
= (GLint
) (rgba
[i
][BCOMP
] * scale
+ 0.5F
);
907 GLint jA
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
908 rgba
[i
][RCOMP
] = lut
[jR
* 4 + 0];
909 rgba
[i
][GCOMP
] = lut
[jG
* 4 + 1];
910 rgba
[i
][BCOMP
] = lut
[jB
* 4 + 2];
911 rgba
[i
][ACOMP
] = lut
[jA
* 4 + 3];
916 gl_problem(NULL
, "Bad format in _mesa_lookup_rgba");
924 * Apply color index shift and offset to an array of pixels.
927 _mesa_shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
929 GLint shift
= ctx
->Pixel
.IndexShift
;
930 GLint offset
= ctx
->Pixel
.IndexOffset
;
934 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
937 else if (shift
< 0) {
940 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
945 indexes
[i
] = indexes
[i
] + offset
;
952 * Apply color index mapping to color indexes.
955 _mesa_map_ci( const GLcontext
*ctx
, GLuint n
, GLuint index
[] )
957 GLuint mask
= ctx
->Pixel
.MapItoIsize
- 1;
960 index
[i
] = ctx
->Pixel
.MapItoI
[ index
[i
] & mask
];
966 * Map color indexes to rgba values.
969 _mesa_map_ci_to_rgba_chan( const GLcontext
*ctx
, GLuint n
,
970 const GLuint index
[], GLchan rgba
[][4] )
973 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
974 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
975 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
976 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
977 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
978 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
979 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
980 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
983 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
984 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
985 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
986 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
989 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
990 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
991 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
992 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
993 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
994 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
995 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
996 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
999 rgba
[i
][RCOMP
] = FLOAT_TO_CHAN(rMap
[index
[i
] & rmask
]);
1000 rgba
[i
][GCOMP
] = FLOAT_TO_CHAN(gMap
[index
[i
] & gmask
]);
1001 rgba
[i
][BCOMP
] = FLOAT_TO_CHAN(bMap
[index
[i
] & bmask
]);
1002 rgba
[i
][ACOMP
] = FLOAT_TO_CHAN(aMap
[index
[i
] & amask
]);
1009 * Map color indexes to float rgba values.
1012 _mesa_map_ci_to_rgba( const GLcontext
*ctx
, GLuint n
,
1013 const GLuint index
[], GLfloat rgba
[][4] )
1015 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1016 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1017 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1018 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1019 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1020 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1021 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1022 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1025 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1026 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1027 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1028 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1034 * Map 8-bit color indexes to rgb values.
1037 _mesa_map_ci8_to_rgba( const GLcontext
*ctx
, GLuint n
, const GLubyte index
[],
1041 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1042 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1043 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1044 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1045 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
1046 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
1047 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
1048 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
1051 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1052 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1053 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1054 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1057 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
1058 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
1059 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
1060 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
1061 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
1062 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
1063 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
1064 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
1067 rgba
[i
][RCOMP
] = FLOAT_TO_CHAN(rMap
[index
[i
] & rmask
]);
1068 rgba
[i
][GCOMP
] = FLOAT_TO_CHAN(gMap
[index
[i
] & gmask
]);
1069 rgba
[i
][BCOMP
] = FLOAT_TO_CHAN(bMap
[index
[i
] & bmask
]);
1070 rgba
[i
][ACOMP
] = FLOAT_TO_CHAN(aMap
[index
[i
] & amask
]);
1077 _mesa_shift_and_offset_stencil( const GLcontext
*ctx
, GLuint n
,
1078 GLstencil stencil
[] )
1081 GLint shift
= ctx
->Pixel
.IndexShift
;
1082 GLint offset
= ctx
->Pixel
.IndexOffset
;
1085 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
1088 else if (shift
< 0) {
1091 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
1096 stencil
[i
] = stencil
[i
] + offset
;
1104 _mesa_map_stencil( const GLcontext
*ctx
, GLuint n
, GLstencil stencil
[] )
1106 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
1109 stencil
[i
] = ctx
->Pixel
.MapStoS
[ stencil
[i
] & mask
];
1116 * This function converts an array of GLchan colors to GLfloat colors.
1117 * Most importantly, it undoes the non-uniform quantization of pixel
1118 * values introduced when we convert shallow (< 8 bit) pixel values
1119 * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1120 * This fixes a number of OpenGL conformance failures when running on
1121 * 16bpp displays, for example.
1124 _mesa_chan_to_float_span(const GLcontext
*ctx
, GLuint n
,
1125 CONST GLchan rgba
[][4], GLfloat rgbaf
[][4])
1127 const GLuint rShift
= CHAN_BITS
- ctx
->Visual
.RedBits
;
1128 const GLuint gShift
= CHAN_BITS
- ctx
->Visual
.GreenBits
;
1129 const GLuint bShift
= CHAN_BITS
- ctx
->Visual
.BlueBits
;
1131 const GLfloat rScale
= 1.0 / (GLfloat
) ((1 << ctx
->Visual
.RedBits
) - 1);
1132 const GLfloat gScale
= 1.0 / (GLfloat
) ((1 << ctx
->Visual
.GreenBits
) - 1);
1133 const GLfloat bScale
= 1.0 / (GLfloat
) ((1 << ctx
->Visual
.BlueBits
) - 1);
1137 if (ctx
->Visual
.AlphaBits
> 0) {
1138 aShift
= CHAN_BITS
- ctx
->Visual
.AlphaBits
;
1139 aScale
= 1.0 / (GLfloat
) ((1 << ctx
->Visual
.AlphaBits
) - 1);
1143 aScale
= 1.0F
/ CHAN_MAXF
;
1146 for (i
= 0; i
< n
; i
++) {
1147 const GLint r
= rgba
[i
][RCOMP
] >> rShift
;
1148 const GLint g
= rgba
[i
][GCOMP
] >> gShift
;
1149 const GLint b
= rgba
[i
][BCOMP
] >> bShift
;
1150 const GLint a
= rgba
[i
][ACOMP
] >> aShift
;
1151 rgbaf
[i
][RCOMP
] = (GLfloat
) r
* rScale
;
1152 rgbaf
[i
][GCOMP
] = (GLfloat
) g
* gScale
;
1153 rgbaf
[i
][BCOMP
] = (GLfloat
) b
* bScale
;
1154 rgbaf
[i
][ACOMP
] = (GLfloat
) a
* aScale
;