ReactOS  0.4.14-dev-52-g6116262
depth.c
Go to the documentation of this file.
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 
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 
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 
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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 
void gl_DepthFunc(GLcontext *ctx, GLenum func)
Definition: depth.c:98
GLenum func
Definition: glext.h:6028
#define GL_LEQUAL
Definition: gl.h:296
void gl_read_depth_span_int(GLcontext *ctx, GLuint n, GLint x, GLint y, GLdepth depth[])
Definition: depth.c:820
GLframebuffer * Buffer
Definition: types.h:1273
GLuint NewState
Definition: types.h:1355
unsigned char GLubyte
Definition: gl.h:157
#define GL_FALSE
Definition: gl.h:173
GLint Ymin
Definition: types.h:1195
#define free
Definition: debug_ros.c:5
GLenum GLenum GLenum GLenum GLenum scale
Definition: glext.h:9032
void gl_depth_test_pixels_less(GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], const GLdepth z[], GLubyte mask[])
Definition: depth.c:726
GLdouble n
Definition: glext.h:7729
#define GL_GEQUAL
Definition: gl.h:299
void gl_DepthMask(GLcontext *ctx, GLboolean flag)
Definition: depth.c:124
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLvisual * Visual
Definition: types.h:1272
GLint Height
Definition: types.h:1179
const GLfloat * m
Definition: glext.h:10848
#define GL_LESS
Definition: gl.h:294
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
#define Z_ADDRESS(CTX, X, Y)
Definition: depth.h:45
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
GLenum GLint GLuint mask
Definition: glext.h:6028
void gl_clear_depth_buffer(GLcontext *ctx)
Definition: depth.c:875
#define CLAMP(f, min, max)
Definition: tif_color.c:177
unsigned char GLboolean
Definition: gl.h:151
void gl_read_depth_span_float(GLcontext *ctx, GLuint n, GLint x, GLint y, GLfloat depth[])
Definition: depth.c:789
GLdouble GLdouble z
Definition: glext.h:5874
smooth NULL
Definition: ftsmooth.c:416
Definition: bufpool.h:45
GLint Xmin
Definition: types.h:1195
double GLclampd
Definition: gl.h:164
void gl_depth_test_pixels_generic(GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], const GLdepth z[], GLubyte mask[])
Definition: depth.c:489
#define GL_NOTEQUAL
Definition: gl.h:298
struct gl_scissor_attrib Scissor
Definition: types.h:1332
GLfloat f
Definition: glext.h:7540
#define GL_ALWAYS
Definition: gl.h:300
GLint GLdepth
Definition: types.h:218
#define d
Definition: ke_i.h:81
#define GL_GREATER
Definition: gl.h:297
void gl_alloc_depth_buffer(GLcontext *ctx)
Definition: depth.c:848
GLuint gl_depth_test_span_greater(GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], GLubyte mask[])
Definition: depth.c:447
#define MEMCPY(DST, SRC, BYTES)
Definition: macros.h:231
GLdepth * Depth
Definition: types.h:1181
GLuint gl_depth_test_span_generic(GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], GLubyte mask[])
Definition: depth.c:193
#define GL_NEVER
Definition: gl.h:293
#define GL_INVALID_OPERATION
Definition: gl.h:696
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
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 flag
Definition: glfuncs.h:52
#define NEW_RASTER_OPS
Definition: types.h:1233
unsigned int GLenum
Definition: gl.h:150
void gl_problem(const GLcontext *ctx, const char *s)
Definition: context.c:1394
void gl_DepthRange(GLcontext *ctx, GLclampd nearval, GLclampd farval)
Definition: depth.c:141
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
struct gl_depthbuffer_attrib Depth
Definition: types.h:1321
void gl_ClearDepth(GLcontext *ctx, GLclampd depth)
Definition: depth.c:87
unsigned int GLuint
Definition: gl.h:159
#define f
Definition: ke_i.h:83
#define GL_INVALID_ENUM
Definition: gl.h:694
struct gl_viewport_attrib Viewport
Definition: types.h:1336
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLint Width
Definition: types.h:1178
#define GL_OUT_OF_MEMORY
Definition: gl.h:699
float GLfloat
Definition: gl.h:161
void gl_depth_test_pixels_greater(GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], const GLdepth z[], GLubyte mask[])
Definition: depth.c:752
int GLint
Definition: gl.h:156
#define malloc
Definition: debug_ros.c:4
GLint Xmax
Definition: types.h:1195
GLuint gl_depth_test_span_less(GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], GLubyte mask[])
Definition: depth.c:419
GLint DepthBits
Definition: types.h:1161
#define GL_EQUAL
Definition: gl.h:295
#define DEPTH_SCALE
Definition: config.h:146