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/cva.c

    r2938 r3598  
    1 /* $Id: cva.c,v 1.1 2000-02-29 00:50:01 sandervl Exp $ */
     1/* $Id: cva.c,v 1.2 2000-05-23 20:40:27 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.
    … …  
    2929 */
    3030
    31 #ifndef XFree86Server
    32 #include <stdlib.h>
    33 #include <stdio.h>
    34 #else
    35 #include "GL/xf86glx.h"
    36 #endif
    37 #include "api.h"
     31#include "glheader.h"
    3832#include "types.h"
    3933#include "cva.h"
     34#include "mem.h"
    4035#include "context.h"
    4136#include "macros.h"
    … …  
    7166
    7267static void translate_4f( GLvector4f *dest,
    73                           CONST GLvector4f *src,
    74                           CONST GLuint elt[],
    75                           GLuint nr )
     68                          CONST GLvector4f *src,
     69                          CONST GLuint elt[],
     70                          GLuint nr )
    7671{
    7772   GLuint i;
    … …  
    8277   if (stride == 4 * sizeof(GLfloat)) {
    8378      for (i = 0 ; i < nr ; i++)
    84         COPY_4FV( to[i], from[elt[i]] );
     79        COPY_4FV( to[i], from[elt[i]] );
    8580   } else {
    8681      for (i = 0 ; i < nr ; i++) {
    87         CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
    88         COPY_4FV( to[i], (GLfloat *)f );
     82        CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
     83        COPY_4FV( to[i], (GLfloat *)f );
    8984      }
    9085   }
    … …  
    9691
    9792static void translate_3f( GLvector3f *dest,
    98                           CONST GLvector3f *src,
    99                           CONST GLuint elt[],
    100                           GLuint nr )
     93                          CONST GLvector3f *src,
     94                          CONST GLuint elt[],
     95                          GLuint nr )
    10196{
    10297   GLuint i;
    … …  
    107102   if (stride == 3 * sizeof(GLfloat)) {
    108103      for (i = 0 ; i < nr ; i++)
    109         COPY_3FV( to[i], from[elt[i]] );
     104        COPY_3FV( to[i], from[elt[i]] );
    110105   } else {
    111106      for (i = 0 ; i < nr ; i++) {
    112         CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
    113         COPY_3FV( to[i], (GLfloat *)f );
     107        CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
     108        COPY_3FV( to[i], (GLfloat *)f );
    114109      }
    115110   }
    … …  
    119114
    120115static void translate_4ub( GLvector4ub *dest,
    121                            CONST GLvector4ub *src,
    122                            GLuint elt[],
    123                            GLuint nr )
     116                           CONST GLvector4ub *src,
     117                           GLuint elt[],
     118                           GLuint nr )
    124119{
    125120   GLuint i;
    … …  
    130125   if (stride == 4 * sizeof(GLubyte)) {
    131126      for (i = 0 ; i < nr ; i++)
    132         COPY_4UBV( to[i], from[elt[i]]);
     127        COPY_4UBV( to[i], from[elt[i]]);
    133128   } else {
    134129      for (i = 0 ; i < nr ; i++) {
    135         CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
    136         COPY_4UBV( to[i], f );
     130        CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
     131        COPY_4UBV( to[i], f );
    137132      }
    138133   }
    … …  
    142137
    143138static void translate_1ui( GLvector1ui *dest,
    144                            GLvector1ui *src,
    145                            GLuint elt[],
    146                            GLuint nr )
     139                           GLvector1ui *src,
     140                           GLuint elt[],
     141                           GLuint nr )
    147142{
    148143   GLuint i;
    … …  
    153148   if (stride == sizeof(GLuint)) {
    154149      for (i = 0 ; i < nr ; i++)
    155         to[i] = from[elt[i]];
     150        to[i] = from[elt[i]];
    156151   } else {
    157152      for (i = 0 ; i < nr ; i++) {
    158         CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
    159         to[i] = *(GLuint *)f;
     153        CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
     154        to[i] = *(GLuint *)f;
    160155      }
    161156   }
    … …  
    165160
    166161static void translate_1ub( GLvector1ub *dest,
    167                            GLvector1ub *src,
    168                            GLuint elt[],
    169                            GLuint nr )
     162                           GLvector1ub *src,
     163                           GLuint elt[],
     164                           GLuint nr )
    170165{
    171166   GLuint i;
    … …  
    176171   if (stride == sizeof(GLubyte)) {
    177172      for (i = 0 ; i < nr ; i++)
    178         to[i] = from[elt[i]];
     173        to[i] = from[elt[i]];
    179174   } else {
    180175      for (i = 0 ; i < nr ; i++) {
    181         CONST GLubyte *f = from + elt[i] * stride;
    182         to[i] = *f;
     176        CONST GLubyte *f = from + elt[i] * stride;
     177        to[i] = *f;
    183178      }
    184179   }
    … …  
    200195 */
    201196void gl_merge_cva( struct vertex_buffer *VB,
    202                    struct vertex_buffer *cvaVB )
     197                   struct vertex_buffer *cvaVB )
    203198{
    204199   GLcontext *ctx = VB->ctx;
    … …  
    217212   {
    218213      if (MESA_VERBOSE & VERBOSE_PIPELINE)
    219         gl_print_vert_flags("extra flags for setup",
    220                              ctx->RenderFlags & available & ~required);
     214        gl_print_vert_flags("extra flags for setup",
     215                             ctx->RenderFlags & available & ~required);
    221216      required |= ctx->RenderFlags;
    222217   }
    … …  
    237232      if (cvaVB->ClipOrMask) {
    238233
    239         /* Copy clipmask back into VB, build a new clipOrMask */
    240         copy_clipmask( VB->ClipMask + VB->Start,
    241                         &VB->ClipOrMask, &VB->ClipAndMask,
    242                         cvaVB->ClipMask,
    243                         elt,
    244                         VB->Count - VB->Start );
    245        
    246         /* overkill if !VB->ClipOrMask - should just copy 'copied' verts */
    247         translate_4f( VB->ClipPtr, cvaVB->ClipPtr, elt, count);
    248 
    249         if (VB->ClipOrMask & CLIP_USER_BIT) {
    250             GLubyte or = 0, and = ~0;
    251 
    252             copy_clipmask( VB->UserClipMask + VB->Start,
    253                            &or, &and,
    254                            cvaVB->UserClipMask,
    255                            elt,
    256                            VB->Count - VB->Start);
    257        
    258             if (and) VB->ClipAndMask |= CLIP_USER_BIT;
    259         }
    260 
    261         if (VB->ClipOrMask)
    262             VB->CullMode |= CLIP_MASK_ACTIVE;
    263 
    264         if (VB->ClipAndMask) {
    265             VB->Culled = 1;
    266             gl_dont_cull_vb( VB );
    267             return;
    268         }
     234        /* Copy clipmask back into VB, build a new clipOrMask */
     235        copy_clipmask( VB->ClipMask + VB->Start,
     236                        &VB->ClipOrMask, &VB->ClipAndMask,
     237                        cvaVB->ClipMask,
     238                        elt,
     239                        VB->Count - VB->Start );
     240
     241        /* overkill if !VB->ClipOrMask - should just copy 'copied' verts */
     242        translate_4f( VB->ClipPtr, cvaVB->ClipPtr, elt, count);
     243
     244        if (VB->ClipOrMask & CLIP_USER_BIT) {
     245            GLubyte or = 0, and = ~0;
     246
     247            copy_clipmask( VB->UserClipMask + VB->Start,
     248                           &or, &and,
     249                           cvaVB->UserClipMask,
     250                           elt,
     251                           VB->Count - VB->Start);
     252
     253            if (and) VB->ClipAndMask |= CLIP_USER_BIT;
     254        }
     255
     256        if (VB->ClipOrMask)
     257            VB->CullMode |= CLIP_MASK_ACTIVE;
     258
     259        if (VB->ClipAndMask) {
     260            VB->Culled = 1;
     261            gl_dont_cull_vb( VB );
     262            return;
     263        }
    269264      }
    270265
    … …  
    275270      if (ctx->IndirectTriangles & DD_ANY_CULL)
    276271      {
    277         GLuint cullcount = gl_cull_vb( VB );
    278         if (cullcount) VB->CullMode |= CULL_MASK_ACTIVE;
    279         if (cullcount == VB->Count) { VB->Culled = 2 ; return; }
     272        GLuint cullcount = gl_cull_vb( VB );
     273        if (cullcount) VB->CullMode |= CULL_MASK_ACTIVE;
     274        if (cullcount == VB->Count) { VB->Culled = 2 ; return; }
    280275      }
    281276      else
    282         gl_dont_cull_vb( VB );
     277        gl_dont_cull_vb( VB );
    283278   } else {
    284279      VB->ClipPtr = &VB->Clip;
    … …  
    312307
    313308      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
    314         VB->Color[1] = VB->LitColor[1];
    315         translate_4ub( VB->Color[1], cvaVB->Color[1], elt, count );
     309        VB->Color[1] = VB->LitColor[1];
     310        translate_4ub( VB->Color[1], cvaVB->Color[1], elt, count );
    316311      }
    317312   }
    … …  
    323318
    324319      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
    325         VB->Index[1] = VB->LitIndex[1];
    326         translate_1ui( VB->Index[1], cvaVB->Index[1], elt, count );
     320        VB->Index[1] = VB->LitIndex[1];
     321        translate_1ui( VB->Index[1], cvaVB->Index[1], elt, count );
    327322      }
    328323   }
    … …  
    376371 * calling render_vb.
    377372 */
    378 void GLAPIENTRY glLockArraysEXT(CTX_ARG GLint first, GLsizei count )
    379 {
    380    GLcontext *ctx;
    381    GET_CONTEXT;
    382    CHECK_CONTEXT;
    383    ctx = CC;
     373void
     374_mesa_LockArraysEXT(GLint first, GLsizei count)
     375{
     376   GET_CURRENT_CONTEXT(ctx);
    384377   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "unlock arrays" );
    385378
    … …  
    397390
    398391      if (!ctx->Array.LockCount) {
    399         ctx->Array.NewArrayState = ~0;
    400         ctx->CVA.lock_changed ^= 1;
    401         ctx->NewState |= NEW_CLIENT_STATE;
     392        ctx->Array.NewArrayState = ~0;
     393        ctx->CVA.lock_changed ^= 1;
     394        ctx->NewState |= NEW_CLIENT_STATE;
    402395      }
    403396
    … …  
    407400
    408401      if (!cva->VB) {
    409         cva->VB = gl_vb_create_for_cva( ctx, ctx->Const.MaxArrayLockSize );
    410         gl_alloc_cva_store( cva, cva->VB->Size );
    411         gl_reset_cva_vb( cva->VB, ~0 );
     402        cva->VB = gl_vb_create_for_cva( ctx, ctx->Const.MaxArrayLockSize );
     403        gl_alloc_cva_store( cva, cva->VB->Size );
     404        gl_reset_cva_vb( cva->VB, ~0 );
    412405      }
    413406   }
    … …  
    415408   {
    416409      if (ctx->Array.LockCount) {
    417         ctx->CVA.lock_changed ^= 1;
    418         ctx->NewState |= NEW_CLIENT_STATE;
     410        ctx->CVA.lock_changed ^= 1;
     411        ctx->NewState |= NEW_CLIENT_STATE;
    419412      }
    420413
    … …  
    429422
    430423
    431 void GLAPIENTRY glUnlockArraysEXT(CTX_VOID )
    432 {
    433    GLcontext *ctx;
    434    GET_CONTEXT;
    435    CHECK_CONTEXT;
    436    ctx = CC;
     424void
     425_mesa_UnlockArraysEXT( void )
     426{
     427   GET_CURRENT_CONTEXT(ctx);
    437428   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "unlock arrays" );
    438429
    … …  
    487478   GLuint n = ctx->Array.LockCount;
    488479   GLuint enable = ((ctx->Array.NewArrayState & ctx->Array.Summary) |
    489                     VB->pipeline->fallback);
     480                    VB->pipeline->fallback);
    490481   GLuint disable = ctx->Array.NewArrayState & ~enable;
    491482   GLuint i;
    … …  
    503494      if (enable & VERT_ELT)
    504495      {
    505         GLvector1ui *elt = VB->EltPtr = &cva->v.Elt;
    506 
    507         if (cva->Elt.Type == GL_UNSIGNED_INT)
    508         {
    509             elt->data = (GLuint *) cva->Elt.Ptr;
    510             elt->stride = sizeof(GLuint);
    511             elt->flags = 0;
    512         } else {
    513             elt->data = cva->store.Elt;
    514             elt->stride = sizeof(GLuint);
    515 
    516             if (cva->elt_count > cva->elt_size)
    517             {
    518                while (cva->elt_count > (cva->elt_size *= 2)) {};
    519                FREE(cva->store.Elt);
    520                cva->store.Elt = (GLuint *) MALLOC(cva->elt_size *
    521                                                   sizeof(GLuint));
    522             }
    523             cva->EltFunc( elt->data, &cva->Elt, 0, cva->elt_count );
    524          }     
    525         elt->start = VEC_ELT(elt, GLuint, 0);
    526         elt->count = cva->elt_count;
    527 
    528         fallback |= (cva->pre.new_inputs & ~ctx->Array.Summary);
    529         enable |= fallback;
    530         disable &= ~fallback;
    531         if (MESA_VERBOSE&VERBOSE_PIPELINE) {
    532             gl_print_vert_flags("*** NEW INPUTS", cva->pre.new_inputs);
    533             gl_print_vert_flags("*** FALLBACK", fallback);
    534         }
     496        GLvector1ui *elt = VB->EltPtr = &cva->v.Elt;
     497
     498        if (cva->Elt.Type == GL_UNSIGNED_INT)
     499        {
     500            elt->data = (GLuint *) cva->Elt.Ptr;
     501            elt->stride = sizeof(GLuint);
     502            elt->flags = 0;
     503        } else {
     504            elt->data = cva->store.Elt;
     505            elt->stride = sizeof(GLuint);
     506
     507            if (cva->elt_count > cva->elt_size)
     508            {
     509               while (cva->elt_count > (cva->elt_size *= 2)) {};
     510               FREE(cva->store.Elt);
     511               cva->store.Elt = (GLuint *) MALLOC(cva->elt_size *
     512                                                  sizeof(GLuint));
     513            }
     514            cva->EltFunc( elt->data, &cva->Elt, 0, cva->elt_count );
     515         }
     516        elt->start = VEC_ELT(elt, GLuint, 0);
     517        elt->count = cva->elt_count;
     518
     519        fallback |= (cva->pre.new_inputs & ~ctx->Array.Summary);
     520        enable |= fallback;
     521        disable &= ~fallback;
     522        if (MESA_VERBOSE&VERBOSE_PIPELINE) {
     523            gl_print_vert_flags("*** NEW INPUTS", cva->pre.new_inputs);
     524            gl_print_vert_flags("*** FALLBACK", fallback);
     525        }
    535526      }
    536527
    537528      if (enable & VERT_RGBA)
    538529      {
    539         GLvector4ub *col = &cva->v.Color;
    540 
    541         client_data = &ctx->Array.Color;
    542         if (fallback & VERT_RGBA) client_data = &ctx->Fallback.Color;
    543 
    544         VB->Color[0] = VB->Color[1] = VB->ColorPtr = &cva->v.Color;
    545 
    546         if (client_data->Type != GL_UNSIGNED_BYTE ||
    547              client_data->Size != 4)
    548         {
    549             col->data = cva->store.Color;
    550             col->stride = 4 * sizeof(GLubyte);
    551             ctx->Array.ColorFunc( col->data, client_data, start, n );
    552             col->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
    553         } else {
    554             col->data = (GLubyte (*)[4]) client_data->Ptr;
    555             col->stride = client_data->StrideB;
    556             col->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
    557             if (client_data->StrideB != 4 * sizeof(GLubyte))
    558                col->flags ^= VEC_STRIDE_FLAGS;
    559          }     
    560         col->start = VEC_ELT(col, GLubyte, start);
    561         col->count = n;
     530        GLvector4ub *col = &cva->v.Color;
     531
     532        client_data = &ctx->Array.Color;
     533        if (fallback & VERT_RGBA) client_data = &ctx->Fallback.Color;
     534
     535        VB->Color[0] = VB->Color[1] = VB->ColorPtr = &cva->v.Color;
     536
     537        if (client_data->Type != GL_UNSIGNED_BYTE ||
     538             client_data->Size != 4)
     539        {
     540            col->data = cva->store.Color;
     541            col->stride = 4 * sizeof(GLubyte);
     542            ctx->Array.ColorFunc( col->data, client_data, start, n );
     543            col->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
     544        } else {
     545            col->data = (GLubyte (*)[4]) client_data->Ptr;
     546            col->stride = client_data->StrideB;
     547            col->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
     548            if (client_data->StrideB != 4 * sizeof(GLubyte))
     549               col->flags ^= VEC_STRIDE_FLAGS;
     550         }
     551        col->start = VEC_ELT(col, GLubyte, start);
     552        col->count = n;
    562553      }
    563554
    564555      if (enable & VERT_INDEX)
    565556      {
    566         GLvector1ui *index = VB->IndexPtr = &cva->v.Index;
    567         VB->Index[0] = VB->Index[1] = VB->IndexPtr;
    568 
    569         client_data = &ctx->Array.Index;
    570         if (fallback & VERT_INDEX) client_data = &ctx->Fallback.Index;
    571 
    572         if (client_data->Type != GL_UNSIGNED_INT)
    573         {
    574             index->data = cva->store.Index;
    575             index->stride = sizeof(GLuint);
    576             ctx->Array.IndexFunc( index->data, client_data, start, n );
    577             index->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
    578         } else {
    579             index->data = (GLuint *) client_data->Ptr;
    580             index->stride = client_data->StrideB;
    581             index->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
    582             if (index->stride != sizeof(GLuint))
    583                index->flags ^= VEC_STRIDE_FLAGS;
    584          }     
    585         index->count = n;
    586         index->start = VEC_ELT(index, GLuint, start);
     557        GLvector1ui *index = VB->IndexPtr = &cva->v.Index;
     558        VB->Index[0] = VB->Index[1] = VB->IndexPtr;
     559
     560        client_data = &ctx->Array.Index;
     561        if (fallback & VERT_INDEX) client_data = &ctx->Fallback.Index;
     562
     563        if (client_data->Type != GL_UNSIGNED_INT)
     564        {
     565            index->data = cva->store.Index;
     566            index->stride = sizeof(GLuint);
     567            ctx->Array.IndexFunc( index->data, client_data, start, n );
     568            index->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
     569        } else {
     570            index->data = (GLuint *) client_data->Ptr;
     571            index->stride = client_data->StrideB;
     572            index->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
     573            if (index->stride != sizeof(GLuint))
     574               index->flags ^= VEC_STRIDE_FLAGS;
     575         }
     576        index->count = n;
     577        index->start = VEC_ELT(index, GLuint, start);
    587578      }
    588579
    589580      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
    590         if (enable & PIPE_TEX(i)) {
    591             GLvector4f *tc = VB->TexCoordPtr[i] = &cva->v.TexCoord[i];
    592 
    593             client_data = &ctx->Array.TexCoord[i];
    594 
    595             if (fallback & PIPE_TEX(i)) {
    596                client_data = &ctx->Fallback.TexCoord[i];
    597                client_data->Size = gl_texcoord_size( ctx->Current.Flag, i );
    598             }
    599 
    600             /* Writeability and stride handled lazily by
    601              * gl_import_client_data().
    602              */
    603             if (client_data->Type == GL_FLOAT)
    604             {
    605                tc->data = (GLfloat (*)[4]) client_data->Ptr;
    606                tc->stride = client_data->StrideB;
    607                tc->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
    608                if (tc->stride != 4 * sizeof(GLfloat))
    609                   tc->flags ^= VEC_STRIDE_FLAGS;
    610             } else {
    611                tc->data = cva->store.TexCoord[i];
    612                tc->stride = 4 * sizeof(GLfloat);
    613                ctx->Array.TexCoordFunc[i]( tc->data, client_data, start, n );
    614                tc->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
    615             }           
    616             tc->count = n;
    617             tc->start = VEC_ELT(tc, GLfloat, start);
    618             tc->size = client_data->Size;
    619         }
     581        if (enable & PIPE_TEX(i)) {
     582            GLvector4f *tc = VB->TexCoordPtr[i] = &cva->v.TexCoord[i];
     583
     584            client_data = &ctx->Array.TexCoord[i];
     585
     586            if (fallback & PIPE_TEX(i)) {
     587               client_data = &ctx->Fallback.TexCoord[i];
     588               client_data->Size = gl_texcoord_size( ctx->Current.Flag, i );
     589            }
     590
     591            /* Writeability and stride handled lazily by
     592             * gl_import_client_data().
     593             */
     594            if (client_data->Type == GL_FLOAT)
     595            {
     596               tc->data = (GLfloat (*)[4]) client_data->Ptr;
     597               tc->stride = client_data->StrideB;
     598               tc->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
     599               if (tc->stride != 4 * sizeof(GLfloat))
     600                  tc->flags ^= VEC_STRIDE_FLAGS;
     601            } else {
     602               tc->data = cva->store.TexCoord[i];
     603               tc->stride = 4 * sizeof(GLfloat);
     604               ctx->Array.TexCoordFunc[i]( tc->data, client_data, start, n );
     605               tc->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
     606            }
     607            tc->count = n;
     608            tc->start = VEC_ELT(tc, GLfloat, start);
     609            tc->size = client_data->Size;
     610        }
    620611
    621612      if (enable & VERT_OBJ_ANY)
    622613      {
    623         GLvector4f *obj = VB->ObjPtr = &cva->v.Obj;
    624 
    625         if (ctx->Array.Vertex.Type == GL_FLOAT)
    626         {
    627             obj->data = (GLfloat (*)[4]) ctx->Array.Vertex.Ptr;
    628             obj->stride = ctx->Array.Vertex.StrideB;
    629             obj->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
    630             if (obj->stride != 4 * sizeof(GLfloat))
    631                obj->flags ^= VEC_STRIDE_FLAGS;
    632         } else {
    633             obj->data = cva->store.Obj;
    634             obj->stride = 4 * sizeof(GLfloat);
    635             ctx->Array.VertexFunc( obj->data, &ctx->Array.Vertex, start, n );
    636             obj->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
    637         }
    638         obj->count = n;
    639         obj->start = VEC_ELT(obj, GLfloat, start);
    640         obj->size = ctx->Array.Vertex.Size;
     614        GLvector4f *obj = VB->ObjPtr = &cva->v.Obj;
     615
     616        if (ctx->Array.Vertex.Type == GL_FLOAT)
     617        {
     618            obj->data = (GLfloat (*)[4]) ctx->Array.Vertex.Ptr;
     619            obj->stride = ctx->Array.Vertex.StrideB;
     620            obj->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
     621            if (obj->stride != 4 * sizeof(GLfloat))
     622               obj->flags ^= VEC_STRIDE_FLAGS;
     623        } else {
     624            obj->data = cva->store.Obj;
     625            obj->stride = 4 * sizeof(GLfloat);
     626            ctx->Array.VertexFunc( obj->data, &ctx->Array.Vertex, start, n );
     627            obj->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
     628        }
     629        obj->count = n;
     630        obj->start = VEC_ELT(obj, GLfloat, start);
     631        obj->size = ctx->Array.Vertex.Size;
    641632      }
    642633
    643634      if (enable & VERT_NORM)
    644635      {
    645         GLvector3f *norm = VB->NormalPtr = &cva->v.Normal;
    646 
    647         client_data = &ctx->Array.Normal;
    648 
    649         if (fallback & VERT_NORM)
    650             client_data = &ctx->Fallback.Normal;
    651 
    652         /* Never need to write to normals, and we can always cope with stride.
    653           */
    654         if (client_data->Type == GL_FLOAT) {
    655             norm->data = (GLfloat (*)[3]) client_data->Ptr;
    656             norm->stride = client_data->StrideB;
    657         } else {
    658             norm->data = cva->store.Normal;
    659             norm->stride = 3 * sizeof(GLfloat);
    660             ctx->Array.NormalFunc( norm->data, client_data, start, n );
    661         }
    662         norm->flags = 0;
    663         norm->count = n;
    664         norm->start = VEC_ELT(norm, GLfloat, start);
     636        GLvector3f *norm = VB->NormalPtr = &cva->v.Normal;
     637
     638        client_data = &ctx->Array.Normal;
     639
     640        if (fallback & VERT_NORM)
     641            client_data = &ctx->Fallback.Normal;
     642
     643        /* Never need to write to normals, and we can always cope with stride.
     644          */
     645        if (client_data->Type == GL_FLOAT) {
     646            norm->data = (GLfloat (*)[3]) client_data->Ptr;
     647            norm->stride = client_data->StrideB;
     648        } else {
     649            norm->data = cva->store.Normal;
     650            norm->stride = 3 * sizeof(GLfloat);
     651            ctx->Array.NormalFunc( norm->data, client_data, start, n );
     652        }
     653        norm->flags = 0;
     654        norm->count = n;
     655        norm->start = VEC_ELT(norm, GLfloat, start);
    665656      }
    666657
    667658      if (enable & VERT_EDGE)
    668659      {
    669         GLvector1ub *edge = VB->EdgeFlagPtr = &cva->v.EdgeFlag;
    670 
    671         client_data = &ctx->Array.EdgeFlag;
    672 
    673         if (fallback & VERT_EDGE)
    674             client_data = &ctx->Fallback.EdgeFlag;
    675 
    676         edge->data = (GLboolean *) client_data->Ptr;
    677         edge->stride = client_data->StrideB;
    678         edge->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
    679         if (edge->stride != sizeof(GLubyte))
    680             edge->flags ^= VEC_STRIDE_FLAGS;
    681 
    682         edge->count = n;
    683         edge->start = VEC_ELT(edge, GLubyte, start);
     660        GLvector1ub *edge = VB->EdgeFlagPtr = &cva->v.EdgeFlag;
     661
     662        client_data = &ctx->Array.EdgeFlag;
     663
     664        if (fallback & VERT_EDGE)
     665            client_data = &ctx->Fallback.EdgeFlag;
     666
     667        edge->data = (GLboolean *) client_data->Ptr;
     668        edge->stride = client_data->StrideB;
     669        edge->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
     670        if (edge->stride != sizeof(GLubyte))
     671            edge->flags ^= VEC_STRIDE_FLAGS;
     672
     673        edge->count = n;
     674        edge->start = VEC_ELT(edge, GLubyte, start);
    684675      }
    685676   }
    … …  
    697688   VB->Flag[VB->Count] &= ~VERT_END_VB;
    698689   VB->Count = n;
    699        
     690
    700691   if (ctx->Enabled & ENABLE_LIGHT)
    701692   {
    702693      if (ctx->Array.Flags != VB->Flag[0])
    703         VB->FlagMax = 0;
     694        VB->FlagMax = 0;
    704695
    705696      if (VB->FlagMax < n) {
    706         for (i = VB->FlagMax ; i < n ; i++)
    707             VB->Flag[i] = ctx->Array.Flags;
    708         VB->Flag[i] = 0;
    709         VB->FlagMax = n;
     697        for (i = VB->FlagMax ; i < n ; i++)
     698            VB->Flag[i] = ctx->Array.Flags;
     699        VB->Flag[i] = 0;
     700        VB->FlagMax = n;
    710701      }
    711702
    … …  
    740731      if (IM->OrFlag & cva->pre.forbidden_inputs)
    741732      {
    742         cva->pre.pipeline_valid = 0;
    743         cva->pre.data_valid = 0;
    744         cva->pre.forbidden_inputs = 0;
     733        cva->pre.pipeline_valid = 0;
     734        cva->pre.data_valid = 0;
     735        cva->pre.forbidden_inputs = 0;
    745736      }
    746737
    747738      if ((IM->OrFlag & cva->elt.forbidden_inputs))
    748739      {
    749         cva->elt.forbidden_inputs = 0;
     740        cva->elt.forbidden_inputs = 0;
    750741      }
    751742
    … …  
    758749   {
    759750      if (!cva->pre.pipeline_valid)
    760         gl_build_precalc_pipeline( ctx );
     751        gl_build_precalc_pipeline( ctx );
    761752
    762753      gl_cva_force_precalc( ctx );
Note: See TracChangeset for help on using the changeset viewer.