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 _mesa_PixelMapfv( GLenum map
, GLsizei mapsize
, const GLfloat
*values
)
142 GET_CURRENT_CONTEXT(ctx
);
143 ASSERT_OUTSIDE_BEGIN_END(ctx
);
145 /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
146 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
147 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
151 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
152 /* test that mapsize is a power of two */
153 if (!_mesa_is_pow_two(mapsize
)) {
154 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
159 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
161 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
162 /* unpack pixelmap from PBO */
164 /* Note, need to use DefaultPacking and Unpack's buffer object */
165 ctx
->DefaultPacking
.BufferObj
= ctx
->Unpack
.BufferObj
;
166 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
167 GL_INTENSITY
, GL_FLOAT
, values
)) {
168 _mesa_error(ctx
, GL_INVALID_OPERATION
,
169 "glPixelMapfv(invalid PBO access)");
173 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
174 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
176 ctx
->Unpack
.BufferObj
);
178 /* buffer is already mapped - that's an error */
179 _mesa_error(ctx
, GL_INVALID_OPERATION
,
180 "glPixelMapfv(PBO is mapped)");
183 values
= (const GLfloat
*) ADD_POINTERS(buf
, values
);
189 store_pixelmap(ctx
, map
, mapsize
, values
);
191 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
192 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
193 ctx
->Unpack
.BufferObj
);
199 _mesa_PixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
*values
)
201 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
202 GET_CURRENT_CONTEXT(ctx
);
203 ASSERT_OUTSIDE_BEGIN_END(ctx
);
205 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
206 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
210 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
211 /* test that mapsize is a power of two */
212 if (!_mesa_is_pow_two(mapsize
)) {
213 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
218 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
220 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
221 /* unpack pixelmap from PBO */
223 /* Note, need to use DefaultPacking and Unpack's buffer object */
224 ctx
->DefaultPacking
.BufferObj
= ctx
->Unpack
.BufferObj
;
225 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
226 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
227 _mesa_error(ctx
, GL_INVALID_OPERATION
,
228 "glPixelMapuiv(invalid PBO access)");
232 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
233 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
235 ctx
->Unpack
.BufferObj
);
237 /* buffer is already mapped - that's an error */
238 _mesa_error(ctx
, GL_INVALID_OPERATION
,
239 "glPixelMapuiv(PBO is mapped)");
242 values
= (const GLuint
*) ADD_POINTERS(buf
, values
);
248 /* convert to floats */
249 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
251 for (i
= 0; i
< mapsize
; i
++) {
252 fvalues
[i
] = (GLfloat
) values
[i
];
257 for (i
= 0; i
< mapsize
; i
++) {
258 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
262 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
263 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
264 ctx
->Unpack
.BufferObj
);
267 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
272 _mesa_PixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
*values
)
274 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
275 GET_CURRENT_CONTEXT(ctx
);
276 ASSERT_OUTSIDE_BEGIN_END(ctx
);
278 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
279 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapusv(mapsize)" );
283 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
284 /* test that mapsize is a power of two */
285 if (!_mesa_is_pow_two(mapsize
)) {
286 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
291 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
293 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
294 /* unpack pixelmap from PBO */
296 /* Note, need to use DefaultPacking and Unpack's buffer object */
297 ctx
->DefaultPacking
.BufferObj
= ctx
->Unpack
.BufferObj
;
298 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
299 GL_INTENSITY
, GL_UNSIGNED_SHORT
,
301 _mesa_error(ctx
, GL_INVALID_OPERATION
,
302 "glPixelMapusv(invalid PBO access)");
306 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
307 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
309 ctx
->Unpack
.BufferObj
);
311 /* buffer is already mapped - that's an error */
312 _mesa_error(ctx
, GL_INVALID_OPERATION
,
313 "glPixelMapusv(PBO is mapped)");
316 values
= (const GLushort
*) ADD_POINTERS(buf
, values
);
322 /* convert to floats */
323 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
325 for (i
= 0; i
< mapsize
; i
++) {
326 fvalues
[i
] = (GLfloat
) values
[i
];
331 for (i
= 0; i
< mapsize
; i
++) {
332 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
336 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
337 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
338 ctx
->Unpack
.BufferObj
);
341 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
346 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
348 GET_CURRENT_CONTEXT(ctx
);
350 const struct gl_pixelmap
*pm
;
352 ASSERT_OUTSIDE_BEGIN_END(ctx
);
354 pm
= get_pixelmap(ctx
, map
);
356 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv(map)");
362 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
363 /* pack pixelmap into PBO */
365 /* Note, need to use DefaultPacking and Pack's buffer object */
366 ctx
->DefaultPacking
.BufferObj
= ctx
->Pack
.BufferObj
;
367 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
368 GL_INTENSITY
, GL_FLOAT
, values
)) {
369 _mesa_error(ctx
, GL_INVALID_OPERATION
,
370 "glGetPixelMapfv(invalid PBO access)");
374 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
375 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
377 ctx
->Pack
.BufferObj
);
379 /* buffer is already mapped - that's an error */
380 _mesa_error(ctx
, GL_INVALID_OPERATION
,
381 "glGetPixelMapfv(PBO is mapped)");
384 values
= (GLfloat
*) ADD_POINTERS(buf
, values
);
390 if (map
== GL_PIXEL_MAP_S_TO_S
) {
392 for (i
= 0; i
< mapsize
; i
++) {
393 values
[i
] = (GLfloat
) ctx
->PixelMaps
.StoS
.Map
[i
];
397 MEMCPY(values
, pm
->Map
, mapsize
* sizeof(GLfloat
));
400 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
401 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
402 ctx
->Pack
.BufferObj
);
408 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
410 GET_CURRENT_CONTEXT(ctx
);
412 const struct gl_pixelmap
*pm
;
414 ASSERT_OUTSIDE_BEGIN_END(ctx
);
416 pm
= get_pixelmap(ctx
, map
);
418 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapuiv(map)");
423 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
424 /* pack pixelmap into PBO */
426 /* Note, need to use DefaultPacking and Pack's buffer object */
427 ctx
->DefaultPacking
.BufferObj
= ctx
->Pack
.BufferObj
;
428 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
429 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
430 _mesa_error(ctx
, GL_INVALID_OPERATION
,
431 "glGetPixelMapuiv(invalid PBO access)");
435 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
436 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
438 ctx
->Pack
.BufferObj
);
440 /* buffer is already mapped - that's an error */
441 _mesa_error(ctx
, GL_INVALID_OPERATION
,
442 "glGetPixelMapuiv(PBO is mapped)");
445 values
= (GLuint
*) ADD_POINTERS(buf
, values
);
451 if (map
== GL_PIXEL_MAP_S_TO_S
) {
453 MEMCPY(values
, ctx
->PixelMaps
.StoS
.Map
, mapsize
* sizeof(GLint
));
456 for (i
= 0; i
< mapsize
; i
++) {
457 values
[i
] = FLOAT_TO_UINT( pm
->Map
[i
] );
461 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
462 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
463 ctx
->Pack
.BufferObj
);
469 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
471 GET_CURRENT_CONTEXT(ctx
);
473 const struct gl_pixelmap
*pm
;
475 ASSERT_OUTSIDE_BEGIN_END(ctx
);
477 pm
= get_pixelmap(ctx
, map
);
479 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapusv(map)");
482 mapsize
= pm
? pm
->Size
: 0;
484 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
485 /* pack pixelmap into PBO */
487 /* Note, need to use DefaultPacking and Pack's buffer object */
488 ctx
->DefaultPacking
.BufferObj
= ctx
->Pack
.BufferObj
;
489 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
490 GL_INTENSITY
, GL_UNSIGNED_SHORT
,
492 _mesa_error(ctx
, GL_INVALID_OPERATION
,
493 "glGetPixelMapusv(invalid PBO access)");
497 ctx
->DefaultPacking
.BufferObj
= ctx
->Shared
->NullBufferObj
;
498 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
500 ctx
->Pack
.BufferObj
);
502 /* buffer is already mapped - that's an error */
503 _mesa_error(ctx
, GL_INVALID_OPERATION
,
504 "glGetPixelMapusv(PBO is mapped)");
507 values
= (GLushort
*) ADD_POINTERS(buf
, values
);
515 case GL_PIXEL_MAP_I_TO_I
:
516 for (i
= 0; i
< mapsize
; i
++) {
517 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.ItoI
.Map
[i
], 0.0, 65535.);
520 case GL_PIXEL_MAP_S_TO_S
:
521 for (i
= 0; i
< mapsize
; i
++) {
522 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.StoS
.Map
[i
], 0.0, 65535.);
526 for (i
= 0; i
< mapsize
; i
++) {
527 CLAMPED_FLOAT_TO_USHORT(values
[i
], pm
->Map
[i
] );
531 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
532 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
533 ctx
->Pack
.BufferObj
);
539 /**********************************************************************/
540 /***** glPixelTransfer *****/
541 /**********************************************************************/
545 * Implements glPixelTransfer[fi] whether called immediately or from a
549 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
551 GET_CURRENT_CONTEXT(ctx
);
552 ASSERT_OUTSIDE_BEGIN_END(ctx
);
556 if (ctx
->Pixel
.MapColorFlag
== (param
? GL_TRUE
: GL_FALSE
))
558 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
559 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
562 if (ctx
->Pixel
.MapStencilFlag
== (param
? GL_TRUE
: GL_FALSE
))
564 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
565 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
568 if (ctx
->Pixel
.IndexShift
== (GLint
) param
)
570 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
571 ctx
->Pixel
.IndexShift
= (GLint
) param
;
573 case GL_INDEX_OFFSET
:
574 if (ctx
->Pixel
.IndexOffset
== (GLint
) param
)
576 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
577 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
580 if (ctx
->Pixel
.RedScale
== param
)
582 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
583 ctx
->Pixel
.RedScale
= param
;
586 if (ctx
->Pixel
.RedBias
== param
)
588 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
589 ctx
->Pixel
.RedBias
= param
;
592 if (ctx
->Pixel
.GreenScale
== param
)
594 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
595 ctx
->Pixel
.GreenScale
= param
;
598 if (ctx
->Pixel
.GreenBias
== param
)
600 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
601 ctx
->Pixel
.GreenBias
= param
;
604 if (ctx
->Pixel
.BlueScale
== param
)
606 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
607 ctx
->Pixel
.BlueScale
= param
;
610 if (ctx
->Pixel
.BlueBias
== param
)
612 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
613 ctx
->Pixel
.BlueBias
= param
;
616 if (ctx
->Pixel
.AlphaScale
== param
)
618 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
619 ctx
->Pixel
.AlphaScale
= param
;
622 if (ctx
->Pixel
.AlphaBias
== param
)
624 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
625 ctx
->Pixel
.AlphaBias
= param
;
628 if (ctx
->Pixel
.DepthScale
== param
)
630 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
631 ctx
->Pixel
.DepthScale
= param
;
634 if (ctx
->Pixel
.DepthBias
== param
)
636 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
637 ctx
->Pixel
.DepthBias
= param
;
639 case GL_POST_COLOR_MATRIX_RED_SCALE
:
640 if (ctx
->Pixel
.PostColorMatrixScale
[0] == param
)
642 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
643 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
645 case GL_POST_COLOR_MATRIX_RED_BIAS
:
646 if (ctx
->Pixel
.PostColorMatrixBias
[0] == param
)
648 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
649 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
651 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
652 if (ctx
->Pixel
.PostColorMatrixScale
[1] == param
)
654 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
655 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
657 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
658 if (ctx
->Pixel
.PostColorMatrixBias
[1] == param
)
660 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
661 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
663 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
664 if (ctx
->Pixel
.PostColorMatrixScale
[2] == param
)
666 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
667 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
669 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
670 if (ctx
->Pixel
.PostColorMatrixBias
[2] == param
)
672 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
673 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
675 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
676 if (ctx
->Pixel
.PostColorMatrixScale
[3] == param
)
678 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
679 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
681 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
682 if (ctx
->Pixel
.PostColorMatrixBias
[3] == param
)
684 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
685 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
687 case GL_POST_CONVOLUTION_RED_SCALE
:
688 if (ctx
->Pixel
.PostConvolutionScale
[0] == param
)
690 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
691 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
693 case GL_POST_CONVOLUTION_RED_BIAS
:
694 if (ctx
->Pixel
.PostConvolutionBias
[0] == param
)
696 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
697 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
699 case GL_POST_CONVOLUTION_GREEN_SCALE
:
700 if (ctx
->Pixel
.PostConvolutionScale
[1] == param
)
702 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
703 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
705 case GL_POST_CONVOLUTION_GREEN_BIAS
:
706 if (ctx
->Pixel
.PostConvolutionBias
[1] == param
)
708 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
709 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
711 case GL_POST_CONVOLUTION_BLUE_SCALE
:
712 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
714 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
715 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
717 case GL_POST_CONVOLUTION_BLUE_BIAS
:
718 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
720 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
721 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
723 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
724 if (ctx
->Pixel
.PostConvolutionScale
[3] == param
)
726 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
727 ctx
->Pixel
.PostConvolutionScale
[3] = param
;
729 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
730 if (ctx
->Pixel
.PostConvolutionBias
[3] == param
)
732 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
733 ctx
->Pixel
.PostConvolutionBias
[3] = param
;
736 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
743 _mesa_PixelTransferi( GLenum pname
, GLint param
)
745 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
750 /**********************************************************************/
751 /***** State Management *****/
752 /**********************************************************************/
755 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
756 * pixel transfer operations are enabled.
759 update_image_transfer_state(GLcontext
*ctx
)
763 if (ctx
->Pixel
.RedScale
!= 1.0F
|| ctx
->Pixel
.RedBias
!= 0.0F
||
764 ctx
->Pixel
.GreenScale
!= 1.0F
|| ctx
->Pixel
.GreenBias
!= 0.0F
||
765 ctx
->Pixel
.BlueScale
!= 1.0F
|| ctx
->Pixel
.BlueBias
!= 0.0F
||
766 ctx
->Pixel
.AlphaScale
!= 1.0F
|| ctx
->Pixel
.AlphaBias
!= 0.0F
)
767 mask
|= IMAGE_SCALE_BIAS_BIT
;
769 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
)
770 mask
|= IMAGE_SHIFT_OFFSET_BIT
;
772 if (ctx
->Pixel
.MapColorFlag
)
773 mask
|= IMAGE_MAP_COLOR_BIT
;
775 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_PRECONVOLUTION
])
776 mask
|= IMAGE_COLOR_TABLE_BIT
;
778 if (ctx
->Pixel
.Convolution1DEnabled
||
779 ctx
->Pixel
.Convolution2DEnabled
||
780 ctx
->Pixel
.Separable2DEnabled
) {
781 mask
|= IMAGE_CONVOLUTION_BIT
;
782 if (ctx
->Pixel
.PostConvolutionScale
[0] != 1.0F
||
783 ctx
->Pixel
.PostConvolutionScale
[1] != 1.0F
||
784 ctx
->Pixel
.PostConvolutionScale
[2] != 1.0F
||
785 ctx
->Pixel
.PostConvolutionScale
[3] != 1.0F
||
786 ctx
->Pixel
.PostConvolutionBias
[0] != 0.0F
||
787 ctx
->Pixel
.PostConvolutionBias
[1] != 0.0F
||
788 ctx
->Pixel
.PostConvolutionBias
[2] != 0.0F
||
789 ctx
->Pixel
.PostConvolutionBias
[3] != 0.0F
) {
790 mask
|= IMAGE_POST_CONVOLUTION_SCALE_BIAS
;
794 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCONVOLUTION
])
795 mask
|= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
;
797 if (ctx
->ColorMatrixStack
.Top
->type
!= MATRIX_IDENTITY
||
798 ctx
->Pixel
.PostColorMatrixScale
[0] != 1.0F
||
799 ctx
->Pixel
.PostColorMatrixBias
[0] != 0.0F
||
800 ctx
->Pixel
.PostColorMatrixScale
[1] != 1.0F
||
801 ctx
->Pixel
.PostColorMatrixBias
[1] != 0.0F
||
802 ctx
->Pixel
.PostColorMatrixScale
[2] != 1.0F
||
803 ctx
->Pixel
.PostColorMatrixBias
[2] != 0.0F
||
804 ctx
->Pixel
.PostColorMatrixScale
[3] != 1.0F
||
805 ctx
->Pixel
.PostColorMatrixBias
[3] != 0.0F
)
806 mask
|= IMAGE_COLOR_MATRIX_BIT
;
808 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCOLORMATRIX
])
809 mask
|= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
;
811 if (ctx
->Pixel
.HistogramEnabled
)
812 mask
|= IMAGE_HISTOGRAM_BIT
;
814 if (ctx
->Pixel
.MinMaxEnabled
)
815 mask
|= IMAGE_MIN_MAX_BIT
;
817 ctx
->_ImageTransferState
= mask
;
822 * Update mesa pixel transfer derived state.
824 void _mesa_update_pixel( GLcontext
*ctx
, GLuint new_state
)
826 if (new_state
& _NEW_COLOR_MATRIX
)
827 _math_matrix_analyse( ctx
->ColorMatrixStack
.Top
);
829 /* References ColorMatrix.type (derived above).
831 if (new_state
& _MESA_NEW_TRANSFER_STATE
)
832 update_image_transfer_state(ctx
);
836 /**********************************************************************/
837 /***** Initialization *****/
838 /**********************************************************************/
841 init_pixelmap(struct gl_pixelmap
*map
)
850 * Initialize the context's PIXEL attribute group.
853 _mesa_init_pixel( GLcontext
*ctx
)
858 ctx
->Pixel
.RedBias
= 0.0;
859 ctx
->Pixel
.RedScale
= 1.0;
860 ctx
->Pixel
.GreenBias
= 0.0;
861 ctx
->Pixel
.GreenScale
= 1.0;
862 ctx
->Pixel
.BlueBias
= 0.0;
863 ctx
->Pixel
.BlueScale
= 1.0;
864 ctx
->Pixel
.AlphaBias
= 0.0;
865 ctx
->Pixel
.AlphaScale
= 1.0;
866 ctx
->Pixel
.DepthBias
= 0.0;
867 ctx
->Pixel
.DepthScale
= 1.0;
868 ctx
->Pixel
.IndexOffset
= 0;
869 ctx
->Pixel
.IndexShift
= 0;
870 ctx
->Pixel
.ZoomX
= 1.0;
871 ctx
->Pixel
.ZoomY
= 1.0;
872 ctx
->Pixel
.MapColorFlag
= GL_FALSE
;
873 ctx
->Pixel
.MapStencilFlag
= GL_FALSE
;
874 init_pixelmap(&ctx
->PixelMaps
.StoS
);
875 init_pixelmap(&ctx
->PixelMaps
.ItoI
);
876 init_pixelmap(&ctx
->PixelMaps
.ItoR
);
877 init_pixelmap(&ctx
->PixelMaps
.ItoG
);
878 init_pixelmap(&ctx
->PixelMaps
.ItoB
);
879 init_pixelmap(&ctx
->PixelMaps
.ItoA
);
880 init_pixelmap(&ctx
->PixelMaps
.RtoR
);
881 init_pixelmap(&ctx
->PixelMaps
.GtoG
);
882 init_pixelmap(&ctx
->PixelMaps
.BtoB
);
883 init_pixelmap(&ctx
->PixelMaps
.AtoA
);
884 ctx
->Pixel
.HistogramEnabled
= GL_FALSE
;
885 ctx
->Pixel
.MinMaxEnabled
= GL_FALSE
;
886 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixScale
, 1.0, 1.0, 1.0, 1.0);
887 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixBias
, 0.0, 0.0, 0.0, 0.0);
888 for (i
= 0; i
< COLORTABLE_MAX
; i
++) {
889 ASSIGN_4V(ctx
->Pixel
.ColorTableScale
[i
], 1.0, 1.0, 1.0, 1.0);
890 ASSIGN_4V(ctx
->Pixel
.ColorTableBias
[i
], 0.0, 0.0, 0.0, 0.0);
891 ctx
->Pixel
.ColorTableEnabled
[i
] = GL_FALSE
;
893 ctx
->Pixel
.Convolution1DEnabled
= GL_FALSE
;
894 ctx
->Pixel
.Convolution2DEnabled
= GL_FALSE
;
895 ctx
->Pixel
.Separable2DEnabled
= GL_FALSE
;
896 for (i
= 0; i
< 3; i
++) {
897 ASSIGN_4V(ctx
->Pixel
.ConvolutionBorderColor
[i
], 0.0, 0.0, 0.0, 0.0);
898 ctx
->Pixel
.ConvolutionBorderMode
[i
] = GL_REDUCE
;
899 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterScale
[i
], 1.0, 1.0, 1.0, 1.0);
900 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterBias
[i
], 0.0, 0.0, 0.0, 0.0);
902 for (i
= 0; i
< MAX_CONVOLUTION_WIDTH
* MAX_CONVOLUTION_WIDTH
* 4; i
++) {
903 ctx
->Convolution1D
.Filter
[i
] = 0.0;
904 ctx
->Convolution2D
.Filter
[i
] = 0.0;
905 ctx
->Separable2D
.Filter
[i
] = 0.0;
907 ASSIGN_4V(ctx
->Pixel
.PostConvolutionScale
, 1.0, 1.0, 1.0, 1.0);
908 ASSIGN_4V(ctx
->Pixel
.PostConvolutionBias
, 0.0, 0.0, 0.0, 0.0);
909 /* GL_SGI_texture_color_table */
910 ASSIGN_4V(ctx
->Pixel
.TextureColorTableScale
, 1.0, 1.0, 1.0, 1.0);
911 ASSIGN_4V(ctx
->Pixel
.TextureColorTableBias
, 0.0, 0.0, 0.0, 0.0);
913 if (ctx
->Visual
.doubleBufferMode
) {
914 ctx
->Pixel
.ReadBuffer
= GL_BACK
;
917 ctx
->Pixel
.ReadBuffer
= GL_FRONT
;
921 ctx
->_ImageTransferState
= 0;