2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 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.
26 #include "bufferobj.h"
35 /**********************************************************************/
36 /***** glPixelZoom *****/
37 /**********************************************************************/
42 _mesa_PixelZoom( GLfloat xfactor
, GLfloat yfactor
)
44 GET_CURRENT_CONTEXT(ctx
);
46 if (ctx
->Pixel
.ZoomX
== xfactor
&&
47 ctx
->Pixel
.ZoomY
== yfactor
)
50 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
51 ctx
->Pixel
.ZoomX
= xfactor
;
52 ctx
->Pixel
.ZoomY
= yfactor
;
57 /**********************************************************************/
58 /***** glPixelStore *****/
59 /**********************************************************************/
63 _mesa_PixelStorei( GLenum pname
, GLint param
)
65 /* NOTE: this call can't be compiled into the display list */
66 GET_CURRENT_CONTEXT(ctx
);
67 ASSERT_OUTSIDE_BEGIN_END(ctx
);
70 case GL_PACK_SWAP_BYTES
:
71 if (param
== (GLint
)ctx
->Pack
.SwapBytes
)
73 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
74 ctx
->Pack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
76 case GL_PACK_LSB_FIRST
:
77 if (param
== (GLint
)ctx
->Pack
.LsbFirst
)
79 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
80 ctx
->Pack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
82 case GL_PACK_ROW_LENGTH
:
84 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
87 if (ctx
->Pack
.RowLength
== param
)
89 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
90 ctx
->Pack
.RowLength
= param
;
92 case GL_PACK_IMAGE_HEIGHT
:
94 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
97 if (ctx
->Pack
.ImageHeight
== param
)
99 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
100 ctx
->Pack
.ImageHeight
= param
;
102 case GL_PACK_SKIP_PIXELS
:
104 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
107 if (ctx
->Pack
.SkipPixels
== param
)
109 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
110 ctx
->Pack
.SkipPixels
= param
;
112 case GL_PACK_SKIP_ROWS
:
114 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
117 if (ctx
->Pack
.SkipRows
== param
)
119 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
120 ctx
->Pack
.SkipRows
= param
;
122 case GL_PACK_SKIP_IMAGES
:
124 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
127 if (ctx
->Pack
.SkipImages
== param
)
129 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
130 ctx
->Pack
.SkipImages
= param
;
132 case GL_PACK_ALIGNMENT
:
133 if (param
!=1 && param
!=2 && param
!=4 && param
!=8) {
134 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
137 if (ctx
->Pack
.Alignment
== param
)
139 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
140 ctx
->Pack
.Alignment
= param
;
142 case GL_PACK_INVERT_MESA
:
143 if (!ctx
->Extensions
.MESA_pack_invert
) {
144 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelstore(pname)" );
147 if (ctx
->Pack
.Invert
== param
)
149 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
150 ctx
->Pack
.Invert
= param
;
153 case GL_UNPACK_SWAP_BYTES
:
154 if (param
== (GLint
)ctx
->Unpack
.SwapBytes
)
156 if ((GLint
)ctx
->Unpack
.SwapBytes
== param
)
158 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
159 ctx
->Unpack
.SwapBytes
= param
? GL_TRUE
: GL_FALSE
;
161 case GL_UNPACK_LSB_FIRST
:
162 if (param
== (GLint
)ctx
->Unpack
.LsbFirst
)
164 if ((GLint
)ctx
->Unpack
.LsbFirst
== param
)
166 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
167 ctx
->Unpack
.LsbFirst
= param
? GL_TRUE
: GL_FALSE
;
169 case GL_UNPACK_ROW_LENGTH
:
171 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
174 if (ctx
->Unpack
.RowLength
== param
)
176 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
177 ctx
->Unpack
.RowLength
= param
;
179 case GL_UNPACK_IMAGE_HEIGHT
:
181 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
184 if (ctx
->Unpack
.ImageHeight
== param
)
187 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
188 ctx
->Unpack
.ImageHeight
= param
;
190 case GL_UNPACK_SKIP_PIXELS
:
192 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
195 if (ctx
->Unpack
.SkipPixels
== param
)
197 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
198 ctx
->Unpack
.SkipPixels
= param
;
200 case GL_UNPACK_SKIP_ROWS
:
202 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
205 if (ctx
->Unpack
.SkipRows
== param
)
207 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
208 ctx
->Unpack
.SkipRows
= param
;
210 case GL_UNPACK_SKIP_IMAGES
:
212 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore(param)" );
215 if (ctx
->Unpack
.SkipImages
== param
)
217 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
218 ctx
->Unpack
.SkipImages
= param
;
220 case GL_UNPACK_ALIGNMENT
:
221 if (param
!=1 && param
!=2 && param
!=4 && param
!=8) {
222 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelStore" );
225 if (ctx
->Unpack
.Alignment
== param
)
227 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
228 ctx
->Unpack
.Alignment
= param
;
230 case GL_UNPACK_CLIENT_STORAGE_APPLE
:
231 if (param
== (GLint
)ctx
->Unpack
.ClientStorage
)
233 FLUSH_VERTICES(ctx
, _NEW_PACKUNPACK
);
234 ctx
->Unpack
.ClientStorage
= param
? GL_TRUE
: GL_FALSE
;
237 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelStore" );
244 _mesa_PixelStoref( GLenum pname
, GLfloat param
)
246 _mesa_PixelStorei( pname
, (GLint
) param
);
251 /**********************************************************************/
252 /***** glPixelMap *****/
253 /**********************************************************************/
256 * Return pointer to a pixelmap by name.
258 static struct gl_pixelmap
*
259 get_pixelmap(GLcontext
*ctx
, GLenum map
)
262 case GL_PIXEL_MAP_I_TO_I
:
263 return &ctx
->PixelMaps
.ItoI
;
264 case GL_PIXEL_MAP_S_TO_S
:
265 return &ctx
->PixelMaps
.StoS
;
266 case GL_PIXEL_MAP_I_TO_R
:
267 return &ctx
->PixelMaps
.ItoR
;
268 case GL_PIXEL_MAP_I_TO_G
:
269 return &ctx
->PixelMaps
.ItoG
;
270 case GL_PIXEL_MAP_I_TO_B
:
271 return &ctx
->PixelMaps
.ItoB
;
272 case GL_PIXEL_MAP_I_TO_A
:
273 return &ctx
->PixelMaps
.ItoA
;
274 case GL_PIXEL_MAP_R_TO_R
:
275 return &ctx
->PixelMaps
.RtoR
;
276 case GL_PIXEL_MAP_G_TO_G
:
277 return &ctx
->PixelMaps
.GtoG
;
278 case GL_PIXEL_MAP_B_TO_B
:
279 return &ctx
->PixelMaps
.BtoB
;
280 case GL_PIXEL_MAP_A_TO_A
:
281 return &ctx
->PixelMaps
.AtoA
;
289 * Helper routine used by the other _mesa_PixelMap() functions.
292 store_pixelmap(GLcontext
*ctx
, GLenum map
, GLsizei mapsize
,
293 const GLfloat
*values
)
296 struct gl_pixelmap
*pm
= get_pixelmap(ctx
, map
);
298 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPixelMap(map)");
303 case GL_PIXEL_MAP_S_TO_S
:
305 ctx
->PixelMaps
.StoS
.Size
= mapsize
;
306 for (i
= 0; i
< mapsize
; i
++) {
307 ctx
->PixelMaps
.StoS
.Map
[i
] = IROUND(values
[i
]);
310 case GL_PIXEL_MAP_I_TO_I
:
312 ctx
->PixelMaps
.ItoI
.Size
= mapsize
;
313 for (i
= 0; i
< mapsize
; i
++) {
314 ctx
->PixelMaps
.ItoI
.Map
[i
] = values
[i
];
320 for (i
= 0; i
< mapsize
; i
++) {
321 GLfloat val
= CLAMP(values
[i
], 0.0F
, 1.0F
);
323 pm
->Map8
[i
] = (GLint
) (val
* 255.0F
);
330 _mesa_PixelMapfv( GLenum map
, GLsizei mapsize
, const GLfloat
*values
)
332 GET_CURRENT_CONTEXT(ctx
);
333 ASSERT_OUTSIDE_BEGIN_END(ctx
);
335 /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
336 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
337 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
341 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
342 /* test that mapsize is a power of two */
343 if (_mesa_bitcount((GLuint
) mapsize
) != 1) {
344 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapfv(mapsize)" );
349 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
351 if (ctx
->Unpack
.BufferObj
->Name
) {
352 /* unpack pixelmap from PBO */
354 /* Note, need to use DefaultPacking and Unpack's buffer object */
355 ctx
->DefaultPacking
.BufferObj
= ctx
->Unpack
.BufferObj
;
356 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
357 GL_INTENSITY
, GL_FLOAT
, values
)) {
358 _mesa_error(ctx
, GL_INVALID_OPERATION
,
359 "glPixelMapfv(invalid PBO access)");
363 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
364 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
366 ctx
->Unpack
.BufferObj
);
368 /* buffer is already mapped - that's an error */
369 _mesa_error(ctx
, GL_INVALID_OPERATION
,
370 "glPixelMapfv(PBO is mapped)");
373 values
= (const GLfloat
*) ADD_POINTERS(buf
, values
);
379 store_pixelmap(ctx
, map
, mapsize
, values
);
381 if (ctx
->Unpack
.BufferObj
->Name
) {
382 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
383 ctx
->Unpack
.BufferObj
);
389 _mesa_PixelMapuiv(GLenum map
, GLsizei mapsize
, const GLuint
*values
)
391 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
392 GET_CURRENT_CONTEXT(ctx
);
393 ASSERT_OUTSIDE_BEGIN_END(ctx
);
395 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
396 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
400 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
401 /* test that mapsize is a power of two */
402 if (_mesa_bitcount((GLuint
) mapsize
) != 1) {
403 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
408 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
410 if (ctx
->Unpack
.BufferObj
->Name
) {
411 /* unpack pixelmap from PBO */
413 /* Note, need to use DefaultPacking and Unpack's buffer object */
414 ctx
->DefaultPacking
.BufferObj
= ctx
->Unpack
.BufferObj
;
415 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
416 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
417 _mesa_error(ctx
, GL_INVALID_OPERATION
,
418 "glPixelMapuiv(invalid PBO access)");
422 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
423 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
425 ctx
->Unpack
.BufferObj
);
427 /* buffer is already mapped - that's an error */
428 _mesa_error(ctx
, GL_INVALID_OPERATION
,
429 "glPixelMapuiv(PBO is mapped)");
432 values
= (const GLuint
*) ADD_POINTERS(buf
, values
);
438 /* convert to floats */
439 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
441 for (i
= 0; i
< mapsize
; i
++) {
442 fvalues
[i
] = (GLfloat
) values
[i
];
447 for (i
= 0; i
< mapsize
; i
++) {
448 fvalues
[i
] = UINT_TO_FLOAT( values
[i
] );
452 if (ctx
->Unpack
.BufferObj
->Name
) {
453 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
454 ctx
->Unpack
.BufferObj
);
457 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
462 _mesa_PixelMapusv(GLenum map
, GLsizei mapsize
, const GLushort
*values
)
464 GLfloat fvalues
[MAX_PIXEL_MAP_TABLE
];
465 GET_CURRENT_CONTEXT(ctx
);
466 ASSERT_OUTSIDE_BEGIN_END(ctx
);
468 if (mapsize
< 1 || mapsize
> MAX_PIXEL_MAP_TABLE
) {
469 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapusv(mapsize)" );
473 if (map
>= GL_PIXEL_MAP_S_TO_S
&& map
<= GL_PIXEL_MAP_I_TO_A
) {
474 /* test that mapsize is a power of two */
475 if (_mesa_bitcount((GLuint
) mapsize
) != 1) {
476 _mesa_error( ctx
, GL_INVALID_VALUE
, "glPixelMapuiv(mapsize)" );
481 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
483 if (ctx
->Unpack
.BufferObj
->Name
) {
484 /* unpack pixelmap from PBO */
486 /* Note, need to use DefaultPacking and Unpack's buffer object */
487 ctx
->DefaultPacking
.BufferObj
= ctx
->Unpack
.BufferObj
;
488 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
489 GL_INTENSITY
, GL_UNSIGNED_SHORT
,
491 _mesa_error(ctx
, GL_INVALID_OPERATION
,
492 "glPixelMapusv(invalid PBO access)");
496 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
497 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
499 ctx
->Unpack
.BufferObj
);
501 /* buffer is already mapped - that's an error */
502 _mesa_error(ctx
, GL_INVALID_OPERATION
,
503 "glPixelMapusv(PBO is mapped)");
506 values
= (const GLushort
*) ADD_POINTERS(buf
, values
);
512 /* convert to floats */
513 if (map
== GL_PIXEL_MAP_I_TO_I
|| map
== GL_PIXEL_MAP_S_TO_S
) {
515 for (i
= 0; i
< mapsize
; i
++) {
516 fvalues
[i
] = (GLfloat
) values
[i
];
521 for (i
= 0; i
< mapsize
; i
++) {
522 fvalues
[i
] = USHORT_TO_FLOAT( values
[i
] );
526 if (ctx
->Unpack
.BufferObj
->Name
) {
527 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
528 ctx
->Unpack
.BufferObj
);
531 store_pixelmap(ctx
, map
, mapsize
, fvalues
);
536 _mesa_GetPixelMapfv( GLenum map
, GLfloat
*values
)
538 GET_CURRENT_CONTEXT(ctx
);
540 const struct gl_pixelmap
*pm
;
542 ASSERT_OUTSIDE_BEGIN_END(ctx
);
544 pm
= get_pixelmap(ctx
, map
);
546 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapfv(map)");
552 if (ctx
->Pack
.BufferObj
->Name
) {
553 /* pack pixelmap into PBO */
555 /* Note, need to use DefaultPacking and Pack's buffer object */
556 ctx
->DefaultPacking
.BufferObj
= ctx
->Pack
.BufferObj
;
557 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
558 GL_INTENSITY
, GL_FLOAT
, values
)) {
559 _mesa_error(ctx
, GL_INVALID_OPERATION
,
560 "glGetPixelMapfv(invalid PBO access)");
564 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
565 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
567 ctx
->Pack
.BufferObj
);
569 /* buffer is already mapped - that's an error */
570 _mesa_error(ctx
, GL_INVALID_OPERATION
,
571 "glGetPixelMapfv(PBO is mapped)");
574 values
= (GLfloat
*) ADD_POINTERS(buf
, values
);
580 if (map
== GL_PIXEL_MAP_S_TO_S
) {
582 for (i
= 0; i
< mapsize
; i
++) {
583 values
[i
] = (GLfloat
) ctx
->PixelMaps
.StoS
.Map
[i
];
587 MEMCPY(values
, pm
->Map
, mapsize
* sizeof(GLfloat
));
590 if (ctx
->Pack
.BufferObj
->Name
) {
591 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
592 ctx
->Pack
.BufferObj
);
598 _mesa_GetPixelMapuiv( GLenum map
, GLuint
*values
)
600 GET_CURRENT_CONTEXT(ctx
);
602 const struct gl_pixelmap
*pm
;
604 ASSERT_OUTSIDE_BEGIN_END(ctx
);
606 pm
= get_pixelmap(ctx
, map
);
608 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapuiv(map)");
613 if (ctx
->Pack
.BufferObj
->Name
) {
614 /* pack pixelmap into PBO */
616 /* Note, need to use DefaultPacking and Pack's buffer object */
617 ctx
->DefaultPacking
.BufferObj
= ctx
->Pack
.BufferObj
;
618 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
619 GL_INTENSITY
, GL_UNSIGNED_INT
, values
)) {
620 _mesa_error(ctx
, GL_INVALID_OPERATION
,
621 "glGetPixelMapuiv(invalid PBO access)");
625 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
626 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
628 ctx
->Pack
.BufferObj
);
630 /* buffer is already mapped - that's an error */
631 _mesa_error(ctx
, GL_INVALID_OPERATION
,
632 "glGetPixelMapuiv(PBO is mapped)");
635 values
= (GLuint
*) ADD_POINTERS(buf
, values
);
641 if (map
== GL_PIXEL_MAP_S_TO_S
) {
643 MEMCPY(values
, ctx
->PixelMaps
.StoS
.Map
, mapsize
* sizeof(GLint
));
646 for (i
= 0; i
< mapsize
; i
++) {
647 values
[i
] = FLOAT_TO_UINT( pm
->Map
[i
] );
651 if (ctx
->Pack
.BufferObj
->Name
) {
652 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
653 ctx
->Pack
.BufferObj
);
659 _mesa_GetPixelMapusv( GLenum map
, GLushort
*values
)
661 GET_CURRENT_CONTEXT(ctx
);
663 const struct gl_pixelmap
*pm
;
665 ASSERT_OUTSIDE_BEGIN_END(ctx
);
667 pm
= get_pixelmap(ctx
, map
);
669 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetPixelMapusv(map)");
672 mapsize
= pm
? pm
->Size
: 0;
674 if (ctx
->Pack
.BufferObj
->Name
) {
675 /* pack pixelmap into PBO */
677 /* Note, need to use DefaultPacking and Pack's buffer object */
678 ctx
->DefaultPacking
.BufferObj
= ctx
->Pack
.BufferObj
;
679 if (!_mesa_validate_pbo_access(1, &ctx
->DefaultPacking
, mapsize
, 1, 1,
680 GL_INTENSITY
, GL_UNSIGNED_SHORT
,
682 _mesa_error(ctx
, GL_INVALID_OPERATION
,
683 "glGetPixelMapusv(invalid PBO access)");
687 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
688 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
690 ctx
->Pack
.BufferObj
);
692 /* buffer is already mapped - that's an error */
693 _mesa_error(ctx
, GL_INVALID_OPERATION
,
694 "glGetPixelMapusv(PBO is mapped)");
697 values
= (GLushort
*) ADD_POINTERS(buf
, values
);
705 case GL_PIXEL_MAP_I_TO_I
:
706 for (i
= 0; i
< mapsize
; i
++) {
707 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.ItoI
.Map
[i
], 0.0, 65535.);
710 case GL_PIXEL_MAP_S_TO_S
:
711 for (i
= 0; i
< mapsize
; i
++) {
712 values
[i
] = (GLushort
) CLAMP(ctx
->PixelMaps
.StoS
.Map
[i
], 0.0, 65535.);
716 for (i
= 0; i
< mapsize
; i
++) {
717 CLAMPED_FLOAT_TO_USHORT(values
[i
], pm
->Map
[i
] );
721 if (ctx
->Pack
.BufferObj
->Name
) {
722 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
723 ctx
->Pack
.BufferObj
);
729 /**********************************************************************/
730 /***** glPixelTransfer *****/
731 /**********************************************************************/
735 * Implements glPixelTransfer[fi] whether called immediately or from a
739 _mesa_PixelTransferf( GLenum pname
, GLfloat param
)
741 GET_CURRENT_CONTEXT(ctx
);
742 ASSERT_OUTSIDE_BEGIN_END(ctx
);
746 if (ctx
->Pixel
.MapColorFlag
== (param
? GL_TRUE
: GL_FALSE
))
748 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
749 ctx
->Pixel
.MapColorFlag
= param
? GL_TRUE
: GL_FALSE
;
752 if (ctx
->Pixel
.MapStencilFlag
== (param
? GL_TRUE
: GL_FALSE
))
754 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
755 ctx
->Pixel
.MapStencilFlag
= param
? GL_TRUE
: GL_FALSE
;
758 if (ctx
->Pixel
.IndexShift
== (GLint
) param
)
760 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
761 ctx
->Pixel
.IndexShift
= (GLint
) param
;
763 case GL_INDEX_OFFSET
:
764 if (ctx
->Pixel
.IndexOffset
== (GLint
) param
)
766 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
767 ctx
->Pixel
.IndexOffset
= (GLint
) param
;
770 if (ctx
->Pixel
.RedScale
== param
)
772 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
773 ctx
->Pixel
.RedScale
= param
;
776 if (ctx
->Pixel
.RedBias
== param
)
778 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
779 ctx
->Pixel
.RedBias
= param
;
782 if (ctx
->Pixel
.GreenScale
== param
)
784 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
785 ctx
->Pixel
.GreenScale
= param
;
788 if (ctx
->Pixel
.GreenBias
== param
)
790 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
791 ctx
->Pixel
.GreenBias
= param
;
794 if (ctx
->Pixel
.BlueScale
== param
)
796 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
797 ctx
->Pixel
.BlueScale
= param
;
800 if (ctx
->Pixel
.BlueBias
== param
)
802 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
803 ctx
->Pixel
.BlueBias
= param
;
806 if (ctx
->Pixel
.AlphaScale
== param
)
808 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
809 ctx
->Pixel
.AlphaScale
= param
;
812 if (ctx
->Pixel
.AlphaBias
== param
)
814 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
815 ctx
->Pixel
.AlphaBias
= param
;
818 if (ctx
->Pixel
.DepthScale
== param
)
820 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
821 ctx
->Pixel
.DepthScale
= param
;
824 if (ctx
->Pixel
.DepthBias
== param
)
826 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
827 ctx
->Pixel
.DepthBias
= param
;
829 case GL_POST_COLOR_MATRIX_RED_SCALE
:
830 if (ctx
->Pixel
.PostColorMatrixScale
[0] == param
)
832 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
833 ctx
->Pixel
.PostColorMatrixScale
[0] = param
;
835 case GL_POST_COLOR_MATRIX_RED_BIAS
:
836 if (ctx
->Pixel
.PostColorMatrixBias
[0] == param
)
838 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
839 ctx
->Pixel
.PostColorMatrixBias
[0] = param
;
841 case GL_POST_COLOR_MATRIX_GREEN_SCALE
:
842 if (ctx
->Pixel
.PostColorMatrixScale
[1] == param
)
844 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
845 ctx
->Pixel
.PostColorMatrixScale
[1] = param
;
847 case GL_POST_COLOR_MATRIX_GREEN_BIAS
:
848 if (ctx
->Pixel
.PostColorMatrixBias
[1] == param
)
850 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
851 ctx
->Pixel
.PostColorMatrixBias
[1] = param
;
853 case GL_POST_COLOR_MATRIX_BLUE_SCALE
:
854 if (ctx
->Pixel
.PostColorMatrixScale
[2] == param
)
856 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
857 ctx
->Pixel
.PostColorMatrixScale
[2] = param
;
859 case GL_POST_COLOR_MATRIX_BLUE_BIAS
:
860 if (ctx
->Pixel
.PostColorMatrixBias
[2] == param
)
862 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
863 ctx
->Pixel
.PostColorMatrixBias
[2] = param
;
865 case GL_POST_COLOR_MATRIX_ALPHA_SCALE
:
866 if (ctx
->Pixel
.PostColorMatrixScale
[3] == param
)
868 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
869 ctx
->Pixel
.PostColorMatrixScale
[3] = param
;
871 case GL_POST_COLOR_MATRIX_ALPHA_BIAS
:
872 if (ctx
->Pixel
.PostColorMatrixBias
[3] == param
)
874 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
875 ctx
->Pixel
.PostColorMatrixBias
[3] = param
;
877 case GL_POST_CONVOLUTION_RED_SCALE
:
878 if (ctx
->Pixel
.PostConvolutionScale
[0] == param
)
880 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
881 ctx
->Pixel
.PostConvolutionScale
[0] = param
;
883 case GL_POST_CONVOLUTION_RED_BIAS
:
884 if (ctx
->Pixel
.PostConvolutionBias
[0] == param
)
886 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
887 ctx
->Pixel
.PostConvolutionBias
[0] = param
;
889 case GL_POST_CONVOLUTION_GREEN_SCALE
:
890 if (ctx
->Pixel
.PostConvolutionScale
[1] == param
)
892 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
893 ctx
->Pixel
.PostConvolutionScale
[1] = param
;
895 case GL_POST_CONVOLUTION_GREEN_BIAS
:
896 if (ctx
->Pixel
.PostConvolutionBias
[1] == param
)
898 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
899 ctx
->Pixel
.PostConvolutionBias
[1] = param
;
901 case GL_POST_CONVOLUTION_BLUE_SCALE
:
902 if (ctx
->Pixel
.PostConvolutionScale
[2] == param
)
904 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
905 ctx
->Pixel
.PostConvolutionScale
[2] = param
;
907 case GL_POST_CONVOLUTION_BLUE_BIAS
:
908 if (ctx
->Pixel
.PostConvolutionBias
[2] == param
)
910 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
911 ctx
->Pixel
.PostConvolutionBias
[2] = param
;
913 case GL_POST_CONVOLUTION_ALPHA_SCALE
:
914 if (ctx
->Pixel
.PostConvolutionScale
[3] == param
)
916 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
917 ctx
->Pixel
.PostConvolutionScale
[3] = param
;
919 case GL_POST_CONVOLUTION_ALPHA_BIAS
:
920 if (ctx
->Pixel
.PostConvolutionBias
[3] == param
)
922 FLUSH_VERTICES(ctx
, _NEW_PIXEL
);
923 ctx
->Pixel
.PostConvolutionBias
[3] = param
;
926 _mesa_error( ctx
, GL_INVALID_ENUM
, "glPixelTransfer(pname)" );
933 _mesa_PixelTransferi( GLenum pname
, GLint param
)
935 _mesa_PixelTransferf( pname
, (GLfloat
) param
);
940 /**********************************************************************/
941 /***** Pixel processing functions ******/
942 /**********************************************************************/
945 * Apply scale and bias factors to an array of RGBA pixels.
948 _mesa_scale_and_bias_rgba(GLuint n
, GLfloat rgba
[][4],
949 GLfloat rScale
, GLfloat gScale
,
950 GLfloat bScale
, GLfloat aScale
,
951 GLfloat rBias
, GLfloat gBias
,
952 GLfloat bBias
, GLfloat aBias
)
954 if (rScale
!= 1.0 || rBias
!= 0.0) {
956 for (i
= 0; i
< n
; i
++) {
957 rgba
[i
][RCOMP
] = rgba
[i
][RCOMP
] * rScale
+ rBias
;
960 if (gScale
!= 1.0 || gBias
!= 0.0) {
962 for (i
= 0; i
< n
; i
++) {
963 rgba
[i
][GCOMP
] = rgba
[i
][GCOMP
] * gScale
+ gBias
;
966 if (bScale
!= 1.0 || bBias
!= 0.0) {
968 for (i
= 0; i
< n
; i
++) {
969 rgba
[i
][BCOMP
] = rgba
[i
][BCOMP
] * bScale
+ bBias
;
972 if (aScale
!= 1.0 || aBias
!= 0.0) {
974 for (i
= 0; i
< n
; i
++) {
975 rgba
[i
][ACOMP
] = rgba
[i
][ACOMP
] * aScale
+ aBias
;
982 * Apply pixel mapping to an array of floating point RGBA pixels.
985 _mesa_map_rgba( const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4] )
987 const GLfloat rscale
= (GLfloat
) (ctx
->PixelMaps
.RtoR
.Size
- 1);
988 const GLfloat gscale
= (GLfloat
) (ctx
->PixelMaps
.GtoG
.Size
- 1);
989 const GLfloat bscale
= (GLfloat
) (ctx
->PixelMaps
.BtoB
.Size
- 1);
990 const GLfloat ascale
= (GLfloat
) (ctx
->PixelMaps
.AtoA
.Size
- 1);
991 const GLfloat
*rMap
= ctx
->PixelMaps
.RtoR
.Map
;
992 const GLfloat
*gMap
= ctx
->PixelMaps
.GtoG
.Map
;
993 const GLfloat
*bMap
= ctx
->PixelMaps
.BtoB
.Map
;
994 const GLfloat
*aMap
= ctx
->PixelMaps
.AtoA
.Map
;
997 GLfloat r
= CLAMP(rgba
[i
][RCOMP
], 0.0F
, 1.0F
);
998 GLfloat g
= CLAMP(rgba
[i
][GCOMP
], 0.0F
, 1.0F
);
999 GLfloat b
= CLAMP(rgba
[i
][BCOMP
], 0.0F
, 1.0F
);
1000 GLfloat a
= CLAMP(rgba
[i
][ACOMP
], 0.0F
, 1.0F
);
1001 rgba
[i
][RCOMP
] = rMap
[IROUND(r
* rscale
)];
1002 rgba
[i
][GCOMP
] = gMap
[IROUND(g
* gscale
)];
1003 rgba
[i
][BCOMP
] = bMap
[IROUND(b
* bscale
)];
1004 rgba
[i
][ACOMP
] = aMap
[IROUND(a
* ascale
)];
1010 * Apply the color matrix and post color matrix scaling and biasing.
1013 _mesa_transform_rgba(const GLcontext
*ctx
, GLuint n
, GLfloat rgba
[][4])
1015 const GLfloat rs
= ctx
->Pixel
.PostColorMatrixScale
[0];
1016 const GLfloat rb
= ctx
->Pixel
.PostColorMatrixBias
[0];
1017 const GLfloat gs
= ctx
->Pixel
.PostColorMatrixScale
[1];
1018 const GLfloat gb
= ctx
->Pixel
.PostColorMatrixBias
[1];
1019 const GLfloat bs
= ctx
->Pixel
.PostColorMatrixScale
[2];
1020 const GLfloat bb
= ctx
->Pixel
.PostColorMatrixBias
[2];
1021 const GLfloat as
= ctx
->Pixel
.PostColorMatrixScale
[3];
1022 const GLfloat ab
= ctx
->Pixel
.PostColorMatrixBias
[3];
1023 const GLfloat
*m
= ctx
->ColorMatrixStack
.Top
->m
;
1025 for (i
= 0; i
< n
; i
++) {
1026 const GLfloat r
= rgba
[i
][RCOMP
];
1027 const GLfloat g
= rgba
[i
][GCOMP
];
1028 const GLfloat b
= rgba
[i
][BCOMP
];
1029 const GLfloat a
= rgba
[i
][ACOMP
];
1030 rgba
[i
][RCOMP
] = (m
[0] * r
+ m
[4] * g
+ m
[ 8] * b
+ m
[12] * a
) * rs
+ rb
;
1031 rgba
[i
][GCOMP
] = (m
[1] * r
+ m
[5] * g
+ m
[ 9] * b
+ m
[13] * a
) * gs
+ gb
;
1032 rgba
[i
][BCOMP
] = (m
[2] * r
+ m
[6] * g
+ m
[10] * b
+ m
[14] * a
) * bs
+ bb
;
1033 rgba
[i
][ACOMP
] = (m
[3] * r
+ m
[7] * g
+ m
[11] * b
+ m
[15] * a
) * as
+ ab
;
1039 * Apply a color table lookup to an array of floating point RGBA colors.
1042 _mesa_lookup_rgba_float(const struct gl_color_table
*table
,
1043 GLuint n
, GLfloat rgba
[][4])
1045 const GLint max
= table
->Size
- 1;
1046 const GLfloat scale
= (GLfloat
) max
;
1047 const GLfloat
*lut
= table
->TableF
;
1050 if (!table
->TableF
|| table
->Size
== 0)
1053 switch (table
->_BaseFormat
) {
1055 /* replace RGBA with I */
1056 for (i
= 0; i
< n
; i
++) {
1057 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
1058 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
1066 /* replace RGB with L */
1067 for (i
= 0; i
< n
; i
++) {
1068 GLint j
= IROUND(rgba
[i
][RCOMP
] * scale
);
1069 GLfloat c
= lut
[CLAMP(j
, 0, max
)];
1076 /* replace A with A */
1077 for (i
= 0; i
< n
; i
++) {
1078 GLint j
= IROUND(rgba
[i
][ACOMP
] * scale
);
1079 rgba
[i
][ACOMP
] = lut
[CLAMP(j
, 0, max
)];
1082 case GL_LUMINANCE_ALPHA
:
1083 /* replace RGBA with LLLA */
1084 for (i
= 0; i
< n
; i
++) {
1085 GLint jL
= IROUND(rgba
[i
][RCOMP
] * scale
);
1086 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1087 GLfloat luminance
, alpha
;
1088 jL
= CLAMP(jL
, 0, max
);
1089 jA
= CLAMP(jA
, 0, max
);
1090 luminance
= lut
[jL
* 2 + 0];
1091 alpha
= lut
[jA
* 2 + 1];
1094 rgba
[i
][BCOMP
] = luminance
;
1095 rgba
[i
][ACOMP
] = alpha
;;
1099 /* replace RGB with RGB */
1100 for (i
= 0; i
< n
; i
++) {
1101 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1102 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1103 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1104 jR
= CLAMP(jR
, 0, max
);
1105 jG
= CLAMP(jG
, 0, max
);
1106 jB
= CLAMP(jB
, 0, max
);
1107 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
1108 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
1109 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
1113 /* replace RGBA with RGBA */
1114 for (i
= 0; i
< n
; i
++) {
1115 GLint jR
= IROUND(rgba
[i
][RCOMP
] * scale
);
1116 GLint jG
= IROUND(rgba
[i
][GCOMP
] * scale
);
1117 GLint jB
= IROUND(rgba
[i
][BCOMP
] * scale
);
1118 GLint jA
= IROUND(rgba
[i
][ACOMP
] * scale
);
1119 jR
= CLAMP(jR
, 0, max
);
1120 jG
= CLAMP(jG
, 0, max
);
1121 jB
= CLAMP(jB
, 0, max
);
1122 jA
= CLAMP(jA
, 0, max
);
1123 rgba
[i
][RCOMP
] = lut
[jR
* 4 + 0];
1124 rgba
[i
][GCOMP
] = lut
[jG
* 4 + 1];
1125 rgba
[i
][BCOMP
] = lut
[jB
* 4 + 2];
1126 rgba
[i
][ACOMP
] = lut
[jA
* 4 + 3];
1130 _mesa_problem(NULL
, "Bad format in _mesa_lookup_rgba_float");
1138 * Apply a color table lookup to an array of ubyte/RGBA colors.
1141 _mesa_lookup_rgba_ubyte(const struct gl_color_table
*table
,
1142 GLuint n
, GLubyte rgba
[][4])
1144 const GLubyte
*lut
= table
->TableUB
;
1145 const GLfloat scale
= (GLfloat
) (table
->Size
- 1) / 255.0;
1148 if (!table
->TableUB
|| table
->Size
== 0)
1151 switch (table
->_BaseFormat
) {
1153 /* replace RGBA with I */
1154 if (table
->Size
== 256) {
1155 for (i
= 0; i
< n
; i
++) {
1156 const GLubyte c
= lut
[rgba
[i
][RCOMP
]];
1164 for (i
= 0; i
< n
; i
++) {
1165 GLint j
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1169 rgba
[i
][ACOMP
] = lut
[j
];
1174 /* replace RGB with L */
1175 if (table
->Size
== 256) {
1176 for (i
= 0; i
< n
; i
++) {
1177 const GLubyte c
= lut
[rgba
[i
][RCOMP
]];
1184 for (i
= 0; i
< n
; i
++) {
1185 GLint j
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1188 rgba
[i
][BCOMP
] = lut
[j
];
1193 /* replace A with A */
1194 if (table
->Size
== 256) {
1195 for (i
= 0; i
< n
; i
++) {
1196 rgba
[i
][ACOMP
] = lut
[rgba
[i
][ACOMP
]];
1200 for (i
= 0; i
< n
; i
++) {
1201 GLint j
= IROUND((GLfloat
) rgba
[i
][ACOMP
] * scale
);
1202 rgba
[i
][ACOMP
] = lut
[j
];
1206 case GL_LUMINANCE_ALPHA
:
1207 /* replace RGBA with LLLA */
1208 if (table
->Size
== 256) {
1209 for (i
= 0; i
< n
; i
++) {
1210 GLubyte l
= lut
[rgba
[i
][RCOMP
] * 2 + 0];
1211 GLubyte a
= lut
[rgba
[i
][ACOMP
] * 2 + 1];;
1219 for (i
= 0; i
< n
; i
++) {
1220 GLint jL
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1221 GLint jA
= IROUND((GLfloat
) rgba
[i
][ACOMP
] * scale
);
1222 GLubyte luminance
= lut
[jL
* 2 + 0];
1223 GLubyte alpha
= lut
[jA
* 2 + 1];
1226 rgba
[i
][BCOMP
] = luminance
;
1227 rgba
[i
][ACOMP
] = alpha
;
1232 if (table
->Size
== 256) {
1233 for (i
= 0; i
< n
; i
++) {
1234 rgba
[i
][RCOMP
] = lut
[rgba
[i
][RCOMP
] * 3 + 0];
1235 rgba
[i
][GCOMP
] = lut
[rgba
[i
][GCOMP
] * 3 + 1];
1236 rgba
[i
][BCOMP
] = lut
[rgba
[i
][BCOMP
] * 3 + 2];
1240 for (i
= 0; i
< n
; i
++) {
1241 GLint jR
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1242 GLint jG
= IROUND((GLfloat
) rgba
[i
][GCOMP
] * scale
);
1243 GLint jB
= IROUND((GLfloat
) rgba
[i
][BCOMP
] * scale
);
1244 rgba
[i
][RCOMP
] = lut
[jR
* 3 + 0];
1245 rgba
[i
][GCOMP
] = lut
[jG
* 3 + 1];
1246 rgba
[i
][BCOMP
] = lut
[jB
* 3 + 2];
1251 if (table
->Size
== 256) {
1252 for (i
= 0; i
< n
; i
++) {
1253 rgba
[i
][RCOMP
] = lut
[rgba
[i
][RCOMP
] * 4 + 0];
1254 rgba
[i
][GCOMP
] = lut
[rgba
[i
][GCOMP
] * 4 + 1];
1255 rgba
[i
][BCOMP
] = lut
[rgba
[i
][BCOMP
] * 4 + 2];
1256 rgba
[i
][ACOMP
] = lut
[rgba
[i
][ACOMP
] * 4 + 3];
1260 for (i
= 0; i
< n
; i
++) {
1261 GLint jR
= IROUND((GLfloat
) rgba
[i
][RCOMP
] * scale
);
1262 GLint jG
= IROUND((GLfloat
) rgba
[i
][GCOMP
] * scale
);
1263 GLint jB
= IROUND((GLfloat
) rgba
[i
][BCOMP
] * scale
);
1264 GLint jA
= IROUND((GLfloat
) rgba
[i
][ACOMP
] * scale
);
1265 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][RCOMP
], lut
[jR
* 4 + 0]);
1266 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][GCOMP
], lut
[jG
* 4 + 1]);
1267 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][BCOMP
], lut
[jB
* 4 + 2]);
1268 CLAMPED_FLOAT_TO_CHAN(rgba
[i
][ACOMP
], lut
[jA
* 4 + 3]);
1273 _mesa_problem(NULL
, "Bad format in _mesa_lookup_rgba_chan");
1281 * Map color indexes to float rgba values.
1284 _mesa_map_ci_to_rgba( const GLcontext
*ctx
, GLuint n
,
1285 const GLuint index
[], GLfloat rgba
[][4] )
1287 GLuint rmask
= ctx
->PixelMaps
.ItoR
.Size
- 1;
1288 GLuint gmask
= ctx
->PixelMaps
.ItoG
.Size
- 1;
1289 GLuint bmask
= ctx
->PixelMaps
.ItoB
.Size
- 1;
1290 GLuint amask
= ctx
->PixelMaps
.ItoA
.Size
- 1;
1291 const GLfloat
*rMap
= ctx
->PixelMaps
.ItoR
.Map
;
1292 const GLfloat
*gMap
= ctx
->PixelMaps
.ItoG
.Map
;
1293 const GLfloat
*bMap
= ctx
->PixelMaps
.ItoB
.Map
;
1294 const GLfloat
*aMap
= ctx
->PixelMaps
.ItoA
.Map
;
1297 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1298 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1299 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1300 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1306 * Map ubyte color indexes to ubyte/RGBA values.
1309 _mesa_map_ci8_to_rgba8(const GLcontext
*ctx
, GLuint n
, const GLubyte index
[],
1312 GLuint rmask
= ctx
->PixelMaps
.ItoR
.Size
- 1;
1313 GLuint gmask
= ctx
->PixelMaps
.ItoG
.Size
- 1;
1314 GLuint bmask
= ctx
->PixelMaps
.ItoB
.Size
- 1;
1315 GLuint amask
= ctx
->PixelMaps
.ItoA
.Size
- 1;
1316 const GLubyte
*rMap
= ctx
->PixelMaps
.ItoR
.Map8
;
1317 const GLubyte
*gMap
= ctx
->PixelMaps
.ItoG
.Map8
;
1318 const GLubyte
*bMap
= ctx
->PixelMaps
.ItoB
.Map8
;
1319 const GLubyte
*aMap
= ctx
->PixelMaps
.ItoA
.Map8
;
1322 rgba
[i
][RCOMP
] = rMap
[index
[i
] & rmask
];
1323 rgba
[i
][GCOMP
] = gMap
[index
[i
] & gmask
];
1324 rgba
[i
][BCOMP
] = bMap
[index
[i
] & bmask
];
1325 rgba
[i
][ACOMP
] = aMap
[index
[i
] & amask
];
1331 _mesa_scale_and_bias_depth(const GLcontext
*ctx
, GLuint n
,
1332 GLfloat depthValues
[])
1334 const GLfloat scale
= ctx
->Pixel
.DepthScale
;
1335 const GLfloat bias
= ctx
->Pixel
.DepthBias
;
1337 for (i
= 0; i
< n
; i
++) {
1338 GLfloat d
= depthValues
[i
] * scale
+ bias
;
1339 depthValues
[i
] = CLAMP(d
, 0.0F
, 1.0F
);
1345 /**********************************************************************/
1346 /***** State Management *****/
1347 /**********************************************************************/
1350 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
1351 * pixel transfer operations are enabled.
1354 update_image_transfer_state(GLcontext
*ctx
)
1358 if (ctx
->Pixel
.RedScale
!= 1.0F
|| ctx
->Pixel
.RedBias
!= 0.0F
||
1359 ctx
->Pixel
.GreenScale
!= 1.0F
|| ctx
->Pixel
.GreenBias
!= 0.0F
||
1360 ctx
->Pixel
.BlueScale
!= 1.0F
|| ctx
->Pixel
.BlueBias
!= 0.0F
||
1361 ctx
->Pixel
.AlphaScale
!= 1.0F
|| ctx
->Pixel
.AlphaBias
!= 0.0F
)
1362 mask
|= IMAGE_SCALE_BIAS_BIT
;
1364 if (ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
)
1365 mask
|= IMAGE_SHIFT_OFFSET_BIT
;
1367 if (ctx
->Pixel
.MapColorFlag
)
1368 mask
|= IMAGE_MAP_COLOR_BIT
;
1370 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_PRECONVOLUTION
])
1371 mask
|= IMAGE_COLOR_TABLE_BIT
;
1373 if (ctx
->Pixel
.Convolution1DEnabled
||
1374 ctx
->Pixel
.Convolution2DEnabled
||
1375 ctx
->Pixel
.Separable2DEnabled
) {
1376 mask
|= IMAGE_CONVOLUTION_BIT
;
1377 if (ctx
->Pixel
.PostConvolutionScale
[0] != 1.0F
||
1378 ctx
->Pixel
.PostConvolutionScale
[1] != 1.0F
||
1379 ctx
->Pixel
.PostConvolutionScale
[2] != 1.0F
||
1380 ctx
->Pixel
.PostConvolutionScale
[3] != 1.0F
||
1381 ctx
->Pixel
.PostConvolutionBias
[0] != 0.0F
||
1382 ctx
->Pixel
.PostConvolutionBias
[1] != 0.0F
||
1383 ctx
->Pixel
.PostConvolutionBias
[2] != 0.0F
||
1384 ctx
->Pixel
.PostConvolutionBias
[3] != 0.0F
) {
1385 mask
|= IMAGE_POST_CONVOLUTION_SCALE_BIAS
;
1389 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCONVOLUTION
])
1390 mask
|= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT
;
1392 if (ctx
->ColorMatrixStack
.Top
->type
!= MATRIX_IDENTITY
||
1393 ctx
->Pixel
.PostColorMatrixScale
[0] != 1.0F
||
1394 ctx
->Pixel
.PostColorMatrixBias
[0] != 0.0F
||
1395 ctx
->Pixel
.PostColorMatrixScale
[1] != 1.0F
||
1396 ctx
->Pixel
.PostColorMatrixBias
[1] != 0.0F
||
1397 ctx
->Pixel
.PostColorMatrixScale
[2] != 1.0F
||
1398 ctx
->Pixel
.PostColorMatrixBias
[2] != 0.0F
||
1399 ctx
->Pixel
.PostColorMatrixScale
[3] != 1.0F
||
1400 ctx
->Pixel
.PostColorMatrixBias
[3] != 0.0F
)
1401 mask
|= IMAGE_COLOR_MATRIX_BIT
;
1403 if (ctx
->Pixel
.ColorTableEnabled
[COLORTABLE_POSTCOLORMATRIX
])
1404 mask
|= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT
;
1406 if (ctx
->Pixel
.HistogramEnabled
)
1407 mask
|= IMAGE_HISTOGRAM_BIT
;
1409 if (ctx
->Pixel
.MinMaxEnabled
)
1410 mask
|= IMAGE_MIN_MAX_BIT
;
1412 ctx
->_ImageTransferState
= mask
;
1416 void _mesa_update_pixel( GLcontext
*ctx
, GLuint new_state
)
1418 if (new_state
& _NEW_COLOR_MATRIX
)
1419 _math_matrix_analyse( ctx
->ColorMatrixStack
.Top
);
1421 /* References ColorMatrix.type (derived above).
1423 if (new_state
& _IMAGE_NEW_TRANSFER_STATE
)
1424 update_image_transfer_state(ctx
);
1428 /**********************************************************************/
1429 /***** Initialization *****/
1430 /**********************************************************************/
1433 init_pixelmap(struct gl_pixelmap
*map
)
1442 * Initialize the context's PIXEL attribute group.
1445 _mesa_init_pixel( GLcontext
*ctx
)
1450 ctx
->Pixel
.RedBias
= 0.0;
1451 ctx
->Pixel
.RedScale
= 1.0;
1452 ctx
->Pixel
.GreenBias
= 0.0;
1453 ctx
->Pixel
.GreenScale
= 1.0;
1454 ctx
->Pixel
.BlueBias
= 0.0;
1455 ctx
->Pixel
.BlueScale
= 1.0;
1456 ctx
->Pixel
.AlphaBias
= 0.0;
1457 ctx
->Pixel
.AlphaScale
= 1.0;
1458 ctx
->Pixel
.DepthBias
= 0.0;
1459 ctx
->Pixel
.DepthScale
= 1.0;
1460 ctx
->Pixel
.IndexOffset
= 0;
1461 ctx
->Pixel
.IndexShift
= 0;
1462 ctx
->Pixel
.ZoomX
= 1.0;
1463 ctx
->Pixel
.ZoomY
= 1.0;
1464 ctx
->Pixel
.MapColorFlag
= GL_FALSE
;
1465 ctx
->Pixel
.MapStencilFlag
= GL_FALSE
;
1466 init_pixelmap(&ctx
->PixelMaps
.StoS
);
1467 init_pixelmap(&ctx
->PixelMaps
.ItoI
);
1468 init_pixelmap(&ctx
->PixelMaps
.ItoR
);
1469 init_pixelmap(&ctx
->PixelMaps
.ItoG
);
1470 init_pixelmap(&ctx
->PixelMaps
.ItoB
);
1471 init_pixelmap(&ctx
->PixelMaps
.ItoA
);
1472 init_pixelmap(&ctx
->PixelMaps
.RtoR
);
1473 init_pixelmap(&ctx
->PixelMaps
.GtoG
);
1474 init_pixelmap(&ctx
->PixelMaps
.BtoB
);
1475 init_pixelmap(&ctx
->PixelMaps
.AtoA
);
1476 ctx
->Pixel
.HistogramEnabled
= GL_FALSE
;
1477 ctx
->Pixel
.MinMaxEnabled
= GL_FALSE
;
1478 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixScale
, 1.0, 1.0, 1.0, 1.0);
1479 ASSIGN_4V(ctx
->Pixel
.PostColorMatrixBias
, 0.0, 0.0, 0.0, 0.0);
1480 for (i
= 0; i
< COLORTABLE_MAX
; i
++) {
1481 ASSIGN_4V(ctx
->Pixel
.ColorTableScale
[i
], 1.0, 1.0, 1.0, 1.0);
1482 ASSIGN_4V(ctx
->Pixel
.ColorTableBias
[i
], 0.0, 0.0, 0.0, 0.0);
1483 ctx
->Pixel
.ColorTableEnabled
[i
] = GL_FALSE
;
1485 ctx
->Pixel
.Convolution1DEnabled
= GL_FALSE
;
1486 ctx
->Pixel
.Convolution2DEnabled
= GL_FALSE
;
1487 ctx
->Pixel
.Separable2DEnabled
= GL_FALSE
;
1488 for (i
= 0; i
< 3; i
++) {
1489 ASSIGN_4V(ctx
->Pixel
.ConvolutionBorderColor
[i
], 0.0, 0.0, 0.0, 0.0);
1490 ctx
->Pixel
.ConvolutionBorderMode
[i
] = GL_REDUCE
;
1491 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterScale
[i
], 1.0, 1.0, 1.0, 1.0);
1492 ASSIGN_4V(ctx
->Pixel
.ConvolutionFilterBias
[i
], 0.0, 0.0, 0.0, 0.0);
1494 for (i
= 0; i
< MAX_CONVOLUTION_WIDTH
* MAX_CONVOLUTION_WIDTH
* 4; i
++) {
1495 ctx
->Convolution1D
.Filter
[i
] = 0.0;
1496 ctx
->Convolution2D
.Filter
[i
] = 0.0;
1497 ctx
->Separable2D
.Filter
[i
] = 0.0;
1499 ASSIGN_4V(ctx
->Pixel
.PostConvolutionScale
, 1.0, 1.0, 1.0, 1.0);
1500 ASSIGN_4V(ctx
->Pixel
.PostConvolutionBias
, 0.0, 0.0, 0.0, 0.0);
1501 /* GL_SGI_texture_color_table */
1502 ASSIGN_4V(ctx
->Pixel
.TextureColorTableScale
, 1.0, 1.0, 1.0, 1.0);
1503 ASSIGN_4V(ctx
->Pixel
.TextureColorTableBias
, 0.0, 0.0, 0.0, 0.0);
1505 /* Pixel transfer */
1506 ctx
->Pack
.Alignment
= 4;
1507 ctx
->Pack
.RowLength
= 0;
1508 ctx
->Pack
.ImageHeight
= 0;
1509 ctx
->Pack
.SkipPixels
= 0;
1510 ctx
->Pack
.SkipRows
= 0;
1511 ctx
->Pack
.SkipImages
= 0;
1512 ctx
->Pack
.SwapBytes
= GL_FALSE
;
1513 ctx
->Pack
.LsbFirst
= GL_FALSE
;
1514 ctx
->Pack
.ClientStorage
= GL_FALSE
;
1515 ctx
->Pack
.Invert
= GL_FALSE
;
1516 #if FEATURE_EXT_pixel_buffer_object
1517 ctx
->Pack
.BufferObj
= ctx
->Array
.NullBufferObj
;
1519 ctx
->Unpack
.Alignment
= 4;
1520 ctx
->Unpack
.RowLength
= 0;
1521 ctx
->Unpack
.ImageHeight
= 0;
1522 ctx
->Unpack
.SkipPixels
= 0;
1523 ctx
->Unpack
.SkipRows
= 0;
1524 ctx
->Unpack
.SkipImages
= 0;
1525 ctx
->Unpack
.SwapBytes
= GL_FALSE
;
1526 ctx
->Unpack
.LsbFirst
= GL_FALSE
;
1527 ctx
->Unpack
.ClientStorage
= GL_FALSE
;
1528 ctx
->Unpack
.Invert
= GL_FALSE
;
1529 #if FEATURE_EXT_pixel_buffer_object
1530 ctx
->Unpack
.BufferObj
= ctx
->Array
.NullBufferObj
;
1534 * _mesa_unpack_image() returns image data in this format. When we
1535 * execute image commands (glDrawPixels(), glTexImage(), etc) from
1536 * within display lists we have to be sure to set the current
1537 * unpacking parameters to these values!
1539 ctx
->DefaultPacking
.Alignment
= 1;
1540 ctx
->DefaultPacking
.RowLength
= 0;
1541 ctx
->DefaultPacking
.SkipPixels
= 0;
1542 ctx
->DefaultPacking
.SkipRows
= 0;
1543 ctx
->DefaultPacking
.ImageHeight
= 0;
1544 ctx
->DefaultPacking
.SkipImages
= 0;
1545 ctx
->DefaultPacking
.SwapBytes
= GL_FALSE
;
1546 ctx
->DefaultPacking
.LsbFirst
= GL_FALSE
;
1547 ctx
->DefaultPacking
.ClientStorage
= GL_FALSE
;
1548 ctx
->DefaultPacking
.Invert
= GL_FALSE
;
1549 #if FEATURE_EXT_pixel_buffer_object
1550 ctx
->DefaultPacking
.BufferObj
= ctx
->Array
.NullBufferObj
;
1553 if (ctx
->Visual
.doubleBufferMode
) {
1554 ctx
->Pixel
.ReadBuffer
= GL_BACK
;
1557 ctx
->Pixel
.ReadBuffer
= GL_FRONT
;
1561 ctx
->_ImageTransferState
= 0;