source: trunk/src/opengl/mesa/depth.c@ 3084

Last change on this file since 3084 was 2962, checked in by jeroen, 25 years ago

* empty log message *
File size: 19.3 KB
Line 
1/* $Id: depth.c,v 1.2 2000-03-01 18:49:26 jeroen Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28/* $XFree86: xc/lib/GL/mesa/src/depth.c,v 1.3 1999/04/04 00:20:22 dawes Exp $ */
29
30/*
31 * Depth buffer functions
32 */
33
34#include <stdlib.h>
35
36#ifdef PC_HEADER
37#include "all.h"
38#else
39#ifndef XFree86Server
40#include <stdio.h>
41#include <string.h>
42#else
43#include "GL/xf86glx.h"
44#endif
45#include "types.h"
46#include "context.h"
47#include "enums.h"
48#include "depth.h"
49#include "macros.h"
50#endif
51
52
53
54/**********************************************************************/
55/***** API Functions *****/
56/**********************************************************************/
57
58
59
60void gl_ClearDepth( GLcontext* ctx, GLclampd depth )
61{
62 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearDepth");
63 ctx->Depth.Clear = (GLfloat) CLAMP( depth, 0.0, 1.0 );
64 if (ctx->Driver.ClearDepth)
65 (*ctx->Driver.ClearDepth)( ctx, ctx->Depth.Clear );
66}
67
68
69
70void gl_DepthFunc( GLcontext* ctx, GLenum func )
71{
72 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthFunc");
73
74 if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
75 fprintf(stderr, "glDepthFunc %s\n", gl_lookup_enum_by_nr(func));
76
77 switch (func) {
78 case GL_LESS: /* (default) pass if incoming z < stored z */
79 case GL_GEQUAL:
80 case GL_LEQUAL:
81 case GL_GREATER:
82 case GL_NOTEQUAL:
83 case GL_EQUAL:
84 case GL_ALWAYS:
85 if (ctx->Depth.Func != func) {
86 ctx->Depth.Func = func;
87 ctx->NewState |= NEW_RASTER_OPS;
88 ctx->TriangleCaps &= ~DD_Z_NEVER;
89 if (ctx->Driver.DepthFunc) {
90 (*ctx->Driver.DepthFunc)( ctx, func );
91 }
92 }
93 break;
94 case GL_NEVER:
95 if (ctx->Depth.Func != func) {
96 ctx->Depth.Func = func;
97 ctx->NewState |= NEW_RASTER_OPS;
98 ctx->TriangleCaps |= DD_Z_NEVER;
99 if (ctx->Driver.DepthFunc) {
100 (*ctx->Driver.DepthFunc)( ctx, func );
101 }
102 }
103 break;
104 default:
105 gl_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );
106 }
107}
108
109
110
111void gl_DepthMask( GLcontext* ctx, GLboolean flag )
112{
113 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthMask");
114
115 if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
116 fprintf(stderr, "glDepthMask %d\n", flag);
117
118 /*
119 * GL_TRUE indicates depth buffer writing is enabled (default)
120 * GL_FALSE indicates depth buffer writing is disabled
121 */
122 if (ctx->Depth.Mask != flag) {
123 ctx->Depth.Mask = flag;
124 ctx->NewState |= NEW_RASTER_OPS;
125 if (ctx->Driver.DepthMask) {
126 (*ctx->Driver.DepthMask)( ctx, flag );
127 }
128 }
129}
130
131
132
133/**********************************************************************/
134/***** Depth Testing Functions *****/
135/**********************************************************************/
136
137
138/*
139 * Depth test horizontal spans of fragments. These functions are called
140 * via ctx->Driver.depth_test_span only.
141 *
142 * Input: n - number of pixels in the span
143 * x, y - location of leftmost pixel in span in window coords
144 * z - array [n] of integer depth values
145 * In/Out: mask - array [n] of flags (1=draw pixel, 0=don't draw)
146 * Return: number of pixels which passed depth test
147 */
148
149
150/*
151 * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
152 */
153GLuint gl_depth_test_span_generic( GLcontext* ctx,
154 GLuint n, GLint x, GLint y,
155 const GLdepth z[],
156 GLubyte mask[] )
157{
158 GLdepth *zptr = Z_ADDRESS( ctx, x, y );
159 GLubyte *m = mask;
160 GLuint i;
161 GLuint passed = 0;
162
163 /* switch cases ordered from most frequent to less frequent */
164 switch (ctx->Depth.Func) {
165 case GL_LESS:
166 if (ctx->Depth.Mask) {
167 /* Update Z buffer */
168 for (i=0; i<n; i++,zptr++,m++) {
169 if (*m) {
170 if (z[i] < *zptr) {
171 /* pass */
172 *zptr = z[i];
173 passed++;
174 }
175 else {
176 /* fail */
177 *m = 0;
178 }
179 }
180 }
181 }
182 else {
183 /* Don't update Z buffer */
184 for (i=0; i<n; i++,zptr++,m++) {
185 if (*m) {
186 if (z[i] < *zptr) {
187 /* pass */
188 passed++;
189 }
190 else {
191 *m = 0;
192 }
193 }
194 }
195 }
196 break;
197 case GL_LEQUAL:
198 if (ctx->Depth.Mask) {
199 /* Update Z buffer */
200 for (i=0;i<n;i++,zptr++,m++) {
201 if (*m) {
202 if (z[i] <= *zptr) {
203 *zptr = z[i];
204 passed++;
205 }
206 else {
207 *m = 0;
208 }
209 }
210 }
211 }
212 else {
213 /* Don't update Z buffer */
214 for (i=0;i<n;i++,zptr++,m++) {
215 if (*m) {
216 if (z[i] <= *zptr) {
217 /* pass */
218 passed++;
219 }
220 else {
221 *m = 0;
222 }
223 }
224 }
225 }
226 break;
227 case GL_GEQUAL:
228 if (ctx->Depth.Mask) {
229 /* Update Z buffer */
230 for (i=0;i<n;i++,zptr++,m++) {
231 if (*m) {
232 if (z[i] >= *zptr) {
233 *zptr = z[i];
234 passed++;
235 }
236 else {
237 *m = 0;
238 }
239 }
240 }
241 }
242 else {
243 /* Don't update Z buffer */
244 for (i=0;i<n;i++,zptr++,m++) {
245 if (*m) {
246 if (z[i] >= *zptr) {
247 /* pass */
248 passed++;
249 }
250 else {
251 *m = 0;
252 }
253 }
254 }
255 }
256 break;
257 case GL_GREATER:
258 if (ctx->Depth.Mask) {
259 /* Update Z buffer */
260 for (i=0;i<n;i++,zptr++,m++) {
261 if (*m) {
262 if (z[i] > *zptr) {
263 *zptr = z[i];
264 passed++;
265 }
266 else {
267 *m = 0;
268 }
269 }
270 }
271 }
272 else {
273 /* Don't update Z buffer */
274 for (i=0;i<n;i++,zptr++,m++) {
275 if (*m) {
276 if (z[i] > *zptr) {
277 /* pass */
278 passed++;
279 }
280 else {
281 *m = 0;
282 }
283 }
284 }
285 }
286 break;
287 case GL_NOTEQUAL:
288 if (ctx->Depth.Mask) {
289 /* Update Z buffer */
290 for (i=0;i<n;i++,zptr++,m++) {
291 if (*m) {
292 if (z[i] != *zptr) {
293 *zptr = z[i];
294 passed++;
295 }
296 else {
297 *m = 0;
298 }
299 }
300 }
301 }
302 else {
303 /* Don't update Z buffer */
304 for (i=0;i<n;i++,zptr++,m++) {
305 if (*m) {
306 if (z[i] != *zptr) {
307 /* pass */
308 passed++;
309 }
310 else {
311 *m = 0;
312 }
313 }
314 }
315 }
316 break;
317 case GL_EQUAL:
318 if (ctx->Depth.Mask) {
319 /* Update Z buffer */
320 for (i=0;i<n;i++,zptr++,m++) {
321 if (*m) {
322 if (z[i] == *zptr) {
323 *zptr = z[i];
324 passed++;
325 }
326 else {
327 *m =0;
328 }
329 }
330 }
331 }
332 else {
333 /* Don't update Z buffer */
334 for (i=0;i<n;i++,zptr++,m++) {
335 if (*m) {
336 if (z[i] == *zptr) {
337 /* pass */
338 passed++;
339 }
340 else {
341 *m =0;
342 }
343 }
344 }
345 }
346 break;
347 case GL_ALWAYS:
348 if (ctx->Depth.Mask) {
349 /* Update Z buffer */
350 for (i=0;i<n;i++,zptr++,m++) {
351 if (*m) {
352 *zptr = z[i];
353 passed++;
354 }
355 }
356 }
357 else {
358 /* Don't update Z buffer or mask */
359 passed = n;
360 }
361 break;
362 case GL_NEVER:
363 for (i=0;i<n;i++) {
364 mask[i] = 0;
365 }
366 break;
367 default:
368 gl_problem(ctx, "Bad depth func in gl_depth_test_span_generic");
369 } /*switch*/
370
371 return passed;
372}
373
374
375
376/*
377 * glDepthFunc(GL_LESS) and glDepthMask(GL_TRUE).
378 */
379GLuint gl_depth_test_span_less( GLcontext* ctx,
380 GLuint n, GLint x, GLint y, const GLdepth z[],
381 GLubyte mask[] )
382{
383 GLdepth *zptr = Z_ADDRESS( ctx, x, y );
384 GLuint i;
385 GLuint passed = 0;
386
387 for (i=0; i<n; i++) {
388 if (mask[i]) {
389 if (z[i] < zptr[i]) {
390 /* pass */
391 zptr[i] = z[i];
392 passed++;
393 }
394 else {
395 /* fail */
396 mask[i] = 0;
397 }
398 }
399 }
400 return passed;
401}
402
403
404/*
405 * glDepthFunc(GL_GREATER) and glDepthMask(GL_TRUE).
406 */
407GLuint gl_depth_test_span_greater( GLcontext* ctx,
408 GLuint n, GLint x, GLint y,
409 const GLdepth z[],
410 GLubyte mask[] )
411{
412 GLdepth *zptr = Z_ADDRESS( ctx, x, y );
413 GLuint i;
414 GLuint passed = 0;
415
416 for (i=0; i<n; i++) {
417 if (mask[i]) {
418 if (z[i] > zptr[i]) {
419 /* pass */
420 zptr[i] = z[i];
421 passed++;
422 }
423 else {
424 /* fail */
425 mask[i] = 0;
426 }
427 }
428 }
429 return passed;
430}
431
432
433
434/*
435 * Depth test an array of randomly positioned fragments.
436 */
437
438
439#define ZADDR_SETUP GLdepth *depthbuffer = ctx->Buffer->Depth; \
440 GLint width = ctx->Buffer->Width;
441
442#define ZADDR( X, Y ) (depthbuffer + (Y) * width + (X) )
443
444
445
446/*
447 * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
448 */
449void gl_depth_test_pixels_generic( GLcontext* ctx,
450 GLuint n, const GLint x[], const GLint y[],
451 const GLdepth z[], GLubyte mask[] )
452{
453 register GLdepth *zptr;
454 register GLuint i;
455
456 /* switch cases ordered from most frequent to less frequent */
457 switch (ctx->Depth.Func) {
458 case GL_LESS:
459 if (ctx->Depth.Mask) {
460 /* Update Z buffer */
461 for (i=0; i<n; i++) {
462 if (mask[i]) {
463 zptr = Z_ADDRESS(ctx,x[i],y[i]);
464 if (z[i] < *zptr) {
465 /* pass */
466 *zptr = z[i];
467 }
468 else {
469 /* fail */
470 mask[i] = 0;
471 }
472 }
473 }
474 }
475 else {
476 /* Don't update Z buffer */
477 for (i=0; i<n; i++) {
478 if (mask[i]) {
479 zptr = Z_ADDRESS(ctx,x[i],y[i]);
480 if (z[i] < *zptr) {
481 /* pass */
482 }
483 else {
484 /* fail */
485 mask[i] = 0;
486 }
487 }
488 }
489 }
490 break;
491 case GL_LEQUAL:
492 if (ctx->Depth.Mask) {
493 /* Update Z buffer */
494 for (i=0; i<n; i++) {
495 if (mask[i]) {
496 zptr = Z_ADDRESS(ctx,x[i],y[i]);
497 if (z[i] <= *zptr) {
498 /* pass */
499 *zptr = z[i];
500 }
501 else {
502 /* fail */
503 mask[i] = 0;
504 }
505 }
506 }
507 }
508 else {
509 /* Don't update Z buffer */
510 for (i=0; i<n; i++) {
511 if (mask[i]) {
512 zptr = Z_ADDRESS(ctx,x[i],y[i]);
513 if (z[i] <= *zptr) {
514 /* pass */
515 }
516 else {
517 /* fail */
518 mask[i] = 0;
519 }
520 }
521 }
522 }
523 break;
524 case GL_GEQUAL:
525 if (ctx->Depth.Mask) {
526 /* Update Z buffer */
527 for (i=0; i<n; i++) {
528 if (mask[i]) {
529 zptr = Z_ADDRESS(ctx,x[i],y[i]);
530 if (z[i] >= *zptr) {
531 /* pass */
532 *zptr = z[i];
533 }
534 else {
535 /* fail */
536 mask[i] = 0;
537 }
538 }
539 }
540 }
541 else {
542 /* Don't update Z buffer */
543 for (i=0; i<n; i++) {
544 if (mask[i]) {
545 zptr = Z_ADDRESS(ctx,x[i],y[i]);
546 if (z[i] >= *zptr) {
547 /* pass */
548 }
549 else {
550 /* fail */
551 mask[i] = 0;
552 }
553 }
554 }
555 }
556 break;
557 case GL_GREATER:
558 if (ctx->Depth.Mask) {
559 /* Update Z buffer */
560 for (i=0; i<n; i++) {
561 if (mask[i]) {
562 zptr = Z_ADDRESS(ctx,x[i],y[i]);
563 if (z[i] > *zptr) {
564 /* pass */
565 *zptr = z[i];
566 }
567 else {
568 /* fail */
569 mask[i] = 0;
570 }
571 }
572 }
573 }
574 else {
575 /* Don't update Z buffer */
576 for (i=0; i<n; i++) {
577 if (mask[i]) {
578 zptr = Z_ADDRESS(ctx,x[i],y[i]);
579 if (z[i] > *zptr) {
580 /* pass */
581 }
582 else {
583 /* fail */
584 mask[i] = 0;
585 }
586 }
587 }
588 }
589 break;
590 case GL_NOTEQUAL:
591 if (ctx->Depth.Mask) {
592 /* Update Z buffer */
593 for (i=0; i<n; i++) {
594 if (mask[i]) {
595 zptr = Z_ADDRESS(ctx,x[i],y[i]);
596 if (z[i] != *zptr) {
597 /* pass */
598 *zptr = z[i];
599 }
600 else {
601 /* fail */
602 mask[i] = 0;
603 }
604 }
605 }
606 }
607 else {
608 /* Don't update Z buffer */
609 for (i=0; i<n; i++) {
610 if (mask[i]) {
611 zptr = Z_ADDRESS(ctx,x[i],y[i]);
612 if (z[i] != *zptr) {
613 /* pass */
614 }
615 else {
616 /* fail */
617 mask[i] = 0;
618 }
619 }
620 }
621 }
622 break;
623 case GL_EQUAL:
624 if (ctx->Depth.Mask) {
625 /* Update Z buffer */
626 for (i=0; i<n; i++) {
627 if (mask[i]) {
628 zptr = Z_ADDRESS(ctx,x[i],y[i]);
629 if (z[i] == *zptr) {
630 /* pass */
631 *zptr = z[i];
632 }
633 else {
634 /* fail */
635 mask[i] = 0;
636 }
637 }
638 }
639 }
640 else {
641 /* Don't update Z buffer */
642 for (i=0; i<n; i++) {
643 if (mask[i]) {
644 zptr = Z_ADDRESS(ctx,x[i],y[i]);
645 if (z[i] == *zptr) {
646 /* pass */
647 }
648 else {
649 /* fail */
650 mask[i] = 0;
651 }
652 }
653 }
654 }
655 break;
656 case GL_ALWAYS:
657 if (ctx->Depth.Mask) {
658 /* Update Z buffer */
659 for (i=0; i<n; i++) {
660 if (mask[i]) {
661 zptr = Z_ADDRESS(ctx,x[i],y[i]);
662 *zptr = z[i];
663 }
664 }
665 }
666 else {
667 /* Don't update Z buffer or mask */
668 }
669 break;
670 case GL_NEVER:
671 /* depth test never passes */
672 for (i=0;i<n;i++) {
673 mask[i] = 0;
674 }
675 break;
676 default:
677 gl_problem(ctx, "Bad depth func in gl_depth_test_pixels_generic");
678 } /*switch*/
679}
680
681
682
683/*
684 * glDepthFunc( GL_LESS ) and glDepthMask( GL_TRUE ).
685 */
686void gl_depth_test_pixels_less( GLcontext* ctx,
687 GLuint n, const GLint x[], const GLint y[],
688 const GLdepth z[], GLubyte mask[] )
689{
690 GLdepth *zptr;
691 GLuint i;
692
693 for (i=0; i<n; i++) {
694 if (mask[i]) {
695 zptr = Z_ADDRESS(ctx,x[i],y[i]);
696 if (z[i] < *zptr) {
697 /* pass */
698 *zptr = z[i];
699 }
700 else {
701 /* fail */
702 mask[i] = 0;
703 }
704 }
705 }
706}
707
708
709/*
710 * glDepthFunc( GL_GREATER ) and glDepthMask( GL_TRUE ).
711 */
712void gl_depth_test_pixels_greater( GLcontext* ctx,
713 GLuint n, const GLint x[], const GLint y[],
714 const GLdepth z[], GLubyte mask[] )
715{
716 GLdepth *zptr;
717 GLuint i;
718
719 for (i=0; i<n; i++) {
720 if (mask[i]) {
721 zptr = Z_ADDRESS(ctx,x[i],y[i]);
722 if (z[i] > *zptr) {
723 /* pass */
724 *zptr = z[i];
725 }
726 else {
727 /* fail */
728 mask[i] = 0;
729 }
730 }
731 }
732}
733
734
735
736
737/**********************************************************************/
738/***** Read Depth Buffer *****/
739/**********************************************************************/
740
741
742/*
743 * Return a span of depth values from the depth buffer as floats in [0,1].
744 * This function is only called through Driver.read_depth_span_float()
745 * Input: n - how many pixels
746 * x,y - location of first pixel
747 * Output: depth - the array of depth values
748 */
749void gl_read_depth_span_float( GLcontext* ctx,
750 GLuint n, GLint x, GLint y, GLfloat depth[] )
751{
752 GLdepth *zptr;
753 GLfloat scale;
754 GLuint i;
755
756 scale = 1.0F / DEPTH_SCALE;
757
758 if (ctx->Buffer->Depth) {
759 zptr = Z_ADDRESS( ctx, x, y );
760 for (i=0;i<n;i++) {
761 depth[i] = (GLfloat) zptr[i] * scale;
762 }
763 }
764 else {
765 for (i=0;i<n;i++) {
766 depth[i] = 0.0F;
767 }
768 }
769}
770
771
772/*
773 * Return a span of depth values from the depth buffer as integers in
774 * [0,MAX_DEPTH].
775 * This function is only called through Driver.read_depth_span_int()
776 * Input: n - how many pixels
777 * x,y - location of first pixel
778 * Output: depth - the array of depth values
779 */
780void gl_read_depth_span_int( GLcontext* ctx,
781 GLuint n, GLint x, GLint y, GLdepth depth[] )
782{
783 if (ctx->Buffer->Depth) {
784 GLdepth *zptr = Z_ADDRESS( ctx, x, y );
785 MEMCPY( depth, zptr, n * sizeof(GLdepth) );
786 }
787 else {
788 GLuint i;
789 for (i=0;i<n;i++) {
790 depth[i] = 0;
791 }
792 }
793}
794
795
796
797/**********************************************************************/
798/***** Allocate and Clear Depth Buffer *****/
799/**********************************************************************/
800
801
802
803/*
804 * Allocate a new depth buffer. If there's already a depth buffer allocated
805 * it will be free()'d. The new depth buffer will be uniniitalized.
806 * This function is only called through Driver.alloc_depth_buffer.
807 */
808void gl_alloc_depth_buffer( GLcontext* ctx )
809{
810 /* deallocate current depth buffer if present */
811 if (ctx->Buffer->Depth) {
812 FREE(ctx->Buffer->Depth);
813 ctx->Buffer->Depth = NULL;
814 }
815
816 /* allocate new depth buffer, but don't initialize it */
817 ctx->Buffer->Depth = (GLdepth *) MALLOC( ctx->Buffer->Width
818 * ctx->Buffer->Height
819 * sizeof(GLdepth) );
820 if (!ctx->Buffer->Depth) {
821 /* out of memory */
822 ctx->Depth.Test = GL_FALSE;
823 ctx->NewState |= NEW_RASTER_OPS;
824 gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer" );
825 }
826}
827
828
829
830
831/*
832 * Clear the depth buffer. If the depth buffer doesn't exist yet we'll
833 * allocate it now.
834 * This function is only called through Driver.clear_depth_buffer.
835 */
836void gl_clear_depth_buffer( GLcontext* ctx )
837{
838 GLdepth clear_value = (GLdepth) (ctx->Depth.Clear * DEPTH_SCALE);
839
840 if (ctx->Visual->DepthBits==0 || !ctx->Buffer->Depth || !ctx->Depth.Mask) {
841 /* no depth buffer, or writing to it is disabled */
842 return;
843 }
844
845 /* The loops in this function have been written so the IRIX 5.3
846 * C compiler can unroll them. Hopefully other compilers can too!
847 */
848
849 if (ctx->Scissor.Enabled) {
850 /* only clear scissor region */
851 GLint y;
852 for (y=ctx->Buffer->Ymin; y<=ctx->Buffer->Ymax; y++) {
853 GLdepth *d = Z_ADDRESS( ctx, ctx->Buffer->Xmin, y );
854 GLint n = ctx->Buffer->Xmax - ctx->Buffer->Xmin + 1;
855 do {
856 *d++ = clear_value;
857 n--;
858 } while (n);
859 }
860 }
861 else {
862 /* clear whole buffer */
863 if (sizeof(GLdepth)==2 && (clear_value&0xff)==(clear_value>>8)) {
864 /* lower and upper bytes of clear_value are same, use MEMSET */
865 MEMSET( ctx->Buffer->Depth, clear_value&0xff,
866 2*ctx->Buffer->Width*ctx->Buffer->Height);
867 }
868 else {
869 GLdepth *d = ctx->Buffer->Depth;
870 GLint n = ctx->Buffer->Width * ctx->Buffer->Height;
871 while (n>=16) {
872 d[0] = clear_value; d[1] = clear_value;
873 d[2] = clear_value; d[3] = clear_value;
874 d[4] = clear_value; d[5] = clear_value;
875 d[6] = clear_value; d[7] = clear_value;
876 d[8] = clear_value; d[9] = clear_value;
877 d[10] = clear_value; d[11] = clear_value;
878 d[12] = clear_value; d[13] = clear_value;
879 d[14] = clear_value; d[15] = clear_value;
880 d += 16;
881 n -= 16;
882 }
883 while (n>0) {
884 *d++ = clear_value;
885 n--;
886 }
887 }
888 }
889}
890
891
892
Note: See TracBrowser for help on using the repository browser.