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"
38 #include "main/dispatch.h"
41 #if FEATURE_pixel_transfer
44 /**********************************************************************/
45 /***** glPixelZoom *****/
46 /**********************************************************************/
48 static void GLAPIENTRY
49 _mesa_PixelZoom( GLfloat xfactor
, GLfloat yfactor
)
51 GET_CURRENT_CONTEXT(ctx
);
53 if (ctx
->Pixel
.ZoomX
== xfactor
&&
54 ctx
->Pixel
.ZoomY
== yfactor
)
57 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
58 ctx
->Pixel
.ZoomX
= xfactor
;
59 ctx
->Pixel
.ZoomY
= yfactor
;
64 /**********************************************************************/
65 /***** glPixelMap *****/
66 /**********************************************************************/
69 * Return pointer to a pixelmap by name.
71 static struct gl_pixelmap
*
72 get_pixelmap(GLcontext
*ctx
, GLenum map
)
75 case GL_PIXEL_MAP_I_TO_I
:
76 return &ctx
->PixelMaps
.ItoI
;
77 case GL_PIXEL_MAP_S_TO_S
:
78 return &ctx
->PixelMaps
.StoS
;
79 case GL_PIXEL_MAP_I_TO_R
:
80 return &ctx
->PixelMaps
.ItoR
;
81 case GL_PIXEL_MAP_I_TO_G
:
82 return &ctx
->PixelMaps
.ItoG
;
83 case GL_PIXEL_MAP_I_TO_B
:
84 return &ctx
->PixelMaps
.ItoB
;
85 case GL_PIXEL_MAP_I_TO_A
:
86 return &ctx
->PixelMaps
.ItoA
;
87 case GL_PIXEL_MAP_R_TO_R
:
88 return &ctx
->PixelMaps
.RtoR
;
89 case GL_PIXEL_MAP_G_TO_G
:
90 return &ctx
->PixelMaps
.GtoG
;
91 case GL_PIXEL_MAP_B_TO_B
:
92 return &ctx
->PixelMaps
.BtoB
;
93 case GL_PIXEL_MAP_A_TO_A
:
94 return &ctx
->PixelMaps
.AtoA
;
102 * Helper routine used by the other _mesa_PixelMap() functions.
105 store_pixelmap(GLcontext
*ctx
, GLenum map
, GLsizei mapsize
,
106 const GLfloat
*values
)
109 struct gl_pixelmap
*pm
= get_pixelmap(ctx
, map
);
111 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPixelMap(map)");
116 case GL_PIXEL_MAP_S_TO_S
:
118 ctx
->PixelMaps
.StoS
.Size
= mapsize
;
119 for (i
= 0; i
< mapsize
; i
++) {
120 ctx
->PixelMaps
.StoS
.Map
[i
] = (GLfloat
)IROUND(values
[i
]);
123 case GL_PIXEL_MAP_I_TO_I
:
125 ctx
->PixelMaps
.ItoI
.Size
= mapsize
;
126 for (i
= 0; i
< mapsize
; i
++) {
127 ctx
->PixelMaps
.ItoI
.Map
[i
] = values
[i
];
133 for (i
= 0; i
< mapsize
; i
++) {
134 GLfloat val
= CLAMP(values
[i
], 0.0F
, 1.0F
);
136 pm
->Map8
[i
] = (GLint
) (val
* 255.0F
);
143 * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap().
146 validate_pbo_access(GLcontext
*ctx
, struct gl_pixelstore_attrib
*pack
,
147 GLsizei mapsize
, GLenum format
, GLenum type
,
152 /* Note, need to use DefaultPacking and Unpack's buffer object */
153 _mesa_reference_buffer_object(ctx
,
154 &ctx
->DefaultPacking
.BufferObj
,
157 ok
= _mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
161 _mesa_reference_buffer_object(ctx
,
162 &ctx
->DefaultPacking
.BufferObj
,
163 ctx
->Shared
->NullBufferObj
);
166 _mesa_error(ctx
, GL_INVALID_OPERATION
,
167 "glPixelMap(invalid PBO access)");
173 static void GLAPIENTRY
174 _mesa_PixelMapfv( GLenum map
, GLsizei mapsize
, const GLfloat
*values
)
176 GET_CURRENT_CONTEXT(ctx
);
177 ASSERT_OUTSIDE_BEGIN_END(ctx
);
179 /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
180 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
181 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
185 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
186 /* test that mapsize is a power of two */
187 if (!_mesa_is_pow_two(mapsize
)) {
188 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
193 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
195 if (!validate_pbo_access(ctx
, &ctx
->Unpack
, mapsize
,
196 GL_INTENSITY
, GL_FLOAT
, values
)) {
200 values
= (const GLfloat
*) _mesa_map_pbo_source(ctx
, &ctx
->Unpack
, values
);
202 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
203 _mesa_error(ctx
, GL_INVALID_OPERATION
,
204 "glPixelMapfv(PBO is mapped)");
209 store_pixelmap(ctx
, map
, mapsize
, values
);
211 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
215 static void GLAPIENTRY
216 _mesa_PixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
*values
)
218 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
219 GET_CURRENT_CONTEXT(ctx
);
220 ASSERT_OUTSIDE_BEGIN_END(ctx
);
222 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
223 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
227 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
228 /* test that mapsize is a power of two */
229 if (!_mesa_is_pow_two(mapsize
)) {
230 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
235 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
237 if (!validate_pbo_access(ctx
, &ctx
->Unpack
, mapsize
,
238 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
242 values
= (const GLuint
*) _mesa_map_pbo_source(ctx
, &ctx
->Unpack
, values
);
244 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
245 _mesa_error(ctx
, GL_INVALID_OPERATION
,
246 "glPixelMapuiv(PBO is mapped)");
251 /* convert to floats */
252 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
254 for (i
= 0; i
< mapsize
; i
++) {
255 fvalues
[i
] = (GLfloat
) values
[i
];
260 for (i
= 0; i
< mapsize
; i
++) {
261 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
265 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
267 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
271 static void GLAPIENTRY
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 (!validate_pbo_access(ctx
, &ctx
->Unpack
, mapsize
,
294 GL_INTENSITY
, GL_UNSIGNED_SHORT
, values
)) {
298 values
= (const GLushort
*) _mesa_map_pbo_source(ctx
, &ctx
->Unpack
, values
);
300 if (_mesa_is_bufferobj(ctx
->Unpack
.BufferObj
)) {
301 _mesa_error(ctx
, GL_INVALID_OPERATION
,
302 "glPixelMapusv(PBO is mapped)");
307 /* convert to floats */
308 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
310 for (i
= 0; i
< mapsize
; i
++) {
311 fvalues
[i
] = (GLfloat
) values
[i
];
316 for (i
= 0; i
< mapsize
; i
++) {
317 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
321 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
323 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
327 static void GLAPIENTRY
328 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
330 GET_CURRENT_CONTEXT(ctx
);
332 const struct gl_pixelmap
*pm
;
334 ASSERT_OUTSIDE_BEGIN_END(ctx
);
336 pm
= get_pixelmap(ctx
, map
);
338 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv(map)");
344 if (!validate_pbo_access(ctx
, &ctx
->Pack
, mapsize
,
345 GL_INTENSITY
, GL_FLOAT
, values
)) {
349 values
= (GLfloat
*) _mesa_map_pbo_dest(ctx
, &ctx
->Pack
, values
);
351 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
352 _mesa_error(ctx
, GL_INVALID_OPERATION
,
353 "glGetPixelMapfv(PBO is mapped)");
358 if (map
== GL_PIXEL_MAP_S_TO_S
) {
360 for (i
= 0; i
< mapsize
; i
++) {
361 values
[i
] = (GLfloat
) ctx
->PixelMaps
.StoS
.Map
[i
];
365 memcpy(values
, pm
->Map
, mapsize
* sizeof(GLfloat
));
368 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
372 static void GLAPIENTRY
373 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
375 GET_CURRENT_CONTEXT(ctx
);
377 const struct gl_pixelmap
*pm
;
379 ASSERT_OUTSIDE_BEGIN_END(ctx
);
381 pm
= get_pixelmap(ctx
, map
);
383 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapuiv(map)");
388 if (!validate_pbo_access(ctx
, &ctx
->Pack
, mapsize
,
389 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
393 values
= (GLuint
*) _mesa_map_pbo_dest(ctx
, &ctx
->Pack
, values
);
395 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
396 _mesa_error(ctx
, GL_INVALID_OPERATION
,
397 "glGetPixelMapuiv(PBO is mapped)");
402 if (map
== GL_PIXEL_MAP_S_TO_S
) {
404 memcpy(values
, ctx
->PixelMaps
.StoS
.Map
, mapsize
* sizeof(GLint
));
407 for (i
= 0; i
< mapsize
; i
++) {
408 values
[i
] = FLOAT_TO_UINT( pm
->Map
[i
] );
412 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
416 static void GLAPIENTRY
417 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
419 GET_CURRENT_CONTEXT(ctx
);
421 const struct gl_pixelmap
*pm
;
423 ASSERT_OUTSIDE_BEGIN_END(ctx
);
425 pm
= get_pixelmap(ctx
, map
);
427 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapusv(map)");
432 if (!validate_pbo_access(ctx
, &ctx
->Pack
, mapsize
,
433 GL_INTENSITY
, GL_UNSIGNED_SHORT
, values
)) {
437 values
= (GLushort
*) _mesa_map_pbo_dest(ctx
, &ctx
->Pack
, values
);
439 if (_mesa_is_bufferobj(ctx
->Pack
.BufferObj
)) {
440 _mesa_error(ctx
, GL_INVALID_OPERATION
,
441 "glGetPixelMapusv(PBO is mapped)");
448 case GL_PIXEL_MAP_I_TO_I
:
449 for (i
= 0; i
< mapsize
; i
++) {
450 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.ItoI
.Map
[i
], 0.0, 65535.);
453 case GL_PIXEL_MAP_S_TO_S
:
454 for (i
= 0; i
< mapsize
; i
++) {
455 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.StoS
.Map
[i
], 0.0, 65535.);
459 for (i
= 0; i
< mapsize
; i
++) {
460 CLAMPED_FLOAT_TO_USHORT(values
[i
], pm
->Map
[i
] );
464 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
469 /**********************************************************************/
470 /***** glPixelTransfer *****/
471 /**********************************************************************/
475 * Implements glPixelTransfer[fi] whether called immediately or from a
478 static void GLAPIENTRY
479 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
481 GET_CURRENT_CONTEXT(ctx
);
482 ASSERT_OUTSIDE_BEGIN_END(ctx
);
486 if (ctx
->Pixel
.MapColorFlag
== (param
? GL_TRUE
: GL_FALSE
))
488 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
489 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
492 if (ctx
->Pixel
.MapStencilFlag
== (param
? GL_TRUE
: GL_FALSE
))
494 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
495 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
498 if (ctx
->Pixel
.IndexShift
== (GLint
) param
)
500 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
501 ctx
->Pixel
.IndexShift
= (GLint
) param
;
503 case GL_INDEX_OFFSET
:
504 if (ctx
->Pixel
.IndexOffset
== (GLint
) param
)
506 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
507 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
510 if (ctx
->Pixel
.RedScale
== param
)
512 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
513 ctx
->Pixel
.RedScale
= param
;
516 if (ctx
->Pixel
.RedBias
== param
)
518 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
519 ctx
->Pixel
.RedBias
= param
;
522 if (ctx
->Pixel
.GreenScale
== param
)
524 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
525 ctx
->Pixel
.GreenScale
= param
;
528 if (ctx
->Pixel
.GreenBias
== param
)
530 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
531 ctx
->Pixel
.GreenBias
= param
;
534 if (ctx
->Pixel
.BlueScale
== param
)
536 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
537 ctx
->Pixel
.BlueScale
= param
;
540 if (ctx
->Pixel
.BlueBias
== param
)
542 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
543 ctx
->Pixel
.BlueBias
= param
;
546 if (ctx
->Pixel
.AlphaScale
== param
)
548 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
549 ctx
->Pixel
.AlphaScale
= param
;
552 if (ctx
->Pixel
.AlphaBias
== param
)
554 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
555 ctx
->Pixel
.AlphaBias
= param
;
558 if (ctx
->Pixel
.DepthScale
== param
)
560 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
561 ctx
->Pixel
.DepthScale
= param
;
564 if (ctx
->Pixel
.DepthBias
== param
)
566 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
567 ctx
->Pixel
.DepthBias
= param
;
569 case GL_POST_COLOR_MATRIX_RED_SCALE
:
570 if (ctx
->Pixel
.PostColorMatrixScale
[0] == param
)
572 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
573 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
575 case GL_POST_COLOR_MATRIX_RED_BIAS
:
576 if (ctx
->Pixel
.PostColorMatrixBias
[0] == param
)
578 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
579 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
581 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
582 if (ctx
->Pixel
.PostColorMatrixScale
[1] == param
)
584 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
585 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
587 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
588 if (ctx
->Pixel
.PostColorMatrixBias
[1] == param
)
590 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
591 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
593 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
594 if (ctx
->Pixel
.PostColorMatrixScale
[2] == param
)
596 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
597 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
599 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
600 if (ctx
->Pixel
.PostColorMatrixBias
[2] == param
)
602 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
603 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
605 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
606 if (ctx
->Pixel
.PostColorMatrixScale
[3] == param
)
608 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
609 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
611 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
612 if (ctx
->Pixel
.PostColorMatrixBias
[3] == param
)
614 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
615 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
617 case GL_POST_CONVOLUTION_RED_SCALE
:
618 if (ctx
->Pixel
.PostConvolutionScale
[0] == param
)
620 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
621 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
623 case GL_POST_CONVOLUTION_RED_BIAS
:
624 if (ctx
->Pixel
.PostConvolutionBias
[0] == param
)
626 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
627 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
629 case GL_POST_CONVOLUTION_GREEN_SCALE
:
630 if (ctx
->Pixel
.PostConvolutionScale
[1] == param
)
632 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
633 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
635 case GL_POST_CONVOLUTION_GREEN_BIAS
:
636 if (ctx
->Pixel
.PostConvolutionBias
[1] == param
)
638 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
639 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
641 case GL_POST_CONVOLUTION_BLUE_SCALE
:
642 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
644 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
645 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
647 case GL_POST_CONVOLUTION_BLUE_BIAS
:
648 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
650 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
651 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
653 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
654 if (ctx
->Pixel
.PostConvolutionScale
[3] == param
)
656 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
657 ctx
->Pixel
.PostConvolutionScale
[3] = param
;
659 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
660 if (ctx
->Pixel
.PostConvolutionBias
[3] == param
)
662 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
663 ctx
->Pixel
.PostConvolutionBias
[3] = param
;
666 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
672 static void GLAPIENTRY
673 _mesa_PixelTransferi( GLenum pname
, GLint param
)
675 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
680 /**********************************************************************/
681 /***** State Management *****/
682 /**********************************************************************/
685 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
686 * pixel transfer operations are enabled.
689 update_image_transfer_state(GLcontext
*ctx
)
693 if (ctx
->Pixel
.RedScale
!= 1.0F
|| ctx
->Pixel
.RedBias
!= 0.0F
||
694 ctx
->Pixel
.GreenScale
!= 1.0F
|| ctx
->Pixel
.GreenBias
!= 0.0F
||
695 ctx
->Pixel
.BlueScale
!= 1.0F
|| ctx
->Pixel
.BlueBias
!= 0.0F
||
696 ctx
->Pixel
.AlphaScale
!= 1.0F
|| ctx
->Pixel
.AlphaBias
!= 0.0F
)
697 mask
|= IMAGE_SCALE_BIAS_BIT
;
699 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
)
700 mask
|= IMAGE_SHIFT_OFFSET_BIT
;
702 if (ctx
->Pixel
.MapColorFlag
)
703 mask
|= IMAGE_MAP_COLOR_BIT
;
705 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_PRECONVOLUTION
])
706 mask
|= IMAGE_COLOR_TABLE_BIT
;
708 if (ctx
->Pixel
.Convolution1DEnabled
||
709 ctx
->Pixel
.Convolution2DEnabled
||
710 ctx
->Pixel
.Separable2DEnabled
) {
711 mask
|= IMAGE_CONVOLUTION_BIT
;
712 if (ctx
->Pixel
.PostConvolutionScale
[0] != 1.0F
||
713 ctx
->Pixel
.PostConvolutionScale
[1] != 1.0F
||
714 ctx
->Pixel
.PostConvolutionScale
[2] != 1.0F
||
715 ctx
->Pixel
.PostConvolutionScale
[3] != 1.0F
||
716 ctx
->Pixel
.PostConvolutionBias
[0] != 0.0F
||
717 ctx
->Pixel
.PostConvolutionBias
[1] != 0.0F
||
718 ctx
->Pixel
.PostConvolutionBias
[2] != 0.0F
||
719 ctx
->Pixel
.PostConvolutionBias
[3] != 0.0F
) {
720 mask
|= IMAGE_POST_CONVOLUTION_SCALE_BIAS
;
724 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCONVOLUTION
])
725 mask
|= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
;
727 if (ctx
->ColorMatrixStack
.Top
->type
!= MATRIX_IDENTITY
||
728 ctx
->Pixel
.PostColorMatrixScale
[0] != 1.0F
||
729 ctx
->Pixel
.PostColorMatrixBias
[0] != 0.0F
||
730 ctx
->Pixel
.PostColorMatrixScale
[1] != 1.0F
||
731 ctx
->Pixel
.PostColorMatrixBias
[1] != 0.0F
||
732 ctx
->Pixel
.PostColorMatrixScale
[2] != 1.0F
||
733 ctx
->Pixel
.PostColorMatrixBias
[2] != 0.0F
||
734 ctx
->Pixel
.PostColorMatrixScale
[3] != 1.0F
||
735 ctx
->Pixel
.PostColorMatrixBias
[3] != 0.0F
)
736 mask
|= IMAGE_COLOR_MATRIX_BIT
;
738 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCOLORMATRIX
])
739 mask
|= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
;
741 if (ctx
->Pixel
.HistogramEnabled
)
742 mask
|= IMAGE_HISTOGRAM_BIT
;
744 if (ctx
->Pixel
.MinMaxEnabled
)
745 mask
|= IMAGE_MIN_MAX_BIT
;
747 ctx
->_ImageTransferState
= mask
;
752 * Update mesa pixel transfer derived state.
754 void _mesa_update_pixel( GLcontext
*ctx
, GLuint new_state
)
756 if (new_state
& _NEW_COLOR_MATRIX
)
757 _math_matrix_analyse( ctx
->ColorMatrixStack
.Top
);
759 /* References ColorMatrix.type (derived above).
761 if (new_state
& _MESA_NEW_TRANSFER_STATE
)
762 update_image_transfer_state(ctx
);
767 _mesa_init_pixel_dispatch(struct _glapi_table
*disp
)
769 SET_GetPixelMapfv(disp
, _mesa_GetPixelMapfv
);
770 SET_GetPixelMapuiv(disp
, _mesa_GetPixelMapuiv
);
771 SET_GetPixelMapusv(disp
, _mesa_GetPixelMapusv
);
772 SET_PixelMapfv(disp
, _mesa_PixelMapfv
);
773 SET_PixelMapuiv(disp
, _mesa_PixelMapuiv
);
774 SET_PixelMapusv(disp
, _mesa_PixelMapusv
);
775 SET_PixelTransferf(disp
, _mesa_PixelTransferf
);
776 SET_PixelTransferi(disp
, _mesa_PixelTransferi
);
777 SET_PixelZoom(disp
, _mesa_PixelZoom
);
781 #endif /* FEATURE_pixel_transfer */
784 /**********************************************************************/
785 /***** Initialization *****/
786 /**********************************************************************/
789 init_pixelmap(struct gl_pixelmap
*map
)
798 * Initialize the context's PIXEL attribute group.
801 _mesa_init_pixel( GLcontext
*ctx
)
806 ctx
->Pixel
.RedBias
= 0.0;
807 ctx
->Pixel
.RedScale
= 1.0;
808 ctx
->Pixel
.GreenBias
= 0.0;
809 ctx
->Pixel
.GreenScale
= 1.0;
810 ctx
->Pixel
.BlueBias
= 0.0;
811 ctx
->Pixel
.BlueScale
= 1.0;
812 ctx
->Pixel
.AlphaBias
= 0.0;
813 ctx
->Pixel
.AlphaScale
= 1.0;
814 ctx
->Pixel
.DepthBias
= 0.0;
815 ctx
->Pixel
.DepthScale
= 1.0;
816 ctx
->Pixel
.IndexOffset
= 0;
817 ctx
->Pixel
.IndexShift
= 0;
818 ctx
->Pixel
.ZoomX
= 1.0;
819 ctx
->Pixel
.ZoomY
= 1.0;
820 ctx
->Pixel
.MapColorFlag
= GL_FALSE
;
821 ctx
->Pixel
.MapStencilFlag
= GL_FALSE
;
822 init_pixelmap(&ctx
->PixelMaps
.StoS
);
823 init_pixelmap(&ctx
->PixelMaps
.ItoI
);
824 init_pixelmap(&ctx
->PixelMaps
.ItoR
);
825 init_pixelmap(&ctx
->PixelMaps
.ItoG
);
826 init_pixelmap(&ctx
->PixelMaps
.ItoB
);
827 init_pixelmap(&ctx
->PixelMaps
.ItoA
);
828 init_pixelmap(&ctx
->PixelMaps
.RtoR
);
829 init_pixelmap(&ctx
->PixelMaps
.GtoG
);
830 init_pixelmap(&ctx
->PixelMaps
.BtoB
);
831 init_pixelmap(&ctx
->PixelMaps
.AtoA
);
832 ctx
->Pixel
.HistogramEnabled
= GL_FALSE
;
833 ctx
->Pixel
.MinMaxEnabled
= GL_FALSE
;
834 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixScale
, 1.0, 1.0, 1.0, 1.0);
835 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixBias
, 0.0, 0.0, 0.0, 0.0);
836 for (i
= 0; i
< COLORTABLE_MAX
; i
++) {
837 ASSIGN_4V(ctx
->Pixel
.ColorTableScale
[i
], 1.0, 1.0, 1.0, 1.0);
838 ASSIGN_4V(ctx
->Pixel
.ColorTableBias
[i
], 0.0, 0.0, 0.0, 0.0);
839 ctx
->Pixel
.ColorTableEnabled
[i
] = GL_FALSE
;
841 ctx
->Pixel
.Convolution1DEnabled
= GL_FALSE
;
842 ctx
->Pixel
.Convolution2DEnabled
= GL_FALSE
;
843 ctx
->Pixel
.Separable2DEnabled
= GL_FALSE
;
844 for (i
= 0; i
< 3; i
++) {
845 ASSIGN_4V(ctx
->Pixel
.ConvolutionBorderColor
[i
], 0.0, 0.0, 0.0, 0.0);
846 ctx
->Pixel
.ConvolutionBorderMode
[i
] = GL_REDUCE
;
847 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterScale
[i
], 1.0, 1.0, 1.0, 1.0);
848 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterBias
[i
], 0.0, 0.0, 0.0, 0.0);
850 for (i
= 0; i
< MAX_CONVOLUTION_WIDTH
* MAX_CONVOLUTION_WIDTH
* 4; i
++) {
851 ctx
->Convolution1D
.Filter
[i
] = 0.0;
852 ctx
->Convolution2D
.Filter
[i
] = 0.0;
853 ctx
->Separable2D
.Filter
[i
] = 0.0;
855 ASSIGN_4V(ctx
->Pixel
.PostConvolutionScale
, 1.0, 1.0, 1.0, 1.0);
856 ASSIGN_4V(ctx
->Pixel
.PostConvolutionBias
, 0.0, 0.0, 0.0, 0.0);
857 /* GL_SGI_texture_color_table */
858 ASSIGN_4V(ctx
->Pixel
.TextureColorTableScale
, 1.0, 1.0, 1.0, 1.0);
859 ASSIGN_4V(ctx
->Pixel
.TextureColorTableBias
, 0.0, 0.0, 0.0, 0.0);
861 if (ctx
->Visual
.doubleBufferMode
) {
862 ctx
->Pixel
.ReadBuffer
= GL_BACK
;
865 ctx
->Pixel
.ReadBuffer
= GL_FRONT
;
869 ctx
->_ImageTransferState
= 0;