Ignore:
Timestamp:
May 23, 2000, 10:35:01 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/tritemp.h

    r2938 r3597  
    1 /* $Id: tritemp.h,v 1.1 2000-02-29 00:48:40 sandervl Exp $ */
     1/* $Id: tritemp.h,v 1.2 2000-05-23 20:34:58 jeroen Exp $ */
    22
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    5151 *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
    5252 *                          Y==0 at bottom of screen and increases upward.
     53 *
     54 * Similarly, for direct depth buffer access, this type is used for depth
     55 * buffer addressing:
     56 *    DEPTH_TYPE          - either GLushort or GLuint
    5357 *
    5458 * Optionally, one may provide one-time setup code per triangle:
    … …  
    8488   } EdgeT;
    8589
    86    struct vertex_buffer *VB = ctx->VB;
     90#ifdef INTERP_Z
     91   const GLint depthBits = ctx->Visual->DepthBits;
     92   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
     93   const GLfloat maxDepth = ctx->Visual->DepthMaxF;
     94#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
     95#endif
     96   const struct vertex_buffer *VB = ctx->VB;
    8797   EdgeT eMaj, eTop, eBot;
    8898   GLfloat oneOverArea;
    … …  
    135145   /* compute oneOverArea */
    136146   {
    137       GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
     147      const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
    138148
    139149      /* Do backface culling */
    140       if (
    141          area * bf < 0 ||
    142          area * area < .0025
    143          )
     150      if (area * bf < 0 || area * area < .0025)
    144151         return;
    145 
    146152
    147153      oneOverArea = 1.0F / area;
    … …  
    227233   {
    228234      GLint ltor;               /* true if scanning left-to-right */
    229 #if INTERP_Z
     235#ifdef INTERP_Z
    230236      GLfloat dzdx, dzdy;      GLfixed fdzdx;
    231237#endif
    232 #if INTERP_RGB
     238#ifdef INTERP_RGB
    233239      GLfloat drdx, drdy;      GLfixed fdrdx;
    234240      GLfloat dgdx, dgdy;      GLfixed fdgdx;
    235241      GLfloat dbdx, dbdy;      GLfixed fdbdx;
    236242#endif
    237 #if INTERP_SPEC
     243#ifdef INTERP_SPEC
    238244      GLfloat dsrdx, dsrdy;    GLfixed fdsrdx;
    239245      GLfloat dsgdx, dsgdy;    GLfixed fdsgdx;
    240246      GLfloat dsbdx, dsbdy;    GLfixed fdsbdx;
    241247#endif
    242 #if INTERP_ALPHA
     248#ifdef INTERP_ALPHA
    243249      GLfloat dadx, dady;      GLfixed fdadx;
    244250#endif
    245 #if INTERP_INDEX
     251#ifdef INTERP_INDEX
    246252      GLfloat didx, didy;      GLfixed fdidx;
    247253#endif
    248 #if INTERP_INT_ST
     254#ifdef INTERP_INT_ST
    249255      GLfloat dsdx, dsdy;      GLfixed fdsdx;
    250256      GLfloat dtdx, dtdy;      GLfixed fdtdx;
    251257#endif
    252 #if INTERP_STUV
     258#ifdef INTERP_STUV
    253259      GLfloat dsdx, dsdy;
    254260      GLfloat dtdx, dtdy;
    … …  
    256262      GLfloat dvdx, dvdy;
    257263#endif
    258 #if INTERP_STUV1
     264#ifdef INTERP_STUV1
    259265      GLfloat ds1dx, ds1dy;
    260266      GLfloat dt1dx, dt1dy;
    … …  
    273279
    274280      /* compute d?/dx and d?/dy derivatives */
    275 #if INTERP_Z
     281#ifdef INTERP_Z
    276282      {
    277283         GLfloat eMaj_dz, eBot_dz;
    … …  
    279285         eBot_dz = VB->Win.data[vMid][2] - VB->Win.data[vMin][2];
    280286         dzdx = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);
    281          if (dzdx>DEPTH_SCALE || dzdx<-DEPTH_SCALE) {
     287         if (dzdx > maxDepth || dzdx < -maxDepth) {
    282288            /* probably a sliver triangle */
    283289            dzdx = 0.0;
    … …  
    287293            dzdy = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);
    288294         }
    289 #if DEPTH_BITS==16
    290          fdzdx = SignedFloatToFixed(dzdx);
    291 #else
    292          fdzdx = (GLint) dzdx;
    293 #endif
    294       }
    295 #endif
    296 #if INTERP_RGB
     295         if (depthBits <= 16)
     296            fdzdx = SignedFloatToFixed(dzdx);
     297         else
     298            fdzdx = (GLint) dzdx;
     299      }
     300#endif
     301#ifdef INTERP_RGB
    297302      {
    298303         GLfloat eMaj_dr, eBot_dr;
    … …  
    320325      }
    321326#endif
    322 #if INTERP_SPEC
     327#ifdef INTERP_SPEC
    323328      {
    324329         GLfloat eMaj_dsr, eBot_dsr;
    … …  
    346351      }
    347352#endif
    348 #if INTERP_ALPHA
     353#ifdef INTERP_ALPHA
    349354      {
    350355         GLfloat eMaj_da, eBot_da;
    … …  
    356361      }
    357362#endif
    358 #if INTERP_INDEX
     363#ifdef INTERP_INDEX
    359364      {
    360365         GLfloat eMaj_di, eBot_di;
    … …  
    366371      }
    367372#endif
    368 #if INTERP_INT_ST
     373#ifdef INTERP_INT_ST
    369374      {
    370375         GLfloat eMaj_ds, eBot_ds;
    … …  
    390395
    391396#endif
    392 #if INTERP_STUV
     397#ifdef INTERP_STUV
    393398      {
    394399         GLfloat wMax = VB->Win.data[vMax][3];
    … …  
    442447      }
    443448#endif
    444 #if INTERP_STUV1
     449#ifdef INTERP_STUV1
    445450      {
    446451         GLfloat wMax = VB->Win.data[vMax][3];
    … …  
    461466            eBot_dt = VB->TexCoordPtr[1]->data[vMid][1]*wMid - VB->TexCoordPtr[1]->data[vMin][1]*wMin;
    462467            dt1dx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
    463             dt1dy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
    464         }
    465         else
    466         {
    467             dt1dx = 0;
    468             dt1dy = 0;
    469         }
    470 
    471         if (VB->TexCoordPtr[1]->size > 2)
    472         {
    473             eMaj_du = VB->TexCoordPtr[1]->data[vMax][2]*wMax - VB->TexCoordPtr[1]->data[vMin][2]*wMin;
    474             eBot_du = VB->TexCoordPtr[1]->data[vMid][2]*wMid - VB->TexCoordPtr[1]->data[vMin][2]*wMin;
    475             du1dx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du);
    476             du1dy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx);
    477         }
    478         else
    479         {
    480             du1dx = 0;
    481             du1dy = 0;
    482         }
    483 
    484         if (VB->TexCoordPtr[1]->size > 3)
    485         {
    486             eMaj_dv = VB->TexCoordPtr[1]->data[vMax][3]*wMax - VB->TexCoordPtr[1]->data[vMin][3]*wMin;
    487             eBot_dv = VB->TexCoordPtr[1]->data[vMid][3]*wMid - VB->TexCoordPtr[1]->data[vMin][3]*wMin;
    488             dv1dx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
    489             dv1dy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
    490         }
    491         else
    492         {
    493             eMaj_dv = wMax - wMin;
    494             eBot_dv = wMid - wMin;
    495             dv1dx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
    496             dv1dy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
    497         }
     468            dt1dy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
     469        }
     470        else
     471        {
     472            dt1dx = 0;
     473            dt1dy = 0;
     474        }
     475
     476        if (VB->TexCoordPtr[1]->size > 2)
     477        {
     478            eMaj_du = VB->TexCoordPtr[1]->data[vMax][2]*wMax - VB->TexCoordPtr[1]->data[vMin][2]*wMin;
     479            eBot_du = VB->TexCoordPtr[1]->data[vMid][2]*wMid - VB->TexCoordPtr[1]->data[vMin][2]*wMin;
     480            du1dx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du);
     481            du1dy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx);
     482        }
     483        else
     484        {
     485            du1dx = 0;
     486            du1dy = 0;
     487        }
     488
     489        if (VB->TexCoordPtr[1]->size > 3)
     490        {
     491            eMaj_dv = VB->TexCoordPtr[1]->data[vMax][3]*wMax - VB->TexCoordPtr[1]->data[vMin][3]*wMin;
     492            eBot_dv = VB->TexCoordPtr[1]->data[vMid][3]*wMid - VB->TexCoordPtr[1]->data[vMin][3]*wMin;
     493            dv1dx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
     494            dv1dy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
     495        }
     496        else
     497        {
     498            eMaj_dv = wMax - wMin;
     499            eBot_dv = wMid - wMin;
     500            dv1dx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
     501            dv1dy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
     502        }
    498503      }
    499504#endif
    … …  
    560565         int dPRowOuter, dPRowInner;  /* offset in bytes */
    561566#endif
    562 #if INTERP_Z
    563          GLdepth *zRow;
     567#ifdef INTERP_Z
     568#  ifdef DEPTH_TYPE
     569         DEPTH_TYPE *zRow;
    564570         int dZRowOuter, dZRowInner;  /* offset in bytes */
     571#  endif
    565572         GLfixed fz, fdzOuter, fdzInner;
    566573#endif
    567 #if INTERP_RGB
     574#ifdef INTERP_RGB
    568575         GLfixed fr, fdrOuter, fdrInner;
    569576         GLfixed fg, fdgOuter, fdgInner;
    570577         GLfixed fb, fdbOuter, fdbInner;
    571578#endif
    572 #if INTERP_SPEC
     579#ifdef INTERP_SPEC
    573580         GLfixed fsr, fdsrOuter, fdsrInner;
    574581         GLfixed fsg, fdsgOuter, fdsgInner;
    575582         GLfixed fsb, fdsbOuter, fdsbInner;
    576583#endif
    577 #if INTERP_ALPHA
     584#ifdef INTERP_ALPHA
    578585         GLfixed fa, fdaOuter, fdaInner;
    579586#endif
    580 #if INTERP_INDEX
     587#ifdef INTERP_INDEX
    581588         GLfixed fi, fdiOuter, fdiInner;
    582589#endif
    583 #if INTERP_INT_ST
     590#ifdef INTERP_INT_ST
    584591         GLfixed fs, fdsOuter, fdsInner;
    585592         GLfixed ft, fdtOuter, fdtInner;
    586593#endif
    587 #if INTERP_STUV
     594#ifdef INTERP_STUV
    588595         GLfloat sLeft, dsOuter, dsInner;
    589596         GLfloat tLeft, dtOuter, dtInner;
    … …  
    591598         GLfloat vLeft, dvOuter, dvInner;
    592599#endif
    593 #if INTERP_STUV1
     600#ifdef INTERP_STUV1
    594601         GLfloat s1Left, ds1Outer, ds1Inner;
    595602         GLfloat t1Left, dt1Outer, dt1Inner;
    … …  
    665672#ifdef PIXEL_ADDRESS
    666673               {
    667                   pRow = (PIXEL_TYPE *) PIXEL_ADDRESS( FixedToInt(fxLeftEdge), iy );
     674                  pRow = (PIXEL_TYPE *)PIXEL_ADDRESS( FixedToInt(fxLeftEdge), iy );
    668675                  dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);
    669676                  /* negative because Y=0 at bottom and increases upward */
    … …  
    680687                */
    681688
    682 #if INTERP_Z
     689#ifdef INTERP_Z
    683690               {
    684                   GLfloat z0, tmp;
    685                   z0 = VB->Win.data[vLower][2] + ctx->PolygonZoffset;
    686 #if DEPTH_BITS==16
    687                   /* interpolate fixed-pt values */
    688                   tmp = (z0 * FIXED_SCALE + dzdx * adjx + dzdy * adjy) + FIXED_HALF;
    689                   if (tmp < MAX_GLUINT/2)
    690                      fz = (GLfixed) tmp;
    691                   else
    692                      fz = MAX_GLUINT/2;
    693                   fdzOuter = SignedFloatToFixed(dzdy + dxOuter * dzdx);
    694 #else
    695                   (void) tmp;
    696                   /* interpolate depth values exactly */
    697                   fz = (GLint) (z0 + dzdx*FixedToFloat(adjx) + dzdy*FixedToFloat(adjy));
    698                   fdzOuter = (GLint) (dzdy + dxOuter * dzdx);
    699 #endif
    700                   zRow = Z_ADDRESS( ctx, FixedToInt(fxLeftEdge), iy );
    701                   dZRowOuter = (ctx->Buffer->Width + idxOuter) * sizeof(GLdepth);
    702                }
    703 #endif
    704 #if INTERP_RGB
     691                  GLfloat z0 = VB->Win.data[vLower][2] + ctx->PolygonZoffset;
     692                  if (depthBits <= 16) {
     693                     /* interpolate fixed-pt values */
     694                     GLfloat tmp = (z0 * FIXED_SCALE + dzdx * adjx + dzdy * adjy) + FIXED_HALF;
     695                     if (tmp < MAX_GLUINT / 2)
     696                        fz = (GLfixed) tmp;
     697                     else
     698                        fz = MAX_GLUINT / 2;
     699                     fdzOuter = SignedFloatToFixed(dzdy + dxOuter * dzdx);
     700                  }
     701                  else {
     702                     /* interpolate depth values exactly */
     703                     fz = (GLint) (z0 + dzdx*FixedToFloat(adjx) + dzdy*FixedToFloat(adjy));
     704                     fdzOuter = (GLint) (dzdy + dxOuter * dzdx);
     705                  }
     706#  ifdef DEPTH_TYPE
     707                  zRow = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, FixedToInt(fxLeftEdge), iy);
     708                  dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
     709#  endif
     710               }
     711#endif
     712#ifdef INTERP_RGB
    705713               fr = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][0]) + drdx * adjx + drdy * adjy)
    706714                    + FIXED_HALF;
    … …  
    715723               fdbOuter = SignedFloatToFixed(dbdy + dxOuter * dbdx);
    716724#endif
    717 #if INTERP_SPEC
     725#ifdef INTERP_SPEC
    718726               fsr = (GLfixed)(IntToFixed(VB->Specular[vLower][0]) + dsrdx * adjx + dsrdy * adjy)
    719727                    + FIXED_HALF;
    … …  
    728736               fdsbOuter = SignedFloatToFixed(dsbdy + dxOuter * dsbdx);
    729737#endif
    730 #if INTERP_ALPHA
     738#ifdef INTERP_ALPHA
    731739               fa = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][3]) + dadx * adjx + dady * adjy)
    732740                    + FIXED_HALF;
    733741               fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx);
    734742#endif
    735 #if INTERP_INDEX
     743#ifdef INTERP_INDEX
    736744               fi = (GLfixed)(VB->IndexPtr->data[vLower] * FIXED_SCALE + didx * adjx
    737745                              + didy * adjy) + FIXED_HALF;
    738746               fdiOuter = SignedFloatToFixed(didy + dxOuter * didx);
    739747#endif
    740 #if INTERP_INT_ST
     748#ifdef INTERP_INT_ST
    741749               {
    742750                  GLfloat s0, t0;
    … …  
    745753                  fdsOuter = SignedFloatToFixed(dsdy + dxOuter * dsdx);
    746754
    747                   if (VB->TexCoordPtr[0]->size > 1)
    748                   {
    749                      t0 = VB->TexCoordPtr[0]->data[vLower][1] * T_SCALE;
    750                      ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + dtdy * adjy) + FIXED_HALF;
    751                      fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx);
    752                   }
    753                   else
    754                   {
    755                      t0 = 0;
    756                      ft = (GLfixed) FIXED_HALF;
    757                      fdtOuter = SignedFloatToFixed(0);
    758                   }
    759                }
    760 #endif
    761 #if INTERP_STUV
     755                  if (VB->TexCoordPtr[0]->size > 1)
     756                  {
     757                     t0 = VB->TexCoordPtr[0]->data[vLower][1] * T_SCALE;
     758                     ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + dtdy * adjy) + FIXED_HALF;
     759                     fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx);
     760                  }
     761                  else
     762                  {
     763                     t0 = 0;
     764                     ft = (GLfixed) FIXED_HALF;
     765                     fdtOuter = SignedFloatToFixed(0);
     766                  }
     767               }
     768#endif
     769#ifdef INTERP_STUV
    762770               {
    763771                  GLfloat invW = VB->Win.data[vLower][3];
    … …  
    766774                  sLeft = s0 + (dsdx * adjx + dsdy * adjy) * (1.0F/FIXED_SCALE);
    767775                  dsOuter = dsdy + dxOuter * dsdx;
    768                   if (VB->TexCoordPtr[0]->size > 1)
    769                   {             
    770                      t0 = VB->TexCoordPtr[0]->data[vLower][1] * invW;
    771                      tLeft = t0 + (dtdx * adjx + dtdy * adjy) * (1.0F/FIXED_SCALE);
    772                      dtOuter = dtdy + dxOuter * dtdx;
    773                   } else {
    774                      tLeft = dtOuter = 0;
    775                   }
    776                   if (VB->TexCoordPtr[0]->size > 2)
    777                   {             
    778                      u0 = VB->TexCoordPtr[0]->data[vLower][2] * invW;
    779                      uLeft = u0 + (dudx * adjx + dudy * adjy) * (1.0F/FIXED_SCALE);
    780                      duOuter = dudy + dxOuter * dudx;
    781                   } else {
    782                      uLeft = duOuter = 0;
    783                   }
    784                   if (VB->TexCoordPtr[0]->size > 3)
    785                   {             
    786                      v0 = VB->TexCoordPtr[0]->data[vLower][3] * invW;
    787                   } else {
    788                      v0 = invW;
    789                   }
    790                   vLeft = v0 + (dvdx * adjx + dvdy * adjy) * (1.0F/FIXED_SCALE);
    791                   dvOuter = dvdy + dxOuter * dvdx;
    792                }
    793 #endif
    794 #if INTERP_STUV1
     776                  if (VB->TexCoordPtr[0]->size > 1)
     777                  {
     778                     t0 = VB->TexCoordPtr[0]->data[vLower][1] * invW;
     779                     tLeft = t0 + (dtdx * adjx + dtdy * adjy) * (1.0F/FIXED_SCALE);
     780                     dtOuter = dtdy + dxOuter * dtdx;
     781                  } else {
     782                     tLeft = dtOuter = 0;
     783                  }
     784                  if (VB->TexCoordPtr[0]->size > 2)
     785                  {
     786                     u0 = VB->TexCoordPtr[0]->data[vLower][2] * invW;
     787                     uLeft = u0 + (dudx * adjx + dudy * adjy) * (1.0F/FIXED_SCALE);
     788                     duOuter = dudy + dxOuter * dudx;
     789                  } else {
     790                     uLeft = duOuter = 0;
     791                  }
     792                  if (VB->TexCoordPtr[0]->size > 3)
     793                  {
     794                     v0 = VB->TexCoordPtr[0]->data[vLower][3] * invW;
     795                  } else {
     796                     v0 = invW;
     797                  }
     798                  vLeft = v0 + (dvdx * adjx + dvdy * adjy) * (1.0F/FIXED_SCALE);
     799                  dvOuter = dvdy + dxOuter * dvdx;
     800               }
     801#endif
     802#ifdef INTERP_STUV1
    795803               {
    796804                  GLfloat invW = VB->Win.data[vLower][3];
    … …  
    799807                  s1Left = s0 + (ds1dx * adjx + ds1dy * adjy) * (1.0F/FIXED_SCALE);
    800808                  ds1Outer = ds1dy + dxOuter * ds1dx;
    801                   if (VB->TexCoordPtr[0]->size > 1)
    802                   {             
    803                      t0 = VB->TexCoordPtr[1]->data[vLower][1] * invW;
    804                      t1Left = t0 + (dt1dx * adjx + dt1dy * adjy) * (1.0F/FIXED_SCALE);
    805                      dt1Outer = dt1dy + dxOuter * dt1dx;
    806                   } else {
    807                      t1Left = dt1Outer = 0;
    808                   }
    809                   if (VB->TexCoordPtr[0]->size > 2)
    810                   {             
    811                      u0 = VB->TexCoordPtr[1]->data[vLower][2] * invW;
    812                      u1Left = u0 + (du1dx * adjx + du1dy * adjy) * (1.0F/FIXED_SCALE);
    813                      du1Outer = du1dy + dxOuter * du1dx;
    814                   } else {
    815                      u1Left = du1Outer = 0;
    816                   }
    817                   if (VB->TexCoordPtr[0]->size > 3)
    818                   {             
    819                      v0 = VB->TexCoordPtr[1]->data[vLower][3] * invW;
    820                   } else {
    821                      v0 =  invW;
    822                   }
    823                   v1Left = v0 + (dv1dx * adjx + dv1dy * adjy) * (1.0F/FIXED_SCALE);
    824                   dv1Outer = dv1dy + dxOuter * dv1dx;
     809                  if (VB->TexCoordPtr[0]->size > 1)
     810                  {
     811                     t0 = VB->TexCoordPtr[1]->data[vLower][1] * invW;
     812                     t1Left = t0 + (dt1dx * adjx + dt1dy * adjy) * (1.0F/FIXED_SCALE);
     813                     dt1Outer = dt1dy + dxOuter * dt1dx;
     814                  } else {
     815                     t1Left = dt1Outer = 0;
     816                  }
     817                  if (VB->TexCoordPtr[0]->size > 2)
     818                  {
     819                     u0 = VB->TexCoordPtr[1]->data[vLower][2] * invW;
     820                     u1Left = u0 + (du1dx * adjx + du1dy * adjy) * (1.0F/FIXED_SCALE);
     821                     du1Outer = du1dy + dxOuter * du1dx;
     822                  } else {
     823                     u1Left = du1Outer = 0;
     824                  }
     825                  if (VB->TexCoordPtr[0]->size > 3)
     826                  {
     827                     v0 = VB->TexCoordPtr[1]->data[vLower][3] * invW;
     828                  } else {
     829                     v0 =  invW;
     830                  }
     831                  v1Left = v0 + (dv1dx * adjx + dv1dy * adjy) * (1.0F/FIXED_SCALE);
     832                  dv1Outer = dv1dy + dxOuter * dv1dx;
    825833               }
    826834#endif
    … …  
    843851            dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);
    844852#endif
    845 #if INTERP_Z
    846             dZRowInner = dZRowOuter + sizeof(GLdepth);
     853#ifdef INTERP_Z
     854#  ifdef DEPTH_TYPE
     855            dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);
     856#  endif
    847857            fdzInner = fdzOuter + fdzdx;
    848858#endif
    849 #if INTERP_RGB
     859#ifdef INTERP_RGB
    850860            fdrInner = fdrOuter + fdrdx;
    851861            fdgInner = fdgOuter + fdgdx;
    852862            fdbInner = fdbOuter + fdbdx;
    853863#endif
    854 #if INTERP_SPEC
     864#ifdef INTERP_SPEC
    855865            fdsrInner = fdsrOuter + fdsrdx;
    856866            fdsgInner = fdsgOuter + fdsgdx;
    857867            fdsbInner = fdsbOuter + fdsbdx;
    858868#endif
    859 #if INTERP_ALPHA
     869#ifdef INTERP_ALPHA
    860870            fdaInner = fdaOuter + fdadx;
    861871#endif
    862 #if INTERP_INDEX
     872#ifdef INTERP_INDEX
    863873            fdiInner = fdiOuter + fdidx;
    864874#endif
    865 #if INTERP_INT_ST
     875#ifdef INTERP_INT_ST
    866876            fdsInner = fdsOuter + fdsdx;
    867877            fdtInner = fdtOuter + fdtdx;
    868878#endif
    869 #if INTERP_STUV
    870             dsInner = dsOuter + dsdx;
    871             dtInner = dtOuter + dtdx;
    872             duInner = duOuter + dudx;
    873             dvInner = dvOuter + dvdx;
    874 #endif
    875 #if INTERP_STUV1
    876             ds1Inner = ds1Outer + ds1dx;
    877             dt1Inner = dt1Outer + dt1dx;
    878             du1Inner = du1Outer + du1dx;
    879             dv1Inner = dv1Outer + dv1dx;
     879#ifdef INTERP_STUV
     880            dsInner = dsOuter + dsdx;
     881            dtInner = dtOuter + dtdx;
     882            duInner = duOuter + dudx;
     883            dvInner = dvOuter + dvdx;
     884#endif
     885#ifdef INTERP_STUV1
     886            ds1Inner = ds1Outer + ds1dx;
     887            dt1Inner = dt1Outer + dt1dx;
     888            du1Inner = du1Outer + du1dx;
     889            dv1Inner = dv1Outer + dv1dx;
    880890#endif
    881891
    … …  
    883893               /* initialize the span interpolants to the leftmost value */
    884894               /* ff = fixed-pt fragment */
    885 #if INTERP_Z
     895#ifdef INTERP_Z
    886896               GLfixed ffz = fz;
    887                /*GLdepth *zp = zRow;*/
    888 #endif
    889 #if INTERP_RGB
     897#endif
     898#ifdef INTERP_RGB
    890899               GLfixed ffr = fr,  ffg = fg,  ffb = fb;
    891900#endif
    892 #if INTERP_SPEC
     901#ifdef INTERP_SPEC
    893902               GLfixed ffsr = fsr,  ffsg = fsg,  ffsb = fsb;
    894903#endif
    895 #if INTERP_ALPHA
     904#ifdef INTERP_ALPHA
    896905               GLfixed ffa = fa;
    897906#endif
    898 #if INTERP_INDEX
     907#ifdef INTERP_INDEX
    899908               GLfixed ffi = fi;
    900909#endif
    901 #if INTERP_INT_ST
     910#ifdef INTERP_INT_ST
    902911               GLfixed ffs = fs,  fft = ft;
    903912#endif
    904 #if INTERP_STUV
     913#ifdef INTERP_STUV
    905914               GLfloat ss = sLeft, tt = tLeft, uu = uLeft, vv = vLeft;
    906915#endif
    907 #if INTERP_STUV1
     916#ifdef INTERP_STUV1
    908917               GLfloat ss1 = s1Left, tt1 = t1Left, uu1 = u1Left, vv1 = v1Left;
    909918#endif
    … …  
    911920               GLint right = FixedToInt(fxRightEdge);
    912921
    913 #if INTERP_RGB
     922#ifdef INTERP_RGB
    914923               {
    915924                  /* need this to accomodate round-off errors */
    … …  
    925934               }
    926935#endif
    927 #if INTERP_SPEC
     936#ifdef INTERP_SPEC
    928937               {
    929938                  /* need this to accomodate round-off errors */
    … …  
    939948               }
    940949#endif
    941 #if INTERP_ALPHA
     950#ifdef INTERP_ALPHA
    942951               {
    943952                  GLfixed ffaend = ffa+(right-left-1)*fdadx;
    … …  
    946955               }
    947956#endif
    948 #if INTERP_INDEX
     957#ifdef INTERP_INDEX
    949958               if (ffi<0) ffi = 0;
    950959#endif
    … …  
    969978                  fError -= FIXED_ONE;
    970979#ifdef PIXEL_ADDRESS
    971                   pRow = (PIXEL_TYPE*) ((GLubyte*)pRow + dPRowOuter);
    972 #endif
    973 #if INTERP_Z
    974                   zRow = (GLdepth*) ((GLubyte*)zRow + dZRowOuter);
     980                  pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowOuter);
     981#endif
     982#ifdef INTERP_Z
     983#  ifdef DEPTH_TYPE
     984                  zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowOuter);
     985#  endif
    975986                  fz += fdzOuter;
    976987#endif
    977 #if INTERP_RGB
     988#ifdef INTERP_RGB
    978989                  fr += fdrOuter;   fg += fdgOuter;   fb += fdbOuter;
    979990#endif
    980 #if INTERP_SPEC
     991#ifdef INTERP_SPEC
    981992                  fsr += fdsrOuter;   fsg += fdsgOuter;   fsb += fdsbOuter;
    982993#endif
    983 #if INTERP_ALPHA
     994#ifdef INTERP_ALPHA
    984995                  fa += fdaOuter;
    985996#endif
    986 #if INTERP_INDEX
     997#ifdef INTERP_INDEX
    987998                  fi += fdiOuter;
    988999#endif
    989 #if INTERP_INT_ST
     1000#ifdef INTERP_INT_ST
    9901001                  fs += fdsOuter;   ft += fdtOuter;
    9911002#endif
    992 #if INTERP_STUV
    993                   sLeft += dsOuter;
    994                   tLeft += dtOuter;
    995                   uLeft += duOuter;
    996                   vLeft += dvOuter;
    997 #endif
    998 #if INTERP_STUV1
    999                   s1Left += ds1Outer;
    1000                   t1Left += dt1Outer;
    1001                   u1Left += du1Outer;
    1002                   v1Left += dv1Outer;
     1003#ifdef INTERP_STUV
     1004                  sLeft += dsOuter;
     1005                  tLeft += dtOuter;
     1006                  uLeft += duOuter;
     1007                  vLeft += dvOuter;
     1008#endif
     1009#ifdef INTERP_STUV1
     1010                  s1Left += ds1Outer;
     1011                  t1Left += dt1Outer;
     1012                  u1Left += du1Outer;
     1013                  v1Left += dv1Outer;
    10031014#endif
    10041015               }
    10051016               else {
    10061017#ifdef PIXEL_ADDRESS
    1007                   pRow = (PIXEL_TYPE*) ((GLubyte*)pRow + dPRowInner);
    1008 #endif
    1009 #if INTERP_Z
    1010                   zRow = (GLdepth*) ((GLubyte*)zRow + dZRowInner);
     1018                  pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowInner);
     1019#endif
     1020#ifdef INTERP_Z
     1021#  ifdef DEPTH_TYPE
     1022                  zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowInner);
     1023#  endif
    10111024                  fz += fdzInner;
    10121025#endif
    1013 #if INTERP_RGB
     1026#ifdef INTERP_RGB
    10141027                  fr += fdrInner;   fg += fdgInner;   fb += fdbInner;
    10151028#endif
    1016 #if INTERP_SPEC
     1029#ifdef INTERP_SPEC
    10171030                  fsr += fdsrInner;   fsg += fdsgInner;   fsb += fdsbInner;
    10181031#endif
    1019 #if INTERP_ALPHA
     1032#ifdef INTERP_ALPHA
    10201033                  fa += fdaInner;
    10211034#endif
    1022 #if INTERP_INDEX
     1035#ifdef INTERP_INDEX
    10231036                  fi += fdiInner;
    10241037#endif
    1025 #if INTERP_INT_ST
     1038#ifdef INTERP_INT_ST
    10261039                  fs += fdsInner;   ft += fdtInner;
    10271040#endif
    1028 #if INTERP_STUV
    1029                   sLeft += dsInner;
    1030                   tLeft += dtInner;
    1031                   uLeft += duInner;
    1032                   vLeft += dvInner;
    1033 #endif
    1034 #if INTERP_STUV1
    1035                   s1Left += ds1Inner;
    1036                   t1Left += dt1Inner;
    1037                   u1Left += du1Inner;
    1038                   v1Left += dv1Inner;
     1041#ifdef INTERP_STUV
     1042                  sLeft += dsInner;
     1043                  tLeft += dtInner;
     1044                  uLeft += duInner;
     1045                  vLeft += dvInner;
     1046#endif
     1047#ifdef INTERP_STUV1
     1048                  s1Left += ds1Inner;
     1049                  t1Left += dt1Inner;
     1050                  u1Left += du1Inner;
     1051                  v1Left += dv1Inner;
    10391052#endif
    10401053               }
    … …  
    10651078#undef S_SCALE
    10661079#undef T_SCALE
     1080
     1081#undef FixedToDepth
Note: See TracChangeset for help on using the changeset viewer.