src/mesa/main/depth.c

   1 /* $Id: depth.c,v 1.8 1999/11/08 07:36:43 brianp 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 "context.h"
  46 #include "enums.h"
  47 #include "depth.h"
  48 #include "macros.h"
  49 #include "types.h"
  50 #endif
  51
  52
  53
  54 /**********************************************************************/
  55 /*****                          API Functions                     *****/
  56 /**********************************************************************/
  57
  58
  59
  60 void 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
  70 void 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
 111 void 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  */
 153 GLuint 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  */
 379 GLuint 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  */
 407 GLuint 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  */
 449 void 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  */
 686 void 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  */
 712 void 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  */
 749 void 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  */
 780 void 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  */
 808 void 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  */
 836 void 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