2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 * Pixel transfer functions (glPixelZoom, glPixelMap, glPixelTransfer)
32 #include "bufferobj.h"
41 /**********************************************************************/
42 /***** glPixelZoom *****/
43 /**********************************************************************/
46 _mesa_PixelZoom( GLfloat xfactor
, GLfloat yfactor
)
48 GET_CURRENT_CONTEXT(ctx
);
50 if (ctx
->Pixel
.ZoomX
== xfactor
&&
51 ctx
->Pixel
.ZoomY
== yfactor
)
54 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
55 ctx
->Pixel
.ZoomX
= xfactor
;
56 ctx
->Pixel
.ZoomY
= yfactor
;
61 /**********************************************************************/
62 /***** glPixelMap *****/
63 /**********************************************************************/
66 * Return pointer to a pixelmap by name.
68 static struct gl_pixelmap
*
69 get_pixelmap(GLcontext
*ctx
, GLenum map
)
72 case GL_PIXEL_MAP_I_TO_I
:
73 return &ctx
->PixelMaps
.ItoI
;
74 case GL_PIXEL_MAP_S_TO_S
:
75 return &ctx
->PixelMaps
.StoS
;
76 case GL_PIXEL_MAP_I_TO_R
:
77 return &ctx
->PixelMaps
.ItoR
;
78 case GL_PIXEL_MAP_I_TO_G
:
79 return &ctx
->PixelMaps
.ItoG
;
80 case GL_PIXEL_MAP_I_TO_B
:
81 return &ctx
->PixelMaps
.ItoB
;
82 case GL_PIXEL_MAP_I_TO_A
:
83 return &ctx
->PixelMaps
.ItoA
;
84 case GL_PIXEL_MAP_R_TO_R
:
85 return &ctx
->PixelMaps
.RtoR
;
86 case GL_PIXEL_MAP_G_TO_G
:
87 return &ctx
->PixelMaps
.GtoG
;
88 case GL_PIXEL_MAP_B_TO_B
:
89 return &ctx
->PixelMaps
.BtoB
;
90 case GL_PIXEL_MAP_A_TO_A
:
91 return &ctx
->PixelMaps
.AtoA
;
99 * Helper routine used by the other _mesa_PixelMap() functions.
102 store_pixelmap(GLcontext
*ctx
, GLenum map
, GLsizei mapsize
,
103 const GLfloat
*values
)
106 struct gl_pixelmap
*pm
= get_pixelmap(ctx
, map
);
108 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPixelMap(map)");
113 case GL_PIXEL_MAP_S_TO_S
:
115 ctx
->PixelMaps
.StoS
.Size
= mapsize
;
116 for (i
= 0; i
< mapsize
; i
++) {
117 ctx
->PixelMaps
.StoS
.Map
[i
] = (GLfloat
)IROUND(values
[i
]);
120 case GL_PIXEL_MAP_I_TO_I
:
122 ctx
->PixelMaps
.ItoI
.Size
= mapsize
;
123 for (i
= 0; i
< mapsize
; i
++) {
124 ctx
->PixelMaps
.ItoI
.Map
[i
] = values
[i
];
130 for (i
= 0; i
< mapsize
; i
++) {
131 GLfloat val
= CLAMP(values
[i
], 0.0F
, 1.0F
);
133 pm
->Map8
[i
] = (GLint
) (val
* 255.0F
);
140 * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap().
143 validate_pbo_access(GLcontext
*ctx
, struct gl_pixelstore_attrib
*pack
,
144 GLsizei mapsize
, GLenum format
, GLenum type
,
149 /* Note, need to use DefaultPacking and Unpack's buffer object */
150 ctx
->DefaultPacking
.BufferObj
= pack
->BufferObj
;
152 ok
= _mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
156 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
159 _mesa_error(ctx
, GL_INVALID_OPERATION
,
160 "glPixelMap(invalid PBO access)");
167 _mesa_PixelMapfv( GLenum map
, GLsizei mapsize
, const GLfloat
*values
)
169 GET_CURRENT_CONTEXT(ctx
);
170 ASSERT_OUTSIDE_BEGIN_END(ctx
);
172 /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
173 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
174 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
178 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
179 /* test that mapsize is a power of two */
180 if (!_mesa_is_pow_two(mapsize
)) {
181 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
186 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
188 if (!validate_pbo_access(ctx
, &ctx
->Unpack
, mapsize
,
189 GL_INTENSITY
, GL_FLOAT
, values
)) {
193 values
= (const GLfloat
*) _mesa_map_pbo_source(ctx
, &ctx
->Unpack
, values
);
195 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
196 _mesa_error(ctx
, GL_INVALID_OPERATION
,
197 "glPixelMapfv(PBO is mapped)");
202 store_pixelmap(ctx
, map
, mapsize
, values
);
204 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
209 _mesa_PixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
*values
)
211 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
212 GET_CURRENT_CONTEXT(ctx
);
213 ASSERT_OUTSIDE_BEGIN_END(ctx
);
215 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
216 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
220 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
221 /* test that mapsize is a power of two */
222 if (!_mesa_is_pow_two(mapsize
)) {
223 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
228 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
230 if (!validate_pbo_access(ctx
, &ctx
->Unpack
, mapsize
,
231 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
235 values
= (const GLuint
*) _mesa_map_pbo_source(ctx
, &ctx
->Unpack
, values
);
237 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
238 _mesa_error(ctx
, GL_INVALID_OPERATION
,
239 "glPixelMapuiv(PBO is mapped)");
244 /* convert to floats */
245 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
247 for (i
= 0; i
< mapsize
; i
++) {
248 fvalues
[i
] = (GLfloat
) values
[i
];
253 for (i
= 0; i
< mapsize
; i
++) {
254 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
258 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
260 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
265 _mesa_PixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
*values
)
267 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
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
, "glPixelMapusv(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_is_pow_two(mapsize
)) {
279 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
284 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
286 if (!validate_pbo_access(ctx
, &ctx
->Unpack
, mapsize
,
287 GL_INTENSITY
, GL_UNSIGNED_SHORT
, values
)) {
291 values
= (const GLushort
*) _mesa_map_pbo_source(ctx
, &ctx
->Unpack
, values
);
293 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
294 _mesa_error(ctx
, GL_INVALID_OPERATION
,
295 "glPixelMapusv(PBO is mapped)");
300 /* convert to floats */
301 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
303 for (i
= 0; i
< mapsize
; i
++) {
304 fvalues
[i
] = (GLfloat
) values
[i
];
309 for (i
= 0; i
< mapsize
; i
++) {
310 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
314 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
316 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
321 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
323 GET_CURRENT_CONTEXT(ctx
);
325 const struct gl_pixelmap
*pm
;
327 ASSERT_OUTSIDE_BEGIN_END(ctx
);
329 pm
= get_pixelmap(ctx
, map
);
331 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv(map)");
337 if (!validate_pbo_access(ctx
, &ctx
->Pack
, mapsize
,
338 GL_INTENSITY
, GL_FLOAT
, values
)) {
342 values
= (GLfloat
*) _mesa_map_pbo_dest(ctx
, &ctx
->Pack
, values
);
344 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
345 _mesa_error(ctx
, GL_INVALID_OPERATION
,
346 "glGetPixelMapfv(PBO is mapped)");
351 if (map
== GL_PIXEL_MAP_S_TO_S
) {
353 for (i
= 0; i
< mapsize
; i
++) {
354 values
[i
] = (GLfloat
) ctx
->PixelMaps
.StoS
.Map
[i
];
358 MEMCPY(values
, pm
->Map
, mapsize
* sizeof(GLfloat
));
361 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
366 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
368 GET_CURRENT_CONTEXT(ctx
);
370 const struct gl_pixelmap
*pm
;
372 ASSERT_OUTSIDE_BEGIN_END(ctx
);
374 pm
= get_pixelmap(ctx
, map
);
376 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapuiv(map)");
381 if (!validate_pbo_access(ctx
, &ctx
->Pack
, mapsize
,
382 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
386 values
= (GLuint
*) _mesa_map_pbo_dest(ctx
, &ctx
->Pack
, values
);
388 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
389 _mesa_error(ctx
, GL_INVALID_OPERATION
,
390 "glGetPixelMapuiv(PBO is mapped)");
395 if (map
== GL_PIXEL_MAP_S_TO_S
) {
397 MEMCPY(values
, ctx
->PixelMaps
.StoS
.Map
, mapsize
* sizeof(GLint
));
400 for (i
= 0; i
< mapsize
; i
++) {
401 values
[i
] = FLOAT_TO_UINT( pm
->Map
[i
] );
405 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
410 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
412 GET_CURRENT_CONTEXT(ctx
);
414 const struct gl_pixelmap
*pm
;
416 ASSERT_OUTSIDE_BEGIN_END(ctx
);
418 pm
= get_pixelmap(ctx
, map
);
420 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapusv(map)");
423 mapsize
= pm
? pm
->Size
: 0;
425 if (!validate_pbo_access(ctx
, &ctx
->Pack
, mapsize
,
426 GL_INTENSITY
, GL_UNSIGNED_SHORT
, values
)) {
430 values
= (GLushort
*) _mesa_map_pbo_dest(ctx
, &ctx
->Pack
, values
);
432 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
433 _mesa_error(ctx
, GL_INVALID_OPERATION
,
434 "glGetPixelMapusv(PBO is mapped)");
441 case GL_PIXEL_MAP_I_TO_I
:
442 for (i
= 0; i
< mapsize
; i
++) {
443 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.ItoI
.Map
[i
], 0.0, 65535.);
446 case GL_PIXEL_MAP_S_TO_S
:
447 for (i
= 0; i
< mapsize
; i
++) {
448 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.StoS
.Map
[i
], 0.0, 65535.);
452 for (i
= 0; i
< mapsize
; i
++) {
453 CLAMPED_FLOAT_TO_USHORT(values
[i
], pm
->Map
[i
] );
457 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
462 /**********************************************************************/
463 /***** glPixelTransfer *****/
464 /**********************************************************************/
468 * Implements glPixelTransfer[fi] whether called immediately or from a
472 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
474 GET_CURRENT_CONTEXT(ctx
);
475 ASSERT_OUTSIDE_BEGIN_END(ctx
);
479 if (ctx
->Pixel
.MapColorFlag
== (param
? GL_TRUE
: GL_FALSE
))
481 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
482 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
485 if (ctx
->Pixel
.MapStencilFlag
== (param
? GL_TRUE
: GL_FALSE
))
487 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
488 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
491 if (ctx
->Pixel
.IndexShift
== (GLint
) param
)
493 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
494 ctx
->Pixel
.IndexShift
= (GLint
) param
;
496 case GL_INDEX_OFFSET
:
497 if (ctx
->Pixel
.IndexOffset
== (GLint
) param
)
499 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
500 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
503 if (ctx
->Pixel
.RedScale
== param
)
505 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
506 ctx
->Pixel
.RedScale
= param
;
509 if (ctx
->Pixel
.RedBias
== param
)
511 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
512 ctx
->Pixel
.RedBias
= param
;
515 if (ctx
->Pixel
.GreenScale
== param
)
517 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
518 ctx
->Pixel
.GreenScale
= param
;
521 if (ctx
->Pixel
.GreenBias
== param
)
523 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
524 ctx
->Pixel
.GreenBias
= param
;
527 if (ctx
->Pixel
.BlueScale
== param
)
529 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
530 ctx
->Pixel
.BlueScale
= param
;
533 if (ctx
->Pixel
.BlueBias
== param
)
535 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
536 ctx
->Pixel
.BlueBias
= param
;
539 if (ctx
->Pixel
.AlphaScale
== param
)
541 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
542 ctx
->Pixel
.AlphaScale
= param
;
545 if (ctx
->Pixel
.AlphaBias
== param
)
547 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
548 ctx
->Pixel
.AlphaBias
= param
;
551 if (ctx
->Pixel
.DepthScale
== param
)
553 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
554 ctx
->Pixel
.DepthScale
= param
;
557 if (ctx
->Pixel
.DepthBias
== param
)
559 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
560 ctx
->Pixel
.DepthBias
= param
;
562 case GL_POST_COLOR_MATRIX_RED_SCALE
:
563 if (ctx
->Pixel
.PostColorMatrixScale
[0] == param
)
565 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
566 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
568 case GL_POST_COLOR_MATRIX_RED_BIAS
:
569 if (ctx
->Pixel
.PostColorMatrixBias
[0] == param
)
571 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
572 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
574 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
575 if (ctx
->Pixel
.PostColorMatrixScale
[1] == param
)
577 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
578 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
580 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
581 if (ctx
->Pixel
.PostColorMatrixBias
[1] == param
)
583 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
584 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
586 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
587 if (ctx
->Pixel
.PostColorMatrixScale
[2] == param
)
589 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
590 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
592 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
593 if (ctx
->Pixel
.PostColorMatrixBias
[2] == param
)
595 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
596 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
598 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
599 if (ctx
->Pixel
.PostColorMatrixScale
[3] == param
)
601 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
602 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
604 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
605 if (ctx
->Pixel
.PostColorMatrixBias
[3] == param
)
607 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
608 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
610 case GL_POST_CONVOLUTION_RED_SCALE
:
611 if (ctx
->Pixel
.PostConvolutionScale
[0] == param
)
613 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
614 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
616 case GL_POST_CONVOLUTION_RED_BIAS
:
617 if (ctx
->Pixel
.PostConvolutionBias
[0] == param
)
619 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
620 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
622 case GL_POST_CONVOLUTION_GREEN_SCALE
:
623 if (ctx
->Pixel
.PostConvolutionScale
[1] == param
)
625 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
626 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
628 case GL_POST_CONVOLUTION_GREEN_BIAS
:
629 if (ctx
->Pixel
.PostConvolutionBias
[1] == param
)
631 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
632 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
634 case GL_POST_CONVOLUTION_BLUE_SCALE
:
635 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
637 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
638 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
640 case GL_POST_CONVOLUTION_BLUE_BIAS
:
641 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
643 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
644 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
646 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
647 if (ctx
->Pixel
.PostConvolutionScale
[3] == param
)
649 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
650 ctx
->Pixel
.PostConvolutionScale
[3] = param
;
652 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
653 if (ctx
->Pixel
.PostConvolutionBias
[3] == param
)
655 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
656 ctx
->Pixel
.PostConvolutionBias
[3] = param
;
659 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
666 _mesa_PixelTransferi( GLenum pname
, GLint param
)
668 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
673 /**********************************************************************/
674 /***** State Management *****/
675 /**********************************************************************/
678 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
679 * pixel transfer operations are enabled.
682 update_image_transfer_state(GLcontext
*ctx
)
686 if (ctx
->Pixel
.RedScale
!= 1.0F
|| ctx
->Pixel
.RedBias
!= 0.0F
||
687 ctx
->Pixel
.GreenScale
!= 1.0F
|| ctx
->Pixel
.GreenBias
!= 0.0F
||
688 ctx
->Pixel
.BlueScale
!= 1.0F
|| ctx
->Pixel
.BlueBias
!= 0.0F
||
689 ctx
->Pixel
.AlphaScale
!= 1.0F
|| ctx
->Pixel
.AlphaBias
!= 0.0F
)
690 mask
|= IMAGE_SCALE_BIAS_BIT
;
692 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
)
693 mask
|= IMAGE_SHIFT_OFFSET_BIT
;
695 if (ctx
->Pixel
.MapColorFlag
)
696 mask
|= IMAGE_MAP_COLOR_BIT
;
698 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_PRECONVOLUTION
])
699 mask
|= IMAGE_COLOR_TABLE_BIT
;
701 if (ctx
->Pixel
.Convolution1DEnabled
||
702 ctx
->Pixel
.Convolution2DEnabled
||
703 ctx
->Pixel
.Separable2DEnabled
) {
704 mask
|= IMAGE_CONVOLUTION_BIT
;
705 if (ctx
->Pixel
.PostConvolutionScale
[0] != 1.0F
||
706 ctx
->Pixel
.PostConvolutionScale
[1] != 1.0F
||
707 ctx
->Pixel
.PostConvolutionScale
[2] != 1.0F
||
708 ctx
->Pixel
.PostConvolutionScale
[3] != 1.0F
||
709 ctx
->Pixel
.PostConvolutionBias
[0] != 0.0F
||
710 ctx
->Pixel
.PostConvolutionBias
[1] != 0.0F
||
711 ctx
->Pixel
.PostConvolutionBias
[2] != 0.0F
||
712 ctx
->Pixel
.PostConvolutionBias
[3] != 0.0F
) {
713 mask
|= IMAGE_POST_CONVOLUTION_SCALE_BIAS
;
717 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCONVOLUTION
])
718 mask
|= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
;
720 if (ctx
->ColorMatrixStack
.Top
->type
!= MATRIX_IDENTITY
||
721 ctx
->Pixel
.PostColorMatrixScale
[0] != 1.0F
||
722 ctx
->Pixel
.PostColorMatrixBias
[0] != 0.0F
||
723 ctx
->Pixel
.PostColorMatrixScale
[1] != 1.0F
||
724 ctx
->Pixel
.PostColorMatrixBias
[1] != 0.0F
||
725 ctx
->Pixel
.PostColorMatrixScale
[2] != 1.0F
||
726 ctx
->Pixel
.PostColorMatrixBias
[2] != 0.0F
||
727 ctx
->Pixel
.PostColorMatrixScale
[3] != 1.0F
||
728 ctx
->Pixel
.PostColorMatrixBias
[3] != 0.0F
)
729 mask
|= IMAGE_COLOR_MATRIX_BIT
;
731 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCOLORMATRIX
])
732 mask
|= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
;
734 if (ctx
->Pixel
.HistogramEnabled
)
735 mask
|= IMAGE_HISTOGRAM_BIT
;
737 if (ctx
->Pixel
.MinMaxEnabled
)
738 mask
|= IMAGE_MIN_MAX_BIT
;
740 ctx
->_ImageTransferState
= mask
;
745 * Update mesa pixel transfer derived state.
747 void _mesa_update_pixel( GLcontext
*ctx
, GLuint new_state
)
749 if (new_state
& _NEW_COLOR_MATRIX
)
750 _math_matrix_analyse( ctx
->ColorMatrixStack
.Top
);
752 /* References ColorMatrix.type (derived above).
754 if (new_state
& _MESA_NEW_TRANSFER_STATE
)
755 update_image_transfer_state(ctx
);
759 /**********************************************************************/
760 /***** Initialization *****/
761 /**********************************************************************/
764 init_pixelmap(struct gl_pixelmap
*map
)
773 * Initialize the context's PIXEL attribute group.
776 _mesa_init_pixel( GLcontext
*ctx
)
781 ctx
->Pixel
.RedBias
= 0.0;
782 ctx
->Pixel
.RedScale
= 1.0;
783 ctx
->Pixel
.GreenBias
= 0.0;
784 ctx
->Pixel
.GreenScale
= 1.0;
785 ctx
->Pixel
.BlueBias
= 0.0;
786 ctx
->Pixel
.BlueScale
= 1.0;
787 ctx
->Pixel
.AlphaBias
= 0.0;
788 ctx
->Pixel
.AlphaScale
= 1.0;
789 ctx
->Pixel
.DepthBias
= 0.0;
790 ctx
->Pixel
.DepthScale
= 1.0;
791 ctx
->Pixel
.IndexOffset
= 0;
792 ctx
->Pixel
.IndexShift
= 0;
793 ctx
->Pixel
.ZoomX
= 1.0;
794 ctx
->Pixel
.ZoomY
= 1.0;
795 ctx
->Pixel
.MapColorFlag
= GL_FALSE
;
796 ctx
->Pixel
.MapStencilFlag
= GL_FALSE
;
797 init_pixelmap(&ctx
->PixelMaps
.StoS
);
798 init_pixelmap(&ctx
->PixelMaps
.ItoI
);
799 init_pixelmap(&ctx
->PixelMaps
.ItoR
);
800 init_pixelmap(&ctx
->PixelMaps
.ItoG
);
801 init_pixelmap(&ctx
->PixelMaps
.ItoB
);
802 init_pixelmap(&ctx
->PixelMaps
.ItoA
);
803 init_pixelmap(&ctx
->PixelMaps
.RtoR
);
804 init_pixelmap(&ctx
->PixelMaps
.GtoG
);
805 init_pixelmap(&ctx
->PixelMaps
.BtoB
);
806 init_pixelmap(&ctx
->PixelMaps
.AtoA
);
807 ctx
->Pixel
.HistogramEnabled
= GL_FALSE
;
808 ctx
->Pixel
.MinMaxEnabled
= GL_FALSE
;
809 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixScale
, 1.0, 1.0, 1.0, 1.0);
810 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixBias
, 0.0, 0.0, 0.0, 0.0);
811 for (i
= 0; i
< COLORTABLE_MAX
; i
++) {
812 ASSIGN_4V(ctx
->Pixel
.ColorTableScale
[i
], 1.0, 1.0, 1.0, 1.0);
813 ASSIGN_4V(ctx
->Pixel
.ColorTableBias
[i
], 0.0, 0.0, 0.0, 0.0);
814 ctx
->Pixel
.ColorTableEnabled
[i
] = GL_FALSE
;
816 ctx
->Pixel
.Convolution1DEnabled
= GL_FALSE
;
817 ctx
->Pixel
.Convolution2DEnabled
= GL_FALSE
;
818 ctx
->Pixel
.Separable2DEnabled
= GL_FALSE
;
819 for (i
= 0; i
< 3; i
++) {
820 ASSIGN_4V(ctx
->Pixel
.ConvolutionBorderColor
[i
], 0.0, 0.0, 0.0, 0.0);
821 ctx
->Pixel
.ConvolutionBorderMode
[i
] = GL_REDUCE
;
822 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterScale
[i
], 1.0, 1.0, 1.0, 1.0);
823 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterBias
[i
], 0.0, 0.0, 0.0, 0.0);
825 for (i
= 0; i
< MAX_CONVOLUTION_WIDTH
* MAX_CONVOLUTION_WIDTH
* 4; i
++) {
826 ctx
->Convolution1D
.Filter
[i
] = 0.0;
827 ctx
->Convolution2D
.Filter
[i
] = 0.0;
828 ctx
->Separable2D
.Filter
[i
] = 0.0;
830 ASSIGN_4V(ctx
->Pixel
.PostConvolutionScale
, 1.0, 1.0, 1.0, 1.0);
831 ASSIGN_4V(ctx
->Pixel
.PostConvolutionBias
, 0.0, 0.0, 0.0, 0.0);
832 /* GL_SGI_texture_color_table */
833 ASSIGN_4V(ctx
->Pixel
.TextureColorTableScale
, 1.0, 1.0, 1.0, 1.0);
834 ASSIGN_4V(ctx
->Pixel
.TextureColorTableBias
, 0.0, 0.0, 0.0, 0.0);
836 if (ctx
->Visual
.doubleBufferMode
) {
837 ctx
->Pixel
.ReadBuffer
= GL_BACK
;
840 ctx
->Pixel
.ReadBuffer
= GL_FRONT
;
844 ctx
->_ImageTransferState
= 0;