1 /* $Id: pixel.c,v 1.8 2000/04/17 15:13:53 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.
41 /**********************************************************************/
42 /***** glPixelZoom *****/
43 /**********************************************************************/
48 _mesa_PixelZoom( GLfloat xfactor
, GLfloat yfactor
)
50 GET_CURRENT_CONTEXT(ctx
);
51 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelZoom");
53 ctx
->Pixel
.ZoomX
= xfactor
;
54 ctx
->Pixel
.ZoomY
= yfactor
;
59 /**********************************************************************/
60 /***** glPixelStore *****/
61 /**********************************************************************/
65 _mesa_PixelStorei( GLenum pname
, GLint param
)
67 /* NOTE: this call can't be compiled into the display list */
68 GET_CURRENT_CONTEXT(ctx
);
69 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelStore");
72 case GL_PACK_SWAP_BYTES
:
73 ctx
->Pack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
75 case GL_PACK_LSB_FIRST
:
76 ctx
->Pack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
78 case GL_PACK_ROW_LENGTH
:
80 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
83 ctx
->Pack
.RowLength
= param
;
86 case GL_PACK_IMAGE_HEIGHT
:
88 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
90 ctx
->Pack
.ImageHeight
= param
;
92 case GL_PACK_SKIP_PIXELS
:
94 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
97 ctx
->Pack
.SkipPixels
= param
;
100 case GL_PACK_SKIP_ROWS
:
102 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
105 ctx
->Pack
.SkipRows
= param
;
108 case GL_PACK_ALIGNMENT
:
109 if (param
==1 || param
==2 || param
==4 || param
==8) {
110 ctx
->Pack
.Alignment
= param
;
113 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
116 case GL_UNPACK_SWAP_BYTES
:
117 ctx
->Unpack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
119 case GL_UNPACK_LSB_FIRST
:
120 ctx
->Unpack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
122 case GL_UNPACK_ROW_LENGTH
:
124 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
127 ctx
->Unpack
.RowLength
= param
;
130 case GL_UNPACK_IMAGE_HEIGHT
:
132 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
134 ctx
->Unpack
.ImageHeight
= param
;
136 case GL_UNPACK_SKIP_PIXELS
:
138 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
141 ctx
->Unpack
.SkipPixels
= param
;
144 case GL_UNPACK_SKIP_ROWS
:
146 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
149 ctx
->Unpack
.SkipRows
= param
;
152 case GL_UNPACK_ALIGNMENT
:
153 if (param
==1 || param
==2 || param
==4 || param
==8) {
154 ctx
->Unpack
.Alignment
= param
;
157 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelStore" );
161 gl_error( ctx
, GL_INVALID_ENUM
, "glPixelStore" );
167 _mesa_PixelStoref( GLenum pname
, GLfloat param
)
169 _mesa_PixelStorei( pname
, (GLint
) param
);
174 /**********************************************************************/
175 /***** glPixelMap *****/
176 /**********************************************************************/
181 _mesa_PixelMapfv( GLenum map
, GLint mapsize
, const GLfloat
*values
)
184 GET_CURRENT_CONTEXT(ctx
);
185 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelMapfv");
188 if (mapsize
<0 || mapsize
>MAX_PIXEL_MAP_TABLE
) {
189 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
193 if (map
>=GL_PIXEL_MAP_S_TO_S
&& map
<=GL_PIXEL_MAP_I_TO_A
) {
194 /* test that mapsize is a power of two */
196 GLboolean ok
= GL_FALSE
;
197 for (p
=1; p
<=MAX_PIXEL_MAP_TABLE
; p
=p
<<1) {
198 if ( (p
&mapsize
) == p
) {
204 gl_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
210 case GL_PIXEL_MAP_S_TO_S
:
211 ctx
->Pixel
.MapStoSsize
= mapsize
;
212 for (i
=0;i
<mapsize
;i
++) {
213 ctx
->Pixel
.MapStoS
[i
] = (GLint
) values
[i
];
216 case GL_PIXEL_MAP_I_TO_I
:
217 ctx
->Pixel
.MapItoIsize
= mapsize
;
218 for (i
=0;i
<mapsize
;i
++) {
219 ctx
->Pixel
.MapItoI
[i
] = (GLint
) values
[i
];
222 case GL_PIXEL_MAP_I_TO_R
:
223 ctx
->Pixel
.MapItoRsize
= mapsize
;
224 for (i
=0;i
<mapsize
;i
++) {
225 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
226 ctx
->Pixel
.MapItoR
[i
] = val
;
227 ctx
->Pixel
.MapItoR8
[i
] = (GLint
) (val
* 255.0F
);
230 case GL_PIXEL_MAP_I_TO_G
:
231 ctx
->Pixel
.MapItoGsize
= mapsize
;
232 for (i
=0;i
<mapsize
;i
++) {
233 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
234 ctx
->Pixel
.MapItoG
[i
] = val
;
235 ctx
->Pixel
.MapItoG8
[i
] = (GLint
) (val
* 255.0F
);
238 case GL_PIXEL_MAP_I_TO_B
:
239 ctx
->Pixel
.MapItoBsize
= mapsize
;
240 for (i
=0;i
<mapsize
;i
++) {
241 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
242 ctx
->Pixel
.MapItoB
[i
] = val
;
243 ctx
->Pixel
.MapItoB8
[i
] = (GLint
) (val
* 255.0F
);
246 case GL_PIXEL_MAP_I_TO_A
:
247 ctx
->Pixel
.MapItoAsize
= mapsize
;
248 for (i
=0;i
<mapsize
;i
++) {
249 GLfloat val
= CLAMP( values
[i
], 0.0, 1.0 );
250 ctx
->Pixel
.MapItoA
[i
] = val
;
251 ctx
->Pixel
.MapItoA8
[i
] = (GLint
) (val
* 255.0F
);
254 case GL_PIXEL_MAP_R_TO_R
:
255 ctx
->Pixel
.MapRtoRsize
= mapsize
;
256 for (i
=0;i
<mapsize
;i
++) {
257 ctx
->Pixel
.MapRtoR
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
260 case GL_PIXEL_MAP_G_TO_G
:
261 ctx
->Pixel
.MapGtoGsize
= mapsize
;
262 for (i
=0;i
<mapsize
;i
++) {
263 ctx
->Pixel
.MapGtoG
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
266 case GL_PIXEL_MAP_B_TO_B
:
267 ctx
->Pixel
.MapBtoBsize
= mapsize
;
268 for (i
=0;i
<mapsize
;i
++) {
269 ctx
->Pixel
.MapBtoB
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
272 case GL_PIXEL_MAP_A_TO_A
:
273 ctx
->Pixel
.MapAtoAsize
= mapsize
;
274 for (i
=0;i
<mapsize
;i
++) {
275 ctx
->Pixel
.MapAtoA
[i
] = CLAMP( values
[i
], 0.0, 1.0 );
279 gl_error( ctx
, GL_INVALID_ENUM
, "glPixelMapfv(map)" );
286 _mesa_PixelMapuiv(GLenum map
, GLint mapsize
, const GLuint
*values
)
288 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
290 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
291 for (i
=0;i
<mapsize
;i
++) {
292 fvalues
[i
] = (GLfloat
) values
[i
];
296 for (i
=0;i
<mapsize
;i
++) {
297 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
300 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
306 _mesa_PixelMapusv(GLenum map
, GLint mapsize
, const GLushort
*values
)
308 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
310 if (map
==GL_PIXEL_MAP_I_TO_I
|| map
==GL_PIXEL_MAP_S_TO_S
) {
311 for (i
=0;i
<mapsize
;i
++) {
312 fvalues
[i
] = (GLfloat
) values
[i
];
316 for (i
=0;i
<mapsize
;i
++) {
317 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
320 _mesa_PixelMapfv(map
, mapsize
, fvalues
);
326 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
328 GET_CURRENT_CONTEXT(ctx
);
331 ASSERT_OUTSIDE_BEGIN_END(ctx
, "glGetPixelMapfv");
334 case GL_PIXEL_MAP_I_TO_I
:
335 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
336 values
[i
] = (GLfloat
) ctx
->Pixel
.MapItoI
[i
];
339 case GL_PIXEL_MAP_S_TO_S
:
340 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
341 values
[i
] = (GLfloat
) ctx
->Pixel
.MapStoS
[i
];
344 case GL_PIXEL_MAP_I_TO_R
:
345 MEMCPY(values
,ctx
->Pixel
.MapItoR
,ctx
->Pixel
.MapItoRsize
*sizeof(GLfloat
));
347 case GL_PIXEL_MAP_I_TO_G
:
348 MEMCPY(values
,ctx
->Pixel
.MapItoG
,ctx
->Pixel
.MapItoGsize
*sizeof(GLfloat
));
350 case GL_PIXEL_MAP_I_TO_B
:
351 MEMCPY(values
,ctx
->Pixel
.MapItoB
,ctx
->Pixel
.MapItoBsize
*sizeof(GLfloat
));
353 case GL_PIXEL_MAP_I_TO_A
:
354 MEMCPY(values
,ctx
->Pixel
.MapItoA
,ctx
->Pixel
.MapItoAsize
*sizeof(GLfloat
));
356 case GL_PIXEL_MAP_R_TO_R
:
357 MEMCPY(values
,ctx
->Pixel
.MapRtoR
,ctx
->Pixel
.MapRtoRsize
*sizeof(GLfloat
));
359 case GL_PIXEL_MAP_G_TO_G
:
360 MEMCPY(values
,ctx
->Pixel
.MapGtoG
,ctx
->Pixel
.MapGtoGsize
*sizeof(GLfloat
));
362 case GL_PIXEL_MAP_B_TO_B
:
363 MEMCPY(values
,ctx
->Pixel
.MapBtoB
,ctx
->Pixel
.MapBtoBsize
*sizeof(GLfloat
));
365 case GL_PIXEL_MAP_A_TO_A
:
366 MEMCPY(values
,ctx
->Pixel
.MapAtoA
,ctx
->Pixel
.MapAtoAsize
*sizeof(GLfloat
));
369 gl_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
375 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
377 GET_CURRENT_CONTEXT(ctx
);
380 ASSERT_OUTSIDE_BEGIN_END(ctx
, "glGetPixelMapfv");
383 case GL_PIXEL_MAP_I_TO_I
:
384 MEMCPY(values
, ctx
->Pixel
.MapItoI
, ctx
->Pixel
.MapItoIsize
*sizeof(GLint
));
386 case GL_PIXEL_MAP_S_TO_S
:
387 MEMCPY(values
, ctx
->Pixel
.MapStoS
, ctx
->Pixel
.MapStoSsize
*sizeof(GLint
));
389 case GL_PIXEL_MAP_I_TO_R
:
390 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
391 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoR
[i
] );
394 case GL_PIXEL_MAP_I_TO_G
:
395 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
396 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoG
[i
] );
399 case GL_PIXEL_MAP_I_TO_B
:
400 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
401 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoB
[i
] );
404 case GL_PIXEL_MAP_I_TO_A
:
405 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
406 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapItoA
[i
] );
409 case GL_PIXEL_MAP_R_TO_R
:
410 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
411 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapRtoR
[i
] );
414 case GL_PIXEL_MAP_G_TO_G
:
415 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
416 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapGtoG
[i
] );
419 case GL_PIXEL_MAP_B_TO_B
:
420 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
421 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapBtoB
[i
] );
424 case GL_PIXEL_MAP_A_TO_A
:
425 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
426 values
[i
] = FLOAT_TO_UINT( ctx
->Pixel
.MapAtoA
[i
] );
430 gl_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
436 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
438 GET_CURRENT_CONTEXT(ctx
);
441 ASSERT_OUTSIDE_BEGIN_END(ctx
, "glGetPixelMapfv");
444 case GL_PIXEL_MAP_I_TO_I
:
445 for (i
=0;i
<ctx
->Pixel
.MapItoIsize
;i
++) {
446 values
[i
] = (GLushort
) ctx
->Pixel
.MapItoI
[i
];
449 case GL_PIXEL_MAP_S_TO_S
:
450 for (i
=0;i
<ctx
->Pixel
.MapStoSsize
;i
++) {
451 values
[i
] = (GLushort
) ctx
->Pixel
.MapStoS
[i
];
454 case GL_PIXEL_MAP_I_TO_R
:
455 for (i
=0;i
<ctx
->Pixel
.MapItoRsize
;i
++) {
456 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoR
[i
] );
459 case GL_PIXEL_MAP_I_TO_G
:
460 for (i
=0;i
<ctx
->Pixel
.MapItoGsize
;i
++) {
461 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoG
[i
] );
464 case GL_PIXEL_MAP_I_TO_B
:
465 for (i
=0;i
<ctx
->Pixel
.MapItoBsize
;i
++) {
466 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoB
[i
] );
469 case GL_PIXEL_MAP_I_TO_A
:
470 for (i
=0;i
<ctx
->Pixel
.MapItoAsize
;i
++) {
471 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapItoA
[i
] );
474 case GL_PIXEL_MAP_R_TO_R
:
475 for (i
=0;i
<ctx
->Pixel
.MapRtoRsize
;i
++) {
476 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapRtoR
[i
] );
479 case GL_PIXEL_MAP_G_TO_G
:
480 for (i
=0;i
<ctx
->Pixel
.MapGtoGsize
;i
++) {
481 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapGtoG
[i
] );
484 case GL_PIXEL_MAP_B_TO_B
:
485 for (i
=0;i
<ctx
->Pixel
.MapBtoBsize
;i
++) {
486 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapBtoB
[i
] );
489 case GL_PIXEL_MAP_A_TO_A
:
490 for (i
=0;i
<ctx
->Pixel
.MapAtoAsize
;i
++) {
491 values
[i
] = FLOAT_TO_USHORT( ctx
->Pixel
.MapAtoA
[i
] );
495 gl_error( ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv" );
501 /**********************************************************************/
502 /***** glPixelTransfer *****/
503 /**********************************************************************/
507 * Implements glPixelTransfer[fi] whether called immediately or from a
511 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
513 GET_CURRENT_CONTEXT(ctx
);
514 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
, "glPixelTransfer");
519 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
522 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
525 ctx
->Pixel
.IndexShift
= (GLint
) param
;
527 case GL_INDEX_OFFSET
:
528 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
531 ctx
->Pixel
.RedScale
= param
;
534 ctx
->Pixel
.RedBias
= param
;
537 ctx
->Pixel
.GreenScale
= param
;
540 ctx
->Pixel
.GreenBias
= param
;
543 ctx
->Pixel
.BlueScale
= param
;
546 ctx
->Pixel
.BlueBias
= param
;
549 ctx
->Pixel
.AlphaScale
= param
;
552 ctx
->Pixel
.AlphaBias
= param
;
555 ctx
->Pixel
.DepthScale
= param
;
558 ctx
->Pixel
.DepthBias
= param
;
560 case GL_POST_COLOR_MATRIX_RED_SCALE
:
561 ctx
->Pixel
.PostColorMatrixRedScale
= param
;
563 case GL_POST_COLOR_MATRIX_RED_BIAS
:
564 ctx
->Pixel
.PostColorMatrixRedBias
= param
;
566 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
567 ctx
->Pixel
.PostColorMatrixGreenScale
= param
;
569 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
570 ctx
->Pixel
.PostColorMatrixGreenBias
= param
;
572 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
573 ctx
->Pixel
.PostColorMatrixBlueScale
= param
;
575 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
576 ctx
->Pixel
.PostColorMatrixBlueBias
= param
;
578 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
579 ctx
->Pixel
.PostColorMatrixAlphaScale
= param
;
581 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
582 ctx
->Pixel
.PostColorMatrixAlphaBias
= param
;
585 gl_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
589 if (ctx
->Pixel
.RedScale
!=1.0F
|| ctx
->Pixel
.RedBias
!=0.0F
||
590 ctx
->Pixel
.GreenScale
!=1.0F
|| ctx
->Pixel
.GreenBias
!=0.0F
||
591 ctx
->Pixel
.BlueScale
!=1.0F
|| ctx
->Pixel
.BlueBias
!=0.0F
||
592 ctx
->Pixel
.AlphaScale
!=1.0F
|| ctx
->Pixel
.AlphaBias
!=0.0F
) {
593 ctx
->Pixel
.ScaleOrBiasRGBA
= GL_TRUE
;
596 ctx
->Pixel
.ScaleOrBiasRGBA
= GL_FALSE
;
599 if (ctx
->Pixel
.PostColorMatrixRedScale
!=1.0F
||
600 ctx
->Pixel
.PostColorMatrixRedBias
!=0.0F
||
601 ctx
->Pixel
.PostColorMatrixGreenScale
!=1.0F
||
602 ctx
->Pixel
.PostColorMatrixGreenBias
!=0.0F
||
603 ctx
->Pixel
.PostColorMatrixBlueScale
!=1.0F
||
604 ctx
->Pixel
.PostColorMatrixBlueBias
!=0.0F
||
605 ctx
->Pixel
.PostColorMatrixAlphaScale
!=1.0F
||
606 ctx
->Pixel
.PostColorMatrixAlphaBias
!=0.0F
) {
607 ctx
->Pixel
.ScaleOrBiasRGBApcm
= GL_TRUE
;
610 ctx
->Pixel
.ScaleOrBiasRGBApcm
= GL_FALSE
;
616 _mesa_PixelTransferi( GLenum pname
, GLint param
)
618 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
623 /**********************************************************************/
624 /***** Pixel processing functions ******/
625 /**********************************************************************/
629 * Apply scale and bias factors to an array of RGBA pixels.
632 _mesa_scale_and_bias_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
634 if (ctx
->Pixel
.RedScale
!= 1.0 || ctx
->Pixel
.RedBias
!= 0.0) {
635 const GLfloat scale
= ctx
->Pixel
.RedScale
;
636 const GLfloat bias
= ctx
->Pixel
.RedBias
;
638 for (i
= 0; i
< n
; i
++) {
639 rgba
[i
][RCOMP
] = rgba
[i
][RCOMP
] * scale
+ bias
;
642 if (ctx
->Pixel
.GreenScale
!= 1.0 || ctx
->Pixel
.GreenBias
!= 0.0) {
643 const GLfloat scale
= ctx
->Pixel
.GreenScale
;
644 const GLfloat bias
= ctx
->Pixel
.GreenBias
;
646 for (i
= 0; i
< n
; i
++) {
647 rgba
[i
][GCOMP
] = rgba
[i
][GCOMP
] * scale
+ bias
;
650 if (ctx
->Pixel
.BlueScale
!= 1.0 || ctx
->Pixel
.BlueBias
!= 0.0) {
651 const GLfloat scale
= ctx
->Pixel
.BlueScale
;
652 const GLfloat bias
= ctx
->Pixel
.BlueBias
;
654 for (i
= 0; i
< n
; i
++) {
655 rgba
[i
][BCOMP
] = rgba
[i
][BCOMP
] * scale
+ bias
;
658 if (ctx
->Pixel
.AlphaScale
!= 1.0 || ctx
->Pixel
.AlphaBias
!= 0.0) {
659 const GLfloat scale
= ctx
->Pixel
.AlphaScale
;
660 const GLfloat bias
= ctx
->Pixel
.AlphaBias
;
662 for (i
= 0; i
< n
; i
++) {
663 rgba
[i
][ACOMP
] = rgba
[i
][ACOMP
] * scale
+ bias
;
670 * Apply pixel mapping to an array of floating point RGBA pixels.
673 _mesa_map_rgba( const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4] )
675 const GLfloat rscale
= ctx
->Pixel
.MapRtoRsize
- 1;
676 const GLfloat gscale
= ctx
->Pixel
.MapGtoGsize
- 1;
677 const GLfloat bscale
= ctx
->Pixel
.MapBtoBsize
- 1;
678 const GLfloat ascale
= ctx
->Pixel
.MapAtoAsize
- 1;
679 const GLfloat
*rMap
= ctx
->Pixel
.MapRtoR
;
680 const GLfloat
*gMap
= ctx
->Pixel
.MapGtoG
;
681 const GLfloat
*bMap
= ctx
->Pixel
.MapBtoB
;
682 const GLfloat
*aMap
= ctx
->Pixel
.MapAtoA
;
685 rgba
[i
][RCOMP
] = rMap
[(GLint
) (rgba
[i
][RCOMP
] * rscale
+ 0.5F
)];
686 rgba
[i
][GCOMP
] = gMap
[(GLint
) (rgba
[i
][GCOMP
] * gscale
+ 0.5F
)];
687 rgba
[i
][BCOMP
] = bMap
[(GLint
) (rgba
[i
][BCOMP
] * bscale
+ 0.5F
)];
688 rgba
[i
][ACOMP
] = aMap
[(GLint
) (rgba
[i
][ACOMP
] * ascale
+ 0.5F
)];
694 * Apply the color matrix and post color matrix scaling and biasing.
697 _mesa_transform_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
699 const GLfloat rs
= ctx
->Pixel
.PostColorMatrixRedScale
;
700 const GLfloat rb
= ctx
->Pixel
.PostColorMatrixRedBias
;
701 const GLfloat gs
= ctx
->Pixel
.PostColorMatrixGreenScale
;
702 const GLfloat gb
= ctx
->Pixel
.PostColorMatrixGreenBias
;
703 const GLfloat bs
= ctx
->Pixel
.PostColorMatrixBlueScale
;
704 const GLfloat bb
= ctx
->Pixel
.PostColorMatrixBlueBias
;
705 const GLfloat as
= ctx
->Pixel
.PostColorMatrixAlphaScale
;
706 const GLfloat ab
= ctx
->Pixel
.PostColorMatrixAlphaBias
;
707 const GLfloat
*m
= ctx
->ColorMatrix
.m
;
709 for (i
= 0; i
< n
; i
++) {
710 const GLfloat r
= rgba
[i
][RCOMP
];
711 const GLfloat g
= rgba
[i
][GCOMP
];
712 const GLfloat b
= rgba
[i
][BCOMP
];
713 const GLfloat a
= rgba
[i
][ACOMP
];
714 rgba
[i
][RCOMP
] = (m
[0] * r
+ m
[4] * g
+ m
[ 8] * b
+ m
[12] * a
) * rs
+ rb
;
715 rgba
[i
][GCOMP
] = (m
[1] * r
+ m
[5] * g
+ m
[ 9] * b
+ m
[13] * a
) * gs
+ gb
;
716 rgba
[i
][BCOMP
] = (m
[2] * r
+ m
[6] * g
+ m
[10] * b
+ m
[14] * a
) * bs
+ bb
;
717 rgba
[i
][ACOMP
] = (m
[3] * r
+ m
[7] * g
+ m
[11] * b
+ m
[15] * a
) * as
+ ab
;
723 * Apply a color table lookup to an array of colors.
726 _mesa_lookup_rgba(const struct gl_color_table
*table
,
727 GLuint n
, GLfloat rgba
[][4])
729 switch (table
->Format
) {
732 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
733 const GLfloat
*lut
= table
->TableF
;
735 /* replace RGBA with I */
736 for (i
= 0; i
< n
; i
++) {
737 GLint j
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
739 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] =
740 rgba
[i
][BCOMP
] = rgba
[i
][ACOMP
] = c
;
746 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
747 const GLfloat
*lut
= table
->TableF
;
749 /* replace RGB with L */
750 for (i
= 0; i
< n
; i
++) {
751 GLint j
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
753 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = c
;
759 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
760 const GLfloat
*lut
= table
->TableF
;
762 /* replace A with A */
763 for (i
= 0; i
< n
; i
++) {
764 GLint j
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
765 rgba
[i
][ACOMP
] = lut
[j
];
769 case GL_LUMINANCE_ALPHA
:
771 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
772 const GLfloat
*lut
= table
->TableF
;
774 /* replace RGBA with LLLA */
775 for (i
= 0; i
< n
; i
++) {
776 GLint jL
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
777 GLint jA
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
778 GLubyte luminance
= lut
[jL
* 2 + 0];
779 GLubyte alpha
= lut
[jA
* 2 + 1];
780 rgba
[i
][RCOMP
] = rgba
[i
][GCOMP
] = rgba
[i
][BCOMP
] = luminance
;
781 rgba
[i
][ACOMP
] = alpha
;;
787 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
788 const GLfloat
*lut
= table
->TableF
;
790 /* replace RGB with RGB */
791 for (i
= 0; i
< n
; i
++) {
792 GLint jR
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
793 GLint jG
= (GLint
) (rgba
[i
][GCOMP
] * scale
+ 0.5F
);
794 GLint jB
= (GLint
) (rgba
[i
][BCOMP
] * scale
+ 0.5F
);
795 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
796 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
797 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
803 const GLfloat scale
= (GLfloat
) (table
->Size
- 1);
804 const GLfloat
*lut
= table
->TableF
;
806 /* replace RGBA with RGBA */
807 for (i
= 0; i
< n
; i
++) {
808 GLint jR
= (GLint
) (rgba
[i
][RCOMP
] * scale
+ 0.5F
);
809 GLint jG
= (GLint
) (rgba
[i
][GCOMP
] * scale
+ 0.5F
);
810 GLint jB
= (GLint
) (rgba
[i
][BCOMP
] * scale
+ 0.5F
);
811 GLint jA
= (GLint
) (rgba
[i
][ACOMP
] * scale
+ 0.5F
);
812 rgba
[i
][RCOMP
] = lut
[jR
* 4 + 0];
813 rgba
[i
][GCOMP
] = lut
[jG
* 4 + 1];
814 rgba
[i
][BCOMP
] = lut
[jB
* 4 + 2];
815 rgba
[i
][ACOMP
] = lut
[jA
* 4 + 3];
820 gl_problem(NULL
, "Bad format in _mesa_lookup_rgba");
828 * Apply color index shift and offset to an array of pixels.
831 _mesa_shift_and_offset_ci( const GLcontext
*ctx
, GLuint n
, GLuint indexes
[] )
833 GLint shift
= ctx
->Pixel
.IndexShift
;
834 GLint offset
= ctx
->Pixel
.IndexOffset
;
838 indexes
[i
] = (indexes
[i
] << shift
) + offset
;
841 else if (shift
< 0) {
844 indexes
[i
] = (indexes
[i
] >> shift
) + offset
;
849 indexes
[i
] = indexes
[i
] + offset
;
856 * Apply color index mapping to color indexes.
859 _mesa_map_ci( const GLcontext
*ctx
, GLuint n
, GLuint index
[] )
861 GLuint mask
= ctx
->Pixel
.MapItoIsize
- 1;
864 index
[i
] = ctx
->Pixel
.MapItoI
[ index
[i
] & mask
];
870 * Map color indexes to rgba values.
873 _mesa_map_ci_to_rgba_ubyte( const GLcontext
*ctx
, GLuint n
,
874 const GLuint index
[], GLubyte rgba
[][4] )
876 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
877 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
878 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
879 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
880 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
881 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
882 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
883 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
886 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
887 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
888 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
889 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
895 * Map color indexes to float rgba values.
898 _mesa_map_ci_to_rgba( const GLcontext
*ctx
, GLuint n
,
899 const GLuint index
[], GLfloat rgba
[][4] )
901 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
902 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
903 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
904 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
905 const GLfloat
*rMap
= ctx
->Pixel
.MapItoR
;
906 const GLfloat
*gMap
= ctx
->Pixel
.MapItoG
;
907 const GLfloat
*bMap
= ctx
->Pixel
.MapItoB
;
908 const GLfloat
*aMap
= ctx
->Pixel
.MapItoA
;
911 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
912 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
913 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
914 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
920 * Map 8-bit color indexes to rgb values.
923 _mesa_map_ci8_to_rgba( const GLcontext
*ctx
, GLuint n
, const GLubyte index
[],
926 GLuint rmask
= ctx
->Pixel
.MapItoRsize
- 1;
927 GLuint gmask
= ctx
->Pixel
.MapItoGsize
- 1;
928 GLuint bmask
= ctx
->Pixel
.MapItoBsize
- 1;
929 GLuint amask
= ctx
->Pixel
.MapItoAsize
- 1;
930 const GLubyte
*rMap
= ctx
->Pixel
.MapItoR8
;
931 const GLubyte
*gMap
= ctx
->Pixel
.MapItoG8
;
932 const GLubyte
*bMap
= ctx
->Pixel
.MapItoB8
;
933 const GLubyte
*aMap
= ctx
->Pixel
.MapItoA8
;
936 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
937 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
938 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
939 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
945 _mesa_shift_and_offset_stencil( const GLcontext
*ctx
, GLuint n
,
946 GLstencil stencil
[] )
949 GLint shift
= ctx
->Pixel
.IndexShift
;
950 GLint offset
= ctx
->Pixel
.IndexOffset
;
953 stencil
[i
] = (stencil
[i
] << shift
) + offset
;
956 else if (shift
< 0) {
959 stencil
[i
] = (stencil
[i
] >> shift
) + offset
;
964 stencil
[i
] = stencil
[i
] + offset
;
972 _mesa_map_stencil( const GLcontext
*ctx
, GLuint n
, GLstencil stencil
[] )
974 GLuint mask
= ctx
->Pixel
.MapStoSsize
- 1;
977 stencil
[i
] = ctx
->Pixel
.MapStoS
[ stencil
[i
] & mask
];