projects / mesa.git / blob
? search:


c4fa17f22f9be0e81c8c29c13afa27ed31c0fbed
[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 if (rScale != 1.0 || rBias != 0.0) {
795 GLuint i;
796 for (i = 0; i < n; i++) {
797 rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
798 }
799 }
800 if (gScale != 1.0 || gBias != 0.0) {
801 GLuint i;
802 for (i = 0; i < n; i++) {
803 rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
804 }
805 }
806 if (bScale != 1.0 || bBias != 0.0) {
807 GLuint i;
808 for (i = 0; i < n; i++) {
809 rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
810 }
811 }
812 if (aScale != 1.0 || aBias != 0.0) {
813 GLuint i;
814 for (i = 0; i < n; i++) {
815 rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
816 }
817 }
818 }
819
820
821 /*
822 * Apply pixel mapping to an array of floating point RGBA pixels.
823 */
824 void
825 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
826 {
827 const GLfloat rscale = (GLfloat) (ctx->Pixel.MapRtoRsize - 1);
828 const GLfloat gscale = (GLfloat) (ctx->Pixel.MapGtoGsize - 1);
829 const GLfloat bscale = (GLfloat) (ctx->Pixel.MapBtoBsize - 1);
830 const GLfloat ascale = (GLfloat) (ctx->Pixel.MapAtoAsize - 1);
831 const GLfloat *rMap = ctx->Pixel.MapRtoR;
832 const GLfloat *gMap = ctx->Pixel.MapGtoG;
833 const GLfloat *bMap = ctx->Pixel.MapBtoB;
834 const GLfloat *aMap = ctx->Pixel.MapAtoA;
835 GLuint i;
836 for (i=0;i<n;i++) {
837 GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
838 GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
839 GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
840 GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
841 rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
842 rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
843 rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
844 rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
845 }
846 }
847
848
849 /*
850 * Apply the color matrix and post color matrix scaling and biasing.
851 */
852 void
853 _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
854 {
855 const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0];
856 const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0];
857 const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1];
858 const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1];
859 const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2];
860 const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2];
861 const GLfloat as = ctx->Pixel.PostColorMatrixScale[3];
862 const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3];
863 const GLfloat *m = ctx->ColorMatrixStack.Top->m;
864 GLuint i;
865 for (i = 0; i < n; i++) {
866 const GLfloat r = rgba[i][RCOMP];
867 const GLfloat g = rgba[i][GCOMP];
868 const GLfloat b = rgba[i][BCOMP];
869 const GLfloat a = rgba[i][ACOMP];
870 rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb;
871 rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb;
872 rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb;
873 rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab;
874 }
875 }
876
877
878 /**
879 * Apply a color table lookup to an array of floating point RGBA colors.
880 */
881 void
882 _mesa_lookup_rgba_float(const struct gl_color_table *table,
883 GLuint n, GLfloat rgba[][4])
884 {
885 if (!table->Table || table->Size == 0)
886 return;
887
888 switch (table->Format) {
889 case GL_INTENSITY:
890 /* replace RGBA with I */
891 if (table->Type == GL_FLOAT) {
892 const GLint max = table->Size - 1;
893 const GLfloat scale = (GLfloat) max;
894 const GLfloat *lut = (const GLfloat *) table->Table;
895 GLuint i;
896 for (i = 0; i < n; i++) {
897 GLint j = IROUND(rgba[i][RCOMP] * scale);
898 GLfloat c = lut[CLAMP(j, 0, max)];
899 rgba[i][RCOMP] = rgba[i][GCOMP] =
900 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
901 }
902 }
903 else {
904 const GLint max = table->Size - 1;
905 const GLfloat scale = (GLfloat) max;
906 const GLchan *lut = (const GLchan *) table->Table;
907 GLuint i;
908 for (i = 0; i < n; i++) {
909 GLint j = IROUND(rgba[i][RCOMP] * scale);
910 GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
911 rgba[i][RCOMP] = rgba[i][GCOMP] =
912 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
913 }
914 }
915 break;
916 case GL_LUMINANCE:
917 /* replace RGB with L */
918 if (table->Type == GL_FLOAT) {
919 const GLint max = table->Size - 1;
920 const GLfloat scale = (GLfloat) max;
921 const GLfloat *lut = (const GLfloat *) table->Table;
922 GLuint i;
923 for (i = 0; i < n; i++) {
924 GLint j = IROUND(rgba[i][RCOMP] * scale);
925 GLfloat c = lut[CLAMP(j, 0, max)];
926 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
927 }
928 }
929 else {
930 const GLint max = table->Size - 1;
931 const GLfloat scale = (GLfloat) max;
932 const GLchan *lut = (const GLchan *) table->Table;
933 GLuint i;
934 for (i = 0; i < n; i++) {
935 GLint j = IROUND(rgba[i][RCOMP] * scale);
936 GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
937 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
938 }
939 }
940 break;
941 case GL_ALPHA:
942 /* replace A with A */
943 if (table->Type == GL_FLOAT) {
944 const GLint max = table->Size - 1;
945 const GLfloat scale = (GLfloat) max;
946 const GLfloat *lut = (const GLfloat *) table->Table;
947 GLuint i;
948 for (i = 0; i < n; i++) {
949 GLint j = IROUND(rgba[i][ACOMP] * scale);
950 rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
951 }
952 }
953 else {
954 const GLint max = table->Size - 1;
955 const GLfloat scale = (GLfloat) max;
956 const GLchan *lut = (const GLchan *) table->Table;
957 GLuint i;
958 for (i = 0; i < n; i++) {
959 GLint j = IROUND(rgba[i][ACOMP] * scale);
960 rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
961 }
962 }
963 break;
964 case GL_LUMINANCE_ALPHA:
965 /* replace RGBA with LLLA */
966 if (table->Type == GL_FLOAT) {
967 const GLint max = table->Size - 1;
968 const GLfloat scale = (GLfloat) max;
969 const GLfloat *lut = (const GLfloat *) table->Table;
970 GLuint i;
971 for (i = 0; i < n; i++) {
972 GLint jL = IROUND(rgba[i][RCOMP] * scale);
973 GLint jA = IROUND(rgba[i][ACOMP] * scale);
974 GLfloat luminance, alpha;
975 jL = CLAMP(jL, 0, max);
976 jA = CLAMP(jA, 0, max);
977 luminance = lut[jL * 2 + 0];
978 alpha = lut[jA * 2 + 1];
979 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
980 rgba[i][ACOMP] = alpha;;
981 }
982 }
983 else {
984 const GLint max = table->Size - 1;
985 const GLfloat scale = (GLfloat) max;
986 const GLchan *lut = (const GLchan *) table->Table;
987 GLuint i;
988 for (i = 0; i < n; i++) {
989 GLint jL = IROUND(rgba[i][RCOMP] * scale);
990 GLint jA = IROUND(rgba[i][ACOMP] * scale);
991 GLfloat luminance, alpha;
992 jL = CLAMP(jL, 0, max);
993 jA = CLAMP(jA, 0, max);
994 luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
995 alpha = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
996 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
997 rgba[i][ACOMP] = alpha;;
998 }
999 }
1000 break;
1001 case GL_RGB:
1002 /* replace RGB with RGB */
1003 if (table->Type == GL_FLOAT) {
1004 const GLint max = table->Size - 1;
1005 const GLfloat scale = (GLfloat) max;
1006 const GLfloat *lut = (const GLfloat *) table->Table;
1007 GLuint i;
1008 for (i = 0; i < n; i++) {
1009 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1010 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1011 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1012 jR = CLAMP(jR, 0, max);
1013 jG = CLAMP(jG, 0, max);
1014 jB = CLAMP(jB, 0, max);
1015 rgba[i][RCOMP] = lut[jR * 3 + 0];
1016 rgba[i][GCOMP] = lut[jG * 3 + 1];
1017 rgba[i][BCOMP] = lut[jB * 3 + 2];
1018 }
1019 }
1020 else {
1021 const GLint max = table->Size - 1;
1022 const GLfloat scale = (GLfloat) max;
1023 const GLchan *lut = (const GLchan *) table->Table;
1024 GLuint i;
1025 for (i = 0; i < n; i++) {
1026 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1027 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1028 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1029 jR = CLAMP(jR, 0, max);
1030 jG = CLAMP(jG, 0, max);
1031 jB = CLAMP(jB, 0, max);
1032 rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
1033 rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
1034 rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
1035 }
1036 }
1037 break;
1038 case GL_RGBA:
1039 /* replace RGBA with RGBA */
1040 if (table->Type == GL_FLOAT) {
1041 const GLint max = table->Size - 1;
1042 const GLfloat scale = (GLfloat) max;
1043 const GLfloat *lut = (const GLfloat *) table->Table;
1044 GLuint i;
1045 for (i = 0; i < n; i++) {
1046 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1047 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1048 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1049 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1050 jR = CLAMP(jR, 0, max);
1051 jG = CLAMP(jG, 0, max);
1052 jB = CLAMP(jB, 0, max);
1053 jA = CLAMP(jA, 0, max);
1054 rgba[i][RCOMP] = lut[jR * 4 + 0];
1055 rgba[i][GCOMP] = lut[jG * 4 + 1];
1056 rgba[i][BCOMP] = lut[jB * 4 + 2];
1057 rgba[i][ACOMP] = lut[jA * 4 + 3];
1058 }
1059 }
1060 else {
1061 const GLint max = table->Size - 1;
1062 const GLfloat scale = (GLfloat) max;
1063 const GLchan *lut = (const GLchan *) table->Table;
1064 GLuint i;
1065 for (i = 0; i < n; i++) {
1066 GLint jR = IROUND(rgba[i][RCOMP] * scale);
1067 GLint jG = IROUND(rgba[i][GCOMP] * scale);
1068 GLint jB = IROUND(rgba[i][BCOMP] * scale);
1069 GLint jA = IROUND(rgba[i][ACOMP] * scale);
1070 jR = CLAMP(jR, 0, max);
1071 jG = CLAMP(jG, 0, max);
1072 jB = CLAMP(jB, 0, max);
1073 jA = CLAMP(jA, 0, max);
1074 rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
1075 rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
1076 rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
1077 rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
1078 }
1079 }
1080 break;
1081 default:
1082 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
1083 return;
1084 }
1085 }
1086
1087
1088
1089 /**
1090 * Apply a color table lookup to an array of GLchan RGBA colors.
1091 */
1092 void
1093 _mesa_lookup_rgba_chan(const struct gl_color_table *table,
1094 GLuint n, GLchan rgba[][4])
1095 {
1096 if (!table->Table || table->Size == 0)
1097 return;
1098
1099 switch (table->Format) {
1100 case GL_INTENSITY:
1101 /* replace RGBA with I */
1102 if (table->Type == GL_FLOAT) {
1103 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1104 const GLfloat *lut = (const GLfloat *) table->Table;
1105 GLuint i;
1106 for (i = 0; i < n; i++) {
1107 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1108 GLchan c;
1109 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1110 rgba[i][RCOMP] = rgba[i][GCOMP] =
1111 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1112 }
1113 }
1114 else {
1115 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1116 if (table->Size == 256) {
1117 /* common case */
1118 const GLchan *lut = (const GLchan *) table->Table;
1119 GLuint i;
1120 for (i = 0; i < n; i++) {
1121 const GLchan c = lut[rgba[i][RCOMP]];
1122 rgba[i][RCOMP] = rgba[i][GCOMP] =
1123 rgba[i][BCOMP] = rgba[i][ACOMP] = c;
1124 }
1125 }
1126 else
1127 #endif
1128 {
1129 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1130 const GLchan *lut = (const GLchan *) table->Table;
1131 GLuint i;
1132 for (i = 0; i < n; i++) {
1133 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1134 rgba[i][RCOMP] = rgba[i][GCOMP] =
1135 rgba[i][BCOMP] = rgba[i][ACOMP] = lut[j];
1136 }
1137 }
1138 }
1139 break;
1140 case GL_LUMINANCE:
1141 /* replace RGB with L */
1142 if (table->Type == GL_FLOAT) {
1143 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1144 const GLfloat *lut = (const GLfloat *) table->Table;
1145 GLuint i;
1146 for (i = 0; i < n; i++) {
1147 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1148 GLchan c;
1149 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1150 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1151 }
1152 }
1153 else {
1154 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1155 if (table->Size == 256) {
1156 /* common case */
1157 const GLchan *lut = (const GLchan *) table->Table;
1158 GLuint i;
1159 for (i = 0; i < n; i++) {
1160 const GLchan c = lut[rgba[i][RCOMP]];
1161 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
1162 }
1163 }
1164 else
1165 #endif
1166 {
1167 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1168 const GLchan *lut = (const GLchan *) table->Table;
1169 GLuint i;
1170 for (i = 0; i < n; i++) {
1171 GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1172 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = lut[j];
1173 }
1174 }
1175 }
1176 break;
1177 case GL_ALPHA:
1178 /* replace A with A */
1179 if (table->Type == GL_FLOAT) {
1180 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1181 const GLfloat *lut = (const GLfloat *) table->Table;
1182 GLuint i;
1183 for (i = 0; i < n; i++) {
1184 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1185 GLchan c;
1186 CLAMPED_FLOAT_TO_CHAN(c, lut[j]);
1187 rgba[i][ACOMP] = c;
1188 }
1189 }
1190 else {
1191 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1192 if (table->Size == 256) {
1193 /* common case */
1194 const GLchan *lut = (const GLchan *) table->Table;
1195 GLuint i;
1196 for (i = 0; i < n; i++) {
1197 rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
1198 }
1199 }
1200 else
1201 #endif
1202 {
1203 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1204 const GLchan *lut = (const GLchan *) table->Table;
1205 GLuint i;
1206 for (i = 0; i < n; i++) {
1207 GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1208 rgba[i][ACOMP] = lut[j];
1209 }
1210 }
1211 }
1212 break;
1213 case GL_LUMINANCE_ALPHA:
1214 /* replace RGBA with LLLA */
1215 if (table->Type == GL_FLOAT) {
1216 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1217 const GLfloat *lut = (const GLfloat *) table->Table;
1218 GLuint i;
1219 for (i = 0; i < n; i++) {
1220 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1221 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1222 GLchan luminance, alpha;
1223 CLAMPED_FLOAT_TO_CHAN(luminance, lut[jL * 2 + 0]);
1224 CLAMPED_FLOAT_TO_CHAN(alpha, lut[jA * 2 + 1]);
1225 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1226 rgba[i][ACOMP] = alpha;;
1227 }
1228 }
1229 else {
1230 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1231 if (table->Size == 256) {
1232 /* common case */
1233 const GLchan *lut = (const GLchan *) table->Table;
1234 GLuint i;
1235 for (i = 0; i < n; i++) {
1236 GLchan l = lut[rgba[i][RCOMP] * 2 + 0];
1237 GLchan a = lut[rgba[i][ACOMP] * 2 + 1];;
1238 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = l;
1239 rgba[i][ACOMP] = a;
1240 }
1241 }
1242 else
1243 #endif
1244 {
1245 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1246 const GLchan *lut = (const GLchan *) table->Table;
1247 GLuint i;
1248 for (i = 0; i < n; i++) {
1249 GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1250 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1251 GLchan luminance = lut[jL * 2 + 0];
1252 GLchan alpha = lut[jA * 2 + 1];
1253 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1254 rgba[i][ACOMP] = alpha;
1255 }
1256 }
1257 }
1258 break;
1259 case GL_RGB:
1260 /* replace RGB with RGB */
1261 if (table->Type == GL_FLOAT) {
1262 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1263 const GLfloat *lut = (const GLfloat *) table->Table;
1264 GLuint i;
1265 for (i = 0; i < n; i++) {
1266 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1267 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1268 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1269 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 3 + 0]);
1270 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 3 + 1]);
1271 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 3 + 2]);
1272 }
1273 }
1274 else {
1275 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1276 if (table->Size == 256) {
1277 /* common case */
1278 const GLchan *lut = (const GLchan *) table->Table;
1279 GLuint i;
1280 for (i = 0; i < n; i++) {
1281 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
1282 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
1283 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
1284 }
1285 }
1286 else
1287 #endif
1288 {
1289 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1290 const GLchan *lut = (const GLchan *) table->Table;
1291 GLuint i;
1292 for (i = 0; i < n; i++) {
1293 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1294 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1295 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1296 rgba[i][RCOMP] = lut[jR * 3 + 0];
1297 rgba[i][GCOMP] = lut[jG * 3 + 1];
1298 rgba[i][BCOMP] = lut[jB * 3 + 2];
1299 }
1300 }
1301 }
1302 break;
1303 case GL_RGBA:
1304 /* replace RGBA with RGBA */
1305 if (table->Type == GL_FLOAT) {
1306 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1307 const GLfloat *lut = (const GLfloat *) table->Table;
1308 GLuint i;
1309 for (i = 0; i < n; i++) {
1310 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1311 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1312 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1313 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1314 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1315 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1316 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1317 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1318 }
1319 }
1320 else {
1321 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1322 if (table->Size == 256) {
1323 /* common case */
1324 const GLchan *lut = (const GLchan *) table->Table;
1325 GLuint i;
1326 for (i = 0; i < n; i++) {
1327 rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
1328 rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
1329 rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
1330 rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
1331 }
1332 }
1333 else
1334 #endif
1335 {
1336 const GLfloat scale = (GLfloat) (table->Size - 1) / CHAN_MAXF;
1337 const GLfloat *lut = (const GLfloat *) table->Table;
1338 GLuint i;
1339 for (i = 0; i < n; i++) {
1340 GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
1341 GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
1342 GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
1343 GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
1344 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
1345 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
1346 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
1347 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
1348 }
1349 }
1350 }
1351 break;
1352 default:
1353 _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
1354 return;
1355 }
1356 }
1357
1358
1359
1360 /*
1361 * Apply color index shift and offset to an array of pixels.
1362 */
1363 void
1364 _mesa_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1365 {
1366 GLint shift = ctx->Pixel.IndexShift;
1367 GLint offset = ctx->Pixel.IndexOffset;
1368 GLuint i;
1369 if (shift > 0) {
1370 for (i=0;i<n;i++) {
1371 indexes[i] = (indexes[i] << shift) + offset;
1372 }
1373 }
1374 else if (shift < 0) {
1375 shift = -shift;
1376 for (i=0;i<n;i++) {
1377 indexes[i] = (indexes[i] >> shift) + offset;
1378 }
1379 }
1380 else {
1381 for (i=0;i<n;i++) {
1382 indexes[i] = indexes[i] + offset;
1383 }
1384 }
1385 }
1386
1387
1388 /*
1389 * Apply color index mapping to color indexes.
1390 */
1391 void
1392 _mesa_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
1393 {
1394 GLuint mask = ctx->Pixel.MapItoIsize - 1;
1395 GLuint i;
1396 for (i=0;i<n;i++) {
1397 index[i] = ctx->Pixel.MapItoI[ index[i] & mask ];
1398 }
1399 }
1400
1401
1402 /*
1403 * Map color indexes to rgba values.
1404 */
1405 void
1406 _mesa_map_ci_to_rgba_chan( const GLcontext *ctx, GLuint n,
1407 const GLuint index[], GLchan rgba[][4] )
1408 {
1409 #if CHAN_BITS == 8
1410 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1411 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1412 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1413 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1414 const GLubyte *rMap = ctx->Pixel.MapItoR8;
1415 const GLubyte *gMap = ctx->Pixel.MapItoG8;
1416 const GLubyte *bMap = ctx->Pixel.MapItoB8;
1417 const GLubyte *aMap = ctx->Pixel.MapItoA8;
1418 GLuint i;
1419 for (i=0;i<n;i++) {
1420 rgba[i][RCOMP] = rMap[index[i] & rmask];
1421 rgba[i][GCOMP] = gMap[index[i] & gmask];
1422 rgba[i][BCOMP] = bMap[index[i] & bmask];
1423 rgba[i][ACOMP] = aMap[index[i] & amask];
1424 }
1425 #else
1426 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1427 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1428 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1429 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1430 const GLfloat *rMap = ctx->Pixel.MapItoR;
1431 const GLfloat *gMap = ctx->Pixel.MapItoG;
1432 const GLfloat *bMap = ctx->Pixel.MapItoB;
1433 const GLfloat *aMap = ctx->Pixel.MapItoA;
1434 GLuint i;
1435 for (i=0;i<n;i++) {
1436 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1437 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1438 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1439 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1440 }
1441 #endif
1442 }
1443
1444
1445 /*
1446 * Map color indexes to float rgba values.
1447 */
1448 void
1449 _mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n,
1450 const GLuint index[], GLfloat rgba[][4] )
1451 {
1452 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1453 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1454 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1455 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1456 const GLfloat *rMap = ctx->Pixel.MapItoR;
1457 const GLfloat *gMap = ctx->Pixel.MapItoG;
1458 const GLfloat *bMap = ctx->Pixel.MapItoB;
1459 const GLfloat *aMap = ctx->Pixel.MapItoA;
1460 GLuint i;
1461 for (i=0;i<n;i++) {
1462 rgba[i][RCOMP] = rMap[index[i] & rmask];
1463 rgba[i][GCOMP] = gMap[index[i] & gmask];
1464 rgba[i][BCOMP] = bMap[index[i] & bmask];
1465 rgba[i][ACOMP] = aMap[index[i] & amask];
1466 }
1467 }
1468
1469
1470 /*
1471 * Map 8-bit color indexes to rgb values.
1472 */
1473 void
1474 _mesa_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
1475 GLchan rgba[][4] )
1476 {
1477 #if CHAN_BITS == 8
1478 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1479 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1480 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1481 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1482 const GLubyte *rMap = ctx->Pixel.MapItoR8;
1483 const GLubyte *gMap = ctx->Pixel.MapItoG8;
1484 const GLubyte *bMap = ctx->Pixel.MapItoB8;
1485 const GLubyte *aMap = ctx->Pixel.MapItoA8;
1486 GLuint i;
1487 for (i=0;i<n;i++) {
1488 rgba[i][RCOMP] = rMap[index[i] & rmask];
1489 rgba[i][GCOMP] = gMap[index[i] & gmask];
1490 rgba[i][BCOMP] = bMap[index[i] & bmask];
1491 rgba[i][ACOMP] = aMap[index[i] & amask];
1492 }
1493 #else
1494 GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1495 GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1496 GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1497 GLuint amask = ctx->Pixel.MapItoAsize - 1;
1498 const GLfloat *rMap = ctx->Pixel.MapItoR;
1499 const GLfloat *gMap = ctx->Pixel.MapItoG;
1500 const GLfloat *bMap = ctx->Pixel.MapItoB;
1501 const GLfloat *aMap = ctx->Pixel.MapItoA;
1502 GLuint i;
1503 for (i=0;i<n;i++) {
1504 CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1505 CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1506 CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1507 CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1508 }
1509 #endif
1510 }
1511
1512
1513 void
1514 _mesa_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
1515 GLstencil stencil[] )
1516 {
1517 GLuint i;
1518 GLint shift = ctx->Pixel.IndexShift;
1519 GLint offset = ctx->Pixel.IndexOffset;
1520 if (shift > 0) {
1521 for (i=0;i<n;i++) {
1522 stencil[i] = (stencil[i] << shift) + offset;
1523 }
1524 }
1525 else if (shift < 0) {
1526 shift = -shift;
1527 for (i=0;i<n;i++) {
1528 stencil[i] = (stencil[i] >> shift) + offset;
1529 }
1530 }
1531 else {
1532 for (i=0;i<n;i++) {
1533 stencil[i] = stencil[i] + offset;
1534 }
1535 }
1536
1537 }
1538
1539
1540 void
1541 _mesa_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
1542 {
1543 GLuint mask = ctx->Pixel.MapStoSsize - 1;
1544 GLuint i;
1545 for (i=0;i<n;i++) {
1546 stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
1547 }
1548 }
1549
1550
1551
1552 /*
1553 * This function converts an array of GLchan colors to GLfloat colors.
1554 * Most importantly, it undoes the non-uniform quantization of pixel
1555 * values introduced when we convert shallow (< 8 bit) pixel values
1556 * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1557 * This fixes a number of OpenGL conformance failures when running on
1558 * 16bpp displays, for example.
1559 */
1560 void
1561 _mesa_chan_to_float_span(const GLcontext *ctx, GLuint n,
1562 CONST GLchan rgba[][4], GLfloat rgbaf[][4])
1563 {
1564 #if CHAN_TYPE == GL_FLOAT
1565 MEMCPY(rgbaf, rgba, n * 4 * sizeof(GLfloat));
1566 #else
1567 const GLuint rShift = CHAN_BITS - ctx->Visual.redBits;
1568 const GLuint gShift = CHAN_BITS - ctx->Visual.greenBits;
1569 const GLuint bShift = CHAN_BITS - ctx->Visual.blueBits;
1570 GLuint aShift;
1571 const GLfloat rScale = 1.0F / (GLfloat) ((1 << ctx->Visual.redBits ) - 1);
1572 const GLfloat gScale = 1.0F / (GLfloat) ((1 << ctx->Visual.greenBits) - 1);
1573 const GLfloat bScale = 1.0F / (GLfloat) ((1 << ctx->Visual.blueBits ) - 1);
1574 GLfloat aScale;
1575 GLuint i;
1576
1577 if (ctx->Visual.alphaBits > 0) {
1578 aShift = CHAN_BITS - ctx->Visual.alphaBits;
1579 aScale = 1.0F / (GLfloat) ((1 << ctx->Visual.alphaBits) - 1);
1580 }
1581 else {
1582 aShift = 0;
1583 aScale = 1.0F / CHAN_MAXF;
1584 }
1585
1586 for (i = 0; i < n; i++) {
1587 const GLint r = rgba[i][RCOMP] >> rShift;
1588 const GLint g = rgba[i][GCOMP] >> gShift;
1589 const GLint b = rgba[i][BCOMP] >> bShift;
1590 const GLint a = rgba[i][ACOMP] >> aShift;
1591 rgbaf[i][RCOMP] = (GLfloat) r * rScale;
1592 rgbaf[i][GCOMP] = (GLfloat) g * gScale;
1593 rgbaf[i][BCOMP] = (GLfloat) b * bScale;
1594 rgbaf[i][ACOMP] = (GLfloat) a * aScale;
1595 }
1596 #endif
1597 }
1598
1599 /**********************************************************************/
1600 /***** State Management *****/
1601 /**********************************************************************/
1602
1603 /*
1604 * Return a bitmask of IMAGE_*_BIT flags which to indicate which
1605 * pixel transfer operations are enabled.
1606 */
1607 static void
1608 update_image_transfer_state(GLcontext *ctx)
1609 {
1610 GLuint mask = 0;
1611
1612 if (ctx->Pixel.RedScale != 1.0F || ctx->Pixel.RedBias != 0.0F ||
1613 ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||
1614 ctx->Pixel.BlueScale != 1.0F || ctx->Pixel.BlueBias != 0.0F ||
1615 ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)
1616 mask |= IMAGE_SCALE_BIAS_BIT;
1617
1618 if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)
1619 mask |= IMAGE_SHIFT_OFFSET_BIT;
1620
1621 if (ctx->Pixel.MapColorFlag)
1622 mask |= IMAGE_MAP_COLOR_BIT;
1623
1624 if (ctx->Pixel.ColorTableEnabled)
1625 mask |= IMAGE_COLOR_TABLE_BIT;
1626
1627 if (ctx->Pixel.Convolution1DEnabled ||
1628 ctx->Pixel.Convolution2DEnabled ||
1629 ctx->Pixel.Separable2DEnabled) {
1630 mask |= IMAGE_CONVOLUTION_BIT;
1631 if (ctx->Pixel.PostConvolutionScale[0] != 1.0F ||
1632 ctx->Pixel.PostConvolutionScale[1] != 1.0F ||
1633 ctx->Pixel.PostConvolutionScale[2] != 1.0F ||
1634 ctx->Pixel.PostConvolutionScale[3] != 1.0F ||
1635 ctx->Pixel.PostConvolutionBias[0] != 0.0F ||
1636 ctx->Pixel.PostConvolutionBias[1] != 0.0F ||
1637 ctx->Pixel.PostConvolutionBias[2] != 0.0F ||
1638 ctx->Pixel.PostConvolutionBias[3] != 0.0F) {
1639 mask |= IMAGE_POST_CONVOLUTION_SCALE_BIAS;
1640 }
1641 }
1642
1643 if (ctx->Pixel.PostConvolutionColorTableEnabled)
1644 mask |= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT;
1645
1646 if (ctx->ColorMatrixStack.Top->type != MATRIX_IDENTITY ||
1647 ctx->Pixel.PostColorMatrixScale[0] != 1.0F ||
1648 ctx->Pixel.PostColorMatrixBias[0] != 0.0F ||
1649 ctx->Pixel.PostColorMatrixScale[1] != 1.0F ||
1650 ctx->Pixel.PostColorMatrixBias[1] != 0.0F ||
1651 ctx->Pixel.PostColorMatrixScale[2] != 1.0F ||
1652 ctx->Pixel.PostColorMatrixBias[2] != 0.0F ||
1653 ctx->Pixel.PostColorMatrixScale[3] != 1.0F ||
1654 ctx->Pixel.PostColorMatrixBias[3] != 0.0F)
1655 mask |= IMAGE_COLOR_MATRIX_BIT;
1656
1657 if (ctx->Pixel.PostColorMatrixColorTableEnabled)
1658 mask |= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT;
1659
1660 if (ctx->Pixel.HistogramEnabled)
1661 mask |= IMAGE_HISTOGRAM_BIT;
1662
1663 if (ctx->Pixel.MinMaxEnabled)
1664 mask |= IMAGE_MIN_MAX_BIT;
1665
1666 ctx->_ImageTransferState = mask;
1667 }
1668
1669
1670 void _mesa_update_pixel( GLcontext *ctx, GLuint new_state )
1671 {
1672 if (new_state & _NEW_COLOR_MATRIX)
1673 _math_matrix_analyse( ctx->ColorMatrixStack.Top );
1674
1675 /* References ColorMatrix.type (derived above).
1676 */
1677 if (new_state & _IMAGE_NEW_TRANSFER_STATE)
1678 update_image_transfer_state(ctx);
1679 }
1680
1681
1682 /**********************************************************************/
1683 /***** Initialization *****/
1684 /**********************************************************************/
1685
1686
1687 /**
1688 * Initialize the context's PIXEL attribute group.
1689 */
1690 void
1691 _mesa_init_pixel( GLcontext *ctx )
1692 {
1693 int i;
1694
1695 /* Pixel group */
1696 ctx->Pixel.RedBias = 0.0;
1697 ctx->Pixel.RedScale = 1.0;
1698 ctx->Pixel.GreenBias = 0.0;
1699 ctx->Pixel.GreenScale = 1.0;
1700 ctx->Pixel.BlueBias = 0.0;
1701 ctx->Pixel.BlueScale = 1.0;
1702 ctx->Pixel.AlphaBias = 0.0;
1703 ctx->Pixel.AlphaScale = 1.0;
1704 ctx->Pixel.DepthBias = 0.0;
1705 ctx->Pixel.DepthScale = 1.0;
1706 ctx->Pixel.IndexOffset = 0;
1707 ctx->Pixel.IndexShift = 0;
1708 ctx->Pixel.ZoomX = 1.0;
1709 ctx->Pixel.ZoomY = 1.0;
1710 ctx->Pixel.MapColorFlag = GL_FALSE;
1711 ctx->Pixel.MapStencilFlag = GL_FALSE;
1712 ctx->Pixel.MapStoSsize = 1;
1713 ctx->Pixel.MapItoIsize = 1;
1714 ctx->Pixel.MapItoRsize = 1;
1715 ctx->Pixel.MapItoGsize = 1;
1716 ctx->Pixel.MapItoBsize = 1;
1717 ctx->Pixel.MapItoAsize = 1;
1718 ctx->Pixel.MapRtoRsize = 1;
1719 ctx->Pixel.MapGtoGsize = 1;
1720 ctx->Pixel.MapBtoBsize = 1;
1721 ctx->Pixel.MapAtoAsize = 1;
1722 ctx->Pixel.MapStoS[0] = 0;
1723 ctx->Pixel.MapItoI[0] = 0;
1724 ctx->Pixel.MapItoR[0] = 0.0;
1725 ctx->Pixel.MapItoG[0] = 0.0;
1726 ctx->Pixel.MapItoB[0] = 0.0;
1727 ctx->Pixel.MapItoA[0] = 0.0;
1728 ctx->Pixel.MapItoR8[0] = 0;
1729 ctx->Pixel.MapItoG8[0] = 0;
1730 ctx->Pixel.MapItoB8[0] = 0;
1731 ctx->Pixel.MapItoA8[0] = 0;
1732 ctx->Pixel.MapRtoR[0] = 0.0;
1733 ctx->Pixel.MapGtoG[0] = 0.0;
1734 ctx->Pixel.MapBtoB[0] = 0.0;
1735 ctx->Pixel.MapAtoA[0] = 0.0;
1736 ctx->Pixel.HistogramEnabled = GL_FALSE;
1737 ctx->Pixel.MinMaxEnabled = GL_FALSE;
1738 ctx->Pixel.PixelTextureEnabled = GL_FALSE;
1739 ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
1740 ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
1741 ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
1742 ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
1743 ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
1744 ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
1745 ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
1746 ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
1747 ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
1748 ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
1749 ctx->Pixel.ColorTableEnabled = GL_FALSE;
1750 ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
1751 ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
1752 ctx->Pixel.Convolution1DEnabled = GL_FALSE;
1753 ctx->Pixel.Convolution2DEnabled = GL_FALSE;
1754 ctx->Pixel.Separable2DEnabled = GL_FALSE;
1755 for (i = 0; i < 3; i++) {
1756 ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
1757 ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
1758 ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
1759 ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
1760 }
1761 for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
1762 ctx->Convolution1D.Filter[i] = 0.0;
1763 ctx->Convolution2D.Filter[i] = 0.0;
1764 ctx->Separable2D.Filter[i] = 0.0;
1765 }
1766 ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
1767 ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
1768 /* GL_SGI_texture_color_table */
1769 ASSIGN_4V(ctx->Pixel.TextureColorTableScale, 1.0, 1.0, 1.0, 1.0);
1770 ASSIGN_4V(ctx->Pixel.TextureColorTableBias, 0.0, 0.0, 0.0, 0.0);
1771
1772 /* Pixel transfer */
1773 ctx->Pack.Alignment = 4;
1774 ctx->Pack.RowLength = 0;
1775 ctx->Pack.ImageHeight = 0;
1776 ctx->Pack.SkipPixels = 0;
1777 ctx->Pack.SkipRows = 0;
1778 ctx->Pack.SkipImages = 0;
1779 ctx->Pack.SwapBytes = GL_FALSE;
1780 ctx->Pack.LsbFirst = GL_FALSE;
1781 ctx->Pack.ClientStorage = GL_FALSE;
1782 ctx->Pack.Invert = GL_FALSE;
1783 #if FEATURE_EXT_pixel_buffer_object
1784 ctx->Pack.BufferObj = ctx->Array.NullBufferObj;
1785 #endif
1786 ctx->Unpack.Alignment = 4;
1787 ctx->Unpack.RowLength = 0;
1788 ctx->Unpack.ImageHeight = 0;
1789 ctx->Unpack.SkipPixels = 0;
1790 ctx->Unpack.SkipRows = 0;
1791 ctx->Unpack.SkipImages = 0;
1792 ctx->Unpack.SwapBytes = GL_FALSE;
1793 ctx->Unpack.LsbFirst = GL_FALSE;
1794 ctx->Unpack.ClientStorage = GL_FALSE;
1795 ctx->Unpack.Invert = GL_FALSE;
1796 #if FEATURE_EXT_pixel_buffer_object
1797 ctx->Unpack.BufferObj = ctx->Array.NullBufferObj;
1798 #endif
1799
1800 /*
1801 * _mesa_unpack_image() returns image data in this format. When we
1802 * execute image commands (glDrawPixels(), glTexImage(), etc) from
1803 * within display lists we have to be sure to set the current
1804 * unpacking parameters to these values!
1805 */
1806 ctx->DefaultPacking.Alignment = 1;
1807 ctx->DefaultPacking.RowLength = 0;
1808 ctx->DefaultPacking.SkipPixels = 0;
1809 ctx->DefaultPacking.SkipRows = 0;
1810 ctx->DefaultPacking.ImageHeight = 0;
1811 ctx->DefaultPacking.SkipImages = 0;
1812 ctx->DefaultPacking.SwapBytes = GL_FALSE;
1813 ctx->DefaultPacking.LsbFirst = GL_FALSE;
1814 ctx->DefaultPacking.ClientStorage = GL_FALSE;
1815 ctx->DefaultPacking.Invert = GL_FALSE;
1816 #if FEATURE_EXT_pixel_buffer_object
1817 ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
1818 #endif
1819
1820 if (ctx->Visual.doubleBufferMode) {
1821 ctx->Pixel.ReadBuffer = GL_BACK;
1822 ctx->Pixel._ReadSrcMask = DD_BACK_LEFT_BIT;
1823 }
1824 else {
1825 ctx->Pixel.ReadBuffer = GL_FRONT;
1826 ctx->Pixel._ReadSrcMask = DD_FRONT_LEFT_BIT;
1827 }
1828
1829 /* Miscellaneous */
1830 ctx->_ImageTransferState = 0;
1831 }