ReactOS 0.4.15-dev-8227-g32d615f
logic.h File Reference
#include "types.h"
Include dependency graph for logic.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void gl_LogicOp (GLcontext *ctx, GLenum opcode)
 
void gl_logicop_ci_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLuint index[], GLubyte mask[])
 
void gl_logicop_ci_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLuint index[], GLubyte mask[])
 
void gl_logicop_rgba_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte red[], GLubyte green[], GLubyte blue[], GLubyte alpha[], GLubyte mask[])
 
void gl_logicop_rgba_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte red[], GLubyte green[], GLubyte blue[], GLubyte alpha[], GLubyte mask[])
 

Function Documentation

◆ gl_LogicOp()

void gl_LogicOp ( GLcontext ctx,
GLenum  opcode 
)

Definition at line 66 of file logic.c.

67{
68 if (INSIDE_BEGIN_END(ctx)) {
69 gl_error( ctx, GL_INVALID_OPERATION, "glLogicOp" );
70 return;
71 }
72 switch (opcode) {
73 case GL_CLEAR:
74 case GL_SET:
75 case GL_COPY:
77 case GL_NOOP:
78 case GL_INVERT:
79 case GL_AND:
80 case GL_NAND:
81 case GL_OR:
82 case GL_NOR:
83 case GL_XOR:
84 case GL_EQUIV:
85 case GL_AND_REVERSE:
86 case GL_AND_INVERTED:
87 case GL_OR_REVERSE:
88 case GL_OR_INVERTED:
89 ctx->Color.LogicOp = opcode;
90 ctx->NewState |= NEW_RASTER_OPS;
91 return;
92 default:
93 gl_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
94 return;
95 }
96}
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
#define NEW_RASTER_OPS
Definition: types.h:1233
#define GL_SET
Definition: gl.h:431
#define GL_OR
Definition: gl.h:438
#define GL_EQUIV
Definition: gl.h:441
#define GL_AND_REVERSE
Definition: gl.h:442
#define GL_AND_INVERTED
Definition: gl.h:443
#define GL_INVALID_OPERATION
Definition: gl.h:696
#define GL_CLEAR
Definition: gl.h:430
#define GL_NOOP
Definition: gl.h:434
#define GL_COPY_INVERTED
Definition: gl.h:433
#define GL_XOR
Definition: gl.h:440
#define GL_NOR
Definition: gl.h:439
#define GL_OR_REVERSE
Definition: gl.h:444
#define GL_AND
Definition: gl.h:436
#define GL_COPY
Definition: gl.h:432
#define GL_OR_INVERTED
Definition: gl.h:445
#define GL_INVALID_ENUM
Definition: gl.h:694
#define GL_INVERT
Definition: gl.h:435
#define GL_NAND
Definition: gl.h:437
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135

Referenced by execute_list(), and init_exec_pointers().

◆ gl_logicop_ci_pixels()

void gl_logicop_ci_pixels ( GLcontext ctx,
GLuint  n,
const GLint  x[],
const GLint  y[],
GLuint  index[],
GLubyte  mask[] 
)

Definition at line 234 of file logic.c.

237{
239 GLuint i;
240
241 /* Read dest values from frame buffer */
242 (*ctx->Driver.ReadIndexPixels)( ctx, n, x, y, dest, mask );
243
244 switch (ctx->Color.LogicOp) {
245 case GL_CLEAR:
246 for (i=0;i<n;i++) {
247 if (mask[i]) {
248 index[i] = 0;
249 }
250 }
251 break;
252 case GL_SET:
253 for (i=0;i<n;i++) {
254 if (mask[i]) {
255 index[i] = 1;
256 }
257 }
258 break;
259 case GL_COPY:
260 /* do nothing */
261 break;
262 case GL_COPY_INVERTED:
263 for (i=0;i<n;i++) {
264 if (mask[i]) {
265 index[i] = ~index[i];
266 }
267 }
268 break;
269 case GL_NOOP:
270 for (i=0;i<n;i++) {
271 if (mask[i]) {
272 index[i] = dest[i];
273 }
274 }
275 break;
276 case GL_INVERT:
277 for (i=0;i<n;i++) {
278 if (mask[i]) {
279 index[i] = ~dest[i];
280 }
281 }
282 break;
283 case GL_AND:
284 for (i=0;i<n;i++) {
285 if (mask[i]) {
286 index[i] &= dest[i];
287 }
288 }
289 break;
290 case GL_NAND:
291 for (i=0;i<n;i++) {
292 if (mask[i]) {
293 index[i] = ~(index[i] & dest[i]);
294 }
295 }
296 break;
297 case GL_OR:
298 for (i=0;i<n;i++) {
299 if (mask[i]) {
300 index[i] |= dest[i];
301 }
302 }
303 break;
304 case GL_NOR:
305 for (i=0;i<n;i++) {
306 if (mask[i]) {
307 index[i] = ~(index[i] | dest[i]);
308 }
309 }
310 break;
311 case GL_XOR:
312 for (i=0;i<n;i++) {
313 if (mask[i]) {
314 index[i] ^= dest[i];
315 }
316 }
317 break;
318 case GL_EQUIV:
319 for (i=0;i<n;i++) {
320 if (mask[i]) {
321 index[i] = ~(index[i] ^ dest[i]);
322 }
323 }
324 break;
325 case GL_AND_REVERSE:
326 for (i=0;i<n;i++) {
327 if (mask[i]) {
328 index[i] = index[i] & ~dest[i];
329 }
330 }
331 break;
332 case GL_AND_INVERTED:
333 for (i=0;i<n;i++) {
334 if (mask[i]) {
335 index[i] = ~index[i] & dest[i];
336 }
337 }
338 break;
339 case GL_OR_REVERSE:
340 for (i=0;i<n;i++) {
341 if (mask[i]) {
342 index[i] = index[i] | ~dest[i];
343 }
344 }
345 break;
346 case GL_OR_INVERTED:
347 for (i=0;i<n;i++) {
348 if (mask[i]) {
349 index[i] = ~index[i] | dest[i];
350 }
351 }
352 break;
353 default:
354 gl_error( ctx, GL_INVALID_ENUM, "gl_logic_pixels error" );
355 }
356}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
unsigned int GLuint
Definition: gl.h:159
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLdouble n
Definition: glext.h:7729
GLuint index
Definition: glext.h:6031
GLenum GLint GLuint mask
Definition: glext.h:6028
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static char * dest
Definition: rtl.c:135
#define PB_SIZE
Definition: pb.h:52

Referenced by gl_flush_pb().

◆ gl_logicop_ci_span()

void gl_logicop_ci_span ( GLcontext ctx,
GLuint  n,
GLint  x,
GLint  y,
GLuint  index[],
GLubyte  mask[] 
)

Definition at line 105 of file logic.c.

107{
109 GLuint i;
110
111 /* Read dest values from frame buffer */
112 (*ctx->Driver.ReadIndexSpan)( ctx, n, x, y, dest );
113
114 switch (ctx->Color.LogicOp) {
115 case GL_CLEAR:
116 for (i=0;i<n;i++) {
117 if (mask[i]) {
118 index[i] = 0;
119 }
120 }
121 break;
122 case GL_SET:
123 for (i=0;i<n;i++) {
124 if (mask[i]) {
125 index[i] = 1;
126 }
127 }
128 break;
129 case GL_COPY:
130 /* do nothing */
131 break;
132 case GL_COPY_INVERTED:
133 for (i=0;i<n;i++) {
134 if (mask[i]) {
135 index[i] = ~index[i];
136 }
137 }
138 break;
139 case GL_NOOP:
140 for (i=0;i<n;i++) {
141 if (mask[i]) {
142 index[i] = dest[i];
143 }
144 }
145 break;
146 case GL_INVERT:
147 for (i=0;i<n;i++) {
148 if (mask[i]) {
149 index[i] = ~dest[i];
150 }
151 }
152 break;
153 case GL_AND:
154 for (i=0;i<n;i++) {
155 if (mask[i]) {
156 index[i] &= dest[i];
157 }
158 }
159 break;
160 case GL_NAND:
161 for (i=0;i<n;i++) {
162 if (mask[i]) {
163 index[i] = ~(index[i] & dest[i]);
164 }
165 }
166 break;
167 case GL_OR:
168 for (i=0;i<n;i++) {
169 if (mask[i]) {
170 index[i] |= dest[i];
171 }
172 }
173 break;
174 case GL_NOR:
175 for (i=0;i<n;i++) {
176 if (mask[i]) {
177 index[i] = ~(index[i] | dest[i]);
178 }
179 }
180 break;
181 case GL_XOR:
182 for (i=0;i<n;i++) {
183 if (mask[i]) {
184 index[i] ^= dest[i];
185 }
186 }
187 break;
188 case GL_EQUIV:
189 for (i=0;i<n;i++) {
190 if (mask[i]) {
191 index[i] = ~(index[i] ^ dest[i]);
192 }
193 }
194 break;
195 case GL_AND_REVERSE:
196 for (i=0;i<n;i++) {
197 if (mask[i]) {
198 index[i] = index[i] & ~dest[i];
199 }
200 }
201 break;
202 case GL_AND_INVERTED:
203 for (i=0;i<n;i++) {
204 if (mask[i]) {
205 index[i] = ~index[i] & dest[i];
206 }
207 }
208 break;
209 case GL_OR_REVERSE:
210 for (i=0;i<n;i++) {
211 if (mask[i]) {
212 index[i] = index[i] | ~dest[i];
213 }
214 }
215 break;
216 case GL_OR_INVERTED:
217 for (i=0;i<n;i++) {
218 if (mask[i]) {
219 index[i] = ~index[i] | dest[i];
220 }
221 }
222 break;
223 default:
224 gl_error( ctx, GL_INVALID_ENUM, "gl_logic error" );
225 }
226}
#define MAX_WIDTH
Definition: config.h:130

Referenced by gl_write_index_span(), and gl_write_monoindex_span().

◆ gl_logicop_rgba_pixels()

void gl_logicop_rgba_pixels ( GLcontext ctx,
GLuint  n,
const GLint  x[],
const GLint  y[],
GLubyte  red[],
GLubyte  green[],
GLubyte  blue[],
GLubyte  alpha[],
GLubyte  mask[] 
)

Definition at line 548 of file logic.c.

553{
554 GLubyte rdest[PB_SIZE], gdest[PB_SIZE], bdest[PB_SIZE], adest[PB_SIZE];
555 GLuint i;
556
557 /* Read pixels from current color buffer */
558 (*ctx->Driver.ReadColorPixels)( ctx, n, x, y, rdest, gdest, bdest, adest, mask );
559 if (ctx->RasterMask & ALPHABUF_BIT) {
560 gl_read_alpha_pixels( ctx, n, x, y, adest, mask );
561 }
562
563 /* apply logic op */
564 switch (ctx->Color.LogicOp) {
565 case GL_CLEAR:
566 for (i=0;i<n;i++) {
567 if (mask[i]) {
568 red[i] = green[i] = blue[i] = alpha[i] = 0;
569 }
570 }
571 break;
572 case GL_SET:
573 {
574 GLubyte r = (GLint) ctx->Visual->RedScale;
575 GLubyte g = (GLint) ctx->Visual->GreenScale;
576 GLubyte b = (GLint) ctx->Visual->BlueScale;
577 GLubyte a = (GLint) ctx->Visual->AlphaScale;
578 for (i=0;i<n;i++) {
579 if (mask[i]) {
580 red[i] = r;
581 green[i] = g;
582 blue[i] = b;
583 alpha[i] = a;
584 }
585 }
586 }
587 break;
588 case GL_COPY:
589 /* do nothing */
590 break;
591 case GL_COPY_INVERTED:
592 for (i=0;i<n;i++) {
593 if (mask[i]) {
594 red[i] = ~red[i];
595 green[i] = ~green[i];
596 blue[i] = ~blue[i];
597 alpha[i] = ~alpha[i];
598 }
599 }
600 break;
601 case GL_NOOP:
602 for (i=0;i<n;i++) {
603 if (mask[i]) {
604 red[i] = rdest[i];
605 green[i] = gdest[i];
606 blue[i] = bdest[i];
607 alpha[i] = adest[i];
608 }
609 }
610 break;
611 case GL_INVERT:
612 for (i=0;i<n;i++) {
613 if (mask[i]) {
614 red[i] = ~rdest[i];
615 green[i] = ~gdest[i];
616 blue[i] = ~bdest[i];
617 alpha[i] = ~adest[i];
618 }
619 }
620 break;
621 case GL_AND:
622 for (i=0;i<n;i++) {
623 if (mask[i]) {
624 red[i] &= rdest[i];
625 green[i] &= gdest[i];
626 blue[i] &= bdest[i];
627 alpha[i] &= adest[i];
628 }
629 }
630 break;
631 case GL_NAND:
632 for (i=0;i<n;i++) {
633 if (mask[i]) {
634 red[i] = ~(red[i] & rdest[i]);
635 green[i] = ~(green[i] & gdest[i]);
636 blue[i] = ~(blue[i] & bdest[i]);
637 alpha[i] = ~(alpha[i] & adest[i]);
638 }
639 }
640 break;
641 case GL_OR:
642 for (i=0;i<n;i++) {
643 if (mask[i]) {
644 red[i] |= rdest[i];
645 green[i] |= gdest[i];
646 blue[i] |= bdest[i];
647 alpha[i] |= adest[i];
648 }
649 }
650 break;
651 case GL_NOR:
652 for (i=0;i<n;i++) {
653 if (mask[i]) {
654 red[i] = ~(red[i] | rdest[i]);
655 green[i] = ~(green[i] | gdest[i]);
656 blue[i] = ~(blue[i] | bdest[i]);
657 alpha[i] = ~(alpha[i] | adest[i]);
658 }
659 }
660 break;
661 case GL_XOR:
662 for (i=0;i<n;i++) {
663 if (mask[i]) {
664 red[i] ^= rdest[i];
665 green[i] ^= gdest[i];
666 blue[i] ^= bdest[i];
667 alpha[i] ^= adest[i];
668 }
669 }
670 break;
671 case GL_EQUIV:
672 for (i=0;i<n;i++) {
673 if (mask[i]) {
674 red[i] = ~(red[i] ^ rdest[i]);
675 green[i] = ~(green[i] ^ gdest[i]);
676 blue[i] = ~(blue[i] ^ bdest[i]);
677 alpha[i] = ~(alpha[i] ^ adest[i]);
678 }
679 }
680 break;
681 case GL_AND_REVERSE:
682 for (i=0;i<n;i++) {
683 if (mask[i]) {
684 red[i] = red[i] & ~rdest[i];
685 green[i] = green[i] & ~gdest[i];
686 blue[i] = blue[i] & ~bdest[i];
687 alpha[i] = alpha[i] & ~adest[i];
688 }
689 }
690 break;
691 case GL_AND_INVERTED:
692 for (i=0;i<n;i++) {
693 if (mask[i]) {
694 red[i] = ~red[i] & rdest[i];
695 green[i] = ~green[i] & gdest[i];
696 blue[i] = ~blue[i] & bdest[i];
697 alpha[i] = ~alpha[i] & adest[i];
698 }
699 }
700 break;
701 case GL_OR_REVERSE:
702 for (i=0;i<n;i++) {
703 if (mask[i]) {
704 red[i] = red[i] | ~rdest[i];
705 green[i] = green[i] | ~gdest[i];
706 blue[i] = blue[i] | ~bdest[i];
707 alpha[i] = alpha[i] | ~adest[i];
708 }
709 }
710 break;
711 case GL_OR_INVERTED:
712 for (i=0;i<n;i++) {
713 if (mask[i]) {
714 red[i] = ~red[i] | rdest[i];
715 green[i] = ~green[i] | gdest[i];
716 blue[i] = ~blue[i] | bdest[i];
717 alpha[i] = ~alpha[i] | adest[i];
718 }
719 }
720 break;
721 default:
722 /* should never happen */
723 gl_problem(ctx, "Bad function in gl_logicop_rgba_pixels");
724 return;
725 }
726}
void gl_read_alpha_pixels(GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte alpha[], const GLubyte mask[])
Definition: alphabuf.c:257
void gl_problem(const GLcontext *ctx, const char *s)
Definition: context.c:1394
#define ALPHABUF_BIT
Definition: types.h:1223
unsigned char GLubyte
Definition: gl.h:157
GLclampf green
Definition: gl.h:1740
GLclampf GLclampf GLclampf alpha
Definition: gl.h:1740
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLclampf GLclampf blue
Definition: gl.h:1740
int GLint
Definition: gl.h:156
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean g
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
#define a
Definition: ke_i.h:78
#define b
Definition: ke_i.h:79
#define red
Definition: linetest.c:67

Referenced by gl_flush_pb().

◆ gl_logicop_rgba_span()

void gl_logicop_rgba_span ( GLcontext ctx,
GLuint  n,
GLint  x,
GLint  y,
GLubyte  red[],
GLubyte  green[],
GLubyte  blue[],
GLubyte  alpha[],
GLubyte  mask[] 
)

Definition at line 364 of file logic.c.

369{
370 GLubyte rdest[MAX_WIDTH], gdest[MAX_WIDTH];
371 GLubyte bdest[MAX_WIDTH], adest[MAX_WIDTH];
372 GLuint i;
373
374 /* Read span of current frame buffer pixels */
375 gl_read_color_span( ctx, n, x, y, rdest, gdest, bdest, adest );
376
377 /* apply logic op */
378 switch (ctx->Color.LogicOp) {
379 case GL_CLEAR:
380 for (i=0;i<n;i++) {
381 if (mask[i]) {
382 red[i] = green[i] = blue[i] = alpha[i] = 0;
383 }
384 }
385 break;
386 case GL_SET:
387 {
388 GLubyte r = (GLint) ctx->Visual->RedScale;
389 GLubyte g = (GLint) ctx->Visual->GreenScale;
390 GLubyte b = (GLint) ctx->Visual->BlueScale;
391 GLubyte a = (GLint) ctx->Visual->AlphaScale;
392 for (i=0;i<n;i++) {
393 if (mask[i]) {
394 red[i] = r;
395 green[i] = g;
396 blue[i] = b;
397 alpha[i] = a;
398 }
399 }
400 }
401 break;
402 case GL_COPY:
403 /* do nothing */
404 break;
405 case GL_COPY_INVERTED:
406 for (i=0;i<n;i++) {
407 if (mask[i]) {
408 red[i] = ~red[i];
409 green[i] = ~green[i];
410 blue[i] = ~blue[i];
411 alpha[i] = ~alpha[i];
412 }
413 }
414 break;
415 case GL_NOOP:
416 for (i=0;i<n;i++) {
417 if (mask[i]) {
418 red[i] = rdest[i];
419 green[i] = gdest[i];
420 blue[i] = bdest[i];
421 alpha[i] = adest[i];
422 }
423 }
424 break;
425 case GL_INVERT:
426 for (i=0;i<n;i++) {
427 if (mask[i]) {
428 red[i] = ~rdest[i];
429 green[i] = ~gdest[i];
430 blue[i] = ~bdest[i];
431 alpha[i] = ~adest[i];
432 }
433 }
434 break;
435 case GL_AND:
436 for (i=0;i<n;i++) {
437 if (mask[i]) {
438 red[i] &= rdest[i];
439 green[i] &= gdest[i];
440 blue[i] &= bdest[i];
441 alpha[i] &= adest[i];
442 }
443 }
444 break;
445 case GL_NAND:
446 for (i=0;i<n;i++) {
447 if (mask[i]) {
448 red[i] = ~(red[i] & rdest[i]);
449 green[i] = ~(green[i] & gdest[i]);
450 blue[i] = ~(blue[i] & bdest[i]);
451 alpha[i] = ~(alpha[i] & adest[i]);
452 }
453 }
454 break;
455 case GL_OR:
456 for (i=0;i<n;i++) {
457 if (mask[i]) {
458 red[i] |= rdest[i];
459 green[i] |= gdest[i];
460 blue[i] |= bdest[i];
461 alpha[i] |= adest[i];
462 }
463 }
464 break;
465 case GL_NOR:
466 for (i=0;i<n;i++) {
467 if (mask[i]) {
468 red[i] = ~(red[i] | rdest[i]);
469 green[i] = ~(green[i] | gdest[i]);
470 blue[i] = ~(blue[i] | bdest[i]);
471 alpha[i] = ~(alpha[i] | adest[i]);
472 }
473 }
474 break;
475 case GL_XOR:
476 for (i=0;i<n;i++) {
477 if (mask[i]) {
478 red[i] ^= rdest[i];
479 green[i] ^= gdest[i];
480 blue[i] ^= bdest[i];
481 alpha[i] ^= adest[i];
482 }
483 }
484 break;
485 case GL_EQUIV:
486 for (i=0;i<n;i++) {
487 if (mask[i]) {
488 red[i] = ~(red[i] ^ rdest[i]);
489 green[i] = ~(green[i] ^ gdest[i]);
490 blue[i] = ~(blue[i] ^ bdest[i]);
491 alpha[i] = ~(alpha[i] ^ adest[i]);
492 }
493 }
494 break;
495 case GL_AND_REVERSE:
496 for (i=0;i<n;i++) {
497 if (mask[i]) {
498 red[i] = red[i] & ~rdest[i];
499 green[i] = green[i] & ~gdest[i];
500 blue[i] = blue[i] & ~bdest[i];
501 alpha[i] = alpha[i] & ~adest[i];
502 }
503 }
504 break;
505 case GL_AND_INVERTED:
506 for (i=0;i<n;i++) {
507 if (mask[i]) {
508 red[i] = ~red[i] & rdest[i];
509 green[i] = ~green[i] & gdest[i];
510 blue[i] = ~blue[i] & bdest[i];
511 alpha[i] = ~alpha[i] & adest[i];
512 }
513 }
514 break;
515 case GL_OR_REVERSE:
516 for (i=0;i<n;i++) {
517 if (mask[i]) {
518 red[i] = red[i] | ~rdest[i];
519 green[i] = green[i] | ~gdest[i];
520 blue[i] = blue[i] | ~bdest[i];
521 alpha[i] = alpha[i] | ~adest[i];
522 }
523 }
524 break;
525 case GL_OR_INVERTED:
526 for (i=0;i<n;i++) {
527 if (mask[i]) {
528 red[i] = ~red[i] | rdest[i];
529 green[i] = ~green[i] | gdest[i];
530 blue[i] = ~blue[i] | bdest[i];
531 alpha[i] = ~alpha[i] | adest[i];
532 }
533 }
534 break;
535 default:
536 /* should never happen */
537 gl_problem(ctx, "Bad function in gl_logicop_rgba_span");
538 return;
539 }
540}
void gl_read_color_span(GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte red[], GLubyte green[], GLubyte blue[], GLubyte alpha[])
Definition: span.c:850

Referenced by gl_write_color_span(), gl_write_monocolor_span(), and gl_write_texture_span().