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

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/points.c

    r2962 r3598  
    1 /* $Id: points.c,v 1.2 2000-03-01 18:49:34 jeroen Exp $ */
     1/* $Id: points.c,v 1.3 2000-05-23 20:40:50 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.
    … …  
    3131#include "all.h"
    3232#else
    33 #ifndef XFree86Server
    34 #include <math.h>
    35 #else
    36 #include "GL/xf86glx.h"
    37 #endif
     33#include "glheader.h"
    3834#include "types.h"
    3935#include "context.h"
    … …  
    5147
    5248
    53 void gl_PointSize( GLcontext *ctx, GLfloat size )
    54 {
    55    if (size<=0.0) {
     49void
     50_mesa_PointSize( GLfloat size )
     51{
     52   GET_CURRENT_CONTEXT(ctx);
     53   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPointSize");
     54
     55   if (size <= 0.0) {
    5656      gl_error( ctx, GL_INVALID_VALUE, "glPointSize" );
    5757      return;
    5858   }
    59    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPointSize");
    6059
    6160   if (ctx->Point.Size != size) {
    … …  
    6968
    7069
    71 void gl_PointParameterfvEXT( GLcontext *ctx, GLenum pname,
    72                                     const GLfloat *params)
    73 {
     70void
     71_mesa_PointParameterfEXT( GLenum pname, GLfloat param)
     72{
     73   _mesa_PointParameterfvEXT(pname, &param);
     74}
     75
     76
     77void
     78_mesa_PointParameterfvEXT( GLenum pname, const GLfloat *params)
     79{
     80   GET_CURRENT_CONTEXT(ctx);
    7481   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPointParameterfvEXT");
    75    if(pname==GL_DISTANCE_ATTENUATION_EXT) {
    76       GLboolean tmp = ctx->Point.Attenuated;
    77       COPY_3V(ctx->Point.Params,params);
    78       ctx->Point.Attenuated = (params[0] != 1.0 ||
    79                                params[1] != 0.0 ||
    80                                params[2] != 0.0);
    81 
    82       if (tmp != ctx->Point.Attenuated) {
    83          ctx->Enabled ^= ENABLE_POINT_ATTEN;
    84          ctx->TriangleCaps ^= DD_POINT_ATTEN;
    85          ctx->NewState |= NEW_RASTER_OPS;
    86       }
    87    } else {
    88         if (*params<0.0 ) {
     82
     83   switch (pname) {
     84      case GL_DISTANCE_ATTENUATION_EXT:
     85         {
     86            const GLboolean tmp = ctx->Point.Attenuated;
     87            COPY_3V(ctx->Point.Params, params);
     88            ctx->Point.Attenuated = (params[0] != 1.0 ||
     89                                     params[1] != 0.0 ||
     90                                     params[2] != 0.0);
     91
     92            if (tmp != ctx->Point.Attenuated) {
     93               ctx->Enabled ^= ENABLE_POINT_ATTEN;
     94               ctx->TriangleCaps ^= DD_POINT_ATTEN;
     95               ctx->NewState |= NEW_RASTER_OPS;
     96            }
     97         }
     98         break;
     99      case GL_POINT_SIZE_MIN_EXT:
     100         if (*params < 0.0F) {
    89101            gl_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
    90102            return;
    91         }
    92         switch (pname) {
    93             case GL_POINT_SIZE_MIN_EXT:
    94                 ctx->Point.MinSize=*params;
    95                 break;
    96             case GL_POINT_SIZE_MAX_EXT:
    97                 ctx->Point.MaxSize=*params;
    98                 break;
    99             case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
    100                 ctx->Point.Threshold=*params;
    101                 break;
    102             default:
    103                 gl_error( ctx, GL_INVALID_ENUM, "glPointParameterfvEXT" );
    104                 return;
    105         }
    106    }
     103         }
     104         ctx->Point.MinSize = *params;
     105         break;
     106      case GL_POINT_SIZE_MAX_EXT:
     107         if (*params < 0.0F) {
     108            gl_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
     109            return;
     110         }
     111         ctx->Point.MaxSize = *params;
     112         break;
     113      case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
     114         if (*params < 0.0F) {
     115            gl_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
     116            return;
     117         }
     118         ctx->Point.Threshold = *params;
     119         break;
     120      default:
     121         gl_error( ctx, GL_INVALID_ENUM, "glPointParameterfvEXT" );
     122         return;
     123   }
     124
    107125   ctx->NewState |= NEW_RASTER_OPS;
    108126}
    … …  
    343361         blue  = VB->ColorPtr->data[i][2];
    344362         alpha = VB->ColorPtr->data[i][3];
    345        
    346         switch (VB->TexCoordPtr[0]->size) {
    347         case 4:
    348             s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3];
    349             t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3];
    350             u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3];
    351             break;
    352         case 3:
    353             s = VB->TexCoordPtr[0]->data[i][0];
    354             t = VB->TexCoordPtr[0]->data[i][1];
    355             u = VB->TexCoordPtr[0]->data[i][2];
    356             break;
    357         case 2:
    358             s = VB->TexCoordPtr[0]->data[i][0];
    359             t = VB->TexCoordPtr[0]->data[i][1];
    360             u = 0.0;
    361             break;
    362         case 1:
    363             s = VB->TexCoordPtr[0]->data[i][0];
    364             t = 0.0;
    365             u = 0.0;
    366             break;
     363
     364        switch (VB->TexCoordPtr[0]->size) {
     365        case 4:
     366            s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3];
     367            t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3];
     368            u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3];
     369            break;
     370        case 3:
     371            s = VB->TexCoordPtr[0]->data[i][0];
     372            t = VB->TexCoordPtr[0]->data[i][1];
     373            u = VB->TexCoordPtr[0]->data[i][2];
     374            break;
     375        case 2:
     376            s = VB->TexCoordPtr[0]->data[i][0];
     377            t = VB->TexCoordPtr[0]->data[i][1];
     378            u = 0.0;
     379            break;
     380        case 1:
     381            s = VB->TexCoordPtr[0]->data[i][0];
     382            t = 0.0;
     383            u = 0.0;
     384            break;
    367385         default:
    368386            /* should never get here */
    369387            s = t = u = 0.0;
    370388            gl_problem(ctx, "unexpected texcoord size in textured_rgba_points()");
    371         }
     389        }
    372390
    373391/*    don't think this is needed
    … …  
    435453         blue  = VB->ColorPtr->data[i][2];
    436454         alpha = VB->ColorPtr->data[i][3];
    437        
    438         switch (VB->TexCoordPtr[0]->size) {
    439         case 4:
    440             s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3];
    441             t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3];
    442             u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3];
    443             break;
    444         case 3:
    445             s = VB->TexCoordPtr[0]->data[i][0];
    446             t = VB->TexCoordPtr[0]->data[i][1];
    447             u = VB->TexCoordPtr[0]->data[i][2];
    448             break;
    449         case 2:
    450             s = VB->TexCoordPtr[0]->data[i][0];
    451             t = VB->TexCoordPtr[0]->data[i][1];
    452             u = 0.0;
    453             break;
    454         case 1:
    455             s = VB->TexCoordPtr[0]->data[i][0];
    456             t = 0.0;
    457             u = 0.0;
    458             break;
     455
     456        switch (VB->TexCoordPtr[0]->size) {
     457        case 4:
     458            s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3];
     459            t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3];
     460            u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3];
     461            break;
     462        case 3:
     463            s = VB->TexCoordPtr[0]->data[i][0];
     464            t = VB->TexCoordPtr[0]->data[i][1];
     465            u = VB->TexCoordPtr[0]->data[i][2];
     466            break;
     467        case 2:
     468            s = VB->TexCoordPtr[0]->data[i][0];
     469            t = VB->TexCoordPtr[0]->data[i][1];
     470            u = 0.0;
     471            break;
     472        case 1:
     473            s = VB->TexCoordPtr[0]->data[i][0];
     474            t = 0.0;
     475            u = 0.0;
     476            break;
    459477         default:
    460478            /* should never get here */
    461479            s = t = u = 0.0;
    462480            gl_problem(ctx, "unexpected texcoord size in multitextured_rgba_points()");
    463         }
    464 
    465         switch (VB->TexCoordPtr[1]->size) {
    466         case 4:
    467             s1 = VB->TexCoordPtr[1]->data[i][0]/VB->TexCoordPtr[1]->data[i][3];
    468             t1 = VB->TexCoordPtr[1]->data[i][1]/VB->TexCoordPtr[1]->data[i][3];
    469             u1 = VB->TexCoordPtr[1]->data[i][2]/VB->TexCoordPtr[1]->data[i][3];
    470             break;
    471         case 3:
    472             s1 = VB->TexCoordPtr[1]->data[i][0];
    473             t1 = VB->TexCoordPtr[1]->data[i][1];
    474             u1 = VB->TexCoordPtr[1]->data[i][2];
    475             break;
    476         case 2:
    477             s1 = VB->TexCoordPtr[1]->data[i][0];
    478             t1 = VB->TexCoordPtr[1]->data[i][1];
    479             u1 = 0.0;
    480             break;
    481         case 1:
    482             s1 = VB->TexCoordPtr[1]->data[i][0];
    483             t1 = 0.0;
    484             u1 = 0.0;
    485             break;
     481        }
     482
     483        switch (VB->TexCoordPtr[1]->size) {
     484        case 4:
     485            s1 = VB->TexCoordPtr[1]->data[i][0]/VB->TexCoordPtr[1]->data[i][3];
     486            t1 = VB->TexCoordPtr[1]->data[i][1]/VB->TexCoordPtr[1]->data[i][3];
     487            u1 = VB->TexCoordPtr[1]->data[i][2]/VB->TexCoordPtr[1]->data[i][3];
     488            break;
     489        case 3:
     490            s1 = VB->TexCoordPtr[1]->data[i][0];
     491            t1 = VB->TexCoordPtr[1]->data[i][1];
     492            u1 = VB->TexCoordPtr[1]->data[i][2];
     493            break;
     494        case 2:
     495            s1 = VB->TexCoordPtr[1]->data[i][0];
     496            t1 = VB->TexCoordPtr[1]->data[i][1];
     497            u1 = 0.0;
     498            break;
     499        case 1:
     500            s1 = VB->TexCoordPtr[1]->data[i][0];
     501            t1 = 0.0;
     502            u1 = 0.0;
     503            break;
    486504         default:
    487505            /* should never get here */
    488506            s1 = t1 = u1 = 0.0;
    489507            gl_problem(ctx, "unexpected texcoord size in multitextured_rgba_points()");
    490         }
     508        }
    491509
    492510         for (iy=y0;iy<=y1;iy++) {
    … …  
    540558            blue  = VB->ColorPtr->data[i][2];
    541559
    542             switch (VB->TexCoordPtr[0]->size) {
    543             case 4:
    544                s = (VB->TexCoordPtr[0]->data[i][0]/
    545                     VB->TexCoordPtr[0]->data[i][3]);
    546                t = (VB->TexCoordPtr[0]->data[i][1]/
    547                     VB->TexCoordPtr[0]->data[i][3]);
    548                u = (VB->TexCoordPtr[0]->data[i][2]/
    549                     VB->TexCoordPtr[0]->data[i][3]);
    550                break;
    551             case 3:
    552                s = VB->TexCoordPtr[0]->data[i][0];
    553                t = VB->TexCoordPtr[0]->data[i][1];
    554                u = VB->TexCoordPtr[0]->data[i][2];
    555                break;
    556             case 2:
    557                s = VB->TexCoordPtr[0]->data[i][0];
    558                t = VB->TexCoordPtr[0]->data[i][1];
    559                u = 0.0;
    560                break;
    561             case 1:
    562                s = VB->TexCoordPtr[0]->data[i][0];
    563                t = 0.0;
    564                u = 0.0;
    565                break;
     560            switch (VB->TexCoordPtr[0]->size) {
     561            case 4:
     562               s = (VB->TexCoordPtr[0]->data[i][0]/
     563                    VB->TexCoordPtr[0]->data[i][3]);
     564               t = (VB->TexCoordPtr[0]->data[i][1]/
     565                    VB->TexCoordPtr[0]->data[i][3]);
     566               u = (VB->TexCoordPtr[0]->data[i][2]/
     567                    VB->TexCoordPtr[0]->data[i][3]);
     568               break;
     569            case 3:
     570               s = VB->TexCoordPtr[0]->data[i][0];
     571               t = VB->TexCoordPtr[0]->data[i][1];
     572               u = VB->TexCoordPtr[0]->data[i][2];
     573               break;
     574            case 2:
     575               s = VB->TexCoordPtr[0]->data[i][0];
     576               t = VB->TexCoordPtr[0]->data[i][1];
     577               u = 0.0;
     578               break;
     579            case 1:
     580               s = VB->TexCoordPtr[0]->data[i][0];
     581               t = 0.0;
     582               u = 0.0;
     583               break;
    566584            default:
    567585               /* should never get here */
    568586               s = t = u = 0.0;
    569587               gl_problem(ctx, "unexpected texcoord size in antialiased_rgba_points()");
    570             }
    571 
    572             if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
    573                /* Multitextured!  This is probably a slow enough path that
    574                   there's no reason to specialize the multitexture case. */
    575                switch (VB->TexCoordPtr[1]->size) {
    576                case 4:
    577                   s1 = ( VB->TexCoordPtr[1]->data[i][0] /
    578                         VB->TexCoordPtr[1]->data[i][3]);
    579                   t1 = ( VB->TexCoordPtr[1]->data[i][1] /
    580                         VB->TexCoordPtr[1]->data[i][3]);
    581                   u1 = ( VB->TexCoordPtr[1]->data[i][2] /
    582                         VB->TexCoordPtr[1]->data[i][3]);
    583                   break;
    584                case 3:
    585                   s1 = VB->TexCoordPtr[1]->data[i][0];
    586                   t1 = VB->TexCoordPtr[1]->data[i][1];
    587                   u1 = VB->TexCoordPtr[1]->data[i][2];
    588                   break;
    589                case 2:
    590                   s1 = VB->TexCoordPtr[1]->data[i][0];
    591                   t1 = VB->TexCoordPtr[1]->data[i][1];
    592                   u1 = 0.0;
    593                   break;
    594                case 1:
    595                   s1 = VB->TexCoordPtr[1]->data[i][0];
    596                   t1 = 0.0;
    597                   u1 = 0.0;
    598                   break;
     588            }
     589
     590            if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
     591               /* Multitextured!  This is probably a slow enough path that
     592                  there's no reason to specialize the multitexture case. */
     593               switch (VB->TexCoordPtr[1]->size) {
     594               case 4:
     595                  s1 = ( VB->TexCoordPtr[1]->data[i][0] /
     596                        VB->TexCoordPtr[1]->data[i][3]);
     597                  t1 = ( VB->TexCoordPtr[1]->data[i][1] /
     598                        VB->TexCoordPtr[1]->data[i][3]);
     599                  u1 = ( VB->TexCoordPtr[1]->data[i][2] /
     600                        VB->TexCoordPtr[1]->data[i][3]);
     601                  break;
     602               case 3:
     603                  s1 = VB->TexCoordPtr[1]->data[i][0];
     604                  t1 = VB->TexCoordPtr[1]->data[i][1];
     605                  u1 = VB->TexCoordPtr[1]->data[i][2];
     606                  break;
     607               case 2:
     608                  s1 = VB->TexCoordPtr[1]->data[i][0];
     609                  t1 = VB->TexCoordPtr[1]->data[i][1];
     610                  u1 = 0.0;
     611                  break;
     612               case 1:
     613                  s1 = VB->TexCoordPtr[1]->data[i][0];
     614                  t1 = 0.0;
     615                  u1 = 0.0;
     616                  break;
    599617               default:
    600618                  /* should never get here */
    601619                  s1 = t1 = u1 = 0.0;
    602620                  gl_problem(ctx, "unexpected texcoord size in antialiased_rgba_points()");
    603                }
    604             }
     621               }
     622            }
    605623
    606624            for (y=ymin;y<=ymax;y++) {
    … …  
    618636                     if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
    619637                        PB_WRITE_MULTITEX_PIXEL( PB, x,y,z, red, green, blue,
    620                                                 alpha, s, t, u, s1, t1, u1 );
     638                                                alpha, s, t, u, s1, t1, u1 );
    621639                     } else {
    622640                        PB_WRITE_TEX_PIXEL( PB, x,y,z, red, green, blue,
    623                                             alpha, s, t, u );
     641                                            alpha, s, t, u );
    624642                     }
    625643                  }
    … …  
    662680                     }
    663681                     PB_WRITE_RGBA_PIXEL( PB, x, y, z, red, green, blue,
    664                                           alpha );
     682                                          alpha );
    665683                  }
    666684               }
    667685            }
    668686            PB_CHECK_FLUSH(ctx,PB);
    669         }
     687        }
    670688      }
    671689   }
    … …  
    692710 */
    693711static void dist3(GLfloat *out, GLuint first, GLuint last,
    694                   const GLcontext *ctx, const GLvector4f *v)
     712                  const GLcontext *ctx, const GLvector4f *v)
    695713{
    696714   GLuint stride = v->stride;
    697    GLfloat *p = VEC_ELT(v, GLfloat, first);
     715   const GLfloat *p = VEC_ELT(v, GLfloat, first);
    698716   GLuint i;
    699717
    700    for (i = first ; i <= last ; i++, STRIDE_F(p, stride) )
    701    {
     718   for (i = first ; i <= last ; i++, STRIDE_F(p, stride) ) {
    702719      GLfloat dist = GL_SQRT(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]);
    703       out[i] = 1/(ctx->Point.Params[0]+
    704                   dist * (ctx->Point.Params[1] +
    705                           dist * ctx->Point.Params[2]));
     720      out[i] = 1.0F / (ctx->Point.Params[0] +
     721                       dist * (ctx->Point.Params[1] +
     722                               dist * ctx->Point.Params[2]));
    706723   }
    707724}
    708725
    709726static void dist2(GLfloat *out, GLuint first, GLuint last,
    710                   const GLcontext *ctx, const GLvector4f *v)
     727                  const GLcontext *ctx, const GLvector4f *v)
    711728{
    712729   GLuint stride = v->stride;
    713    GLfloat *p = VEC_ELT(v, GLfloat, first);
     730   const GLfloat *p = VEC_ELT(v, GLfloat, first);
    714731   GLuint i;
    715732
    716    for (i = first ; i <= last ; i++, STRIDE_F(p, stride) )
    717    {
     733   for (i = first ; i <= last ; i++, STRIDE_F(p, stride) ) {
    718734      GLfloat dist = GL_SQRT(p[0]*p[0]+p[1]*p[1]);
    719       out[i] = 1/(ctx->Point.Params[0]+
    720                   dist * (ctx->Point.Params[1] +
    721                           dist * ctx->Point.Params[2]));
     735      out[i] = 1.0F / (ctx->Point.Params[0] +
     736                       dist * (ctx->Point.Params[1] +
     737                               dist * ctx->Point.Params[2]));
    722738   }
    723739}
    … …  
    725741
    726742typedef void (*dist_func)(GLfloat *out, GLuint first, GLuint last,
    727                              const GLcontext *ctx, const GLvector4f *v);
     743                             const GLcontext *ctx, const GLvector4f *v);
    728744
    729745
    … …  
    738754
    739755static void clip_dist(GLfloat *out, GLuint first, GLuint last,
    740                       const GLcontext *ctx, GLvector4f *clip)
     756                      const GLcontext *ctx, GLvector4f *clip)
    741757{
    742758   /* this is never called */
    … …  
    758774      GLfloat dist = win[i][2];
    759775      out[i] = 1/(ctx->Point.Params[0]+
    760                   dist * (ctx->Point.Params[1] +
    761                           dist * ctx->Point.Params[2]));
     776                  dist * (ctx->Point.Params[1] +
     777                          dist * ctx->Point.Params[2]));
    762778   }
    763779#endif
    … …  
    770786 */
    771787static void dist_atten_general_ci_points( GLcontext *ctx, GLuint first,
    772                                         GLuint last )
     788                                        GLuint last )
    773789{
    774790   struct vertex_buffer *VB = ctx->VB;
    … …  
    834850 */
    835851static void dist_atten_general_rgba_points( GLcontext *ctx, GLuint first,
    836                                 GLuint last )
     852                                GLuint last )
    837853{
    838854   struct vertex_buffer *VB = ctx->VB;
    … …  
    906922 */
    907923static void dist_atten_textured_rgba_points( GLcontext *ctx, GLuint first,
    908                                         GLuint last )
     924                                        GLuint last )
    909925{
    910926   struct vertex_buffer *VB = ctx->VB;
    … …  
    964980         }
    965981
    966         red   = VB->ColorPtr->data[i][0];
    967         green = VB->ColorPtr->data[i][1];
    968         blue  = VB->ColorPtr->data[i][2];
    969        
    970         switch (VB->TexCoordPtr[0]->size) {
    971         case 4:
    972             s = (VB->TexCoordPtr[0]->data[i][0]/
    973                 VB->TexCoordPtr[0]->data[i][3]);
    974             t = (VB->TexCoordPtr[0]->data[i][1]/
    975                 VB->TexCoordPtr[0]->data[i][3]);
    976             u = (VB->TexCoordPtr[0]->data[i][2]/
    977                 VB->TexCoordPtr[0]->data[i][3]);
    978             break;
    979         case 3:
    980             s = VB->TexCoordPtr[0]->data[i][0];
    981             t = VB->TexCoordPtr[0]->data[i][1];
    982             u = VB->TexCoordPtr[0]->data[i][2];
    983             break;
    984         case 2:
    985             s = VB->TexCoordPtr[0]->data[i][0];
    986             t = VB->TexCoordPtr[0]->data[i][1];
    987             u = 0.0;
    988             break;
    989         case 1:
    990             s = VB->TexCoordPtr[0]->data[i][0];
    991             t = 0.0;
    992             u = 0.0;
    993             break;
     982        red   = VB->ColorPtr->data[i][0];
     983        green = VB->ColorPtr->data[i][1];
     984        blue  = VB->ColorPtr->data[i][2];
     985
     986        switch (VB->TexCoordPtr[0]->size) {
     987        case 4:
     988            s = (VB->TexCoordPtr[0]->data[i][0]/
     989                VB->TexCoordPtr[0]->data[i][3]);
     990            t = (VB->TexCoordPtr[0]->data[i][1]/
     991                VB->TexCoordPtr[0]->data[i][3]);
     992            u = (VB->TexCoordPtr[0]->data[i][2]/
     993                VB->TexCoordPtr[0]->data[i][3]);
     994            break;
     995        case 3:
     996            s = VB->TexCoordPtr[0]->data[i][0];
     997            t = VB->TexCoordPtr[0]->data[i][1];
     998            u = VB->TexCoordPtr[0]->data[i][2];
     999            break;
     1000        case 2:
     1001            s = VB->TexCoordPtr[0]->data[i][0];
     1002            t = VB->TexCoordPtr[0]->data[i][1];
     1003            u = 0.0;
     1004            break;
     1005        case 1:
     1006            s = VB->TexCoordPtr[0]->data[i][0];
     1007            t = 0.0;
     1008            u = 0.0;
     1009            break;
    9941010         default:
    9951011            /* should never get here */
    9961012            s = t = u = 0.0;
    9971013            gl_problem(ctx, "unexpected texcoord size in dist_atten_textured_rgba_points()");
    998         }
    999 
    1000         if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
    1001             /* Multitextured!  This is probably a slow enough path that
    1002                there's no reason to specialize the multitexture case. */
    1003             switch (VB->TexCoordPtr[1]->size) {
    1004             case 4:
    1005                s1 = ( VB->TexCoordPtr[1]->data[i][0] /
    1006                       VB->TexCoordPtr[1]->data[i][3] );
    1007                t1 = ( VB->TexCoordPtr[1]->data[i][1] /
    1008                       VB->TexCoordPtr[1]->data[i][3] );
    1009                u1 = ( VB->TexCoordPtr[1]->data[i][2] /
    1010                       VB->TexCoordPtr[1]->data[i][3] );
    1011                break;
    1012             case 3:
    1013                s1 = VB->TexCoordPtr[1]->data[i][0];
    1014                t1 = VB->TexCoordPtr[1]->data[i][1];
    1015                u1 = VB->TexCoordPtr[1]->data[i][2];
    1016                break;
    1017             case 2:
    1018                s1 = VB->TexCoordPtr[1]->data[i][0];
    1019                t1 = VB->TexCoordPtr[1]->data[i][1];
    1020                u1 = 0.0;
    1021                break;
    1022             case 1:
    1023                s1 = VB->TexCoordPtr[1]->data[i][0];
    1024                t1 = 0.0;
    1025                u1 = 0.0;
    1026                break;
     1014        }
     1015
     1016        if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
     1017            /* Multitextured!  This is probably a slow enough path that
     1018               there's no reason to specialize the multitexture case. */
     1019            switch (VB->TexCoordPtr[1]->size) {
     1020            case 4:
     1021               s1 = ( VB->TexCoordPtr[1]->data[i][0] /
     1022                      VB->TexCoordPtr[1]->data[i][3] );
     1023               t1 = ( VB->TexCoordPtr[1]->data[i][1] /
     1024                      VB->TexCoordPtr[1]->data[i][3] );
     1025               u1 = ( VB->TexCoordPtr[1]->data[i][2] /
     1026                      VB->TexCoordPtr[1]->data[i][3] );
     1027               break;
     1028            case 3:
     1029               s1 = VB->TexCoordPtr[1]->data[i][0];
     1030               t1 = VB->TexCoordPtr[1]->data[i][1];
     1031               u1 = VB->TexCoordPtr[1]->data[i][2];
     1032               break;
     1033            case 2:
     1034               s1 = VB->TexCoordPtr[1]->data[i][0];
     1035               t1 = VB->TexCoordPtr[1]->data[i][1];
     1036               u1 = 0.0;
     1037               break;
     1038            case 1:
     1039               s1 = VB->TexCoordPtr[1]->data[i][0];
     1040               t1 = 0.0;
     1041               u1 = 0.0;
     1042               break;
    10271043            default:
    10281044               /* should never get here */
    10291045               s1 = t1 = u1 = 0.0;
    10301046               gl_problem(ctx, "unexpected texcoord size in dist_atten_textured_rgba_points()");
    1031             }
    1032         }
     1047            }
     1048        }
    10331049
    10341050/*    don't think this is needed
    … …  
    10991115            z = (GLint) (VB->Win.data[i][2] + ctx->PointZoffset);
    11001116
    1101             red   = VB->ColorPtr->data[i][0];
    1102             green = VB->ColorPtr->data[i][1];
    1103             blue  = VB->ColorPtr->data[i][2];
    1104        
    1105             switch (VB->TexCoordPtr[0]->size) {
    1106             case 4:
    1107                s = (VB->TexCoordPtr[0]->data[i][0]/
    1108                     VB->TexCoordPtr[0]->data[i][3]);
    1109                t = (VB->TexCoordPtr[0]->data[i][1]/
    1110                     VB->TexCoordPtr[0]->data[i][3]);
    1111                u = (VB->TexCoordPtr[0]->data[i][2]/
    1112                     VB->TexCoordPtr[0]->data[i][3]);
    1113                break;
    1114             case 3:
    1115                s = VB->TexCoordPtr[0]->data[i][0];
    1116                t = VB->TexCoordPtr[0]->data[i][1];
    1117                u = VB->TexCoordPtr[0]->data[i][2];
    1118                break;
    1119             case 2:
    1120                s = VB->TexCoordPtr[0]->data[i][0];
    1121                t = VB->TexCoordPtr[0]->data[i][1];
    1122                u = 0.0;
    1123                break;
    1124             case 1:
    1125                s = VB->TexCoordPtr[0]->data[i][0];
    1126                t = 0.0;
    1127                u = 0.0;
    1128                break;
     1117            red   = VB->ColorPtr->data[i][0];
     1118            green = VB->ColorPtr->data[i][1];
     1119            blue  = VB->ColorPtr->data[i][2];
     1120
     1121            switch (VB->TexCoordPtr[0]->size) {
     1122            case 4:
     1123               s = (VB->TexCoordPtr[0]->data[i][0]/
     1124                    VB->TexCoordPtr[0]->data[i][3]);
     1125               t = (VB->TexCoordPtr[0]->data[i][1]/
     1126                    VB->TexCoordPtr[0]->data[i][3]);
     1127               u = (VB->TexCoordPtr[0]->data[i][2]/
     1128                    VB->TexCoordPtr[0]->data[i][3]);
     1129               break;
     1130            case 3:
     1131               s = VB->TexCoordPtr[0]->data[i][0];
     1132               t = VB->TexCoordPtr[0]->data[i][1];
     1133               u = VB->TexCoordPtr[0]->data[i][2];
     1134               break;
     1135            case 2:
     1136               s = VB->TexCoordPtr[0]->data[i][0];
     1137               t = VB->TexCoordPtr[0]->data[i][1];
     1138               u = 0.0;
     1139               break;
     1140            case 1:
     1141               s = VB->TexCoordPtr[0]->data[i][0];
     1142               t = 0.0;
     1143               u = 0.0;
     1144               break;
    11291145            default:
    11301146               /* should never get here */
    11311147               s = t = u = 0.0;
    11321148               gl_problem(ctx, "unexpected texcoord size in dist_atten_antialiased_rgba_points()");
    1133             }
    1134 
    1135             if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
    1136                /* Multitextured!  This is probably a slow enough path that
    1137                   there's no reason to specialize the multitexture case. */
    1138                switch (VB->TexCoordPtr[1]->size) {
    1139                case 4:
    1140                   s1 = ( VB->TexCoordPtr[1]->data[i][0] /
    1141                         VB->TexCoordPtr[1]->data[i][3] );
    1142                   t1 = ( VB->TexCoordPtr[1]->data[i][1] /
    1143                         VB->TexCoordPtr[1]->data[i][3] );
    1144                   u1 = ( VB->TexCoordPtr[1]->data[i][2] /
    1145                         VB->TexCoordPtr[1]->data[i][3] );
    1146                   break;
    1147                case 3:
    1148                   s1 = VB->TexCoordPtr[1]->data[i][0];
    1149                   t1 = VB->TexCoordPtr[1]->data[i][1];
    1150                   u1 = VB->TexCoordPtr[1]->data[i][2];
    1151                   break;
    1152                case 2:
    1153                   s1 = VB->TexCoordPtr[1]->data[i][0];
    1154                   t1 = VB->TexCoordPtr[1]->data[i][1];
    1155                   u1 = 0.0;
    1156                   break;
    1157                case 1:
    1158                   s1 = VB->TexCoordPtr[1]->data[i][0];
    1159                   t1 = 0.0;
    1160                   u1 = 0.0;
    1161                   break;
     1149            }
     1150
     1151            if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
     1152               /* Multitextured!  This is probably a slow enough path that
     1153                  there's no reason to specialize the multitexture case. */
     1154               switch (VB->TexCoordPtr[1]->size) {
     1155               case 4:
     1156                  s1 = ( VB->TexCoordPtr[1]->data[i][0] /
     1157                        VB->TexCoordPtr[1]->data[i][3] );
     1158                  t1 = ( VB->TexCoordPtr[1]->data[i][1] /
     1159                        VB->TexCoordPtr[1]->data[i][3] );
     1160                  u1 = ( VB->TexCoordPtr[1]->data[i][2] /
     1161                        VB->TexCoordPtr[1]->data[i][3] );
     1162                  break;
     1163               case 3:
     1164                  s1 = VB->TexCoordPtr[1]->data[i][0];
     1165                  t1 = VB->TexCoordPtr[1]->data[i][1];
     1166                  u1 = VB->TexCoordPtr[1]->data[i][2];
     1167                  break;
     1168               case 2:
     1169                  s1 = VB->TexCoordPtr[1]->data[i][0];
     1170                  t1 = VB->TexCoordPtr[1]->data[i][1];
     1171                  u1 = 0.0;
     1172                  break;
     1173               case 1:
     1174                  s1 = VB->TexCoordPtr[1]->data[i][0];
     1175                  t1 = 0.0;
     1176                  u1 = 0.0;
     1177                  break;
    11621178               default:
    11631179                  /* should never get here */
    11641180                  s = t = u = 0.0;
    11651181                  gl_problem(ctx, "unexpected texcoord size in dist_atten_antialiased_rgba_points()");
    1166                }
    1167             }
     1182               }
     1183            }
    11681184
    11691185            for (y=ymin;y<=ymax;y++) {
    … …  
    12311247                  GLfloat dist2 = dx*dx + dy*dy;
    12321248                  if (dist2<rmax2) {
    1233                      alpha = VB->ColorPtr->data[i][3];
     1249                     alpha = VB->ColorPtr->data[i][3];
    12341250                     if (dist2>=rmin2) {
    12351251                        GLint coverage = (GLint) (256.0F-(dist2-rmin2)*cscale);
    … …  
    12391255                     alpha = (GLint) (alpha * alphaf);
    12401256                     PB_WRITE_RGBA_PIXEL( PB, x, y, z, red, green, blue, alpha )
    1241                         ;
     1257                        ;
    12421258                  }
    12431259               }
    12441260            }
    12451261            PB_CHECK_FLUSH(ctx,PB);
    1246         }
     1262        }
    12471263      }
    12481264   }
    … …  
    12651281      if (ctx->Driver.PointsFunc) {
    12661282         /* Device driver will draw points. */
    1267         ctx->IndirectTriangles &= ~DD_POINT_SW_RASTERIZE;
    1268         return;
     1283        ctx->IndirectTriangles &= ~DD_POINT_SW_RASTERIZE;
     1284        return;
    12691285      }
    12701286
    … …  
    12751291         else if (ctx->Texture.ReallyEnabled) {
    12761292            if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
    1277                ctx->Driver.PointsFunc = multitextured_rgba_points;
     1293               ctx->Driver.PointsFunc = multitextured_rgba_points;
    12781294            }
    12791295            else {
    … …  
    12891305         }
    12901306         else {
    1291             /* every other kind of point rendering */
     1307            /* every other kind of point rendering */
    12921308            if (rgbmode)
    12931309               ctx->Driver.PointsFunc = general_rgba_points;
Note: See TracChangeset for help on using the changeset viewer.