Source/System/NodeCores/Drawables/Geometry/Base/OSGGeoImmediatePumpGroup.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  *                                                                           *
  16  *                                                                           *
  17  * This library is free software; you can redistribute it and/or modify it   *
  18  * under the terms of the GNU Library General Public License as published    *
  19  * by the Free Software Foundation, version 2.                               *
  20  *                                                                           *
  21  * This library is distributed in the hope that it will be useful, but       *
  22  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  24  * Library General Public License for more details.                          *
  25  *                                                                           *
  26  * You should have received a copy of the GNU Library General Public         *
  27  * License along with this library; if not, write to the Free Software       *
  28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  29  *                                                                           *
  30  *                                                                           *
  31 \*---------------------------------------------------------------------------*/
  32 /*---------------------------------------------------------------------------*\
  33  *                                Changes                                    *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37  *                                                                           *
  38  *                                                                           *
  39  *                                                                           *
  40 \*---------------------------------------------------------------------------*/
  41
  42 //---------------------------------------------------------------------------
  43 //  Includes
  44 //---------------------------------------------------------------------------
  45
  46 #include <cstdlib>
  47 #include <cstdio>
  48
  49 #include "OSGConfig.h"
  50
  51 #include "OSGGL.h"
  52 #include "OSGGLEXT.h"
  53
  54 #include "OSGLog.h"
  55
  56 #include "OSGGeometry.h"
  57 #include "OSGDrawEnv.h"
  58
  59 #include "OSGMaterial.h"
  60
  61 #include "OSGGeoImmediatePumpGroup.h"
  62 #include "OSGConceptPropertyChecks.h"
  63
  64 //#define DEBUG_WHICH_PUMP 1
  65
  66 OSG_BEGIN_NAMESPACE
  67
  68 // Intentionally INSIDE the namespace
  69 #include "OSGGeoPumpCommon.inl"
  70
  71 /***************************************************************************\
  72  *                            Description                                  *
  73 \***************************************************************************/
  74
  75 /***************************************************************************\
  76  *                           Class variables                               *
  77 \***************************************************************************/
  78
  79 /*! An InitFuncWrapper to initialize the GeoImmediatePumpGroup.
  80  */
  81
  82 InitFuncWrapper GeoImmediatePumpGroup::_glextInitFuncWrapper(
  83     GeoImmediatePumpGroup::glextInitFunction);
  84
  85 /*! OpenGL extension indices.
  86 */
  87 UInt32 GeoImmediatePumpGroup::_extSecondaryColor;
  88 UInt32 GeoImmediatePumpGroup::_extMultitexture;
  89 UInt32 GeoImmediatePumpGroup::_arbVertexProgram;
  90
  91 /***************************************************************************\
  92  *                           Instance methods                              *
  93 \***************************************************************************/
  94
  95 /*------------- constructors & destructors --------------------------------*/
  96
  97 GeoImmediatePumpGroup::GeoImmediatePumpGroup(void)
  98 {
  99 }
 100
 101 GeoImmediatePumpGroup::~GeoImmediatePumpGroup(void)
 102 {
 103 }
 104
 105 /*-------------------------------------------------------------------------*\
 106  -  private                                                                -
 107 \*-------------------------------------------------------------------------*/
 108
 109 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 110
 111 namespace
 112 {
 113     struct PumpClassicInfo : public PumpData
 114     {
 115         explicit PumpClassicInfo(void);
 116
 117         pumpFunc      attribPump [Geometry::MaxAttribs];
 118         multiPumpFunc attribMPump[Geometry::MaxAttribs];
 119     };
 120
 121     PumpClassicInfo::PumpClassicInfo(void) :
 122         PumpData()
 123     {
 124         for(Int16 i = 0; i < Geometry::MaxAttribs; ++i)
 125         {
 126             attribPump  [i] = NULL;
 127             attribMPump [i] = NULL;
 128         }
 129     }
 130
 131
 132
 133     // collect info for property in 'slot'
 134     bool pumpGLSetup(PumpClassicInfo &info, UInt16 slot, UInt32 pumpSlot)
 135     {
 136         bool retVal = true;
 137
 138         if(slot < info.prop->size())
 139             info.attribPtr  [slot] = (*info.prop   )[slot];
 140
 141         if(slot < info.propIdx->size())
 142             info.attribIndex[slot] = (*info.propIdx)[slot];
 143
 144         if(info.attribPtr[slot]              != NULL  &&
 145            info.attribPtr[slot]->getIgnore() == false   )
 146         {
 147             info.attribData  [slot] = info.attribPtr[slot]->getData();
 148             info.attribStride[slot] = info.attribPtr[slot]->getStride();
 149
 150             if(info.attribStride[slot] == 0)
 151             {
 152                 info.attribStride[slot] =
 153                     info.attribPtr[slot]->getFormatSize() *
 154                     info.attribPtr[slot]->getDimension();
 155             }
 156
 157             UInt16 formatIdx = info.attribPtr[slot]->getFormat() - formatBase;
 158             UInt16 dimIdx    = info.attribPtr[slot]->getDimension() - 1;
 159
 160             info.attribPump[slot] = pumpFuncs[pumpSlot][formatIdx][dimIdx];
 161
 162             if(info.attribPump[slot] == NULL)
 163             {
 164                 SWARNING << "GeoImmediatePumpGroup - pumpGLSetup: "
 165                          << "Invalid pump function for property " << slot
 166                          << " type " << info.attribPtr[slot]->getDimension()
 167                          << "D " << formatNames[formatIdx]
 168                          << endLog;
 169
 170                 info.attribData  [slot] = NULL;
 171                 info.attribStride[slot] = 0;
 172                 info.attribPtr   [slot] = NULL;
 173                 info.attribIndex [slot] = NULL;
 174
 175                 retVal = false;
 176             }
 177         }
 178         else
 179         {
 180             info.attribData  [slot] = NULL;
 181             info.attribStride[slot] = 0;
 182             info.attribPtr   [slot] = NULL;
 183             info.attribIndex [slot] = NULL;
 184         }
 185
 186         return retVal;
 187     }
 188
 189     // collect info for property in 'slot'
 190     bool pumpGLSetup(PumpAttribInfo &info, UInt16 slot)
 191     {
 192         bool retVal = false;
 193
 194         if(slot < info.prop->size())
 195             info.attribPtr[slot] = (*info.prop)[slot];
 196
 197         if(slot < info.propIdx->size())
 198             info.attribIndex[slot] = (*info.propIdx)[slot];
 199
 200         if(info.attribPtr[slot]              != NULL  &&
 201            info.attribPtr[slot]->getIgnore() == false   )
 202         {
 203             info.attribData  [slot] = info.attribPtr[slot]->getData();
 204             info.attribStride[slot] = info.attribPtr[slot]->getStride();
 205
 206             if(info.attribStride[slot] == 0)
 207             {
 208                 info.attribStride[slot] =
 209                     info.attribPtr[slot]->getFormatSize() *
 210                     info.attribPtr[slot]->getDimension();
 211             }
 212
 213             retVal = true;
 214         }
 215
 216         return retVal;
 217     }
 218
 219     // collect info for property in 'slot' - using GL extension
 220     bool pumpGLExtSetup(PumpClassicInfo &info,     UInt16  slot,
 221                         UInt32           pumpSlot, Window *win)
 222     {
 223         if(slot < info.prop->size())
 224             info.attribPtr[slot] = (*info.prop)[slot];
 225
 226         if(slot < info.propIdx->size())
 227             info.attribIndex[slot] = (*info.propIdx)[slot];
 228
 229         if(info.attribPtr[slot]              != NULL  &&
 230            info.attribPtr[slot]->getIgnore() == false   )
 231         {
 232             info.attribData  [slot] = info.attribPtr[slot]->getData();
 233             info.attribStride[slot] = info.attribPtr[slot]->getStride();
 234
 235             if(info.attribStride[slot] == 0)
 236             {
 237                 info.attribStride[slot] =
 238                     info.attribPtr[slot]->getFormatSize() *
 239                     info.attribPtr[slot]->getDimension();
 240             }
 241
 242             UInt16 formatIdx = info.attribPtr[slot]->getFormat() - formatBase;
 243             UInt16 dimIdx    = info.attribPtr[slot]->getDimension() - 1;
 244
 245             UInt32 funcId    = pumpFuncIDs[pumpSlot][formatIdx][dimIdx];
 246
 247             if(funcId == Window::invalidFunctionID)
 248             {
 249                 SWARNING << "GeoImmediatePumpGroup - pumpGLExtSetup: "
 250                          << "Invalid extension function for property " << slot
 251                          << " type " << info.attribPtr[slot]->getDimension()
 252                          << "D " << formatNames[formatIdx]
 253                          << endLog;
 254
 255                 info.attribData  [slot] = NULL;
 256                 info.attribStride[slot] = 0;
 257                 info.attribPtr   [slot] = NULL;
 258                 info.attribIndex [slot] = NULL;
 259
 260                 return false;
 261             }
 262
 263             info.attribPump[slot] =
 264                 reinterpret_cast<pumpFunc>(win->getFunction(funcId));
 265
 266             if(info.attribPump[slot] == NULL)
 267             {
 268                 SWARNING << "GeoImmediatePumpGroup - pumpGLExtSetup: "
 269                          << "Extension function for property " << slot
 270                          << " type " << info.attribPtr[slot]->getDimension()
 271                          << "D " << formatNames[formatIdx]
 272                          << " not supported by Window " << win
 273                          << endLog;
 274
 275                 info.attribData  [slot] = NULL;
 276                 info.attribStride[slot] = 0;
 277                 info.attribPtr   [slot] = NULL;
 278                 info.attribIndex [slot] = NULL;
 279
 280                 return false;
 281             }
 282         }
 283
 284         return true;
 285     }
 286
 287     // collect info for property in 'slot' - using GL extension, multi
 288     bool pumpGLExtMultiSetup(PumpClassicInfo &info,     UInt16  slot,
 289                              UInt32           pumpSlot, Window *win)
 290     {
 291         if(slot < info.prop->size())
 292             info.attribPtr[slot] = (*info.prop)[slot];
 293
 294         if(slot < info.propIdx->size())
 295             info.attribIndex[slot] = (*info.propIdx)[slot];
 296
 297         if(info.attribPtr[slot]              != NULL  &&
 298            info.attribPtr[slot]->getIgnore() == false   )
 299         {
 300             info.attribData  [slot] = info.attribPtr[slot]->getData();
 301             info.attribStride[slot] = info.attribPtr[slot]->getStride();
 302
 303             if(info.attribStride[slot] == 0)
 304             {
 305                 info.attribStride[slot] =
 306                     info.attribPtr[slot]->getFormatSize() *
 307                     info.attribPtr[slot]->getDimension();
 308             }
 309
 310             UInt16 formatIdx = info.attribPtr[slot]->getFormat() - formatBase;
 311             UInt32 dimIdx    = info.attribPtr[slot]->getDimension() - 1;
 312
 313             UInt32 funcId    = pumpFuncIDs[pumpSlot][formatIdx][dimIdx];
 314
 315             if(funcId == Window::invalidFunctionID)
 316             {
 317                 SWARNING << "GeoImmediatePumpGroup - pumpGLExtMultiSetup: "
 318                          << "Invalid extension function for property " << slot
 319                          << " type " << info.attribPtr[slot]->getDimension()
 320                          << "D " << formatNames[formatIdx]
 321                          << endLog;
 322
 323                 info.attribData  [slot] = NULL;
 324                 info.attribStride[slot] = 0;
 325                 info.attribPtr   [slot] = NULL;
 326                 info.attribIndex [slot] = NULL;
 327
 328                 return false;
 329             }
 330
 331             info.attribMPump[slot] =
 332                 reinterpret_cast<multiPumpFunc>(win->getFunction(funcId));
 333
 334             if(info.attribMPump[slot] == NULL)
 335             {
 336                 SWARNING << "GeoImmediatePumpGroup - pumpGLExtMultiSetup: "
 337                          << "Extension function for property " << slot
 338                          << " type " << info.attribPtr[slot]->getDimension()
 339                          << "D " << formatNames[formatIdx]
 340                          << " not supported by Window " << win
 341                          << endLog;
 342
 343                 info.attribData  [slot] = NULL;
 344                 info.attribStride[slot] = 0;
 345                 info.attribPtr   [slot] = NULL;
 346                 info.attribIndex [slot] = NULL;
 347
 348                 return false;
 349             }
 350         }
 351
 352         return true;
 353     }
 354
 355
 356     // handle vertex attrib with global value
 357     void globalAttrib(PumpClassicInfo &info, UInt16 slot, UInt16 pumpSlot)
 358     {
 359         if(info.attribData[slot]         != NULL &&
 360            info.attribPtr [slot]->size() == 1      )
 361         {
 362             OSG_ASSERT(info.attribPump[slot] != NULL);
 363
 364             info.attribPump[slot](info.attribData[slot]);
 365             info.attribData[slot] = NULL;
 366         }
 367     }
 368
 369     // handle vertex attrib with global value - using GL extension
 370     void globalExtAttrib(PumpClassicInfo &info,     UInt16  slot,
 371                          UInt16           pumpSlot, Window *win)
 372     {
 373         if(info.attribData[slot]         != NULL &&
 374            info.attribPtr [slot]->size() == 1      )
 375         {
 376             OSG_ASSERT(info.attribPump[slot] != NULL);
 377
 378             info.attribPump[slot](info.attribData[slot]);
 379             info.attribData[slot] = NULL;
 380         }
 381     }
 382
 383     // handle vertex attrib with global value - using GL extension, multi
 384     void globalExtMultiAttrib(PumpClassicInfo &info,     UInt16  slot,
 385                               UInt16           pumpSlot, GLenum  attrib,
 386                               Window          *win                      )
 387     {
 388         if(info.attribData[slot]         != NULL &&
 389            info.attribPtr [slot]->size() == 1      )
 390         {
 391             OSG_ASSERT(info.attribMPump[slot] != NULL);
 392
 393             info.attribMPump[slot](attrib, info.attribData[slot]);
 394             info.attribData [slot] = NULL;
 395         }
 396     }
 397
 398     // pass a single attrib value to OpenGL
 399     void pumpAttrib(PumpClassicInfo &info, UInt16 slot, UInt32 vertIdx)
 400     {
 401         if(info.attribData[slot] != NULL)
 402         {
 403             OSG_ASSERT(info.attribPump[slot] != NULL);
 404
 405             if(info.attribIndex[slot] != NULL)
 406             {
 407                 info.attribPump[slot](
 408                     info.attribData  [slot] +
 409                     info.attribStride[slot] *
 410                     info.attribIndex [slot]->getValue<UInt32>(vertIdx));
 411             }
 412             else
 413             {
 414                 info.attribPump[slot](
 415                     info.attribData  [slot] +
 416                     info.attribStride[slot] * vertIdx);
 417             }
 418         }
 419     }
 420
 421     // pass a single (multi) attrib value to OpenGL
 422     void pumpMultiAttrib(PumpClassicInfo &info,   UInt16 slot,
 423                          GLenum           attrib, UInt32 vertIdx)
 424     {
 425         if(info.attribData[slot] != NULL)
 426         {
 427             OSG_ASSERT(info.attribMPump[slot] != NULL);
 428
 429             if(info.attribIndex[slot] != NULL)
 430             {
 431                 info.attribMPump[slot](
 432                     attrib,
 433                     info.attribData  [slot] +
 434                     info.attribStride[slot] *
 435                     info.attribIndex [slot]->getValue<UInt32>(vertIdx));
 436             }
 437             else
 438             {
 439                 info.attribMPump[slot](
 440                     attrib,
 441                     info.attribData  [slot] +
 442                     info.attribStride[slot] * vertIdx);
 443             }
 444         }
 445     }
 446
 447 } // namespace
 448
 449 #endif      // remove from all but dev docs
 450
 451 GeoPumpGroup::GeoPump GeoImmediatePumpGroup::getGeoPump(
 452     DrawEnv                 *pEnv,
 453     PropertyCharacteristics  acset)
 454 {
 455     Window *win = pEnv->getWindow();
 456
 457     if(win->hasExtOrVersion(_arbVertexProgram,
 458                             0x0200,
 459                             0x0200           ) && (acset & UsesShader))
 460     {
 461         return masterAttribGeoPump;
 462     }
 463     else
 464     {
 465         return masterClassicGeoPump;
 466     }
 467 }
 468
 469 bool GeoImmediatePumpGroup::glextInitFunction(void)
 470 {
 471     _extSecondaryColor      =
 472         Window::registerExtension("GL_EXT_secondary_color");
 473     _extMultitexture        =
 474         Window::registerExtension("GL_ARB_multitexture");
 475     _arbVertexProgram       =
 476         Window::registerExtension("GL_ARB_vertex_program");
 477
 478     for(UInt16 i = 0; i < numFormats; ++i)
 479     {
 480         for(UInt16 j = 0; j < 4; ++j)
 481         {
 482             pumpFuncIDs[0][i][j] = Window::invalidFunctionID;
 483             pumpFuncIDs[1][i][j] = Window::invalidFunctionID;
 484         }
 485     }
 486
 487     for(UInt16 i = 0; i < uiNumSecColFunc; ++i)
 488         secondaryColorInitFuncs[i].init(pumpFuncIDs[SecColorsPumpSlot],
 489                                         _extSecondaryColor             );
 490
 491     for(UInt16 i = 0; i < uiNumMTexFuncs; ++i)
 492         multiTexCoordsInitFuncs[i].init(pumpFuncIDs[TexCoords1PumpSlot],
 493                                         _extMultitexture                );
 494
 495     for(UInt16 i = 0; i < uiNumAttribFuncs; ++i)
 496         attribInitFuncs[i].init(attribPumpFuncIDs, _arbVertexProgram);
 497
 498     for(UInt16 i = 0; i < uiNumNormAttribFuncs; ++i)
 499         normAttribInitFuncs[i].init(normAttribPumpFuncIDs, _arbVertexProgram);
 500
 501 #if defined(OSG_USE_OGLES_PROTOS) || defined(OSG_USE_OGL3_PROTOS) || \
 502     defined(OSG_USE_OGL4_PROTOS)
 503     osgSinkUnusedWarning(attribPumpFuncs);
 504     osgSinkUnusedWarning(attribNormPumpFuncs);
 505 #endif
 506
 507     return true;
 508 }
 509
 510 void GeoImmediatePumpGroup::masterClassicGeoPump(
 511           DrawEnv                     *pEnv,
 512     const GeoIntegralProperty         *lengths,
 513     const GeoIntegralProperty         *types,
 514     const Geometry::MFPropertiesType  *prop,
 515     const Geometry::MFPropIndicesType *propIdx,
 516           UInt32                              )
 517 {
 518 #ifdef DEBUG_WHICH_PUMP
 519     static bool bPrinted = false;
 520
 521     if(bPrinted == false)
 522     {
 523         fprintf(stderr, "GeoImmediatePumpGroup::masterClassicGeoPump\n");
 524         bPrinted = true;
 525     }
 526 #endif
 527
 528     Window *win = pEnv->getWindow();
 529
 530     // Setup: get all the data
 531
 532     // check for empty geometry
 533     if(types == NULL || types->size() == 0)
 534         return;
 535
 536     if(!pumpInternalSetup(types,   true))
 537         return;
 538     if(!pumpInternalSetup(lengths, false))
 539         return;
 540
 541     PumpClassicInfo pumpInfo;
 542     pumpInfo.lengths = lengths;
 543     pumpInfo.types   = types;
 544     pumpInfo.prop    = prop;
 545     pumpInfo.propIdx = propIdx;
 546
 547     // setup standard properties
 548     pumpGLSetup(pumpInfo, Geometry::PositionsIndex, PositionsPumpSlot);
 549     pumpGLSetup(pumpInfo, Geometry::ColorsIndex,    ColorsPumpSlot);
 550     pumpGLSetup(pumpInfo, Geometry::NormalsIndex,   NormalsPumpSlot);
 551     pumpGLSetup(pumpInfo, Geometry::TexCoordsIndex, TexCoordsPumpSlot);
 552
 553     // setup extension properties
 554     if(win->hasExtOrVersion(_extSecondaryColor, 0x0104) == true)
 555     {
 556         pumpGLExtSetup(pumpInfo, Geometry::SecondaryColorsIndex,
 557                        SecColorsPumpSlot, win);
 558     }
 559
 560     // setup extension multi properties
 561     if(win->hasExtOrVersion(_extMultitexture, 0x0103, 0x0200) == true)
 562     {
 563         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords1Index,
 564                             TexCoords1PumpSlot, win);
 565         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords2Index,
 566                             TexCoords2PumpSlot, win);
 567         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords3Index,
 568                             TexCoords3PumpSlot, win);
 569         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords4Index,
 570                             TexCoords4PumpSlot, win);
 571         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords5Index,
 572                             TexCoords5PumpSlot, win);
 573         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords6Index,
 574                             TexCoords6PumpSlot, win);
 575         pumpGLExtMultiSetup(pumpInfo, Geometry::TexCoords7Index,
 576                             TexCoords7PumpSlot, win);
 577     }
 578
 579     // we need positions
 580     if(pumpInfo.attribPtr[Geometry::PositionsIndex] == NULL)
 581     {
 582         if(pumpInfo.attribPtr[Geometry::PositionsIndex]              == NULL ||
 583            pumpInfo.attribPtr[Geometry::PositionsIndex]->getUseVBO() == false)
 584         {
 585             SWARNING << "GeoImmediatePumpGroup::masterClassicGeoPump: "
 586                      << "No positions." << endLog;
 587             return;
 588         }
 589     }
 590
 591     // global attribs?
 592     globalAttrib(pumpInfo, Geometry::NormalsIndex,   NormalsPumpSlot);
 593     globalAttrib(pumpInfo, Geometry::ColorsIndex,    ColorsPumpSlot);
 594     globalAttrib(pumpInfo, Geometry::TexCoordsIndex, TexCoordsPumpSlot);
 595
 596     if(win->hasExtOrVersion(_extSecondaryColor, 0x0200) == true)
 597     {
 598         globalExtAttrib(pumpInfo,          Geometry::SecondaryColorsIndex,
 599                         SecColorsPumpSlot, win                            );
 600     }
 601
 602     if(win->hasExtOrVersion(_extMultitexture, 0x0103, 0x0200) == true)
 603     {
 604         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 605                              TexCoords1PumpSlot, GL_TEXTURE1_ARB, win);
 606         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 607                              TexCoords2PumpSlot, GL_TEXTURE2_ARB, win);
 608         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 609                              TexCoords3PumpSlot, GL_TEXTURE3_ARB, win);
 610         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 611                              TexCoords4PumpSlot, GL_TEXTURE4_ARB, win);
 612         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 613                              TexCoords5PumpSlot, GL_TEXTURE5_ARB, win);
 614         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 615                              TexCoords6PumpSlot, GL_TEXTURE6_ARB, win);
 616         globalExtMultiAttrib(pumpInfo,           Geometry::TexCoords1Index,
 617                              TexCoords7PumpSlot, GL_TEXTURE7_ARB, win);
 618     }
 619
 620     // Length handling. Special case: no length given
 621
 622     UInt32 curlen;
 623     UInt32 nprims;
 624
 625     // no lengths? use all available data for the first type
 626     if(lengths == NULL)
 627     {
 628         if(types->size() != 1)
 629         {
 630             SWARNING << "GeoImmediatePumpGroup::masterClassicGeoPump: "
 631                      << "No lengths, but more than one type?!"
 632                      << endLog;
 633             return;
 634         }
 635
 636         nprims = 1;
 637         if(pumpInfo.attribIndex[Geometry::PositionsIndex] != NULL)
 638         {
 639             curlen = pumpInfo.attribIndex[Geometry::PositionsIndex]->size32();
 640         }
 641         else
 642         {
 643             curlen = pumpInfo.attribPtr[Geometry::PositionsIndex]->size32();
 644         }
 645     }
 646     else
 647     {
 648         nprims = types->size32();
 649         lengths->getValue(curlen, 0);
 650     }
 651
 652     UInt32 vertindex = 0;
 653
 654     for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 655     {
 656         glBegin(types->getValue<UInt16>(primindex));
 657
 658         if(primindex < lengths->size())
 659             curlen = lengths->getValue<UInt32>(primindex);
 660
 661         for(; curlen > 0; --curlen, ++vertindex)
 662         {
 663             pumpAttrib(pumpInfo, Geometry::NormalsIndex,   vertindex);
 664             pumpAttrib(pumpInfo, Geometry::ColorsIndex,    vertindex);
 665             pumpAttrib(pumpInfo, Geometry::TexCoordsIndex, vertindex);
 666
 667             if(win->hasExtOrVersion(_extSecondaryColor, 0x0104) == true)
 668             {
 669                 pumpAttrib(pumpInfo, Geometry::SecondaryColorsIndex, vertindex);
 670             }
 671
 672             if(win->hasExtOrVersion(_extMultitexture, 0x0103, 0x0200))
 673             {
 674                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords1Index,
 675                                 GL_TEXTURE1_ARB, vertindex);
 676                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords2Index,
 677                                 GL_TEXTURE2_ARB, vertindex);
 678                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords3Index,
 679                                 GL_TEXTURE3_ARB, vertindex);
 680                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords4Index,
 681                                 GL_TEXTURE4_ARB, vertindex);
 682                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords5Index,
 683                                 GL_TEXTURE5_ARB, vertindex);
 684                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords6Index,
 685                                 GL_TEXTURE6_ARB, vertindex);
 686                 pumpMultiAttrib(pumpInfo, Geometry::TexCoords7Index,
 687                                 GL_TEXTURE7_ARB, vertindex);
 688             }
 689
 690             pumpAttrib(pumpInfo, Geometry::PositionsIndex, vertindex);
 691         }
 692
 693         glEnd();
 694     }
 695 }
 696
 697 void GeoImmediatePumpGroup::masterAttribGeoPump(
 698           DrawEnv                     *pEnv,
 699     const GeoIntegralProperty         *lengths,
 700     const GeoIntegralProperty         *types,
 701     const Geometry::MFPropertiesType  *prop,
 702     const Geometry::MFPropIndicesType *propIdx,
 703           UInt32                              )
 704 {
 705 #ifdef DEBUG_WHICH_PUMP
 706     static bool bPrinted = false;
 707
 708     if(bPrinted == false)
 709     {
 710         fprintf(stderr, "GeoImmediatePumpGroup::masterAttribGeoPump\n");
 711         bPrinted = true;
 712     }
 713 #endif
 714
 715     Window *win = pEnv->getWindow();
 716
 717     // Setup: get all the data
 718
 719     // check for empty geometry
 720     if(types == NULL || types->size() == 0)
 721         return;
 722
 723     if(!pumpInternalSetup(types,   true))
 724         return;
 725     if(!pumpInternalSetup(lengths, false))
 726         return;
 727
 728     PumpAttribInfo pumpInfo;
 729     pumpInfo.lengths = lengths;
 730     pumpInfo.types   = types;
 731     pumpInfo.prop    = prop;
 732     pumpInfo.propIdx = propIdx;
 733
 734     UInt16 nattrib = prop->size32();
 735
 736     for(UInt16 i = 0; i < nattrib; ++i)
 737     {
 738         if(pumpGLSetup(pumpInfo, i) == false)
 739             continue;
 740
 741         UInt16 formatIdx = pumpInfo.attribPtr[i]->getFormat   () - formatBase;
 742         UInt16 dimIdx    = pumpInfo.attribPtr[i]->getDimension() - 1;
 743         UInt32 funcId    = Window::invalidFunctionID;
 744
 745         if(pumpInfo.attribPtr[i]->getNormalize() == true)
 746         {
 747             funcId = normAttribPumpFuncIDs[formatIdx][dimIdx];
 748
 749             if(funcId == Window::invalidFunctionID)
 750             {
 751                 SWARNING << "GeoImmediatePumpGroup::masterAttribGeoPump: "
 752                          << "Invalid pump function for property " << i
 753                          << " type " << pumpInfo.attribPtr[i]->getDimension()
 754                          << "D " << formatNames[formatIdx] << " (normalizing)."
 755                          << endLog;
 756
 757                 pumpInfo.attribData[i] = NULL;
 758                 pumpInfo.attribPtr [i] = NULL;
 759                 continue;
 760             }
 761         }
 762         else
 763         {
 764             funcId = attribPumpFuncIDs[formatIdx][dimIdx];
 765
 766             if(funcId == Window::invalidFunctionID)
 767             {
 768                 SWARNING << "GeoImmediatePumpGroup::masterAttribGeoPump: "
 769                          << "Invalid pump function for property " << i
 770                          << " type " << pumpInfo.attribPtr[i]->getDimension()
 771                          << "D " << formatNames[formatIdx]
 772                          << endLog;
 773
 774                 pumpInfo.attribData[i] = NULL;
 775                 pumpInfo.attribPtr [i] = NULL;
 776                 continue;
 777             }
 778         }
 779
 780         pumpInfo.attribPump[i] = reinterpret_cast<attribPumpFunc>(
 781             win->getFunction(funcId));
 782
 783         if(pumpInfo.attribPump[i] == NULL)
 784         {
 785             SWARNING << "GeoImmediatePumpGroup::masterAttribGeoPump: "
 786                      << "Extension function for property " << i
 787                      << " type " << pumpInfo.attribPtr[i]->getDimension()
 788                      << "D " << formatNames[formatIdx]
 789                      << " not supported by Window " << win
 790                      << endLog;
 791
 792             pumpInfo.attribData[i] = NULL;
 793             pumpInfo.attribPtr [i] = NULL;
 794             continue;
 795         }
 796     }
 797
 798     // we need positions
 799     if(pumpInfo.attribPtr[0] == NULL)
 800     {
 801         if(pumpInfo.attribPtr[0]              == NULL ||
 802            pumpInfo.attribPtr[0]->getUseVBO() == false)
 803         {
 804             SWARNING << "GeoImmediatePumpGroup::masterAttribGeoPump: "
 805                      << "No positions." << endLog;
 806             return;
 807         }
 808     }
 809
 810     // global attribs?
 811     for(Int16 i = 0; i < nattrib; ++i)
 812     {
 813         if(pumpInfo.attribData[i]         != NULL &&
 814            pumpInfo.attribPtr [i]->size() == 1      )
 815         {
 816             pumpInfo.attribPump[i](i, pumpInfo.attribData[i]);
 817             pumpInfo.attribData[i] = NULL;
 818         }
 819     }
 820
 821     // Length handling. Special case: no length given
 822
 823     UInt32 curlen;
 824     UInt32 nprims;
 825
 826     // no lengths? use all available data for the first type
 827     if(lengths == NULL)
 828     {
 829         if(types->size() != 1)
 830         {
 831             SWARNING << "GeoImmediatePumpGroup::masterAttribGeoPump: "
 832                      << "No lengths, but more than one type?!"
 833                      << endLog;
 834             return;
 835         }
 836
 837         nprims = 1;
 838         if(pumpInfo.attribIndex[0] != NULL)
 839         {
 840             curlen = pumpInfo.attribIndex[0]->size32();
 841         }
 842         else
 843         {
 844             curlen = pumpInfo.attribPtr[0]->size32();
 845         }
 846     }
 847     else
 848     {
 849         nprims = types->size32();
 850         lengths->getValue(curlen, 0);
 851     }
 852
 853     UInt32 vertindex = 0;
 854
 855     for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 856     {
 857         glBegin(types->getValue<UInt16>(primindex));
 858
 859         if(primindex < lengths->size())
 860             curlen = lengths->getValue<UInt32>(primindex);
 861
 862         for(; curlen > 0; --curlen, ++vertindex)
 863         {
 864             for(Int16 i = nattrib - 1; i >= 0; --i)
 865             {
 866                 if(pumpInfo.attribData[i])
 867                 {
 868                     if(pumpInfo.attribIndex[i] != NULL)
 869                     {
 870                         pumpInfo.attribPump[i](
 871                             i, pumpInfo.attribData  [i] +
 872                                pumpInfo.attribStride[i] *
 873                                pumpInfo.attribIndex [i]->getValue<UInt32>(vertindex));
 874                     }
 875                     else
 876                     {
 877                         pumpInfo.attribPump[i](
 878                             i, pumpInfo.attribData  [i] +
 879                                pumpInfo.attribStride[i] * vertindex);
 880                     }
 881                 }
 882             }
 883         }
 884
 885         glEnd();
 886     }
 887 }
 888
 889 OSG_END_NAMESPACE