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