projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
s/IntFormat/InternalFormat/ and s/Format/_BaseFormat/ for gl_color_table.
[mesa.git] / src / mesa / main / pixel.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.3
4 *
5 * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
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.
23 */
24
25 #include "glheader.h"
26 #include "bufferobj.h"
27 #include "colormac.h"
28 #include "context.h"
29 #include "image.h"
30 #include "macros.h"
31 #include "pixel.h"
32 #include "mtypes.h"
33
34
35 /**********************************************************************/
36 /***** glPixelZoom *****/
37 /**********************************************************************/
38
39
40
41 void GLAPIENTRY
42 _mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
43 {
44 GET_CURRENT_CONTEXT(ctx);
45
46 if (ctx->Pixel.ZoomX == xfactor &&
47 ctx->Pixel.ZoomY == yfactor)
48 return;
49
50 FLUSH_VERTICES(ctx, _NEW_PIXEL);
51 ctx->Pixel.ZoomX = xfactor;
52 ctx->Pixel.ZoomY = yfactor;
53 }
54
55
56
57 /**********************************************************************/
58 /***** glPixelStore *****/
59 /**********************************************************************/
60
61
62 void GLAPIENTRY
63 _mesa_PixelStorei( GLenum pname, GLint param )
64 {
65 /* NOTE: this call can't be compiled into the display list */
66 GET_CURRENT_CONTEXT(ctx);
67 ASSERT_OUTSIDE_BEGIN_END(ctx);
68
69 switch (pname) {
70 case GL_PACK_SWAP_BYTES:
71 if (param == (GLint)ctx->Pack.SwapBytes)
72 return;
73 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
74 ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
75 break;
76 case GL_PACK_LSB_FIRST:
77 if (param == (GLint)ctx->Pack.LsbFirst)
78 return;
79 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
80 ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
81 break;
82 case GL_PACK_ROW_LENGTH:
83 if (param<0) {
84 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
85 return;
86 }
87 if (ctx->Pack.RowLength == param)
88 return;
89 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
90 ctx->Pack.RowLength = param;
91 break;
92 case GL_PACK_IMAGE_HEIGHT:
93 if (param<0) {
94 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
95 return;
96 }
97 if (ctx->Pack.ImageHeight == param)
98 return;
99 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
100 ctx->Pack.ImageHeight = param;
101 break;
102 case GL_PACK_SKIP_PIXELS:
103 if (param<0) {
104 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
105 return;
106 }
107 if (ctx->Pack.SkipPixels == param)
108 return;
109 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
110 ctx->Pack.SkipPixels = param;
111 break;
112 case GL_PACK_SKIP_ROWS:
113 if (param<0) {
114 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
115 return;
116 }
117 if (ctx->Pack.SkipRows == param)
118 return;
119 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
120 ctx->Pack.SkipRows = param;
121 break;
122 case GL_PACK_SKIP_IMAGES:
123 if (param<0) {
124 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
125 return;
126 }
127 if (ctx->Pack.SkipImages == param)
128 return;
129 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
130 ctx->Pack.SkipImages = param;
131 break;
132 case GL_PACK_ALIGNMENT:
133 if (param!=1 && param!=2 && param!=4 && param!=8) {
134 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
135 return;
136 }
137 if (ctx->Pack.Alignment == param)
138 return;
139 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
140 ctx->Pack.Alignment = param;
141 break;
142 case GL_PACK_INVERT_MESA:
143 if (!ctx->Extensions.MESA_pack_invert) {
144 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelstore(pname)" );
145 return;
146 }
147 if (ctx->Pack.Invert == param)
148 return;
149 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
150 ctx->Pack.Invert = param;
151 break;
152
153 case GL_UNPACK_SWAP_BYTES:
154 if (param == (GLint)ctx->Unpack.SwapBytes)
155 return;
156 if ((GLint)ctx->Unpack.SwapBytes == param)
157 return;
158 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
159 ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
160 break;
161 case GL_UNPACK_LSB_FIRST:
162 if (param == (GLint)ctx->Unpack.LsbFirst)
163 return;
164 if ((GLint)ctx->Unpack.LsbFirst == param)
165 return;
166 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
167 ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
168 break;
169 case GL_UNPACK_ROW_LENGTH:
170 if (param<0) {
171 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
172 return;
173 }
174 if (ctx->Unpack.RowLength == param)
175 return;
176 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
177 ctx->Unpack.RowLength = param;
178 break;
179 case GL_UNPACK_IMAGE_HEIGHT:
180 if (param<0) {
181 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
182 return;
183 }
184 if (ctx->Unpack.ImageHeight == param)
185 return;
186
187 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
188 ctx->Unpack.ImageHeight = param;
189 break;
190 case GL_UNPACK_SKIP_PIXELS:
191 if (param<0) {
192 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
193 return;
194 }
195 if (ctx->Unpack.SkipPixels == param)
196 return;
197 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
198 ctx->Unpack.SkipPixels = param;
199 break;
200 case GL_UNPACK_SKIP_ROWS:
201 if (param<0) {
202 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
203 return;
204 }
205 if (ctx->Unpack.SkipRows == param)
206 return;
207 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
208 ctx->Unpack.SkipRows = param;
209 break;
210 case GL_UNPACK_SKIP_IMAGES:
211 if (param < 0) {
212 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
213 return;
214 }
215 if (ctx->Unpack.SkipImages == param)
216 return;
217 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
218 ctx->Unpack.SkipImages = param;
219 break;
220 case GL_UNPACK_ALIGNMENT:
221 if (param!=1 && param!=2 && param!=4 && param!=8) {
222 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
223 return;
224 }
225 if (ctx->Unpack.Alignment == param)
226 return;
227 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
228 ctx->Unpack.Alignment = param;
229 break;
230 case GL_UNPACK_CLIENT_STORAGE_APPLE:
231 if (param == (GLint)ctx->Unpack.ClientStorage)
232 return;
233 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
234 ctx->Unpack.ClientStorage = param ? GL_TRUE : GL_FALSE;
235 break;
236 default:
237 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
238 return;
239 }
240 }
241
242
243 void GLAPIENTRY
244 _mesa_PixelStoref( GLenum pname, GLfloat param )
245 {
246 _mesa_PixelStorei( pname, (GLint) param );
247 }
248
249
250
251 /**********************************************************************/
252 /***** glPixelMap *****/
253 /**********************************************************************/
254
255
256 /**
257 * Helper routine used by the other _mesa_PixelMap() functions.
258 */
259 static void
260 pixelmap(GLcontext *ctx, GLenum map, GLsizei mapsize, const GLfloat *values)
261 {
262 GLint i;
263 switch (map) {
264 case GL_PIXEL_MAP_S_TO_S:
265 ctx->Pixel.MapStoSsize = mapsize;
266 for (i = 0; i < mapsize; i++) {
267 ctx->Pixel.MapStoS[i] = IROUND(values[i]);
268 }
269 break;
270 case GL_PIXEL_MAP_I_TO_I:
271 ctx->Pixel.MapItoIsize = mapsize;
272 for (i = 0; i < mapsize; i++) {
273 ctx->Pixel.MapItoI[i] = values[i];
274 }
275 break;
276 case GL_PIXEL_MAP_I_TO_R:
277 ctx->Pixel.MapItoRsize = mapsize;
278 for (i = 0; i < mapsize; i++) {
279 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
280 ctx->Pixel.MapItoR[i] = val;
281 ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
282 }
283 break;
284 case GL_PIXEL_MAP_I_TO_G:
285 ctx->Pixel.MapItoGsize = mapsize;
286 for (i = 0; i < mapsize; i++) {
287 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
288 ctx->Pixel.MapItoG[i] = val;
289 ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
290 }
291 break;
292 case GL_PIXEL_MAP_I_TO_B:
293 ctx->Pixel.MapItoBsize = mapsize;
294 for (i = 0; i < mapsize; i++) {
295 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
296 ctx->Pixel.MapItoB[i] = val;
297 ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
298 }
299 break;
300 case GL_PIXEL_MAP_I_TO_A:
301 ctx->Pixel.MapItoAsize = mapsize;
302 for (i = 0; i < mapsize; i++) {
303 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
304 ctx->Pixel.MapItoA[i] = val;
305 ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
306 }
307 break;
308 case GL_PIXEL_MAP_R_TO_R:
309 ctx->Pixel.MapRtoRsize = mapsize;
310 for (i = 0; i < mapsize; i++) {
311 ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0F, 1.0F );
312 }
313 break;
314 case GL_PIXEL_MAP_G_TO_G:
315 ctx->Pixel.MapGtoGsize = mapsize;
316 for (i = 0; i < mapsize; i++) {
317 ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0F, 1.0F );
318 }
319 break;
320 case GL_PIXEL_MAP_B_TO_B:
321 ctx->Pixel.MapBtoBsize = mapsize;
322 for (i = 0; i < mapsize; i++) {
323 ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0F, 1.0F );
324 }
325 break;
326 case GL_PIXEL_MAP_A_TO_A:
327 ctx->Pixel.MapAtoAsize = mapsize;
328 for (i = 0; i < mapsize; i++) {
329 ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0F, 1.0F );
330 }
331 break;
332 default:
333 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelMap(map)" );
334 }
335 }
336
337
338 void GLAPIENTRY
339 _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
340 {
341 GET_CURRENT_CONTEXT(ctx);
342 ASSERT_OUTSIDE_BEGIN_END(ctx);
343
344 /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
345 if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
346 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
347 return;
348 }
349
350 if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
351 /* test that mapsize is a power of two */
352 if (_mesa_bitcount((GLuint) mapsize) != 1) {
353 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
354 return;
355 }
356 }
357
358 FLUSH_VERTICES(ctx, _NEW_PIXEL);
359
360 if (ctx->Unpack.BufferObj->Name) {
361 /* unpack pixelmap from PBO */
362 GLubyte *buf;
363 /* Note, need to use DefaultPacking and Unpack's buffer object */
364 ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
365 if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
366 GL_INTENSITY, GL_FLOAT, values)) {
367 _mesa_error(ctx, GL_INVALID_OPERATION,
368 "glPixelMapfv(invalid PBO access)");
369 return;
370 }
371 /* restore */
372 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
373 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
374 GL_READ_ONLY_ARB,
375 ctx->Unpack.BufferObj);
376 if (!buf) {
377 /* buffer is already mapped - that's an error */
378 _mesa_error(ctx, GL_INVALID_OPERATION,
379 "glPixelMapfv(PBO is mapped)");
380 return;
381 }
382 values = (const GLfloat *) ADD_POINTERS(buf, values);
383 }
384 else if (!values) {
385 return;
386 }
387
388 pixelmap(ctx, map, mapsize, values);
389
390 if (ctx->Unpack.BufferObj->Name) {
391 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
392 ctx->Unpack.BufferObj);
393 }
394 }
395
396
397
398 void GLAPIENTRY
399 _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )
400 {
401 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
402 GET_CURRENT_CONTEXT(ctx);
403 ASSERT_OUTSIDE_BEGIN_END(ctx);
404
405 if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
406 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
407 return;
408 }
409
410 if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
411 /* test that mapsize is a power of two */
412 if (_mesa_bitcount((GLuint) mapsize) != 1) {
413 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
414 return;
415 }
416 }
417
418 FLUSH_VERTICES(ctx, _NEW_PIXEL);
419
420 if (ctx->Unpack.BufferObj->Name) {
421 /* unpack pixelmap from PBO */
422 GLubyte *buf;
423 /* Note, need to use DefaultPacking and Unpack's buffer object */
424 ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
425 if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
426 GL_INTENSITY, GL_UNSIGNED_INT, values)) {
427 _mesa_error(ctx, GL_INVALID_OPERATION,
428 "glPixelMapuiv(invalid PBO access)");
429 return;
430 }
431 /* restore */
432 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
433 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
434 GL_READ_ONLY_ARB,
435 ctx->Unpack.BufferObj);
436 if (!buf) {
437 /* buffer is already mapped - that's an error */
438 _mesa_error(ctx, GL_INVALID_OPERATION,
439 "glPixelMapuiv(PBO is mapped)");
440 return;
441 }
442 values = (const GLuint *) ADD_POINTERS(buf, values);
443 }
444 else if (!values) {
445 return;
446 }
447
448 /* convert to floats */
449 if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
450 GLint i;
451 for (i = 0; i < mapsize; i++) {
452 fvalues[i] = (GLfloat) values[i];
453 }
454 }
455 else {
456 GLint i;
457 for (i = 0; i < mapsize; i++) {
458 fvalues[i] = UINT_TO_FLOAT( values[i] );
459 }
460 }
461
462 if (ctx->Unpack.BufferObj->Name) {
463 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
464 ctx->Unpack.BufferObj);
465 }
466
467 pixelmap(ctx, map, mapsize, fvalues);
468 }
469
470
471
472 void GLAPIENTRY
473 _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
474 {
475 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
476 GET_CURRENT_CONTEXT(ctx);
477 ASSERT_OUTSIDE_BEGIN_END(ctx);
478
479 if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
480 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );
481 return;
482 }
483
484 if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
485 /* test that mapsize is a power of two */
486 if (_mesa_bitcount((GLuint) mapsize) != 1) {
487 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
488 return;
489 }
490 }
491
492 FLUSH_VERTICES(ctx, _NEW_PIXEL);
493
494 if (ctx->Unpack.BufferObj->Name) {
495 /* unpack pixelmap from PBO */
496 GLubyte *buf;
497 /* Note, need to use DefaultPacking and Unpack's buffer object */
498 ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
499 if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
500 GL_INTENSITY, GL_UNSIGNED_SHORT,
501 values)) {
502 _mesa_error(ctx, GL_INVALID_OPERATION,
503 "glPixelMapusv(invalid PBO access)");
504 return;
505 }
506 /* restore */
507 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
508 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
509 GL_READ_ONLY_ARB,
510 ctx->Unpack.BufferObj);
511 if (!buf) {
512 /* buffer is already mapped - that's an error */
513 _mesa_error(ctx, GL_INVALID_OPERATION,
514 "glPixelMapusv(PBO is mapped)");
515 return;
516 }
517 values = (const GLushort *) ADD_POINTERS(buf, values);
518 }
519 else if (!values) {
520 return;
521 }
522
523 /* convert to floats */
524 if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
525 GLint i;
526 for (i = 0; i < mapsize; i++) {
527 fvalues[i] = (GLfloat) values[i];
528 }
529 }
530 else {
531 GLint i;
532 for (i = 0; i < mapsize; i++) {
533 fvalues[i] = USHORT_TO_FLOAT( values[i] );
534 }
535 }
536
537 if (ctx->Unpack.BufferObj->Name) {
538 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
539 ctx->Unpack.BufferObj);
540 }
541
542 pixelmap(ctx, map, mapsize, fvalues);
543 }
544
545
546 /**
547 * Return size of the named map.
548 */
549 static GLuint
550 get_map_size(GLcontext *ctx, GLenum map)
551 {
552 switch (map) {
553 case GL_PIXEL_MAP_I_TO_I:
554 return ctx->Pixel.MapItoIsize;
555 case GL_PIXEL_MAP_S_TO_S:
556 return ctx->Pixel.MapStoSsize;
557 case GL_PIXEL_MAP_I_TO_R:
558 return ctx->Pixel.MapItoRsize;
559 case GL_PIXEL_MAP_I_TO_G:
560 return ctx->Pixel.MapItoGsize;
561 case GL_PIXEL_MAP_I_TO_B:
562 return ctx->Pixel.MapItoBsize;
563 case GL_PIXEL_MAP_I_TO_A:
564 return ctx->Pixel.MapItoAsize;
565 case GL_PIXEL_MAP_R_TO_R:
566 return ctx->Pixel.MapRtoRsize;
567 case GL_PIXEL_MAP_G_TO_G:
568 return ctx->Pixel.MapGtoGsize;
569 case GL_PIXEL_MAP_B_TO_B:
570 return ctx->Pixel.MapBtoBsize;
571 case GL_PIXEL_MAP_A_TO_A:
572 return ctx->Pixel.MapAtoAsize;
573 default:
574 return 0;
575 }
576 }
577
578
579 void GLAPIENTRY
580 _mesa_GetPixelMapfv( GLenum map, GLfloat *values )
581 {
582 GET_CURRENT_CONTEXT(ctx);
583 GLuint mapsize, i;
584 ASSERT_OUTSIDE_BEGIN_END(ctx);
585
586 mapsize = get_map_size(ctx, map);
587
588 if (ctx->Pack.BufferObj->Name) {
589 /* pack pixelmap into PBO */
590 GLubyte *buf;
591 /* Note, need to use DefaultPacking and Pack's buffer object */
592 ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj;
593 if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
594 GL_INTENSITY, GL_FLOAT, values)) {
595 _mesa_error(ctx, GL_INVALID_OPERATION,
596 "glGetPixelMapfv(invalid PBO access)");
597 return;
598 }
599 /* restore */
600 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
601 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
602 GL_WRITE_ONLY_ARB,
603 ctx->Pack.BufferObj);
604 if (!buf) {
605 /* buffer is already mapped - that's an error */
606 _mesa_error(ctx, GL_INVALID_OPERATION,
607 "glGetPixelMapfv(PBO is mapped)");
608 return;
609 }
610 values = (GLfloat *) ADD_POINTERS(buf, values);
611 }
612 else if (!values) {
613 return;
614 }
615
616 switch (map) {
617 case GL_PIXEL_MAP_I_TO_I:
618 MEMCPY(values, ctx->Pixel.MapItoI, mapsize * sizeof(GLfloat));
619 break;
620 case GL_PIXEL_MAP_S_TO_S:
621 for (i = 0; i < mapsize; i++) {
622 values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
623 }
624 break;
625 case GL_PIXEL_MAP_I_TO_R:
626 MEMCPY(values, ctx->Pixel.MapItoR, mapsize * sizeof(GLfloat));
627 break;
628 case GL_PIXEL_MAP_I_TO_G:
629 MEMCPY(values, ctx->Pixel.MapItoG, mapsize * sizeof(GLfloat));
630 break;
631 case GL_PIXEL_MAP_I_TO_B:
632 MEMCPY(values, ctx->Pixel.MapItoB, mapsize * sizeof(GLfloat));
633 break;
634 case GL_PIXEL_MAP_I_TO_A:
635 MEMCPY(values, ctx->Pixel.MapItoA, mapsize * sizeof(GLfloat));
636 break;
637 case GL_PIXEL_MAP_R_TO_R:
638 MEMCPY(values, ctx->Pixel.MapRtoR, mapsize * sizeof(GLfloat));
639 break;
640 case GL_PIXEL_MAP_G_TO_G:
641 MEMCPY(values, ctx->Pixel.MapGtoG, mapsize * sizeof(GLfloat));
642 break;
643 case GL_PIXEL_MAP_B_TO_B:
644 MEMCPY(values, ctx->Pixel.MapBtoB, mapsize * sizeof(GLfloat));
645 break;
646 case GL_PIXEL_MAP_A_TO_A:
647 MEMCPY(values, ctx->Pixel.MapAtoA, mapsize * sizeof(GLfloat));
648 break;
649 default:
650 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
651 }
652
653 if (ctx->Pack.BufferObj->Name) {
654 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
655 ctx->Pack.BufferObj);
656 }
657 }
658
659
660 void GLAPIENTRY
661 _mesa_GetPixelMapuiv( GLenum map, GLuint *values )
662 {
663 GET_CURRENT_CONTEXT(ctx);
664 GLint mapsize, i;
665 ASSERT_OUTSIDE_BEGIN_END(ctx);
666
667 mapsize = get_map_size(ctx, map);
668
669 if (ctx->Pack.BufferObj->Name) {
670 /* pack pixelmap into PBO */
671 GLubyte *buf;
672 /* Note, need to use DefaultPacking and Pack's buffer object */
673 ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj;
674 if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
675 GL_INTENSITY, GL_UNSIGNED_INT, values)) {
676 _mesa_error(ctx, GL_INVALID_OPERATION,
677 "glGetPixelMapuiv(invalid PBO access)");
678 return;
679 }
680 /* restore */
681 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
682 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
683 GL_WRITE_ONLY_ARB,
684 ctx->Pack.BufferObj);
685 if (!buf) {
686 /* buffer is already mapped - that's an error */
687 _mesa_error(ctx, GL_INVALID_OPERATION,
688 "glGetPixelMapuiv(PBO is mapped)");
689 return;
690 }
691 values = (GLuint *) ADD_POINTERS(buf, values);
692 }
693 else if (!values) {
694 return;
695 }
696
697 switch (map) {
698 case GL_PIXEL_MAP_I_TO_I:
699 for (i = 0; i < mapsize; i++) {
700 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoI[i] );
701 }
702 break;
703 case GL_PIXEL_MAP_S_TO_S:
704 MEMCPY(values, ctx->Pixel.MapStoS, mapsize * sizeof(GLint));
705 break;
706 case GL_PIXEL_MAP_I_TO_R:
707 for (i = 0; i < mapsize; i++) {
708 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
709 }
710 break;
711 case GL_PIXEL_MAP_I_TO_G:
712 for (i = 0; i < mapsize; i++) {
713 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
714 }
715 break;
716 case GL_PIXEL_MAP_I_TO_B:
717 for (i = 0; i < mapsize; i++) {
718 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
719 }
720 break;
721 case GL_PIXEL_MAP_I_TO_A:
722 for (i = 0; i < mapsize; i++) {
723 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
724 }
725 break;
726 case GL_PIXEL_MAP_R_TO_R:
727 for (i = 0; i < mapsize; i++) {
728 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
729 }
730 break;
731 case GL_PIXEL_MAP_G_TO_G:
732 for (i = 0; i < mapsize; i++) {
733 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
734 }
735 break;
736 case GL_PIXEL_MAP_B_TO_B:
737 for (i = 0; i < mapsize; i++) {
738 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
739 }
740 break;
741 case GL_PIXEL_MAP_A_TO_A:
742 for (i = 0; i < mapsize; i++) {
743 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
744 }
745 break;
746 default:
747 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
748 }
749
750 if (ctx->Pack.BufferObj->Name) {
751 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
752 ctx->Pack.BufferObj);
753 }
754 }
755
756
757 void GLAPIENTRY
758 _mesa_GetPixelMapusv( GLenum map, GLushort *values )
759 {
760 GET_CURRENT_CONTEXT(ctx);
761 GLint mapsize, i;
762 ASSERT_OUTSIDE_BEGIN_END(ctx);
763
764 mapsize = get_map_size(ctx, map);
765
766 if (ctx->Pack.BufferObj->Name) {
767 /* pack pixelmap into PBO */
768 GLubyte *buf;
769 /* Note, need to use DefaultPacking and Pack's buffer object */
770 ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj;
771 if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
772 GL_INTENSITY, GL_UNSIGNED_SHORT,
773 values)) {
774 _mesa_error(ctx, GL_INVALID_OPERATION,
775 "glGetPixelMapusv(invalid PBO access)");
776 return;
777 }
778 /* restore */
779 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
780 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
781 GL_WRITE_ONLY_ARB,
782 ctx->Pack.BufferObj);
783 if (!buf) {
784 /* buffer is already mapped - that's an error */
785 _mesa_error(ctx, GL_INVALID_OPERATION,
786 "glGetPixelMapusv(PBO is mapped)");
787 return;
788 }
789 values = (GLushort *) ADD_POINTERS(buf, values);
790 }
791 else if (!values) {
792 return;
793 }
794
795 switch (map) {
796 case GL_PIXEL_MAP_I_TO_I:
797 for (i = 0; i < mapsize; i++) {
798 values[i] = FLOAT_TO_USHORT(ctx->Pixel.MapItoI[i]);
799 }
800 break;
801 case GL_PIXEL_MAP_S_TO_S:
802 for (i = 0; i < mapsize; i++) {
803 values[i] = (GLushort) ctx->Pixel.MapStoS[i];
804 }
805 break;
806 case GL_PIXEL_MAP_I_TO_R:
807 for (i = 0; i < mapsize; i++) {
808 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
809 }
810 break;
811 case GL_PIXEL_MAP_I_TO_G:
812 for (i = 0; i < mapsize; i++) {
813 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
814 }
815 break;
816 case GL_PIXEL_MAP_I_TO_B:
817 for (i = 0; i < mapsize; i++) {
818 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
819 }
820 break;
821 case GL_PIXEL_MAP_I_TO_A:
822 for (i = 0; i < mapsize; i++) {
823 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
824 }
825 break;
826 case GL_PIXEL_MAP_R_TO_R:
827 for (i = 0; i < mapsize; i++) {
828 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
829 }
830 break;
831 case GL_PIXEL_MAP_G_TO_G:
832 for (i = 0; i < mapsize; i++) {
833 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
834 }
835 break;
836 case GL_PIXEL_MAP_B_TO_B:
837 for (i = 0; i < mapsize; i++) {
838 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
839 }
840 break;
841 case GL_PIXEL_MAP_A_TO_A:
842 for (i = 0; i < mapsize; i++) {
843 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
844 }
845 break;
846 default:
847 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
848 }
849
850 if (ctx->Pack.BufferObj->Name) {
851 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
852 ctx->Pack.BufferObj);
853 }
854 }
855
856
857
858 /**********************************************************************/
859 /***** glPixelTransfer *****/
860 /**********************************************************************/
861
862
863 /*
864 * Implements glPixelTransfer[fi] whether called immediately or from a
865 * display list.
866 */
867 void GLAPIENTRY
868 _mesa_PixelTransferf( GLenum pname, GLfloat param )
869 {
870 GET_CURRENT_CONTEXT(ctx);
871 ASSERT_OUTSIDE_BEGIN_END(ctx);
872
873 switch (pname) {
874 case GL_MAP_COLOR:
875 if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))
876 return;
877 FLUSH_VERTICES(ctx, _NEW_PIXEL);
878 ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
879 break;
880 case GL_MAP_STENCIL:
881 if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))
882 return;
883 FLUSH_VERTICES(ctx, _NEW_PIXEL);
884 ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
885 break;
886 case GL_INDEX_SHIFT:
887 if (ctx->Pixel.IndexShift == (GLint) param)
888 return;
889 FLUSH_VERTICES(ctx, _NEW_PIXEL);
890 ctx->Pixel.IndexShift = (GLint) param;
891 break;
892 case GL_INDEX_OFFSET:
893 if (ctx->Pixel.IndexOffset == (GLint) param)
894 return;
895 FLUSH_VERTICES(ctx, _NEW_PIXEL);
896 ctx->Pixel.IndexOffset = (GLint) param;
897 break;
898 case GL_RED_SCALE:
899 if (ctx->Pixel.RedScale == param)
900 return;
901 FLUSH_VERTICES(ctx, _NEW_PIXEL);
902 ctx->Pixel.RedScale = param;
903 break;
904 case GL_RED_BIAS:
905 if (ctx->Pixel.RedBias == param)
906 return;
907 FLUSH_VERTICES(ctx, _NEW_PIXEL);
908 ctx->Pixel.RedBias = param;
909 break;
910 case GL_GREEN_SCALE:
911 if (ctx->Pixel.GreenScale == param)
912 return;
913 FLUSH_VERTICES(ctx, _NEW_PIXEL);
914 ctx->Pixel.GreenScale = param;
915 break;
916 case GL_GREEN_BIAS:
917 if (ctx->Pixel.GreenBias == param)
918 return;
919 FLUSH_VERTICES(ctx, _NEW_PIXEL);
920 ctx->Pixel.GreenBias = param;
921 break;
922 case GL_BLUE_SCALE:
923 if (ctx->Pixel.BlueScale == param)
924 return;
925 FLUSH_VERTICES(ctx, _NEW_PIXEL);
926 ctx->Pixel.BlueScale = param;
927 break;
928 case GL_BLUE_BIAS:
929 if (ctx->Pixel.BlueBias == param)
930 return;
931 FLUSH_VERTICES(ctx, _NEW_PIXEL);
932 ctx->Pixel.BlueBias = param;
933 break;
934 case GL_ALPHA_SCALE:
935 if (ctx->Pixel.AlphaScale == param)
936 return;
937 FLUSH_VERTICES(ctx, _NEW_PIXEL);
938 ctx->Pixel.AlphaScale = param;
939 break;
940 case GL_ALPHA_BIAS:
941 if (ctx->Pixel.AlphaBias == param)
942 return;
943 FLUSH_VERTICES(ctx, _NEW_PIXEL);
944 ctx->Pixel.AlphaBias = param;
945 break;
946 case GL_DEPTH_SCALE:
947 if (ctx->Pixel.DepthScale == param)
948 return;
949 FLUSH_VERTICES(ctx, _NEW_PIXEL);
950 ctx->Pixel.DepthScale = param;
951 break;
952 case GL_DEPTH_BIAS:
953 if (ctx->Pixel.DepthBias == param)
954 return;
955 FLUSH_VERTICES(ctx, _NEW_PIXEL);
956 ctx->Pixel.DepthBias = param;
957 break;
958 case GL_POST_COLOR_MATRIX_RED_SCALE:
959 if (ctx->Pixel.PostColorMatrixScale[0] == param)
960 return;
961 FLUSH_VERTICES(ctx, _NEW_PIXEL);
962 ctx->Pixel.PostColorMatrixScale[0] = param;
963 break;
964 case GL_POST_COLOR_MATRIX_RED_BIAS:
965 if (ctx->Pixel.PostColorMatrixBias[0] == param)
966 return;
967 FLUSH_VERTICES(ctx, _NEW_PIXEL);
968 ctx->Pixel.PostColorMatrixBias[0] = param;
969 break;
970 case GL_POST_COLOR_MATRIX_GREEN_SCALE:
971 if (ctx->Pixel.PostColorMatrixScale[1] == param)
972 return;
973 FLUSH_VERTICES(ctx, _NEW_PIXEL);
974 ctx->Pixel.PostColorMatrixScale[1] = param;
975 break;
976 case GL_POST_COLOR_MATRIX_GREEN_BIAS:
977 if (ctx->Pixel.PostColorMatrixBias[1] == param)
978 return;
979 FLUSH_VERTICES(ctx, _NEW_PIXEL);
980 ctx->Pixel.PostColorMatrixBias[1] = param;
981 break;
982 case GL_POST_COLOR_MATRIX_BLUE_SCALE:
983 if (ctx->Pixel.PostColorMatrixScale[2] == param)
984 return;
985 FLUSH_VERTICES(ctx, _NEW_PIXEL);
986 ctx->Pixel.PostColorMatrixScale[2] = param;
987 break;
988 case GL_POST_COLOR_MATRIX_BLUE_BIAS:
989 if (ctx->Pixel.PostColorMatrixBias[2] == param)
990 return;
991 FLUSH_VERTICES(ctx, _NEW_PIXEL);
992 ctx->Pixel.PostColorMatrixBias[2] = param;
993 break;
994 case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
995 if (ctx->Pixel.PostColorMatrixScale[3] == param)
996 return;
997 FLUSH_VERTICES(ctx, _NEW_PIXEL);
998 ctx->Pixel.PostColorMatrixScale[3] = param;
999 break;
1000 case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
1001 if (ctx->Pixel.PostColorMatrixBias[3] == param)
1002 return;
1003 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1004 ctx->Pixel.PostColorMatrixBias[3] = param;
1005 break;
1006 case GL_POST_CONVOLUTION_RED_SCALE:
1007 if (ctx->Pixel.PostConvolutionScale[0] == param)
1008 return;
1009 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1010 ctx->Pixel.PostConvolutionScale[0] = param;
1011 break;
1012 case GL_POST_CONVOLUTION_RED_BIAS:
1013 if (ctx->Pixel.PostConvolutionBias[0] == param)
1014 return;
1015 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1016 ctx->Pixel.PostConvolutionBias[0] = param;
1017 break;
1018 case GL_POST_CONVOLUTION_GREEN_SCALE:
1019 if (ctx->Pixel.PostConvolutionScale[1] == param)
1020 return;
1021 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1022 ctx->Pixel.PostConvolutionScale[1] = param;
1023 break;
1024 case GL_POST_CONVOLUTION_GREEN_BIAS:
1025 if (ctx->Pixel.PostConvolutionBias[1] == param)
1026 return;
1027 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1028 ctx->Pixel.PostConvolutionBias[1] = param;
1029 break;
1030 case GL_POST_CONVOLUTION_BLUE_SCALE:
1031 if (ctx->Pixel.PostConvolutionScale[2] == param)
1032 return;
1033 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1034 ctx->Pixel.PostConvolutionScale[2] = param;
1035 break;
1036 case GL_POST_CONVOLUTION_BLUE_BIAS:
1037 if (ctx->Pixel.PostConvolutionBias[2] == param)
1038 return;
1039 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1040 ctx->Pixel.PostConvolutionBias[2] = param;
1041 break;
1042 case GL_POST_CONVOLUTION_ALPHA_SCALE:
1043 if (ctx->Pixel.PostConvolutionScale[2] == param)
1044 return;
1045 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1046 ctx->Pixel.PostConvolutionScale[2] = param;
1047 break;
1048 case GL_POST_CONVOLUTION_ALPHA_BIAS:
1049 if (ctx->Pixel.PostConvolutionBias[2] == param)
1050 return;
1051 FLUSH_VERTICES(ctx, _NEW_PIXEL);
1052 ctx->Pixel.PostConvolutionBias[2] = param;
1053 break;
1054 default:
1055 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
1056 return;
1057 }
1058 }
1059
1060
1061 void GLAPIENTRY
1062 _mesa_PixelTransferi( GLenum pname, GLint param )
1063 {
1064 _mesa_PixelTransferf( pname, (GLfloat) param );
1065 }
1066
1067
1068
1069 /**********************************************************************/
1070 /***** Pixel processing functions ******/
1071 /**********************************************************************/
1072
1073 /*
1074 * Apply scale and bias factors to an array of RGBA pixels.
1075 */
1076 void
1077 _mesa_scale_and_bias_rgba(GLuint n, GLfloat rgba[][4],
1078 GLfloat rScale, GLfloat gScale,
1079 GLfloat bScale, GLfloat aScale,
1080 GLfloat rBias, GLfloat gBias,
1081 GLfloat bBias, GLfloat aBias)
1082 {
1083 if (rScale != 1.0 || rBias != 0.0) {
1084 GLuint i;
1085 for (i = 0; i < n; i++) {
1086 rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
1087 }
1088 }
1089 if (gScale != 1.0 || gBias != 0.0) {
1090 GLuint i;
1091 for (i = 0; i < n; i++) {
1092 rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
1093 }
1094 }
1095 if (bScale != 1.0 || bBias != 0.0) {
1096 GLuint i;
1097 for (i = 0; i < n; i++) {
1098 rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
1099 }
1100 }
1101 if (aScale != 1.0 || aBias != 0.0) {
1102 GLuint i;
1103 for (i = 0; i < n; i++) {
1104 rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
1105 }
1106 }
1107 }
1108
1109
1110 /*
1111 * Apply pixel mapping to an array of floating point RGBA pixels.
1112 */
1113 void
1114 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
1115 {
1116 const GLfloat rscale = (GLfloat) (ctx->Pixel.MapRtoRsize - 1);
1117 const GLfloat gscale = (GLfloat) (ctx->Pixel.MapGtoGsize - 1);
1118 const GLfloat bscale = (GLfloat) (ctx->Pixel.MapBtoBsize - 1);
1119 const GLfloat ascale = (GLfloat) (ctx->Pixel.MapAtoAsize - 1);
1120 const GLfloat *rMap = ctx->Pixel.MapRtoR;
1121 const GLfloat *gMap = ctx->Pixel.MapGtoG;
1122 const GLfloat *bMap = ctx->Pixel.MapBtoB;
1123 const GLfloat *aMap = ctx->Pixel.MapAtoA;
1124 GLuint i;
1125 for (i=0;i<n;i++) {
1126 GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
1127 GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
1128 GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
1129 GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
1130 rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
1131 rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
1132 rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
1133 rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
1134 }
1135 }
1136
1137
1138 /*
1139 * Apply the color matrix and post color matrix scaling and biasing.
1140 */
1141 void
1142 _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
1143 {
1144 const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0];
1145 const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0];
1146 const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1];
1147 const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1];
1148 const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2];
1149 const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2];
1150 const GLfloat as = ctx->Pixel.PostColorMatrixScale[3];
1151 const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3];
1152 const GLfloat *m = ctx->ColorMatrixStack.Top->m;
1153 GLuint i;
1154 for (i = 0; i < n; i++) {
1155 const GLfloat r = rgba[i][RCOMP];
1156 const GLfloat g = rgba[i][GCOMP];
1157 const GLfloat b = rgba[i][BCOMP];
1158 const GLfloat a = rgba[i][ACOMP];
1159 rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb;
1160 rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb;
1161 rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb;
1162 rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab;
1163 }
1164 }
1165
1166
1167 /**
1168 * Apply a color table lookup to an array of floating point RGBA colors.
1169 */
1170 void
1171 _mesa_lookup_rgba_float(const struct gl_color_table *table,
1172 GLuint n, GLfloat rgba[][4])
1173 {
1174 if (!table->Table || table->Size == 0)
1175 return;
1176
1177 switch (table->_BaseFormat) {
1178 case GL_INTENSITY:
1179 /* replace RGBA with I */
1180 if (table->Type == GL_FLOAT) {
1181 const GLint max = table->Size - 1;
1182 const GLfloat scale = (GLfloat) max;
1183 const GLfloat *lut = (const GLfloat *) table->Table;
1184 GLuint i;
1185 for (i = 0; i < n; i++) {
1186 GLint j = IROUND(rgba[i][RCOMP] * scale);
1187 GLfloat c = lut[CLAMP(j, 0, max)];
1188 rgba[i][RCOMP] = rgba[i][GCOMP] =
1189 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1190 }
1191 }
1192 else {
1193 const GLint max = table->Size - 1;
1194 const GLfloat scale = (GLfloat) max;
1195 const GLchan *lut = (const GLchan *) table->Table;
1196 GLuint i;
1197 for (i = 0; i < n; i++) {
1198 GLint j = IROUND(rgba[i][RCOMP] * scale);
1199 GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
1200 rgba[i][RCOMP] = rgba[i][GCOMP] =
1201 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1202 }
1203 }
1204 break;
1205 case GL_LUMINANCE:
1206 /* replace RGB with L */
1207 if (table->Type == GL_FLOAT) {
1208 const GLint max = table->Size - 1;
1209 const GLfloat scale = (GLfloat) max;
1210 const GLfloat *lut = (const GLfloat *) table->Table;
1211 GLuint i;
1212 for (i = 0; i < n; i++) {
1213 GLint j = IROUND(rgba[i][RCOMP] * scale);
1214 GLfloat c = lut[CLAMP(j, 0, max)];
1215 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1216 }
1217 }
1218 else {
1219 const GLint max = table->Size - 1;
1220 const GLfloat scale = (GLfloat) max;
1221 const GLchan *lut = (const GLchan *) table->Table;
1222 GLuint i;
1223 for (i = 0; i < n; i++) {
1224 GLint j = IROUND(rgba[i][RCOMP] * scale);
1225 GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
1226 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1227 }
1228 }
1229 break;
1230 case GL_ALPHA:
1231 /* replace A with A */
1232 if (table->Type == GL_FLOAT) {
1233 const GLint max = table->Size - 1;
1234 const GLfloat scale = (GLfloat) max;
1235 const GLfloat *lut = (const GLfloat *) table->Table;
1236 GLuint i;
1237 for (i = 0; i < n; i++) {
1238 GLint j = IROUND(rgba[i][ACOMP] * scale);
1239 rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
1240 }
1241 }
1242 else {
1243 const GLint max = table->Size - 1;
1244 const GLfloat scale = (GLfloat) max;
1245 const GLchan *lut = (const GLchan *) table->Table;
1246 GLuint i;
1247 for (i = 0; i < n; i++) {
1248 GLint j = IROUND(rgba[i][ACOMP] * scale);
1249 rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
1250 }
1251 }
1252 break;
1253 case GL_LUMINANCE_ALPHA:
1254 /* replace RGBA with LLLA */
1255 if (table->Type == GL_FLOAT) {
1256 const GLint max = table->Size - 1;
1257 const GLfloat scale = (GLfloat) max;
1258 const GLfloat *lut = (const GLfloat *) table->Table;
1259 GLuint i;
1260 for (i = 0; i < n; i++) {
1261 GLint jL = IROUND(rgba[i][RCOMP] * scale);
1262 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1263 GLfloat luminance, alpha;
1264 jL = CLAMP(jL, 0, max);
1265 jA = CLAMP(jA, 0, max);
1266 luminance = lut[jL * 2 + 0];
1267 alpha = lut[jA * 2 + 1];
1268 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1269 rgba[i][ACOMP] = alpha;;
1270 }
1271 }
1272 else {
1273 const GLint max = table->Size - 1;
1274 const GLfloat scale = (GLfloat) max;
1275 const GLchan *lut = (const GLchan *) table->Table;
1276 GLuint i;
1277 for (i = 0; i < n; i++) {
1278 GLint jL = IROUND(rgba[i][RCOMP] * scale);
1279 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1280 GLfloat luminance, alpha;
1281 jL = CLAMP(jL, 0, max);
1282 jA = CLAMP(jA, 0, max);
1283 luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
1284 alpha = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
1285 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1286 rgba[i][ACOMP] = alpha;;
1287 }
1288 }
1289 break;
1290 case GL_RGB:
1291 /* replace RGB with RGB */
1292 if (table->Type == GL_FLOAT) {
1293 const GLint max = table->Size - 1;
1294 const GLfloat scale = (GLfloat) max;
1295 const GLfloat *lut = (const GLfloat *) table->Table;
1296 GLuint i;
1297 for (i = 0; i < n; i++) {
1298 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1299 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1300 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1301 jR = CLAMP(jR, 0, max);
1302 jG = CLAMP(jG, 0, max);
1303 jB = CLAMP(jB, 0, max);
1304 rgba[i][RCOMP] = lut[jR * 3 + 0];
1305 rgba[i][GCOMP] = lut[jG * 3 + 1];
1306 rgba[i][BCOMP] = lut[jB * 3 + 2];
1307 }
1308 }
1309 else {
1310 const GLint max = table->Size - 1;
1311 const GLfloat scale = (GLfloat) max;
1312 const GLchan *lut = (const GLchan *) table->Table;
1313 GLuint i;
1314 for (i = 0; i < n; i++) {
1315 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1316 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1317 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1318 jR = CLAMP(jR, 0, max);
1319 jG = CLAMP(jG, 0, max);
1320 jB = CLAMP(jB, 0, max);
1321 rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
1322 rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
1323 rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
1324 }
1325 }
1326 break;
1327 case GL_RGBA:
1328 /* replace RGBA with RGBA */
1329 if (table->Type == GL_FLOAT) {
1330 const GLint max = table->Size - 1;
1331 const GLfloat scale = (GLfloat) max;
1332 const GLfloat *lut = (const GLfloat *) table->Table;
1333 GLuint i;
1334 for (i = 0; i < n; i++) {
1335 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1336 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1337 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1338 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1339 jR = CLAMP(jR, 0, max);
1340 jG = CLAMP(jG, 0, max);
1341 jB = CLAMP(jB, 0, max);
1342 jA = CLAMP(jA, 0, max);
1343 rgba[i][RCOMP] = lut[jR * 4 + 0];
1344 rgba[i][GCOMP] = lut[jG * 4 + 1];
1345 rgba[i][BCOMP] = lut[jB * 4 + 2];
1346 rgba[i][ACOMP] = lut[jA * 4 + 3];
1347 }
1348 }
1349 else {
1350 const GLint max = table->Size - 1;
1351 const GLfloat scale = (GLfloat) max;
1352 const GLchan *lut = (const GLchan *) table->Table;
1353 GLuint i;
1354 for (i = 0; i < n; i++) {
1355 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1356 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1357 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1358 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1359 jR = CLAMP(jR, 0, max);
1360 jG = CLAMP(jG, 0, max);
1361 jB = CLAMP(jB, 0, max);
1362 jA = CLAMP(jA, 0, max);
1363 rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
1364 rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
1365 rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
1366 rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
1367 }
1368 }
1369 break;
1370 default:
1371 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
1372 return;
1373 }
1374 }
1375
1376
1377
1378 /**
1379 * Apply a color table lookup to an array of GLchan RGBA colors.
1380 */
1381 void
1382 _mesa_lookup_rgba_chan(const struct gl_color_table *table,
1383 GLuint n, GLchan rgba[][4])
1384 {
1385 if (!table->Table || table->Size == 0)
1386 return;
1387
1388 switch (table->_BaseFormat) {
1389 case GL_INTENSITY:
1390 /* replace RGBA with I */
1391 if (table->Type == GL_FLOAT) {
1392 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1393 const GLfloat *lut = (const GLfloat *) table->Table;
1394 GLuint i;
1395 for (i = 0; i < n; i++) {
1396 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1397 GLchan c;
1398 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1399 rgba[i][RCOMP] = rgba[i][GCOMP] =
1400 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1401 }
1402 }
1403 else {
1404 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1405 if (table->Size == 256) {
1406 /* common case */
1407 const GLchan *lut = (const GLchan *) table->Table;
1408 GLuint i;
1409 for (i = 0; i < n; i++) {
1410 const GLchan c = lut[rgba[i][RCOMP]];
1411 rgba[i][RCOMP] = rgba[i][GCOMP] =
1412 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1413 }
1414 }
1415 else
1416 #endif
1417 {
1418 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1419 const GLchan *lut = (const GLchan *) table->Table;
1420 GLuint i;
1421 for (i = 0; i < n; i++) {
1422 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1423 rgba[i][RCOMP] = rgba[i][GCOMP] =
1424 rgba[i][BCOMP] = rgba[i][ACOMP] = lut[j];
1425 }
1426 }
1427 }
1428 break;
1429 case GL_LUMINANCE:
1430 /* replace RGB with L */
1431 if (table->Type == GL_FLOAT) {
1432 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1433 const GLfloat *lut = (const GLfloat *) table->Table;
1434 GLuint i;
1435 for (i = 0; i < n; i++) {
1436 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1437 GLchan c;
1438 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1439 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1440 }
1441 }
1442 else {
1443 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1444 if (table->Size == 256) {
1445 /* common case */
1446 const GLchan *lut = (const GLchan *) table->Table;
1447 GLuint i;
1448 for (i = 0; i < n; i++) {
1449 const GLchan c = lut[rgba[i][RCOMP]];
1450 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1451 }
1452 }
1453 else
1454 #endif
1455 {
1456 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1457 const GLchan *lut = (const GLchan *) table->Table;
1458 GLuint i;
1459 for (i = 0; i < n; i++) {
1460 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1461 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = lut[j];
1462 }
1463 }
1464 }
1465 break;
1466 case GL_ALPHA:
1467 /* replace A with A */
1468 if (table->Type == GL_FLOAT) {
1469 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1470 const GLfloat *lut = (const GLfloat *) table->Table;
1471 GLuint i;
1472 for (i = 0; i < n; i++) {
1473 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1474 GLchan c;
1475 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1476 rgba[i][ACOMP] = c;
1477 }
1478 }
1479 else {
1480 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1481 if (table->Size == 256) {
1482 /* common case */
1483 const GLchan *lut = (const GLchan *) table->Table;
1484 GLuint i;
1485 for (i = 0; i < n; i++) {
1486 rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
1487 }
1488 }
1489 else
1490 #endif
1491 {
1492 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1493 const GLchan *lut = (const GLchan *) table->Table;
1494 GLuint i;
1495 for (i = 0; i < n; i++) {
1496 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1497 rgba[i][ACOMP] = lut[j];
1498 }
1499 }
1500 }
1501 break;
1502 case GL_LUMINANCE_ALPHA:
1503 /* replace RGBA with LLLA */
1504 if (table->Type == GL_FLOAT) {
1505 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1506 const GLfloat *lut = (const GLfloat *) table->Table;
1507 GLuint i;
1508 for (i = 0; i < n; i++) {
1509 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1510 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1511 GLchan luminance, alpha;
1512 CLAMPED_FLOAT_TO_CHAN(luminance, lut[jL * 2 + 0]);
1513 CLAMPED_FLOAT_TO_CHAN(alpha, lut[jA * 2 + 1]);
1514 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1515 rgba[i][ACOMP] = alpha;;
1516 }
1517 }
1518 else {
1519 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1520 if (table->Size == 256) {
1521 /* common case */
1522 const GLchan *lut = (const GLchan *) table->Table;
1523 GLuint i;
1524 for (i = 0; i < n; i++) {
1525 GLchan l = lut[rgba[i][RCOMP] * 2 + 0];
1526 GLchan a = lut[rgba[i][ACOMP] * 2 + 1];;
1527 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = l;
1528 rgba[i][ACOMP] = a;
1529 }
1530 }
1531 else
1532 #endif
1533 {
1534 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1535 const GLchan *lut = (const GLchan *) table->Table;
1536 GLuint i;
1537 for (i = 0; i < n; i++) {
1538 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1539 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1540 GLchan luminance = lut[jL * 2 + 0];
1541 GLchan alpha = lut[jA * 2 + 1];
1542 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1543 rgba[i][ACOMP] = alpha;
1544 }
1545 }
1546 }
1547 break;
1548 case GL_RGB:
1549 /* replace RGB with RGB */
1550 if (table->Type == GL_FLOAT) {
1551 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1552 const GLfloat *lut = (const GLfloat *) table->Table;
1553 GLuint i;
1554 for (i = 0; i < n; i++) {
1555 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1556 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1557 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1558 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 3 + 0]);
1559 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 3 + 1]);
1560 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 3 + 2]);
1561 }
1562 }
1563 else {
1564 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1565 if (table->Size == 256) {
1566 /* common case */
1567 const GLchan *lut = (const GLchan *) table->Table;
1568 GLuint i;
1569 for (i = 0; i < n; i++) {
1570 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
1571 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
1572 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
1573 }
1574 }
1575 else
1576 #endif
1577 {
1578 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1579 const GLchan *lut = (const GLchan *) table->Table;
1580 GLuint i;
1581 for (i = 0; i < n; i++) {
1582 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1583 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1584 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1585 rgba[i][RCOMP] = lut[jR * 3 + 0];
1586 rgba[i][GCOMP] = lut[jG * 3 + 1];
1587 rgba[i][BCOMP] = lut[jB * 3 + 2];
1588 }
1589 }
1590 }
1591 break;
1592 case GL_RGBA:
1593 /* replace RGBA with RGBA */
1594 if (table->Type == GL_FLOAT) {
1595 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1596 const GLfloat *lut = (const GLfloat *) table->Table;
1597 GLuint i;
1598 for (i = 0; i < n; i++) {
1599 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1600 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1601 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1602 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1603 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1604 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1605 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1606 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1607 }
1608 }
1609 else {
1610 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1611 if (table->Size == 256) {
1612 /* common case */
1613 const GLchan *lut = (const GLchan *) table->Table;
1614 GLuint i;
1615 for (i = 0; i < n; i++) {
1616 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
1617 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
1618 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
1619 rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
1620 }
1621 }
1622 else
1623 #endif
1624 {
1625 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1626 const GLfloat *lut = (const GLfloat *) table->Table;
1627 GLuint i;
1628 for (i = 0; i < n; i++) {
1629 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1630 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1631 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1632 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1633 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1634 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1635 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1636 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1637 }
1638 }
1639 }
1640 break;
1641 default:
1642 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
1643 return;
1644 }
1645 }
1646
1647
1648
1649 /*
1650 * Apply color index shift and offset to an array of pixels.
1651 */
1652 void
1653 _mesa_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1654 {
1655 GLint shift = ctx->Pixel.IndexShift;
1656 GLint offset = ctx->Pixel.IndexOffset;
1657 GLuint i;
1658 if (shift > 0) {
1659 for (i=0;i<n;i++) {
1660 indexes[i] = (indexes[i] << shift) + offset;
1661 }
1662 }
1663 else if (shift < 0) {
1664 shift = -shift;
1665 for (i=0;i<n;i++) {
1666 indexes[i] = (indexes[i] >> shift) + offset;
1667 }
1668 }
1669 else {
1670 for (i=0;i<n;i++) {
1671 indexes[i] = indexes[i] + offset;
1672 }
1673 }
1674 }
1675
1676
1677 /*
1678 * Apply color index mapping to color indexes.
1679 */
1680 void
1681 _mesa_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
1682 {
1683 const GLuint mask = ctx->Pixel.MapItoIsize - 1;
1684 GLuint i;
1685 for (i = 0; i < n; i++) {
1686 const GLuint j = index[i] & mask;
1687 index[i] = IROUND(ctx->Pixel.MapItoI[j]);
1688 }
1689 }
1690
1691
1692 /*
1693 * Map color indexes to rgba values.
1694 */
1695 void
1696 _mesa_map_ci_to_rgba_chan( const GLcontext *ctx, GLuint n,
1697 const GLuint index[], GLchan rgba[][4] )
1698 {
1699 #if CHAN_BITS == 8
1700 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1701 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1702 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1703 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1704 const GLubyte *rMap = ctx->Pixel.MapItoR8;
1705 const GLubyte *gMap = ctx->Pixel.MapItoG8;
1706 const GLubyte *bMap = ctx->Pixel.MapItoB8;
1707 const GLubyte *aMap = ctx->Pixel.MapItoA8;
1708 GLuint i;
1709 for (i=0;i<n;i++) {
1710 rgba[i][RCOMP] = rMap[index[i] & rmask];
1711 rgba[i][GCOMP] = gMap[index[i] & gmask];
1712 rgba[i][BCOMP] = bMap[index[i] & bmask];
1713 rgba[i][ACOMP] = aMap[index[i] & amask];
1714 }
1715 #else
1716 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1717 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1718 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1719 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1720 const GLfloat *rMap = ctx->Pixel.MapItoR;
1721 const GLfloat *gMap = ctx->Pixel.MapItoG;
1722 const GLfloat *bMap = ctx->Pixel.MapItoB;
1723 const GLfloat *aMap = ctx->Pixel.MapItoA;
1724 GLuint i;
1725 for (i=0;i<n;i++) {
1726 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1727 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1728 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1729 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1730 }
1731 #endif
1732 }
1733
1734
1735 /*
1736 * Map color indexes to float rgba values.
1737 */
1738 void
1739 _mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n,
1740 const GLuint index[], GLfloat rgba[][4] )
1741 {
1742 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1743 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1744 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1745 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1746 const GLfloat *rMap = ctx->Pixel.MapItoR;
1747 const GLfloat *gMap = ctx->Pixel.MapItoG;
1748 const GLfloat *bMap = ctx->Pixel.MapItoB;
1749 const GLfloat *aMap = ctx->Pixel.MapItoA;
1750 GLuint i;
1751 for (i=0;i<n;i++) {
1752 rgba[i][RCOMP] = rMap[index[i] & rmask];
1753 rgba[i][GCOMP] = gMap[index[i] & gmask];
1754 rgba[i][BCOMP] = bMap[index[i] & bmask];
1755 rgba[i][ACOMP] = aMap[index[i] & amask];
1756 }
1757 }
1758
1759
1760 /*
1761 * Map 8-bit color indexes to rgb values.
1762 */
1763 void
1764 _mesa_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
1765 GLchan rgba[][4] )
1766 {
1767 #if CHAN_BITS == 8
1768 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1769 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1770 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1771 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1772 const GLubyte *rMap = ctx->Pixel.MapItoR8;
1773 const GLubyte *gMap = ctx->Pixel.MapItoG8;
1774 const GLubyte *bMap = ctx->Pixel.MapItoB8;
1775 const GLubyte *aMap = ctx->Pixel.MapItoA8;
1776 GLuint i;
1777 for (i=0;i<n;i++) {
1778 rgba[i][RCOMP] = rMap[index[i] & rmask];
1779 rgba[i][GCOMP] = gMap[index[i] & gmask];
1780 rgba[i][BCOMP] = bMap[index[i] & bmask];
1781 rgba[i][ACOMP] = aMap[index[i] & amask];
1782 }
1783 #else
1784 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1785 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1786 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1787 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1788 const GLfloat *rMap = ctx->Pixel.MapItoR;
1789 const GLfloat *gMap = ctx->Pixel.MapItoG;
1790 const GLfloat *bMap = ctx->Pixel.MapItoB;
1791 const GLfloat *aMap = ctx->Pixel.MapItoA;
1792 GLuint i;
1793 for (i=0;i<n;i++) {
1794 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1795 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1796 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1797 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1798 }
1799 #endif
1800 }
1801
1802
1803 void
1804 _mesa_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
1805 GLstencil stencil[] )
1806 {
1807 GLuint i;
1808 GLint shift = ctx->Pixel.IndexShift;
1809 GLint offset = ctx->Pixel.IndexOffset;
1810 if (shift > 0) {
1811 for (i=0;i<n;i++) {
1812 stencil[i] = (stencil[i] << shift) + offset;
1813 }
1814 }
1815 else if (shift < 0) {
1816 shift = -shift;
1817 for (i=0;i<n;i++) {
1818 stencil[i] = (stencil[i] >> shift) + offset;
1819 }
1820 }
1821 else {
1822 for (i=0;i<n;i++) {
1823 stencil[i] = stencil[i] + offset;
1824 }
1825 }
1826
1827 }
1828
1829
1830 void
1831 _mesa_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
1832 {
1833 GLuint mask = ctx->Pixel.MapStoSsize - 1;
1834 GLuint i;
1835 for (i=0;i<n;i++) {
1836 stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
1837 }
1838 }
1839
1840
1841 void
1842 _mesa_scale_and_bias_depth(const GLcontext *ctx, GLuint n,
1843 GLfloat depthValues[])
1844 {
1845 const GLfloat scale = ctx->Pixel.DepthScale;
1846 const GLfloat bias = ctx->Pixel.DepthBias;
1847 GLuint i;
1848 for (i = 0; i < n; i++) {
1849 GLfloat d = depthValues[i] * scale + bias;
1850 depthValues[i] = CLAMP(d, 0.0F, 1.0F);
1851 }
1852 }
1853
1854
1855 /*
1856 * This function converts an array of GLchan colors to GLfloat colors.
1857 * Most importantly, it undoes the non-uniform quantization of pixel
1858 * values introduced when we convert shallow (< 8 bit) pixel values
1859 * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1860 * This fixes a number of OpenGL conformance failures when running on
1861 * 16bpp displays, for example.
1862 */
1863 void
1864 _mesa_chan_to_float_span(const GLcontext *ctx, GLuint n,
1865 CONST GLchan rgba[][4], GLfloat rgbaf[][4])
1866 {
1867 #if CHAN_TYPE == GL_FLOAT
1868 MEMCPY(rgbaf, rgba, n * 4 * sizeof(GLfloat));
1869 #else
1870 const GLuint rShift = CHAN_BITS - ctx->Visual.redBits;
1871 const GLuint gShift = CHAN_BITS - ctx->Visual.greenBits;
1872 const GLuint bShift = CHAN_BITS - ctx->Visual.blueBits;
1873 GLuint aShift;
1874 const GLfloat rScale = 1.0F / (GLfloat) ((1 << ctx->Visual.redBits ) - 1);
1875 const GLfloat gScale = 1.0F / (GLfloat) ((1 << ctx->Visual.greenBits) - 1);
1876 const GLfloat bScale = 1.0F / (GLfloat) ((1 << ctx->Visual.blueBits ) - 1);
1877 GLfloat aScale;
1878 GLuint i;
1879
1880 if (ctx->Visual.alphaBits > 0) {
1881 aShift = CHAN_BITS - ctx->Visual.alphaBits;
1882 aScale = 1.0F / (GLfloat) ((1 << ctx->Visual.alphaBits) - 1);
1883 }
1884 else {
1885 aShift = 0;
1886 aScale = 1.0F / CHAN_MAXF;
1887 }
1888
1889 for (i = 0; i < n; i++) {
1890 const GLint r = rgba[i][RCOMP] >> rShift;
1891 const GLint g = rgba[i][GCOMP] >> gShift;
1892 const GLint b = rgba[i][BCOMP] >> bShift;
1893 const GLint a = rgba[i][ACOMP] >> aShift;
1894 rgbaf[i][RCOMP] = (GLfloat) r * rScale;
1895 rgbaf[i][GCOMP] = (GLfloat) g * gScale;
1896 rgbaf[i][BCOMP] = (GLfloat) b * bScale;
1897 rgbaf[i][ACOMP] = (GLfloat) a * aScale;
1898 }
1899 #endif
1900 }
1901
1902 /**********************************************************************/
1903 /***** State Management *****/
1904 /**********************************************************************/
1905
1906 /*
1907 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
1908 * pixel transfer operations are enabled.
1909 */
1910 static void
1911 update_image_transfer_state(GLcontext *ctx)
1912 {
1913 GLuint mask = 0;
1914
1915 if (ctx->Pixel.RedScale != 1.0F || ctx->Pixel.RedBias != 0.0F ||
1916 ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||
1917 ctx->Pixel.BlueScale != 1.0F || ctx->Pixel.BlueBias != 0.0F ||
1918 ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)
1919 mask |= IMAGE_SCALE_BIAS_BIT;
1920
1921 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)
1922 mask |= IMAGE_SHIFT_OFFSET_BIT;
1923
1924 if (ctx->Pixel.MapColorFlag)
1925 mask |= IMAGE_MAP_COLOR_BIT;
1926
1927 if (ctx->Pixel.ColorTableEnabled)
1928 mask |= IMAGE_COLOR_TABLE_BIT;
1929
1930 if (ctx->Pixel.Convolution1DEnabled ||
1931 ctx->Pixel.Convolution2DEnabled ||
1932 ctx->Pixel.Separable2DEnabled) {
1933 mask |= IMAGE_CONVOLUTION_BIT;
1934 if (ctx->Pixel.PostConvolutionScale[0] != 1.0F ||
1935 ctx->Pixel.PostConvolutionScale[1] != 1.0F ||
1936 ctx->Pixel.PostConvolutionScale[2] != 1.0F ||
1937 ctx->Pixel.PostConvolutionScale[3] != 1.0F ||
1938 ctx->Pixel.PostConvolutionBias[0] != 0.0F ||
1939 ctx->Pixel.PostConvolutionBias[1] != 0.0F ||
1940 ctx->Pixel.PostConvolutionBias[2] != 0.0F ||
1941 ctx->Pixel.PostConvolutionBias[3] != 0.0F) {
1942 mask |= IMAGE_POST_CONVOLUTION_SCALE_BIAS;
1943 }
1944 }
1945
1946 if (ctx->Pixel.PostConvolutionColorTableEnabled)
1947 mask |= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT;
1948
1949 if (ctx->ColorMatrixStack.Top->type != MATRIX_IDENTITY ||
1950 ctx->Pixel.PostColorMatrixScale[0] != 1.0F ||
1951 ctx->Pixel.PostColorMatrixBias[0] != 0.0F ||
1952 ctx->Pixel.PostColorMatrixScale[1] != 1.0F ||
1953 ctx->Pixel.PostColorMatrixBias[1] != 0.0F ||
1954 ctx->Pixel.PostColorMatrixScale[2] != 1.0F ||
1955 ctx->Pixel.PostColorMatrixBias[2] != 0.0F ||
1956 ctx->Pixel.PostColorMatrixScale[3] != 1.0F ||
1957 ctx->Pixel.PostColorMatrixBias[3] != 0.0F)
1958 mask |= IMAGE_COLOR_MATRIX_BIT;
1959
1960 if (ctx->Pixel.PostColorMatrixColorTableEnabled)
1961 mask |= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT;
1962
1963 if (ctx->Pixel.HistogramEnabled)
1964 mask |= IMAGE_HISTOGRAM_BIT;
1965
1966 if (ctx->Pixel.MinMaxEnabled)
1967 mask |= IMAGE_MIN_MAX_BIT;
1968
1969 ctx->_ImageTransferState = mask;
1970 }
1971
1972
1973 void _mesa_update_pixel( GLcontext *ctx, GLuint new_state )
1974 {
1975 if (new_state & _NEW_COLOR_MATRIX)
1976 _math_matrix_analyse( ctx->ColorMatrixStack.Top );
1977
1978 /* References ColorMatrix.type (derived above).
1979 */
1980 if (new_state & _IMAGE_NEW_TRANSFER_STATE)
1981 update_image_transfer_state(ctx);
1982 }
1983
1984
1985 /**********************************************************************/
1986 /***** Initialization *****/
1987 /**********************************************************************/
1988
1989
1990 /**
1991 * Initialize the context's PIXEL attribute group.
1992 */
1993 void
1994 _mesa_init_pixel( GLcontext *ctx )
1995 {
1996 int i;
1997
1998 /* Pixel group */
1999 ctx->Pixel.RedBias = 0.0;
2000 ctx->Pixel.RedScale = 1.0;
2001 ctx->Pixel.GreenBias = 0.0;
2002 ctx->Pixel.GreenScale = 1.0;
2003 ctx->Pixel.BlueBias = 0.0;
2004 ctx->Pixel.BlueScale = 1.0;
2005 ctx->Pixel.AlphaBias = 0.0;
2006 ctx->Pixel.AlphaScale = 1.0;
2007 ctx->Pixel.DepthBias = 0.0;
2008 ctx->Pixel.DepthScale = 1.0;
2009 ctx->Pixel.IndexOffset = 0;
2010 ctx->Pixel.IndexShift = 0;
2011 ctx->Pixel.ZoomX = 1.0;
2012 ctx->Pixel.ZoomY = 1.0;
2013 ctx->Pixel.MapColorFlag = GL_FALSE;
2014 ctx->Pixel.MapStencilFlag = GL_FALSE;
2015 ctx->Pixel.MapStoSsize = 1;
2016 ctx->Pixel.MapItoIsize = 1;
2017 ctx->Pixel.MapItoRsize = 1;
2018 ctx->Pixel.MapItoGsize = 1;
2019 ctx->Pixel.MapItoBsize = 1;
2020 ctx->Pixel.MapItoAsize = 1;
2021 ctx->Pixel.MapRtoRsize = 1;
2022 ctx->Pixel.MapGtoGsize = 1;
2023 ctx->Pixel.MapBtoBsize = 1;
2024 ctx->Pixel.MapAtoAsize = 1;
2025 ctx->Pixel.MapStoS[0] = 0;
2026 ctx->Pixel.MapItoI[0] = 0.0;
2027 ctx->Pixel.MapItoR[0] = 0.0;
2028 ctx->Pixel.MapItoG[0] = 0.0;
2029 ctx->Pixel.MapItoB[0] = 0.0;
2030 ctx->Pixel.MapItoA[0] = 0.0;
2031 ctx->Pixel.MapItoR8[0] = 0;
2032 ctx->Pixel.MapItoG8[0] = 0;
2033 ctx->Pixel.MapItoB8[0] = 0;
2034 ctx->Pixel.MapItoA8[0] = 0;
2035 ctx->Pixel.MapRtoR[0] = 0.0;
2036 ctx->Pixel.MapGtoG[0] = 0.0;
2037 ctx->Pixel.MapBtoB[0] = 0.0;
2038 ctx->Pixel.MapAtoA[0] = 0.0;
2039 ctx->Pixel.HistogramEnabled = GL_FALSE;
2040 ctx->Pixel.MinMaxEnabled = GL_FALSE;
2041 ctx->Pixel.PixelTextureEnabled = GL_FALSE;
2042 ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
2043 ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
2044 ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
2045 ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
2046 ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
2047 ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
2048 ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
2049 ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
2050 ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
2051 ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
2052 ctx->Pixel.ColorTableEnabled = GL_FALSE;
2053 ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
2054 ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
2055 ctx->Pixel.Convolution1DEnabled = GL_FALSE;
2056 ctx->Pixel.Convolution2DEnabled = GL_FALSE;
2057 ctx->Pixel.Separable2DEnabled = GL_FALSE;
2058 for (i = 0; i < 3; i++) {
2059 ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
2060 ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
2061 ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
2062 ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
2063 }
2064 for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
2065 ctx->Convolution1D.Filter[i] = 0.0;
2066 ctx->Convolution2D.Filter[i] = 0.0;
2067 ctx->Separable2D.Filter[i] = 0.0;
2068 }
2069 ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
2070 ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
2071 /* GL_SGI_texture_color_table */
2072 ASSIGN_4V(ctx->Pixel.TextureColorTableScale, 1.0, 1.0, 1.0, 1.0);
2073 ASSIGN_4V(ctx->Pixel.TextureColorTableBias, 0.0, 0.0, 0.0, 0.0);
2074
2075 /* Pixel transfer */
2076 ctx->Pack.Alignment = 4;
2077 ctx->Pack.RowLength = 0;
2078 ctx->Pack.ImageHeight = 0;
2079 ctx->Pack.SkipPixels = 0;
2080 ctx->Pack.SkipRows = 0;
2081 ctx->Pack.SkipImages = 0;
2082 ctx->Pack.SwapBytes = GL_FALSE;
2083 ctx->Pack.LsbFirst = GL_FALSE;
2084 ctx->Pack.ClientStorage = GL_FALSE;
2085 ctx->Pack.Invert = GL_FALSE;
2086 #if FEATURE_EXT_pixel_buffer_object
2087 ctx->Pack.BufferObj = ctx->Array.NullBufferObj;
2088 #endif
2089 ctx->Unpack.Alignment = 4;
2090 ctx->Unpack.RowLength = 0;
2091 ctx->Unpack.ImageHeight = 0;
2092 ctx->Unpack.SkipPixels = 0;
2093 ctx->Unpack.SkipRows = 0;
2094 ctx->Unpack.SkipImages = 0;
2095 ctx->Unpack.SwapBytes = GL_FALSE;
2096 ctx->Unpack.LsbFirst = GL_FALSE;
2097 ctx->Unpack.ClientStorage = GL_FALSE;
2098 ctx->Unpack.Invert = GL_FALSE;
2099 #if FEATURE_EXT_pixel_buffer_object
2100 ctx->Unpack.BufferObj = ctx->Array.NullBufferObj;
2101 #endif
2102
2103 /*
2104 * _mesa_unpack_image() returns image data in this format. When we
2105 * execute image commands (glDrawPixels(), glTexImage(), etc) from
2106 * within display lists we have to be sure to set the current
2107 * unpacking parameters to these values!
2108 */
2109 ctx->DefaultPacking.Alignment = 1;
2110 ctx->DefaultPacking.RowLength = 0;
2111 ctx->DefaultPacking.SkipPixels = 0;
2112 ctx->DefaultPacking.SkipRows = 0;
2113 ctx->DefaultPacking.ImageHeight = 0;
2114 ctx->DefaultPacking.SkipImages = 0;
2115 ctx->DefaultPacking.SwapBytes = GL_FALSE;
2116 ctx->DefaultPacking.LsbFirst = GL_FALSE;
2117 ctx->DefaultPacking.ClientStorage = GL_FALSE;
2118 ctx->DefaultPacking.Invert = GL_FALSE;
2119 #if FEATURE_EXT_pixel_buffer_object
2120 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
2121 #endif
2122
2123 if (ctx->Visual.doubleBufferMode) {
2124 ctx->Pixel.ReadBuffer = GL_BACK;
2125 }
2126 else {
2127 ctx->Pixel.ReadBuffer = GL_FRONT;
2128 }
2129
2130 /* Miscellaneous */
2131 ctx->_ImageTransferState = 0;
2132 }