projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Silence gcc 3.4 warnings on ReactOS. Mostly unused var warnings. (patch 1015696)
[mesa.git] / src / mesa / main / pixel.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.1
4 *
5 * Copyright (C) 1999-2004 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 "imports.h"
27 #include "image.h"
28 #include "colormac.h"
29 #include "context.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 void GLAPIENTRY
258 _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
259 {
260 GLint i;
261 GET_CURRENT_CONTEXT(ctx);
262 ASSERT_OUTSIDE_BEGIN_END(ctx);
263
264 if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
265 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
266 return;
267 }
268
269 if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
270 /* test that mapsize is a power of two */
271 if (_mesa_bitcount((GLuint) mapsize) != 1) {
272 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
273 return;
274 }
275 }
276
277 FLUSH_VERTICES(ctx, _NEW_PIXEL);
278
279 switch (map) {
280 case GL_PIXEL_MAP_S_TO_S:
281 ctx->Pixel.MapStoSsize = mapsize;
282 for (i=0;i<mapsize;i++) {
283 ctx->Pixel.MapStoS[i] = (GLint) values[i];
284 }
285 break;
286 case GL_PIXEL_MAP_I_TO_I:
287 ctx->Pixel.MapItoIsize = mapsize;
288 for (i=0;i<mapsize;i++) {
289 ctx->Pixel.MapItoI[i] = (GLint) values[i];
290 }
291 break;
292 case GL_PIXEL_MAP_I_TO_R:
293 ctx->Pixel.MapItoRsize = mapsize;
294 for (i=0;i<mapsize;i++) {
295 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
296 ctx->Pixel.MapItoR[i] = val;
297 ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
298 }
299 break;
300 case GL_PIXEL_MAP_I_TO_G:
301 ctx->Pixel.MapItoGsize = mapsize;
302 for (i=0;i<mapsize;i++) {
303 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
304 ctx->Pixel.MapItoG[i] = val;
305 ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
306 }
307 break;
308 case GL_PIXEL_MAP_I_TO_B:
309 ctx->Pixel.MapItoBsize = mapsize;
310 for (i=0;i<mapsize;i++) {
311 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
312 ctx->Pixel.MapItoB[i] = val;
313 ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
314 }
315 break;
316 case GL_PIXEL_MAP_I_TO_A:
317 ctx->Pixel.MapItoAsize = mapsize;
318 for (i=0;i<mapsize;i++) {
319 GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
320 ctx->Pixel.MapItoA[i] = val;
321 ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
322 }
323 break;
324 case GL_PIXEL_MAP_R_TO_R:
325 ctx->Pixel.MapRtoRsize = mapsize;
326 for (i=0;i<mapsize;i++) {
327 ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0F, 1.0F );
328 }
329 break;
330 case GL_PIXEL_MAP_G_TO_G:
331 ctx->Pixel.MapGtoGsize = mapsize;
332 for (i=0;i<mapsize;i++) {
333 ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0F, 1.0F );
334 }
335 break;
336 case GL_PIXEL_MAP_B_TO_B:
337 ctx->Pixel.MapBtoBsize = mapsize;
338 for (i=0;i<mapsize;i++) {
339 ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0F, 1.0F );
340 }
341 break;
342 case GL_PIXEL_MAP_A_TO_A:
343 ctx->Pixel.MapAtoAsize = mapsize;
344 for (i=0;i<mapsize;i++) {
345 ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0F, 1.0F );
346 }
347 break;
348 default:
349 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
350 }
351 }
352
353
354
355 void GLAPIENTRY
356 _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )
357 {
358 const GLint n = MIN2(mapsize, MAX_PIXEL_MAP_TABLE);
359 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
360 GLint i;
361 if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
362 for (i=0;i<n;i++) {
363 fvalues[i] = (GLfloat) values[i];
364 }
365 }
366 else {
367 for (i=0;i<n;i++) {
368 fvalues[i] = UINT_TO_FLOAT( values[i] );
369 }
370 }
371 _mesa_PixelMapfv(map, mapsize, fvalues);
372 }
373
374
375
376 void GLAPIENTRY
377 _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
378 {
379 const GLint n = MIN2(mapsize, MAX_PIXEL_MAP_TABLE);
380 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
381 GLint i;
382 if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
383 for (i=0;i<n;i++) {
384 fvalues[i] = (GLfloat) values[i];
385 }
386 }
387 else {
388 for (i=0;i<n;i++) {
389 fvalues[i] = USHORT_TO_FLOAT( values[i] );
390 }
391 }
392 _mesa_PixelMapfv(map, mapsize, fvalues);
393 }
394
395
396
397 void GLAPIENTRY
398 _mesa_GetPixelMapfv( GLenum map, GLfloat *values )
399 {
400 GET_CURRENT_CONTEXT(ctx);
401 GLint i;
402 ASSERT_OUTSIDE_BEGIN_END(ctx);
403
404 switch (map) {
405 case GL_PIXEL_MAP_I_TO_I:
406 for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
407 values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
408 }
409 break;
410 case GL_PIXEL_MAP_S_TO_S:
411 for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
412 values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
413 }
414 break;
415 case GL_PIXEL_MAP_I_TO_R:
416 MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
417 break;
418 case GL_PIXEL_MAP_I_TO_G:
419 MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
420 break;
421 case GL_PIXEL_MAP_I_TO_B:
422 MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
423 break;
424 case GL_PIXEL_MAP_I_TO_A:
425 MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
426 break;
427 case GL_PIXEL_MAP_R_TO_R:
428 MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
429 break;
430 case GL_PIXEL_MAP_G_TO_G:
431 MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
432 break;
433 case GL_PIXEL_MAP_B_TO_B:
434 MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
435 break;
436 case GL_PIXEL_MAP_A_TO_A:
437 MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
438 break;
439 default:
440 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
441 }
442 }
443
444
445 void GLAPIENTRY
446 _mesa_GetPixelMapuiv( GLenum map, GLuint *values )
447 {
448 GET_CURRENT_CONTEXT(ctx);
449 GLint i;
450 ASSERT_OUTSIDE_BEGIN_END(ctx);
451
452 switch (map) {
453 case GL_PIXEL_MAP_I_TO_I:
454 MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
455 break;
456 case GL_PIXEL_MAP_S_TO_S:
457 MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
458 break;
459 case GL_PIXEL_MAP_I_TO_R:
460 for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
461 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
462 }
463 break;
464 case GL_PIXEL_MAP_I_TO_G:
465 for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
466 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
467 }
468 break;
469 case GL_PIXEL_MAP_I_TO_B:
470 for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
471 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
472 }
473 break;
474 case GL_PIXEL_MAP_I_TO_A:
475 for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
476 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
477 }
478 break;
479 case GL_PIXEL_MAP_R_TO_R:
480 for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
481 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
482 }
483 break;
484 case GL_PIXEL_MAP_G_TO_G:
485 for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
486 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
487 }
488 break;
489 case GL_PIXEL_MAP_B_TO_B:
490 for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
491 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
492 }
493 break;
494 case GL_PIXEL_MAP_A_TO_A:
495 for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
496 values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
497 }
498 break;
499 default:
500 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
501 }
502 }
503
504
505 void GLAPIENTRY
506 _mesa_GetPixelMapusv( GLenum map, GLushort *values )
507 {
508 GET_CURRENT_CONTEXT(ctx);
509 GLint i;
510 ASSERT_OUTSIDE_BEGIN_END(ctx);
511
512 switch (map) {
513 case GL_PIXEL_MAP_I_TO_I:
514 for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
515 values[i] = (GLushort) ctx->Pixel.MapItoI[i];
516 }
517 break;
518 case GL_PIXEL_MAP_S_TO_S:
519 for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
520 values[i] = (GLushort) ctx->Pixel.MapStoS[i];
521 }
522 break;
523 case GL_PIXEL_MAP_I_TO_R:
524 for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
525 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
526 }
527 break;
528 case GL_PIXEL_MAP_I_TO_G:
529 for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
530 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
531 }
532 break;
533 case GL_PIXEL_MAP_I_TO_B:
534 for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
535 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
536 }
537 break;
538 case GL_PIXEL_MAP_I_TO_A:
539 for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
540 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
541 }
542 break;
543 case GL_PIXEL_MAP_R_TO_R:
544 for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
545 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
546 }
547 break;
548 case GL_PIXEL_MAP_G_TO_G:
549 for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
550 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
551 }
552 break;
553 case GL_PIXEL_MAP_B_TO_B:
554 for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
555 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
556 }
557 break;
558 case GL_PIXEL_MAP_A_TO_A:
559 for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
560 values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
561 }
562 break;
563 default:
564 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
565 }
566 }
567
568
569
570 /**********************************************************************/
571 /***** glPixelTransfer *****/
572 /**********************************************************************/
573
574
575 /*
576 * Implements glPixelTransfer[fi] whether called immediately or from a
577 * display list.
578 */
579 void GLAPIENTRY
580 _mesa_PixelTransferf( GLenum pname, GLfloat param )
581 {
582 GET_CURRENT_CONTEXT(ctx);
583 ASSERT_OUTSIDE_BEGIN_END(ctx);
584
585 switch (pname) {
586 case GL_MAP_COLOR:
587 if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))
588 return;
589 FLUSH_VERTICES(ctx, _NEW_PIXEL);
590 ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
591 break;
592 case GL_MAP_STENCIL:
593 if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))
594 return;
595 FLUSH_VERTICES(ctx, _NEW_PIXEL);
596 ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
597 break;
598 case GL_INDEX_SHIFT:
599 if (ctx->Pixel.IndexShift == (GLint) param)
600 return;
601 FLUSH_VERTICES(ctx, _NEW_PIXEL);
602 ctx->Pixel.IndexShift = (GLint) param;
603 break;
604 case GL_INDEX_OFFSET:
605 if (ctx->Pixel.IndexOffset == (GLint) param)
606 return;
607 FLUSH_VERTICES(ctx, _NEW_PIXEL);
608 ctx->Pixel.IndexOffset = (GLint) param;
609 break;
610 case GL_RED_SCALE:
611 if (ctx->Pixel.RedScale == param)
612 return;
613 FLUSH_VERTICES(ctx, _NEW_PIXEL);
614 ctx->Pixel.RedScale = param;
615 break;
616 case GL_RED_BIAS:
617 if (ctx->Pixel.RedBias == param)
618 return;
619 FLUSH_VERTICES(ctx, _NEW_PIXEL);
620 ctx->Pixel.RedBias = param;
621 break;
622 case GL_GREEN_SCALE:
623 if (ctx->Pixel.GreenScale == param)
624 return;
625 FLUSH_VERTICES(ctx, _NEW_PIXEL);
626 ctx->Pixel.GreenScale = param;
627 break;
628 case GL_GREEN_BIAS:
629 if (ctx->Pixel.GreenBias == param)
630 return;
631 FLUSH_VERTICES(ctx, _NEW_PIXEL);
632 ctx->Pixel.GreenBias = param;
633 break;
634 case GL_BLUE_SCALE:
635 if (ctx->Pixel.BlueScale == param)
636 return;
637 FLUSH_VERTICES(ctx, _NEW_PIXEL);
638 ctx->Pixel.BlueScale = param;
639 break;
640 case GL_BLUE_BIAS:
641 if (ctx->Pixel.BlueBias == param)
642 return;
643 FLUSH_VERTICES(ctx, _NEW_PIXEL);
644 ctx->Pixel.BlueBias = param;
645 break;
646 case GL_ALPHA_SCALE:
647 if (ctx->Pixel.AlphaScale == param)
648 return;
649 FLUSH_VERTICES(ctx, _NEW_PIXEL);
650 ctx->Pixel.AlphaScale = param;
651 break;
652 case GL_ALPHA_BIAS:
653 if (ctx->Pixel.AlphaBias == param)
654 return;
655 FLUSH_VERTICES(ctx, _NEW_PIXEL);
656 ctx->Pixel.AlphaBias = param;
657 break;
658 case GL_DEPTH_SCALE:
659 if (ctx->Pixel.DepthScale == param)
660 return;
661 FLUSH_VERTICES(ctx, _NEW_PIXEL);
662 ctx->Pixel.DepthScale = param;
663 break;
664 case GL_DEPTH_BIAS:
665 if (ctx->Pixel.DepthBias == param)
666 return;
667 FLUSH_VERTICES(ctx, _NEW_PIXEL);
668 ctx->Pixel.DepthBias = param;
669 break;
670 case GL_POST_COLOR_MATRIX_RED_SCALE:
671 if (ctx->Pixel.PostColorMatrixScale[0] == param)
672 return;
673 FLUSH_VERTICES(ctx, _NEW_PIXEL);
674 ctx->Pixel.PostColorMatrixScale[0] = param;
675 break;
676 case GL_POST_COLOR_MATRIX_RED_BIAS:
677 if (ctx->Pixel.PostColorMatrixBias[0] == param)
678 return;
679 FLUSH_VERTICES(ctx, _NEW_PIXEL);
680 ctx->Pixel.PostColorMatrixBias[0] = param;
681 break;
682 case GL_POST_COLOR_MATRIX_GREEN_SCALE:
683 if (ctx->Pixel.PostColorMatrixScale[1] == param)
684 return;
685 FLUSH_VERTICES(ctx, _NEW_PIXEL);
686 ctx->Pixel.PostColorMatrixScale[1] = param;
687 break;
688 case GL_POST_COLOR_MATRIX_GREEN_BIAS:
689 if (ctx->Pixel.PostColorMatrixBias[1] == param)
690 return;
691 FLUSH_VERTICES(ctx, _NEW_PIXEL);
692 ctx->Pixel.PostColorMatrixBias[1] = param;
693 break;
694 case GL_POST_COLOR_MATRIX_BLUE_SCALE:
695 if (ctx->Pixel.PostColorMatrixScale[2] == param)
696 return;
697 FLUSH_VERTICES(ctx, _NEW_PIXEL);
698 ctx->Pixel.PostColorMatrixScale[2] = param;
699 break;
700 case GL_POST_COLOR_MATRIX_BLUE_BIAS:
701 if (ctx->Pixel.PostColorMatrixBias[2] == param)
702 return;
703 FLUSH_VERTICES(ctx, _NEW_PIXEL);
704 ctx->Pixel.PostColorMatrixBias[2] = param;
705 break;
706 case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
707 if (ctx->Pixel.PostColorMatrixScale[3] == param)
708 return;
709 FLUSH_VERTICES(ctx, _NEW_PIXEL);
710 ctx->Pixel.PostColorMatrixScale[3] = param;
711 break;
712 case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
713 if (ctx->Pixel.PostColorMatrixBias[3] == param)
714 return;
715 FLUSH_VERTICES(ctx, _NEW_PIXEL);
716 ctx->Pixel.PostColorMatrixBias[3] = param;
717 break;
718 case GL_POST_CONVOLUTION_RED_SCALE:
719 if (ctx->Pixel.PostConvolutionScale[0] == param)
720 return;
721 FLUSH_VERTICES(ctx, _NEW_PIXEL);
722 ctx->Pixel.PostConvolutionScale[0] = param;
723 break;
724 case GL_POST_CONVOLUTION_RED_BIAS:
725 if (ctx->Pixel.PostConvolutionBias[0] == param)
726 return;
727 FLUSH_VERTICES(ctx, _NEW_PIXEL);
728 ctx->Pixel.PostConvolutionBias[0] = param;
729 break;
730 case GL_POST_CONVOLUTION_GREEN_SCALE:
731 if (ctx->Pixel.PostConvolutionScale[1] == param)
732 return;
733 FLUSH_VERTICES(ctx, _NEW_PIXEL);
734 ctx->Pixel.PostConvolutionScale[1] = param;
735 break;
736 case GL_POST_CONVOLUTION_GREEN_BIAS:
737 if (ctx->Pixel.PostConvolutionBias[1] == param)
738 return;
739 FLUSH_VERTICES(ctx, _NEW_PIXEL);
740 ctx->Pixel.PostConvolutionBias[1] = param;
741 break;
742 case GL_POST_CONVOLUTION_BLUE_SCALE:
743 if (ctx->Pixel.PostConvolutionScale[2] == param)
744 return;
745 FLUSH_VERTICES(ctx, _NEW_PIXEL);
746 ctx->Pixel.PostConvolutionScale[2] = param;
747 break;
748 case GL_POST_CONVOLUTION_BLUE_BIAS:
749 if (ctx->Pixel.PostConvolutionBias[2] == param)
750 return;
751 FLUSH_VERTICES(ctx, _NEW_PIXEL);
752 ctx->Pixel.PostConvolutionBias[2] = param;
753 break;
754 case GL_POST_CONVOLUTION_ALPHA_SCALE:
755 if (ctx->Pixel.PostConvolutionScale[2] == param)
756 return;
757 FLUSH_VERTICES(ctx, _NEW_PIXEL);
758 ctx->Pixel.PostConvolutionScale[2] = param;
759 break;
760 case GL_POST_CONVOLUTION_ALPHA_BIAS:
761 if (ctx->Pixel.PostConvolutionBias[2] == param)
762 return;
763 FLUSH_VERTICES(ctx, _NEW_PIXEL);
764 ctx->Pixel.PostConvolutionBias[2] = param;
765 break;
766 default:
767 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
768 return;
769 }
770 }
771
772
773 void GLAPIENTRY
774 _mesa_PixelTransferi( GLenum pname, GLint param )
775 {
776 _mesa_PixelTransferf( pname, (GLfloat) param );
777 }
778
779 /**********************************************************************/
780 /***** Pixel processing functions ******/
781 /**********************************************************************/
782
783
784 /*
785 * Apply scale and bias factors to an array of RGBA pixels.
786 */
787 void
788 _mesa_scale_and_bias_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4],
789 GLfloat rScale, GLfloat gScale,
790 GLfloat bScale, GLfloat aScale,
791 GLfloat rBias, GLfloat gBias,
792 GLfloat bBias, GLfloat aBias)
793 {
794 (void) ctx;
795
796 if (rScale != 1.0 || rBias != 0.0) {
797 GLuint i;
798 for (i = 0; i < n; i++) {
799 rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
800 }
801 }
802 if (gScale != 1.0 || gBias != 0.0) {
803 GLuint i;
804 for (i = 0; i < n; i++) {
805 rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
806 }
807 }
808 if (bScale != 1.0 || bBias != 0.0) {
809 GLuint i;
810 for (i = 0; i < n; i++) {
811 rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
812 }
813 }
814 if (aScale != 1.0 || aBias != 0.0) {
815 GLuint i;
816 for (i = 0; i < n; i++) {
817 rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
818 }
819 }
820 }
821
822
823 /*
824 * Apply pixel mapping to an array of floating point RGBA pixels.
825 */
826 void
827 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
828 {
829 const GLfloat rscale = (GLfloat) (ctx->Pixel.MapRtoRsize - 1);
830 const GLfloat gscale = (GLfloat) (ctx->Pixel.MapGtoGsize - 1);
831 const GLfloat bscale = (GLfloat) (ctx->Pixel.MapBtoBsize - 1);
832 const GLfloat ascale = (GLfloat) (ctx->Pixel.MapAtoAsize - 1);
833 const GLfloat *rMap = ctx->Pixel.MapRtoR;
834 const GLfloat *gMap = ctx->Pixel.MapGtoG;
835 const GLfloat *bMap = ctx->Pixel.MapBtoB;
836 const GLfloat *aMap = ctx->Pixel.MapAtoA;
837 GLuint i;
838 for (i=0;i<n;i++) {
839 GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
840 GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
841 GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
842 GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
843 rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
844 rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
845 rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
846 rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
847 }
848 }
849
850
851 /*
852 * Apply the color matrix and post color matrix scaling and biasing.
853 */
854 void
855 _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
856 {
857 const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0];
858 const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0];
859 const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1];
860 const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1];
861 const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2];
862 const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2];
863 const GLfloat as = ctx->Pixel.PostColorMatrixScale[3];
864 const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3];
865 const GLfloat *m = ctx->ColorMatrixStack.Top->m;
866 GLuint i;
867 for (i = 0; i < n; i++) {
868 const GLfloat r = rgba[i][RCOMP];
869 const GLfloat g = rgba[i][GCOMP];
870 const GLfloat b = rgba[i][BCOMP];
871 const GLfloat a = rgba[i][ACOMP];
872 rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb;
873 rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb;
874 rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb;
875 rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab;
876 }
877 }
878
879
880 /**
881 * Apply a color table lookup to an array of floating point RGBA colors.
882 */
883 void
884 _mesa_lookup_rgba_float(const struct gl_color_table *table,
885 GLuint n, GLfloat rgba[][4])
886 {
887 if (!table->Table || table->Size == 0)
888 return;
889
890 switch (table->Format) {
891 case GL_INTENSITY:
892 /* replace RGBA with I */
893 if (table->Type == GL_FLOAT) {
894 const GLint max = table->Size - 1;
895 const GLfloat scale = (GLfloat) max;
896 const GLfloat *lut = (const GLfloat *) table->Table;
897 GLuint i;
898 for (i = 0; i < n; i++) {
899 GLint j = IROUND(rgba[i][RCOMP] * scale);
900 GLfloat c = lut[CLAMP(j, 0, max)];
901 rgba[i][RCOMP] = rgba[i][GCOMP] =
902 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
903 }
904 }
905 else {
906 const GLint max = table->Size - 1;
907 const GLfloat scale = (GLfloat) max;
908 const GLchan *lut = (const GLchan *) table->Table;
909 GLuint i;
910 for (i = 0; i < n; i++) {
911 GLint j = IROUND(rgba[i][RCOMP] * scale);
912 GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
913 rgba[i][RCOMP] = rgba[i][GCOMP] =
914 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
915 }
916 }
917 break;
918 case GL_LUMINANCE:
919 /* replace RGB with L */
920 if (table->Type == GL_FLOAT) {
921 const GLint max = table->Size - 1;
922 const GLfloat scale = (GLfloat) max;
923 const GLfloat *lut = (const GLfloat *) table->Table;
924 GLuint i;
925 for (i = 0; i < n; i++) {
926 GLint j = IROUND(rgba[i][RCOMP] * scale);
927 GLfloat c = lut[CLAMP(j, 0, max)];
928 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
929 }
930 }
931 else {
932 const GLint max = table->Size - 1;
933 const GLfloat scale = (GLfloat) max;
934 const GLchan *lut = (const GLchan *) table->Table;
935 GLuint i;
936 for (i = 0; i < n; i++) {
937 GLint j = IROUND(rgba[i][RCOMP] * scale);
938 GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
939 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
940 }
941 }
942 break;
943 case GL_ALPHA:
944 /* replace A with A */
945 if (table->Type == GL_FLOAT) {
946 const GLint max = table->Size - 1;
947 const GLfloat scale = (GLfloat) max;
948 const GLfloat *lut = (const GLfloat *) table->Table;
949 GLuint i;
950 for (i = 0; i < n; i++) {
951 GLint j = IROUND(rgba[i][ACOMP] * scale);
952 rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
953 }
954 }
955 else {
956 const GLint max = table->Size - 1;
957 const GLfloat scale = (GLfloat) max;
958 const GLchan *lut = (const GLchan *) table->Table;
959 GLuint i;
960 for (i = 0; i < n; i++) {
961 GLint j = IROUND(rgba[i][ACOMP] * scale);
962 rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
963 }
964 }
965 break;
966 case GL_LUMINANCE_ALPHA:
967 /* replace RGBA with LLLA */
968 if (table->Type == GL_FLOAT) {
969 const GLint max = table->Size - 1;
970 const GLfloat scale = (GLfloat) max;
971 const GLfloat *lut = (const GLfloat *) table->Table;
972 GLuint i;
973 for (i = 0; i < n; i++) {
974 GLint jL = IROUND(rgba[i][RCOMP] * scale);
975 GLint jA = IROUND(rgba[i][ACOMP] * scale);
976 GLfloat luminance, alpha;
977 jL = CLAMP(jL, 0, max);
978 jA = CLAMP(jA, 0, max);
979 luminance = lut[jL * 2 + 0];
980 alpha = lut[jA * 2 + 1];
981 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
982 rgba[i][ACOMP] = alpha;;
983 }
984 }
985 else {
986 const GLint max = table->Size - 1;
987 const GLfloat scale = (GLfloat) max;
988 const GLchan *lut = (const GLchan *) table->Table;
989 GLuint i;
990 for (i = 0; i < n; i++) {
991 GLint jL = IROUND(rgba[i][RCOMP] * scale);
992 GLint jA = IROUND(rgba[i][ACOMP] * scale);
993 GLfloat luminance, alpha;
994 jL = CLAMP(jL, 0, max);
995 jA = CLAMP(jA, 0, max);
996 luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
997 alpha = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
998 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
999 rgba[i][ACOMP] = alpha;;
1000 }
1001 }
1002 break;
1003 case GL_RGB:
1004 /* replace RGB with RGB */
1005 if (table->Type == GL_FLOAT) {
1006 const GLint max = table->Size - 1;
1007 const GLfloat scale = (GLfloat) max;
1008 const GLfloat *lut = (const GLfloat *) table->Table;
1009 GLuint i;
1010 for (i = 0; i < n; i++) {
1011 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1012 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1013 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1014 jR = CLAMP(jR, 0, max);
1015 jG = CLAMP(jG, 0, max);
1016 jB = CLAMP(jB, 0, max);
1017 rgba[i][RCOMP] = lut[jR * 3 + 0];
1018 rgba[i][GCOMP] = lut[jG * 3 + 1];
1019 rgba[i][BCOMP] = lut[jB * 3 + 2];
1020 }
1021 }
1022 else {
1023 const GLint max = table->Size - 1;
1024 const GLfloat scale = (GLfloat) max;
1025 const GLchan *lut = (const GLchan *) table->Table;
1026 GLuint i;
1027 for (i = 0; i < n; i++) {
1028 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1029 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1030 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1031 jR = CLAMP(jR, 0, max);
1032 jG = CLAMP(jG, 0, max);
1033 jB = CLAMP(jB, 0, max);
1034 rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
1035 rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
1036 rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
1037 }
1038 }
1039 break;
1040 case GL_RGBA:
1041 /* replace RGBA with RGBA */
1042 if (table->Type == GL_FLOAT) {
1043 const GLint max = table->Size - 1;
1044 const GLfloat scale = (GLfloat) max;
1045 const GLfloat *lut = (const GLfloat *) table->Table;
1046 GLuint i;
1047 for (i = 0; i < n; i++) {
1048 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1049 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1050 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1051 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1052 jR = CLAMP(jR, 0, max);
1053 jG = CLAMP(jG, 0, max);
1054 jB = CLAMP(jB, 0, max);
1055 jA = CLAMP(jA, 0, max);
1056 rgba[i][RCOMP] = lut[jR * 4 + 0];
1057 rgba[i][GCOMP] = lut[jG * 4 + 1];
1058 rgba[i][BCOMP] = lut[jB * 4 + 2];
1059 rgba[i][ACOMP] = lut[jA * 4 + 3];
1060 }
1061 }
1062 else {
1063 const GLint max = table->Size - 1;
1064 const GLfloat scale = (GLfloat) max;
1065 const GLchan *lut = (const GLchan *) table->Table;
1066 GLuint i;
1067 for (i = 0; i < n; i++) {
1068 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1069 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1070 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1071 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1072 jR = CLAMP(jR, 0, max);
1073 jG = CLAMP(jG, 0, max);
1074 jB = CLAMP(jB, 0, max);
1075 jA = CLAMP(jA, 0, max);
1076 rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
1077 rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
1078 rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
1079 rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
1080 }
1081 }
1082 break;
1083 default:
1084 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
1085 return;
1086 }
1087 }
1088
1089
1090
1091 /**
1092 * Apply a color table lookup to an array of GLchan RGBA colors.
1093 */
1094 void
1095 _mesa_lookup_rgba_chan(const struct gl_color_table *table,
1096 GLuint n, GLchan rgba[][4])
1097 {
1098 if (!table->Table || table->Size == 0)
1099 return;
1100
1101 switch (table->Format) {
1102 case GL_INTENSITY:
1103 /* replace RGBA with I */
1104 if (table->Type == GL_FLOAT) {
1105 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1106 const GLfloat *lut = (const GLfloat *) table->Table;
1107 GLuint i;
1108 for (i = 0; i < n; i++) {
1109 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1110 GLchan c;
1111 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1112 rgba[i][RCOMP] = rgba[i][GCOMP] =
1113 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1114 }
1115 }
1116 else {
1117 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1118 if (table->Size == 256) {
1119 /* common case */
1120 const GLchan *lut = (const GLchan *) table->Table;
1121 GLuint i;
1122 for (i = 0; i < n; i++) {
1123 const GLchan c = lut[rgba[i][RCOMP]];
1124 rgba[i][RCOMP] = rgba[i][GCOMP] =
1125 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1126 }
1127 }
1128 else
1129 #endif
1130 {
1131 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1132 const GLchan *lut = (const GLchan *) table->Table;
1133 GLuint i;
1134 for (i = 0; i < n; i++) {
1135 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1136 rgba[i][RCOMP] = rgba[i][GCOMP] =
1137 rgba[i][BCOMP] = rgba[i][ACOMP] = lut[j];
1138 }
1139 }
1140 }
1141 break;
1142 case GL_LUMINANCE:
1143 /* replace RGB with L */
1144 if (table->Type == GL_FLOAT) {
1145 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1146 const GLfloat *lut = (const GLfloat *) table->Table;
1147 GLuint i;
1148 for (i = 0; i < n; i++) {
1149 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1150 GLchan c;
1151 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1152 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1153 }
1154 }
1155 else {
1156 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1157 if (table->Size == 256) {
1158 /* common case */
1159 const GLchan *lut = (const GLchan *) table->Table;
1160 GLuint i;
1161 for (i = 0; i < n; i++) {
1162 const GLchan c = lut[rgba[i][RCOMP]];
1163 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1164 }
1165 }
1166 else
1167 #endif
1168 {
1169 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1170 const GLchan *lut = (const GLchan *) table->Table;
1171 GLuint i;
1172 for (i = 0; i < n; i++) {
1173 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1174 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = lut[j];
1175 }
1176 }
1177 }
1178 break;
1179 case GL_ALPHA:
1180 /* replace A with A */
1181 if (table->Type == GL_FLOAT) {
1182 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1183 const GLfloat *lut = (const GLfloat *) table->Table;
1184 GLuint i;
1185 for (i = 0; i < n; i++) {
1186 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1187 GLchan c;
1188 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1189 rgba[i][ACOMP] = c;
1190 }
1191 }
1192 else {
1193 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1194 if (table->Size == 256) {
1195 /* common case */
1196 const GLchan *lut = (const GLchan *) table->Table;
1197 GLuint i;
1198 for (i = 0; i < n; i++) {
1199 rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
1200 }
1201 }
1202 else
1203 #endif
1204 {
1205 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1206 const GLchan *lut = (const GLchan *) table->Table;
1207 GLuint i;
1208 for (i = 0; i < n; i++) {
1209 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1210 rgba[i][ACOMP] = lut[j];
1211 }
1212 }
1213 }
1214 break;
1215 case GL_LUMINANCE_ALPHA:
1216 /* replace RGBA with LLLA */
1217 if (table->Type == GL_FLOAT) {
1218 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1219 const GLfloat *lut = (const GLfloat *) table->Table;
1220 GLuint i;
1221 for (i = 0; i < n; i++) {
1222 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1223 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1224 GLchan luminance, alpha;
1225 CLAMPED_FLOAT_TO_CHAN(luminance, lut[jL * 2 + 0]);
1226 CLAMPED_FLOAT_TO_CHAN(alpha, lut[jA * 2 + 1]);
1227 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1228 rgba[i][ACOMP] = alpha;;
1229 }
1230 }
1231 else {
1232 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1233 if (table->Size == 256) {
1234 /* common case */
1235 const GLchan *lut = (const GLchan *) table->Table;
1236 GLuint i;
1237 for (i = 0; i < n; i++) {
1238 GLchan l = lut[rgba[i][RCOMP] * 2 + 0];
1239 GLchan a = lut[rgba[i][ACOMP] * 2 + 1];;
1240 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = l;
1241 rgba[i][ACOMP] = a;
1242 }
1243 }
1244 else
1245 #endif
1246 {
1247 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1248 const GLchan *lut = (const GLchan *) table->Table;
1249 GLuint i;
1250 for (i = 0; i < n; i++) {
1251 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1252 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1253 GLchan luminance = lut[jL * 2 + 0];
1254 GLchan alpha = lut[jA * 2 + 1];
1255 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1256 rgba[i][ACOMP] = alpha;
1257 }
1258 }
1259 }
1260 break;
1261 case GL_RGB:
1262 /* replace RGB with RGB */
1263 if (table->Type == GL_FLOAT) {
1264 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1265 const GLfloat *lut = (const GLfloat *) table->Table;
1266 GLuint i;
1267 for (i = 0; i < n; i++) {
1268 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1269 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1270 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1271 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 3 + 0]);
1272 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 3 + 1]);
1273 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 3 + 2]);
1274 }
1275 }
1276 else {
1277 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1278 if (table->Size == 256) {
1279 /* common case */
1280 const GLchan *lut = (const GLchan *) table->Table;
1281 GLuint i;
1282 for (i = 0; i < n; i++) {
1283 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
1284 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
1285 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
1286 }
1287 }
1288 else
1289 #endif
1290 {
1291 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1292 const GLchan *lut = (const GLchan *) table->Table;
1293 GLuint i;
1294 for (i = 0; i < n; i++) {
1295 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1296 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1297 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1298 rgba[i][RCOMP] = lut[jR * 3 + 0];
1299 rgba[i][GCOMP] = lut[jG * 3 + 1];
1300 rgba[i][BCOMP] = lut[jB * 3 + 2];
1301 }
1302 }
1303 }
1304 break;
1305 case GL_RGBA:
1306 /* replace RGBA with RGBA */
1307 if (table->Type == GL_FLOAT) {
1308 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1309 const GLfloat *lut = (const GLfloat *) table->Table;
1310 GLuint i;
1311 for (i = 0; i < n; i++) {
1312 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1313 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1314 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1315 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1316 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1317 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1318 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1319 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1320 }
1321 }
1322 else {
1323 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1324 if (table->Size == 256) {
1325 /* common case */
1326 const GLchan *lut = (const GLchan *) table->Table;
1327 GLuint i;
1328 for (i = 0; i < n; i++) {
1329 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
1330 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
1331 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
1332 rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
1333 }
1334 }
1335 else
1336 #endif
1337 {
1338 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1339 const GLfloat *lut = (const GLfloat *) table->Table;
1340 GLuint i;
1341 for (i = 0; i < n; i++) {
1342 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1343 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1344 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1345 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1346 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1347 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1348 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1349 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1350 }
1351 }
1352 }
1353 break;
1354 default:
1355 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
1356 return;
1357 }
1358 }
1359
1360
1361
1362 /*
1363 * Apply color index shift and offset to an array of pixels.
1364 */
1365 void
1366 _mesa_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1367 {
1368 GLint shift = ctx->Pixel.IndexShift;
1369 GLint offset = ctx->Pixel.IndexOffset;
1370 GLuint i;
1371 if (shift > 0) {
1372 for (i=0;i<n;i++) {
1373 indexes[i] = (indexes[i] << shift) + offset;
1374 }
1375 }
1376 else if (shift < 0) {
1377 shift = -shift;
1378 for (i=0;i<n;i++) {
1379 indexes[i] = (indexes[i] >> shift) + offset;
1380 }
1381 }
1382 else {
1383 for (i=0;i<n;i++) {
1384 indexes[i] = indexes[i] + offset;
1385 }
1386 }
1387 }
1388
1389
1390 /*
1391 * Apply color index mapping to color indexes.
1392 */
1393 void
1394 _mesa_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
1395 {
1396 GLuint mask = ctx->Pixel.MapItoIsize - 1;
1397 GLuint i;
1398 for (i=0;i<n;i++) {
1399 index[i] = ctx->Pixel.MapItoI[ index[i] & mask ];
1400 }
1401 }
1402
1403
1404 /*
1405 * Map color indexes to rgba values.
1406 */
1407 void
1408 _mesa_map_ci_to_rgba_chan( const GLcontext *ctx, GLuint n,
1409 const GLuint index[], GLchan rgba[][4] )
1410 {
1411 #if CHAN_BITS == 8
1412 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1413 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1414 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1415 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1416 const GLubyte *rMap = ctx->Pixel.MapItoR8;
1417 const GLubyte *gMap = ctx->Pixel.MapItoG8;
1418 const GLubyte *bMap = ctx->Pixel.MapItoB8;
1419 const GLubyte *aMap = ctx->Pixel.MapItoA8;
1420 GLuint i;
1421 for (i=0;i<n;i++) {
1422 rgba[i][RCOMP] = rMap[index[i] & rmask];
1423 rgba[i][GCOMP] = gMap[index[i] & gmask];
1424 rgba[i][BCOMP] = bMap[index[i] & bmask];
1425 rgba[i][ACOMP] = aMap[index[i] & amask];
1426 }
1427 #else
1428 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1429 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1430 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1431 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1432 const GLfloat *rMap = ctx->Pixel.MapItoR;
1433 const GLfloat *gMap = ctx->Pixel.MapItoG;
1434 const GLfloat *bMap = ctx->Pixel.MapItoB;
1435 const GLfloat *aMap = ctx->Pixel.MapItoA;
1436 GLuint i;
1437 for (i=0;i<n;i++) {
1438 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1439 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1440 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1441 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1442 }
1443 #endif
1444 }
1445
1446
1447 /*
1448 * Map color indexes to float rgba values.
1449 */
1450 void
1451 _mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n,
1452 const GLuint index[], GLfloat rgba[][4] )
1453 {
1454 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1455 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1456 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1457 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1458 const GLfloat *rMap = ctx->Pixel.MapItoR;
1459 const GLfloat *gMap = ctx->Pixel.MapItoG;
1460 const GLfloat *bMap = ctx->Pixel.MapItoB;
1461 const GLfloat *aMap = ctx->Pixel.MapItoA;
1462 GLuint i;
1463 for (i=0;i<n;i++) {
1464 rgba[i][RCOMP] = rMap[index[i] & rmask];
1465 rgba[i][GCOMP] = gMap[index[i] & gmask];
1466 rgba[i][BCOMP] = bMap[index[i] & bmask];
1467 rgba[i][ACOMP] = aMap[index[i] & amask];
1468 }
1469 }
1470
1471
1472 /*
1473 * Map 8-bit color indexes to rgb values.
1474 */
1475 void
1476 _mesa_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
1477 GLchan rgba[][4] )
1478 {
1479 #if CHAN_BITS == 8
1480 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1481 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1482 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1483 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1484 const GLubyte *rMap = ctx->Pixel.MapItoR8;
1485 const GLubyte *gMap = ctx->Pixel.MapItoG8;
1486 const GLubyte *bMap = ctx->Pixel.MapItoB8;
1487 const GLubyte *aMap = ctx->Pixel.MapItoA8;
1488 GLuint i;
1489 for (i=0;i<n;i++) {
1490 rgba[i][RCOMP] = rMap[index[i] & rmask];
1491 rgba[i][GCOMP] = gMap[index[i] & gmask];
1492 rgba[i][BCOMP] = bMap[index[i] & bmask];
1493 rgba[i][ACOMP] = aMap[index[i] & amask];
1494 }
1495 #else
1496 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1497 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1498 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1499 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1500 const GLfloat *rMap = ctx->Pixel.MapItoR;
1501 const GLfloat *gMap = ctx->Pixel.MapItoG;
1502 const GLfloat *bMap = ctx->Pixel.MapItoB;
1503 const GLfloat *aMap = ctx->Pixel.MapItoA;
1504 GLuint i;
1505 for (i=0;i<n;i++) {
1506 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1507 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1508 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1509 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1510 }
1511 #endif
1512 }
1513
1514
1515 void
1516 _mesa_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
1517 GLstencil stencil[] )
1518 {
1519 GLuint i;
1520 GLint shift = ctx->Pixel.IndexShift;
1521 GLint offset = ctx->Pixel.IndexOffset;
1522 if (shift > 0) {
1523 for (i=0;i<n;i++) {
1524 stencil[i] = (stencil[i] << shift) + offset;
1525 }
1526 }
1527 else if (shift < 0) {
1528 shift = -shift;
1529 for (i=0;i<n;i++) {
1530 stencil[i] = (stencil[i] >> shift) + offset;
1531 }
1532 }
1533 else {
1534 for (i=0;i<n;i++) {
1535 stencil[i] = stencil[i] + offset;
1536 }
1537 }
1538
1539 }
1540
1541
1542 void
1543 _mesa_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
1544 {
1545 GLuint mask = ctx->Pixel.MapStoSsize - 1;
1546 GLuint i;
1547 for (i=0;i<n;i++) {
1548 stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
1549 }
1550 }
1551
1552
1553
1554 /*
1555 * This function converts an array of GLchan colors to GLfloat colors.
1556 * Most importantly, it undoes the non-uniform quantization of pixel
1557 * values introduced when we convert shallow (< 8 bit) pixel values
1558 * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1559 * This fixes a number of OpenGL conformance failures when running on
1560 * 16bpp displays, for example.
1561 */
1562 void
1563 _mesa_chan_to_float_span(const GLcontext *ctx, GLuint n,
1564 CONST GLchan rgba[][4], GLfloat rgbaf[][4])
1565 {
1566 #if CHAN_TYPE == GL_FLOAT
1567 MEMCPY(rgbaf, rgba, n * 4 * sizeof(GLfloat));
1568 #else
1569 const GLuint rShift = CHAN_BITS - ctx->Visual.redBits;
1570 const GLuint gShift = CHAN_BITS - ctx->Visual.greenBits;
1571 const GLuint bShift = CHAN_BITS - ctx->Visual.blueBits;
1572 GLuint aShift;
1573 const GLfloat rScale = 1.0F / (GLfloat) ((1 << ctx->Visual.redBits ) - 1);
1574 const GLfloat gScale = 1.0F / (GLfloat) ((1 << ctx->Visual.greenBits) - 1);
1575 const GLfloat bScale = 1.0F / (GLfloat) ((1 << ctx->Visual.blueBits ) - 1);
1576 GLfloat aScale;
1577 GLuint i;
1578
1579 if (ctx->Visual.alphaBits > 0) {
1580 aShift = CHAN_BITS - ctx->Visual.alphaBits;
1581 aScale = 1.0F / (GLfloat) ((1 << ctx->Visual.alphaBits) - 1);
1582 }
1583 else {
1584 aShift = 0;
1585 aScale = 1.0F / CHAN_MAXF;
1586 }
1587
1588 for (i = 0; i < n; i++) {
1589 const GLint r = rgba[i][RCOMP] >> rShift;
1590 const GLint g = rgba[i][GCOMP] >> gShift;
1591 const GLint b = rgba[i][BCOMP] >> bShift;
1592 const GLint a = rgba[i][ACOMP] >> aShift;
1593 rgbaf[i][RCOMP] = (GLfloat) r * rScale;
1594 rgbaf[i][GCOMP] = (GLfloat) g * gScale;
1595 rgbaf[i][BCOMP] = (GLfloat) b * bScale;
1596 rgbaf[i][ACOMP] = (GLfloat) a * aScale;
1597 }
1598 #endif
1599 }
1600
1601 /**********************************************************************/
1602 /***** State Management *****/
1603 /**********************************************************************/
1604
1605 /*
1606 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
1607 * pixel transfer operations are enabled.
1608 */
1609 static void
1610 update_image_transfer_state(GLcontext *ctx)
1611 {
1612 GLuint mask = 0;
1613
1614 if (ctx->Pixel.RedScale != 1.0F || ctx->Pixel.RedBias != 0.0F ||
1615 ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||
1616 ctx->Pixel.BlueScale != 1.0F || ctx->Pixel.BlueBias != 0.0F ||
1617 ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)
1618 mask |= IMAGE_SCALE_BIAS_BIT;
1619
1620 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)
1621 mask |= IMAGE_SHIFT_OFFSET_BIT;
1622
1623 if (ctx->Pixel.MapColorFlag)
1624 mask |= IMAGE_MAP_COLOR_BIT;
1625
1626 if (ctx->Pixel.ColorTableEnabled)
1627 mask |= IMAGE_COLOR_TABLE_BIT;
1628
1629 if (ctx->Pixel.Convolution1DEnabled ||
1630 ctx->Pixel.Convolution2DEnabled ||
1631 ctx->Pixel.Separable2DEnabled) {
1632 mask |= IMAGE_CONVOLUTION_BIT;
1633 if (ctx->Pixel.PostConvolutionScale[0] != 1.0F ||
1634 ctx->Pixel.PostConvolutionScale[1] != 1.0F ||
1635 ctx->Pixel.PostConvolutionScale[2] != 1.0F ||
1636 ctx->Pixel.PostConvolutionScale[3] != 1.0F ||
1637 ctx->Pixel.PostConvolutionBias[0] != 0.0F ||
1638 ctx->Pixel.PostConvolutionBias[1] != 0.0F ||
1639 ctx->Pixel.PostConvolutionBias[2] != 0.0F ||
1640 ctx->Pixel.PostConvolutionBias[3] != 0.0F) {
1641 mask |= IMAGE_POST_CONVOLUTION_SCALE_BIAS;
1642 }
1643 }
1644
1645 if (ctx->Pixel.PostConvolutionColorTableEnabled)
1646 mask |= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT;
1647
1648 if (ctx->ColorMatrixStack.Top->type != MATRIX_IDENTITY ||
1649 ctx->Pixel.PostColorMatrixScale[0] != 1.0F ||
1650 ctx->Pixel.PostColorMatrixBias[0] != 0.0F ||
1651 ctx->Pixel.PostColorMatrixScale[1] != 1.0F ||
1652 ctx->Pixel.PostColorMatrixBias[1] != 0.0F ||
1653 ctx->Pixel.PostColorMatrixScale[2] != 1.0F ||
1654 ctx->Pixel.PostColorMatrixBias[2] != 0.0F ||
1655 ctx->Pixel.PostColorMatrixScale[3] != 1.0F ||
1656 ctx->Pixel.PostColorMatrixBias[3] != 0.0F)
1657 mask |= IMAGE_COLOR_MATRIX_BIT;
1658
1659 if (ctx->Pixel.PostColorMatrixColorTableEnabled)
1660 mask |= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT;
1661
1662 if (ctx->Pixel.HistogramEnabled)
1663 mask |= IMAGE_HISTOGRAM_BIT;
1664
1665 if (ctx->Pixel.MinMaxEnabled)
1666 mask |= IMAGE_MIN_MAX_BIT;
1667
1668 ctx->_ImageTransferState = mask;
1669 }
1670
1671
1672 void _mesa_update_pixel( GLcontext *ctx, GLuint new_state )
1673 {
1674 if (new_state & _NEW_COLOR_MATRIX)
1675 _math_matrix_analyse( ctx->ColorMatrixStack.Top );
1676
1677 /* References ColorMatrix.type (derived above).
1678 */
1679 if (new_state & _IMAGE_NEW_TRANSFER_STATE)
1680 update_image_transfer_state(ctx);
1681 }
1682
1683
1684 /**********************************************************************/
1685 /***** Initialization *****/
1686 /**********************************************************************/
1687
1688
1689 /**
1690 * Initialize the context's PIXEL attribute group.
1691 */
1692 void
1693 _mesa_init_pixel( GLcontext *ctx )
1694 {
1695 int i;
1696
1697 /* Pixel group */
1698 ctx->Pixel.RedBias = 0.0;
1699 ctx->Pixel.RedScale = 1.0;
1700 ctx->Pixel.GreenBias = 0.0;
1701 ctx->Pixel.GreenScale = 1.0;
1702 ctx->Pixel.BlueBias = 0.0;
1703 ctx->Pixel.BlueScale = 1.0;
1704 ctx->Pixel.AlphaBias = 0.0;
1705 ctx->Pixel.AlphaScale = 1.0;
1706 ctx->Pixel.DepthBias = 0.0;
1707 ctx->Pixel.DepthScale = 1.0;
1708 ctx->Pixel.IndexOffset = 0;
1709 ctx->Pixel.IndexShift = 0;
1710 ctx->Pixel.ZoomX = 1.0;
1711 ctx->Pixel.ZoomY = 1.0;
1712 ctx->Pixel.MapColorFlag = GL_FALSE;
1713 ctx->Pixel.MapStencilFlag = GL_FALSE;
1714 ctx->Pixel.MapStoSsize = 1;
1715 ctx->Pixel.MapItoIsize = 1;
1716 ctx->Pixel.MapItoRsize = 1;
1717 ctx->Pixel.MapItoGsize = 1;
1718 ctx->Pixel.MapItoBsize = 1;
1719 ctx->Pixel.MapItoAsize = 1;
1720 ctx->Pixel.MapRtoRsize = 1;
1721 ctx->Pixel.MapGtoGsize = 1;
1722 ctx->Pixel.MapBtoBsize = 1;
1723 ctx->Pixel.MapAtoAsize = 1;
1724 ctx->Pixel.MapStoS[0] = 0;
1725 ctx->Pixel.MapItoI[0] = 0;
1726 ctx->Pixel.MapItoR[0] = 0.0;
1727 ctx->Pixel.MapItoG[0] = 0.0;
1728 ctx->Pixel.MapItoB[0] = 0.0;
1729 ctx->Pixel.MapItoA[0] = 0.0;
1730 ctx->Pixel.MapItoR8[0] = 0;
1731 ctx->Pixel.MapItoG8[0] = 0;
1732 ctx->Pixel.MapItoB8[0] = 0;
1733 ctx->Pixel.MapItoA8[0] = 0;
1734 ctx->Pixel.MapRtoR[0] = 0.0;
1735 ctx->Pixel.MapGtoG[0] = 0.0;
1736 ctx->Pixel.MapBtoB[0] = 0.0;
1737 ctx->Pixel.MapAtoA[0] = 0.0;
1738 ctx->Pixel.HistogramEnabled = GL_FALSE;
1739 ctx->Pixel.MinMaxEnabled = GL_FALSE;
1740 ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1741 ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1742 ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1743 ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1744 ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1745 ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1746 ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1747 ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
1748 ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
1749 ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
1750 ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
1751 ctx->Pixel.ColorTableEnabled = GL_FALSE;
1752 ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1753 ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1754 ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1755 ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1756 ctx->Pixel.Separable2DEnabled = GL_FALSE;
1757 for (i = 0; i < 3; i++) {
1758 ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1759 ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1760 ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1761 ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1762 }
1763 for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
1764 ctx->Convolution1D.Filter[i] = 0.0;
1765 ctx->Convolution2D.Filter[i] = 0.0;
1766 ctx->Separable2D.Filter[i] = 0.0;
1767 }
1768 ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1769 ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1770 /* GL_SGI_texture_color_table */
1771 ASSIGN_4V(ctx->Pixel.TextureColorTableScale, 1.0, 1.0, 1.0, 1.0);
1772 ASSIGN_4V(ctx->Pixel.TextureColorTableBias, 0.0, 0.0, 0.0, 0.0);
1773
1774 /* Pixel transfer */
1775 ctx->Pack.Alignment = 4;
1776 ctx->Pack.RowLength = 0;
1777 ctx->Pack.ImageHeight = 0;
1778 ctx->Pack.SkipPixels = 0;
1779 ctx->Pack.SkipRows = 0;
1780 ctx->Pack.SkipImages = 0;
1781 ctx->Pack.SwapBytes = GL_FALSE;
1782 ctx->Pack.LsbFirst = GL_FALSE;
1783 ctx->Pack.ClientStorage = GL_FALSE;
1784 ctx->Pack.Invert = GL_FALSE;
1785 #if FEATURE_EXT_pixel_buffer_object
1786 ctx->Pack.BufferObj = ctx->Array.NullBufferObj;
1787 #endif
1788 ctx->Unpack.Alignment = 4;
1789 ctx->Unpack.RowLength = 0;
1790 ctx->Unpack.ImageHeight = 0;
1791 ctx->Unpack.SkipPixels = 0;
1792 ctx->Unpack.SkipRows = 0;
1793 ctx->Unpack.SkipImages = 0;
1794 ctx->Unpack.SwapBytes = GL_FALSE;
1795 ctx->Unpack.LsbFirst = GL_FALSE;
1796 ctx->Unpack.ClientStorage = GL_FALSE;
1797 ctx->Unpack.Invert = GL_FALSE;
1798 #if FEATURE_EXT_pixel_buffer_object
1799 ctx->Unpack.BufferObj = ctx->Array.NullBufferObj;
1800 #endif
1801
1802 /*
1803 * _mesa_unpack_image() returns image data in this format. When we
1804 * execute image commands (glDrawPixels(), glTexImage(), etc) from
1805 * within display lists we have to be sure to set the current
1806 * unpacking parameters to these values!
1807 */
1808 ctx->DefaultPacking.Alignment = 1;
1809 ctx->DefaultPacking.RowLength = 0;
1810 ctx->DefaultPacking.SkipPixels = 0;
1811 ctx->DefaultPacking.SkipRows = 0;
1812 ctx->DefaultPacking.ImageHeight = 0;
1813 ctx->DefaultPacking.SkipImages = 0;
1814 ctx->DefaultPacking.SwapBytes = GL_FALSE;
1815 ctx->DefaultPacking.LsbFirst = GL_FALSE;
1816 ctx->DefaultPacking.ClientStorage = GL_FALSE;
1817 ctx->DefaultPacking.Invert = GL_FALSE;
1818 #if FEATURE_EXT_pixel_buffer_object
1819 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
1820 #endif
1821
1822 if (ctx->Visual.doubleBufferMode) {
1823 ctx->Pixel.ReadBuffer = GL_BACK;
1824 ctx->Pixel._ReadSrcMask = DD_BACK_LEFT_BIT;
1825 }
1826 else {
1827 ctx->Pixel.ReadBuffer = GL_FRONT;
1828 ctx->Pixel._ReadSrcMask = DD_FRONT_LEFT_BIT;
1829 }
1830
1831 /* Miscellaneous */
1832 ctx->_ImageTransferState = 0;
1833 }