Source/System/NodeCores/Drawables/Geometry/Base/OSGGeoSplitVertexArrayPumpGroup.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 "OSGGeoSplitVertexArrayPumpGroup.h"
  62
  63 #include "OSGGLFuncProtos.h"
  64
  65 OSG_BEGIN_NAMESPACE
  66
  67 #define OSG_COMPILE_SPLIT_PUMP 1
  68
  69 // Intentionally INSIDE the namespace
  70 #include "OSGGeoPumpCommon.inl"
  71
  72 //#define DEBUG_WHICH_PUMP 1
  73
  74 /***************************************************************************\
  75  *                            Description                                  *
  76 \***************************************************************************/
  77
  78 /***************************************************************************\
  79  *                           Class variables                               *
  80 \***************************************************************************/
  81
  82 /*! An InitFuncWrapper to initialize the GeoVertexArrayPumpGroup.
  83 */
  84
  85 InitFuncWrapper GeoSplitVertexArrayPumpGroup::_glextInitFuncWrapper(
  86     GeoSplitVertexArrayPumpGroup::glextInitFunction);
  87
  88 /*! OpenGL extension indices.
  89 */
  90
  91 UInt32 GeoSplitVertexArrayPumpGroup::_arbVertexProgram;
  92 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
  93 UInt32 GeoSplitVertexArrayPumpGroup::_extSecondaryColor;
  94 UInt32 GeoSplitVertexArrayPumpGroup::_extMultitexture;
  95 #endif
  96
  97 /***************************************************************************\
  98  *                           Instance methods                              *
  99 \***************************************************************************/
 100
 101 /*------------- constructors & destructors --------------------------------*/
 102
 103 GeoSplitVertexArrayPumpGroup::GeoSplitVertexArrayPumpGroup(void)
 104 {
 105 }
 106
 107 GeoSplitVertexArrayPumpGroup::~GeoSplitVertexArrayPumpGroup(void)
 108 {
 109 }
 110
 111 /*-------------------------------------------------------------------------*\
 112  -  private                                                                -
 113 \*-------------------------------------------------------------------------*/
 114
 115 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 116
 117 namespace
 118 {
 119     // collect info for property in 'slot'
 120     bool pumpGLSetup(PumpData &info, UInt16 slot)
 121     {
 122         bool retVal = false;
 123
 124         if(slot < info.prop->size())
 125             info.attribPtr[slot] = (*info.prop)[slot];
 126
 127         if(slot < info.propIdx->size())
 128             info.attribIndex[slot] = (*info.propIdx)[slot];
 129
 130         if(info.attribPtr[slot]              != NULL  &&
 131            info.attribPtr[slot]->getIgnore() == false   )
 132         {
 133             info.attribData  [slot] = info.attribPtr[slot]->getData();
 134             info.attribStride[slot] = info.attribPtr[slot]->getStride();
 135
 136             if(info.attribStride[slot] == 0)
 137             {
 138                 info.attribStride[slot] =
 139                     info.attribPtr[slot]->getFormatSize() *
 140                     info.attribPtr[slot]->getDimension();
 141             }
 142
 143             retVal = true;
 144         }
 145
 146         return retVal;
 147     }
 148
 149 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 150     // handle vertex attrib with global value
 151     void globalAttrib(PumpData &info, UInt16 slot, UInt16 pumpSlot)
 152     {
 153         if(info.attribData[slot]         != NULL &&
 154            info.attribPtr [slot]->size() == 1      )
 155         {
 156             UInt16 formatIdx = info.attribPtr[slot]->getFormat() - formatBase;
 157             UInt32 dimIdx    = info.attribPtr[slot]->getDimension() - 1;
 158
 159             pumpFunc pump = pumpFuncs[pumpSlot][formatIdx][dimIdx];
 160
 161             if(pump == NULL)
 162             {
 163                 SWARNING << "GeoVertexArrayPumpGroup - globalExtAttrib: "
 164                          << "Invalid pump function for property " << slot
 165                          << " type " << info.attribPtr[slot]->getDimension()
 166                          << "D " << formatNames[formatIdx]
 167                          << endLog;
 168                 return;
 169             }
 170
 171             pump(info.attribData[slot]);
 172             info.attribData[slot] = NULL;
 173             info.attribPtr [slot] = NULL;
 174         }
 175     }
 176 #endif
 177
 178 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 179     // handle vertex attrib with global value - using GL extension
 180     void globalExtAttrib(PumpData &info,     UInt16  slot,
 181                          UInt16    pumpSlot, Window *win)
 182     {
 183         if(info.attribData[slot]         != NULL &&
 184            info.attribPtr [slot]->size() == 1      )
 185         {
 186             UInt16 formatIdx = info.attribPtr[slot]->getFormat() - formatBase;
 187             UInt32 dimIdx    = info.attribPtr[slot]->getDimension() - 1;
 188             UInt32 funcId    = pumpFuncIDs[pumpSlot][formatIdx][dimIdx];
 189
 190             if(funcId == Window::invalidFunctionID)
 191             {
 192                 SWARNING << "GeoVertexArrayPumpGroup - globalExtAttrib: "
 193                          << "Invalid extension function for property " << slot
 194                          << " type " << info.attribPtr[slot]->getDimension()
 195                          << "D " << formatNames[formatIdx]
 196                          << endLog;
 197                 return;
 198             }
 199
 200             pumpFunc pump =
 201                 reinterpret_cast<pumpFunc>(win->getFunction(funcId));
 202
 203             if(pump == NULL)
 204             {
 205                 SWARNING << "GeoVertexArrayPumpGroup - globalExtAttrib: "
 206                          << "Extension function for property " << slot
 207                          << " type " << info.attribPtr[slot]->getDimension()
 208                          << "D " << formatNames[formatIdx]
 209                          << " not supported by Window " << win
 210                          << endLog;
 211                 return;
 212             }
 213
 214             pump(info.attribData[slot]);
 215             info.attribData[slot] = NULL;
 216             info.attribPtr [slot] = NULL;
 217         }
 218     }
 219 #endif
 220
 221 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 222     // handle vertex attrib with global value - using GL extension, multi
 223     void globalExtMultiAttrib(PumpData &info,     UInt16  slot,
 224                               UInt16    pumpSlot, GLenum  attrib,
 225                               Window   *win                      )
 226     {
 227         if(info.attribData[slot]         != NULL &&
 228            info.attribPtr [slot]->size() == 1      )
 229         {
 230             UInt16 formatIdx = info.attribPtr[slot]->getFormat() - formatBase;
 231             UInt32 dimIdx    = info.attribPtr[slot]->getDimension() - 1;
 232             UInt32 funcId    = pumpFuncIDs[pumpSlot][formatIdx][dimIdx];
 233
 234             if(funcId == Window::invalidFunctionID)
 235             {
 236                 SWARNING << "GeoVertexArrayPumpGroup - globalExtMultiAttrib: "
 237                          << "Invalid extension function for property " << slot
 238                          << " type " << info.attribPtr[slot]->getDimension()
 239                          << "D " << formatNames[formatIdx]
 240                          << endLog;
 241                 return;
 242             }
 243
 244             multiPumpFunc pump =
 245                 reinterpret_cast<multiPumpFunc>(win->getFunction(funcId));
 246
 247             if(pump == NULL)
 248             {
 249                 SWARNING << "GeoVertexArrayPumpGroup - globalExtMutliAttrib: "
 250                          << "Extension function for property " << slot
 251                          << " type " << info.attribPtr[slot]->getDimension()
 252                          << "D " << formatNames[formatIdx]
 253                          << " not supported by Window " << win
 254                          << endLog;
 255                 return;
 256             }
 257
 258             pump(attrib, info.attribData[slot]);
 259             info.attribData[slot] = NULL;
 260             info.attribPtr [slot] = NULL;
 261         }
 262     }
 263 #endif
 264
 265 } // namespace
 266
 267 #endif      // remove from all but dev docs
 268
 269
 270
 271 GeoPumpGroup::SplitGeoPump GeoSplitVertexArrayPumpGroup::getSplitGeoPump(
 272     DrawEnv                 *pEnv,
 273     PropertyCharacteristics  acset)
 274 {
 275     SplitGeoPump pump = { NULL, NULL, NULL };
 276
 277     // Remove the stuff we can handle
 278     PropertyCharacteristics prop;
 279     prop = acset & GeoPumpGroup::IndexMask;
 280
 281     if(prop == SingleIndexed || prop == NonIndexed)
 282     {
 283         Window *win = pEnv->getWindow();
 284
 285         if(win->hasExtOrVersion(_arbVertexProgram,
 286                                  0x0200,
 287                                  0x0200           ) && (acset & UsesShader))
 288         {
 289             pump.setupPump    = masterAttribGeoSetupPumpFull;
 290             pump.drawPump     = masterAttribGeoJustDrawPump;
 291             pump.shutdownPump = masterAttribGeoShutdownPump;
 292         }
 293 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 294         else
 295         {
 296             pump.setupPump    = masterClassicGeoSetupPumpFull;
 297             pump.drawPump     = masterClassicGeoJustDrawPump;
 298             pump.shutdownPump = masterClassicGeoShutdownPump;
 299         }
 300 #endif
 301     }
 302
 303     return pump;
 304 }
 305
 306 GeoPumpGroup::GeoPump GeoSplitVertexArrayPumpGroup::getGeoPump(
 307     DrawEnv                 *pEnv,
 308     PropertyCharacteristics  acset)
 309 {
 310     return NULL;
 311 }
 312
 313 bool GeoSplitVertexArrayPumpGroup::glextInitFunction(void)
 314 {
 315 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 316     _extSecondaryColor      =
 317         Window::registerExtension("GL_EXT_secondary_color");
 318     _extMultitexture        =
 319         Window::registerExtension("GL_ARB_multitexture");
 320 #endif
 321
 322 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 323     for(UInt16 i = 0; i < numFormats; ++i)
 324     {
 325         for(UInt16 j = 0; j < 4; ++j)
 326         {
 327             pumpFuncIDs[0][i][j] = Window::invalidFunctionID;
 328             pumpFuncIDs[1][i][j] = Window::invalidFunctionID;
 329         }
 330     }
 331
 332     for(UInt16 i = 0; i < uiNumSecColFunc; ++i)
 333         secondaryColorInitFuncs[i].init(pumpFuncIDs[SecColorsPumpSlot],
 334                                         _extSecondaryColor             );
 335
 336     for(UInt16 i = 0; i < uiNumMTexFuncs; ++i)
 337         multiTexCoordsInitFuncs[i].init(pumpFuncIDs[TexCoords1PumpSlot],
 338                                         _extMultitexture                );
 339 #endif
 340
 341     _arbVertexProgram       =
 342         Window::registerExtension("GL_ARB_vertex_program");
 343
 344     for(UInt16 i = 0; i < uiNumAttribFuncs; ++i)
 345         attribInitFuncs[i].init(attribPumpFuncIDs, _arbVertexProgram);
 346
 347     for(UInt16 i = 0; i < uiNumNormAttribFuncs; ++i)
 348         normAttribInitFuncs[i].init(normAttribPumpFuncIDs, _arbVertexProgram);
 349
 350     return true;
 351 }
 352
 353
 354
 355 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 356 bool GeoSplitVertexArrayPumpGroup::masterClassicGeoSetupPump(
 357           DrawEnv                     *pEnv,
 358     const GeoIntegralProperty         *lengths,
 359     const GeoIntegralProperty         *types,
 360     const Geometry::MFPropertiesType  *prop,
 361     const Geometry::MFPropIndicesType *propIdx,
 362           bool                         withFallback)
 363 {
 364 #ifdef DEBUG_WHICH_PUMP
 365     static bool bPrinted = false;
 366
 367     if(bPrinted == false)
 368     {
 369         fprintf(stderr,
 370                 "GeoSplitVertexArrayPumpGroup::masterClassicGeoSetupPump\n");
 371         bPrinted = true;
 372     }
 373 #endif
 374
 375     // Setup: get all the data
 376     PumpData       pumpData;
 377
 378     pumpData.lengths = lengths;
 379     pumpData.types   = types;
 380     pumpData.prop    = prop;
 381     pumpData.propIdx = propIdx;
 382
 383     UInt16 nattrib = prop->size32();
 384
 385     for(UInt16 i = 0; i < nattrib; ++i)
 386     {
 387         if(pumpGLSetup(pumpData, i) == false)
 388             continue;
 389     }
 390
 391     // we need positions
 392     if(pumpData.attribPtr[0]              == NULL ||
 393        pumpData.attribPtr[0]->getUseVBO() == false)
 394     {
 395 #ifdef DEBUG_WHICH_PUMP
 396         static bool bPrinted1 = false;
 397
 398         if(bPrinted1 == false)
 399         {
 400 #endif
 401         if(withFallback == false)
 402         {
 403             SWARNING << "GeoSplitVertexArrayPumpGroup::masterAttribGeoPump: "
 404                      << "No positions, or positions not in vbo." << endLog;
 405         }
 406 #ifdef DEBUG_WHICH_PUMP
 407             bPrinted1 = true;
 408         }
 409 #endif
 410
 411         return false;
 412     }
 413
 414     for(Int16 i = nattrib - 1; i >= 0; --i)
 415     {
 416         if(pumpData.attribPtr[i] != NULL &&
 417            pumpData.attribPtr[i]->size() != 1    )
 418         {
 419             pumpData.attribPtr[i]->activate(pEnv, i);
 420         }
 421     }
 422
 423     return true;
 424 }
 425
 426
 427 void GeoSplitVertexArrayPumpGroup::masterClassicGeoDrawPump(
 428     DrawEnv                     *pEnv,
 429     const GeoIntegralProperty         *lengths,
 430     const GeoIntegralProperty         *types,
 431     const Geometry::MFPropertiesType  *prop,
 432     const Geometry::MFPropIndicesType *propIdx)
 433 {
 434 #ifdef DEBUG_WHICH_PUMP
 435     static bool bPrinted = false;
 436
 437     if(bPrinted == false)
 438     {
 439         fprintf(stderr,
 440                 "GeoSplitVertexArrayPumpGroup::masterClassicGeoDrawPump\n");
 441         bPrinted = true;
 442     }
 443 #endif
 444
 445     Window *win = pEnv->getWindow();
 446
 447     // check for empty geometry
 448     if(types == NULL || types->size() == 0)
 449         return;
 450
 451     if(!pumpInternalSetup(types,   true))
 452         return;
 453     if(!pumpInternalSetup(lengths, false))
 454         return;
 455
 456     PumpData       pumpData;
 457
 458     pumpData.lengths = lengths;
 459     pumpData.types   = types;
 460     pumpData.prop    = prop;
 461     pumpData.propIdx = propIdx;
 462
 463     UInt16 nattrib = prop->size32();
 464
 465     for(UInt16 i = 0; i < nattrib; ++i)
 466     {
 467         if(pumpGLSetup(pumpData, i) == false)
 468             continue;
 469     }
 470
 471     // Length handling. Special case: no length given
 472
 473     UInt32 curlen;
 474     UInt32 nprims;
 475
 476     // no lengths? use all available data for the first type
 477     if(lengths == NULL)
 478     {
 479         if(types->size() != 1)
 480         {
 481             SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
 482                      << "No lengths, but more than one type?!"
 483                      << endLog;
 484             return;
 485         }
 486
 487         nprims = 1;
 488
 489         if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
 490         {
 491             curlen = (*propIdx)[0]->size32();
 492         }
 493         else
 494         {
 495             curlen = (*prop)[0]->size32();
 496         }
 497     }
 498     else
 499     {
 500         nprims = types->size32();
 501         lengths->getValue(curlen, 0);
 502     }
 503
 504     // global attribs?
 505     globalAttrib(pumpData, Geometry::NormalsIndex,   NormalsPumpSlot);
 506     globalAttrib(pumpData, Geometry::ColorsIndex,    ColorsPumpSlot);
 507     globalAttrib(pumpData, Geometry::TexCoordsIndex, TexCoordsPumpSlot);
 508
 509     if(win->hasExtOrVersion(_extSecondaryColor, 0x0104) == true)
 510     {
 511         globalExtAttrib(pumpData,          Geometry::SecondaryColorsIndex,
 512                         SecColorsPumpSlot, win                            );
 513     }
 514
 515     if(win->hasExtOrVersion(_extMultitexture, 0x0103, 0x0200) == true)
 516     {
 517         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 518                              TexCoords1PumpSlot, GL_TEXTURE1_ARB, win);
 519         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 520                              TexCoords2PumpSlot, GL_TEXTURE2_ARB, win);
 521         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 522                              TexCoords3PumpSlot, GL_TEXTURE3_ARB, win);
 523         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 524                              TexCoords4PumpSlot, GL_TEXTURE4_ARB, win);
 525         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 526                              TexCoords5PumpSlot, GL_TEXTURE5_ARB, win);
 527         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 528                              TexCoords6PumpSlot, GL_TEXTURE6_ARB, win);
 529         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 530                              TexCoords7PumpSlot, GL_TEXTURE7_ARB, win);
 531     }
 532
 533     UInt32 vertindex = 0;
 534
 535     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
 536     {
 537         // Single Indexed
 538
 539         GeoIntegralProperty *index       = (*propIdx)[0];
 540         const UInt8         *indexData   = index->getData();
 541         GLenum               indexFormat = index->getFormat();
 542         UInt32               indexStride =
 543             index->getStride() ? index->getStride() : index->getFormatSize() *
 544             index->getDimension();
 545
 546         index->activate(pEnv, 0);
 547
 548         if(index->isInVBO(pEnv))
 549         {
 550             indexData = NULL;
 551         }
 552
 553         for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 554         {
 555             if(primindex < lengths->size())
 556                 curlen = lengths->getValue<UInt32>(primindex);
 557
 558             if(curlen > 0)
 559             {
 560                 glDrawElements(types->getValue<UInt16>(primindex),
 561                                curlen,
 562                                indexFormat,
 563                                indexData + vertindex * indexStride);
 564
 565                 vertindex += curlen;
 566             }
 567         }
 568
 569         index->deactivate(pEnv, 0);
 570     }
 571     else
 572     {
 573         // Non-indexed
 574         for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 575         {
 576             if(primindex < lengths->size())
 577                 curlen = lengths->getValue<UInt32>(primindex);
 578
 579             if(curlen > 0)
 580             {
 581                 glDrawArrays(types->getValue<UInt16>(primindex), vertindex,
 582                              curlen);
 583                 vertindex += curlen;
 584             }
 585         }
 586     }
 587 }
 588
 589
 590 bool GeoSplitVertexArrayPumpGroup::masterClassicGeoSetupPumpFull(
 591           DrawEnv                     *pEnv,
 592     const GeoIntegralProperty         *lengths,
 593     const GeoIntegralProperty         *types,
 594     const Geometry::MFPropertiesType  *prop,
 595     const Geometry::MFPropIndicesType *propIdx,
 596           bool                         withFallback)
 597 {
 598 #ifdef DEBUG_WHICH_PUMP
 599     static bool bPrinted = false;
 600
 601     if(bPrinted == false)
 602     {
 603         fprintf(stderr,
 604                 "GeoSplitVertexArrayPumpGroup::masterClassicGeoSetupPumpFull\n");
 605         bPrinted = true;
 606     }
 607 #endif
 608
 609     // Setup: get all the data
 610     PumpData       pumpData;
 611
 612     pumpData.lengths = lengths;
 613     pumpData.types   = types;
 614     pumpData.prop    = prop;
 615     pumpData.propIdx = propIdx;
 616
 617     UInt16 nattrib = prop->size32();
 618
 619     for(UInt16 i = 0; i < nattrib; ++i)
 620     {
 621         if(pumpGLSetup(pumpData, i) == false)
 622             continue;
 623     }
 624
 625     // we need positions
 626     if(pumpData.attribPtr[0]              == NULL ||
 627        pumpData.attribPtr[0]->getUseVBO() == false)
 628     {
 629 #ifdef DEBUG_WHICH_PUMP
 630         static bool bPrinted1 = false;
 631
 632         if(bPrinted1 == false)
 633         {
 634 #endif
 635         if(withFallback == false)
 636         {
 637             SWARNING << "GeoSplitVertexArrayPumpGroup::masterAttribGeoPump: "
 638                      << "No positions." << endLog;
 639         }
 640 #ifdef DEBUG_WHICH_PUMP
 641             bPrinted1 = true;
 642         }
 643 #endif
 644         return false;
 645     }
 646
 647     for(Int16 i = nattrib - 1; i >= 0; --i)
 648     {
 649         if(pumpData.attribPtr[i] != NULL &&
 650            pumpData.attribPtr[i]->size() != 1    )
 651         {
 652             pumpData.attribPtr[i]->activate(pEnv, i);
 653         }
 654     }
 655
 656     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
 657     {
 658         (*propIdx)[0]->activate(pEnv, 0);
 659     }
 660
 661     return true;
 662 }
 663
 664 void GeoSplitVertexArrayPumpGroup::masterClassicGeoJustDrawPump(
 665           DrawEnv                     *pEnv,
 666     const GeoIntegralProperty         *lengths,
 667     const GeoIntegralProperty         *types,
 668     const Geometry::MFPropertiesType  *prop,
 669     const Geometry::MFPropIndicesType *propIdx,
 670           UInt32                       uiNumInstances)
 671 {
 672 #ifdef DEBUG_WHICH_PUMP
 673     static bool bPrinted = false;
 674
 675     if(bPrinted == false)
 676     {
 677         fprintf(stderr,
 678                 "GeoSplitVertexArrayPumpGroup::masterClassicGeoJustDrawPump\n");
 679         bPrinted = true;
 680     }
 681 #endif
 682
 683     Window *win = pEnv->getWindow();
 684
 685     // check for empty geometry
 686     if(types == NULL || types->size() == 0)
 687         return;
 688
 689     if(!pumpInternalSetup(types,   true))
 690         return;
 691     if(!pumpInternalSetup(lengths, false))
 692         return;
 693
 694     PumpData       pumpData;
 695
 696     pumpData.lengths = lengths;
 697     pumpData.types   = types;
 698     pumpData.prop    = prop;
 699     pumpData.propIdx = propIdx;
 700
 701     UInt16 nattrib = prop->size32();
 702
 703     for(UInt16 i = 0; i < nattrib; ++i)
 704     {
 705         if(pumpGLSetup(pumpData, i) == false)
 706             continue;
 707     }
 708
 709     // Length handling. Special case: no length given
 710
 711     UInt32 curlen;
 712     UInt32 nprims;
 713
 714     // no lengths? use all available data for the first type
 715     if(lengths == NULL)
 716     {
 717         if(types->size() != 1)
 718         {
 719             SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
 720                      << "No lengths, but more than one type?!"
 721                      << endLog;
 722             return;
 723         }
 724
 725         nprims = 1;
 726
 727         if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
 728         {
 729             curlen = (*propIdx)[0]->size32();
 730         }
 731         else
 732         {
 733             curlen = (*prop)[0]->size32();
 734         }
 735     }
 736     else
 737     {
 738         nprims = types->size32();
 739         lengths->getValue(curlen, 0);
 740     }
 741
 742     // global attribs?
 743     globalAttrib(pumpData, Geometry::NormalsIndex,   NormalsPumpSlot);
 744     globalAttrib(pumpData, Geometry::ColorsIndex,    ColorsPumpSlot);
 745     globalAttrib(pumpData, Geometry::TexCoordsIndex, TexCoordsPumpSlot);
 746
 747     if(win->hasExtOrVersion(_extSecondaryColor, 0x0104) == true)
 748     {
 749         globalExtAttrib(pumpData,          Geometry::SecondaryColorsIndex,
 750                         SecColorsPumpSlot, win                            );
 751     }
 752
 753     if(win->hasExtOrVersion(_extMultitexture, 0x0103, 0x0200) == true)
 754     {
 755         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 756                              TexCoords1PumpSlot, GL_TEXTURE1_ARB, win);
 757         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 758                              TexCoords2PumpSlot, GL_TEXTURE2_ARB, win);
 759         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 760                              TexCoords3PumpSlot, GL_TEXTURE3_ARB, win);
 761         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 762                              TexCoords4PumpSlot, GL_TEXTURE4_ARB, win);
 763         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 764                              TexCoords5PumpSlot, GL_TEXTURE5_ARB, win);
 765         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 766                              TexCoords6PumpSlot, GL_TEXTURE6_ARB, win);
 767         globalExtMultiAttrib(pumpData,           Geometry::TexCoords1Index,
 768                              TexCoords7PumpSlot, GL_TEXTURE7_ARB, win);
 769     }
 770
 771     UInt32 vertindex = 0;
 772
 773     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
 774     {
 775         // Single Indexed
 776
 777         GeoIntegralProperty *index       = (*propIdx)[0];
 778         const UInt8         *indexData   = index->getData();
 779         GLenum               indexFormat = index->getFormat();
 780         UInt32               indexStride =
 781             index->getStride() ? index->getStride() : index->getFormatSize() *
 782             index->getDimension();
 783
 784 #if 0
 785         index->activate(pEnv, 0);
 786
 787         if(index->isInVBO(pEnv))
 788         {
 789 #endif
 790             indexData = NULL;
 791 #if 0
 792         }
 793 #endif
 794
 795         if(uiNumInstances > 1)
 796         {
 797             OSGGETGLFUNCBYID_GL3_ES(glDrawElementsInstanced,
 798                                     osgGlDrawElementsInstanced,
 799                                     Geometry::getFuncIdDrawElementsInstanced(),
 800                                     win);
 801
 802             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 803             {
 804                 if(primindex < lengths->size())
 805                     curlen = lengths->getValue<UInt32>(primindex);
 806
 807                 if(curlen > 0)
 808                 {
 809                     osgGlDrawElementsInstanced(
 810                         types->getValue<UInt16>(primindex),
 811                         curlen,
 812                         indexFormat,
 813                         indexData + vertindex * indexStride,
 814                         uiNumInstances                     );
 815
 816                     vertindex += curlen;
 817                 }
 818             }
 819         }
 820         else
 821         {
 822             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 823             {
 824                 if(primindex < lengths->size())
 825                     curlen = lengths->getValue<UInt32>(primindex);
 826
 827                 if(curlen > 0)
 828                 {
 829                     glDrawElements(types->getValue<UInt16>(primindex),
 830                                    curlen,
 831                                    indexFormat,
 832                                    indexData + vertindex * indexStride);
 833
 834                     vertindex += curlen;
 835                 }
 836             }
 837         }
 838
 839 #if 0
 840         index->deactivate(pEnv, 0);
 841 #endif
 842     }
 843     else
 844     {
 845         if(uiNumInstances > 1)
 846         {
 847             OSGGETGLFUNCBYID_GL3_ES(glDrawArraysInstanced,
 848                                     osgGlDrawArraysInstanced,
 849                                     Geometry::getFuncIdDrawArraysInstanced(),
 850                                     win);
 851             // Non-indexed
 852             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 853             {
 854                 if(primindex < lengths->size())
 855                     curlen = lengths->getValue<UInt32>(primindex);
 856
 857                 if(curlen > 0)
 858                 {
 859                     osgGlDrawArraysInstanced(
 860                         types->getValue<UInt16>(primindex),
 861                         vertindex,
 862                         curlen,
 863                         uiNumInstances);
 864
 865                     vertindex += curlen;
 866                 }
 867             }
 868         }
 869         else
 870         {
 871             // Non-indexed
 872             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
 873             {
 874                 if(primindex < lengths->size())
 875                     curlen = lengths->getValue<UInt32>(primindex);
 876
 877                 if(curlen > 0)
 878                 {
 879                     glDrawArrays(types->getValue<UInt16>(primindex), vertindex,
 880                                  curlen);
 881                     vertindex += curlen;
 882                 }
 883             }
 884         }
 885     }
 886 }
 887
 888 bool GeoSplitVertexArrayPumpGroup::masterClassicGeoShutdownPump(
 889     DrawEnv                     *pEnv,
 890     const GeoIntegralProperty         *lengths,
 891     const GeoIntegralProperty         *types,
 892     const Geometry::MFPropertiesType  *prop,
 893     const Geometry::MFPropIndicesType *propIdx)
 894 {
 895 #ifdef DEBUG_WHICH_PUMP
 896     static bool bPrinted = false;
 897
 898     if(bPrinted == false)
 899     {
 900         fprintf(stderr,
 901                 "GeoSplitVertexArrayPumpGroup::masterClassicGeoShutdownPump\n");
 902         bPrinted = true;
 903     }
 904 #endif
 905
 906     // Setup: get all the data
 907     PumpData       pumpData;
 908
 909     pumpData.lengths = lengths;
 910     pumpData.types   = types;
 911     pumpData.prop    = prop;
 912     pumpData.propIdx = propIdx;
 913
 914     UInt16 nattrib = prop->size32();
 915
 916     for(UInt16 i = 0; i < nattrib; ++i)
 917     {
 918         if(pumpGLSetup(pumpData, i) == false)
 919             continue;
 920     }
 921
 922     // we need positions
 923     if(pumpData.attribPtr[0]              == NULL ||
 924        pumpData.attribPtr[0]->getUseVBO() == false)
 925     {
 926 #ifdef DEBUG_WHICH_PUMP
 927         static bool bPrinted1 = false;
 928
 929         if(bPrinted1 == false)
 930         {
 931 #endif
 932         SWARNING << "GeoSplitVertexArrayPumpGroup::masterAttribGeoPump: "
 933                  << "No positions." << endLog;
 934
 935         return false;
 936 #ifdef DEBUG_WHICH_PUMP
 937             bPrinted1 = true;
 938         }
 939 #endif
 940     }
 941
 942     for(Int16 i = nattrib - 1; i >= 0; --i)
 943     {
 944         if(pumpData.attribPtr[i] != NULL &&
 945            pumpData.attribPtr[i]->size() != 1    )
 946         {
 947             pumpData.attribPtr[i]->deactivate(pEnv, i);
 948         }
 949     }
 950
 951     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
 952     {
 953         (*propIdx)[0]->deactivate(pEnv, 0);
 954     }
 955
 956     return true;
 957 }
 958
 959 #endif
 960
 961
 962 bool GeoSplitVertexArrayPumpGroup::masterAttribGeoSetupPump(
 963           DrawEnv                     *pEnv,
 964     const GeoIntegralProperty         *lengths,
 965     const GeoIntegralProperty         *types,
 966     const Geometry::MFPropertiesType  *prop,
 967     const Geometry::MFPropIndicesType *propIdx,
 968           bool                         withFallback)
 969 {
 970 #ifdef DEBUG_WHICH_PUMP
 971     static bool bPrinted = false;
 972
 973     if(bPrinted == false)
 974     {
 975         fprintf(stderr,
 976                 "GeoSplitVertexArrayPumpGroup::masterAttribGeoSetupPump\n");
 977         bPrinted = true;
 978     }
 979 #endif
 980
 981     // Setup: get all the data
 982     PumpData       pumpData;
 983
 984     pumpData.lengths = lengths;
 985     pumpData.types   = types;
 986     pumpData.prop    = prop;
 987     pumpData.propIdx = propIdx;
 988
 989     UInt16 nattrib = prop->size32();
 990
 991     for(UInt16 i = 0; i < nattrib; ++i)
 992     {
 993         if(pumpGLSetup(pumpData, i) == false)
 994             continue;
 995     }
 996
 997     // we need positions
 998     if(pumpData.attribPtr[0]              == NULL ||
 999        pumpData.attribPtr[0]->getUseVBO() == false)
1000     {
1001 #ifdef DEBUG_WHICH_PUMP
1002         static bool bPrinted1 = false;
1003
1004         if(bPrinted1 == false)
1005         {
1006 #endif
1007         if(withFallback == false)
1008         {
1009             SWARNING << "GeoSplitVertexArrayPumpGroup::masterAttribGeoPump: "
1010                      << "No positions." << endLog;
1011         }
1012 #ifdef DEBUG_WHICH_PUMP
1013             bPrinted1 = true;
1014         }
1015 #endif
1016         return false;
1017     }
1018
1019     for(Int16 i = nattrib - 1; i >= 0; --i)
1020     {
1021         if(pumpData.attribPtr[i]         != NULL &&
1022            pumpData.attribPtr[i]->size() != 1     )
1023         {
1024             pumpData.attribPtr[i]->activate(pEnv, i + 16); // XXX HACK
1025         }
1026     }
1027
1028     return true;
1029 }
1030
1031
1032 void GeoSplitVertexArrayPumpGroup::masterAttribGeoDrawPump(
1033     DrawEnv                     *pEnv,
1034     const GeoIntegralProperty         *lengths,
1035     const GeoIntegralProperty         *types,
1036     const Geometry::MFPropertiesType  *prop,
1037     const Geometry::MFPropIndicesType *propIdx)
1038 {
1039 #ifdef DEBUG_WHICH_PUMP
1040     static bool bPrinted = false;
1041
1042     if(bPrinted == false)
1043     {
1044         fprintf(stderr,
1045                 "GeoSplitVertexArrayPumpGroup::masterAttribGeoDrawPump\n");
1046         bPrinted = true;
1047     }
1048 #endif
1049
1050     Window *win = pEnv->getWindow();
1051
1052     // check for empty geometry
1053     if(types == NULL || types->size() == 0)
1054         return;
1055
1056     if(!pumpInternalSetup(types,   true))
1057         return;
1058     if(!pumpInternalSetup(lengths, false))
1059         return;
1060
1061     attribPumpFunc attribFunc[Geometry::MaxAttribs];
1062     PumpData       pumpData;
1063
1064     pumpData.lengths = lengths;
1065     pumpData.types   = types;
1066     pumpData.prop    = prop;
1067     pumpData.propIdx = propIdx;
1068
1069     UInt16 nattrib = prop->size32();
1070
1071     for(UInt16 i = 0; i < nattrib; ++i)
1072     {
1073         if(pumpGLSetup(pumpData, i) == false)
1074             continue;
1075
1076         UInt16 formatIdx = pumpData.attribPtr[i]->getFormat   () - formatBase;
1077         UInt16 dimIdx    = pumpData.attribPtr[i]->getDimension() - 1;
1078
1079 #if !defined(OSG_USE_OGLES_PROTOS) && !defined(OSG_USE_OGL3_PROTOS) &&  \
1080     !defined(OSG_USE_OGL4_PROTOS)
1081         UInt32 funcId    = Window::invalidFunctionID;
1082
1083         if(pumpData.attribPtr[i]->getNormalize() == true)
1084         {
1085             funcId = normAttribPumpFuncIDs[formatIdx][dimIdx];
1086
1087             if(funcId == Window::invalidFunctionID)
1088             {
1089                 SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1090                          << "Invalid pump function for property " << i
1091                          << " type " << pumpData.attribPtr[i]->getDimension()
1092                          << "D " << formatNames[formatIdx] << " (normalizing)."
1093                          << endLog;
1094
1095                 pumpData.attribData[i] = NULL;
1096                 pumpData.attribPtr [i] = NULL;
1097                 continue;
1098             }
1099         }
1100         else
1101         {
1102             funcId = attribPumpFuncIDs[formatIdx][dimIdx];
1103
1104             if(funcId == Window::invalidFunctionID)
1105             {
1106                 SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1107                          << "Invalid pump function for property " << i
1108                          << " type " << pumpData.attribPtr[i]->getDimension()
1109                          << "D " << formatNames[formatIdx]
1110                          << endLog;
1111
1112                 pumpData.attribData[i] = NULL;
1113                 pumpData.attribPtr [i] = NULL;
1114                 continue;
1115             }
1116         }
1117
1118         attribFunc[i] = reinterpret_cast<attribPumpFunc>(
1119             win->getFunction(funcId));
1120
1121 #else
1122         if(pumpData.attribPtr[i]->getNormalize() == true)
1123         {
1124             attribFunc[i] = attribNormPumpFuncs[formatIdx][dimIdx];
1125         }
1126         else
1127         {
1128             attribFunc[i] = attribPumpFuncs[formatIdx][dimIdx];
1129         }
1130 #endif
1131
1132         if(attribFunc[i] == NULL)
1133         {
1134             SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1135                      << "Extension function for property " << i
1136                      << " type " << pumpData.attribPtr[i]->getDimension()
1137                      << "D " << formatNames[formatIdx]
1138                      << " not supported by Window " << win
1139                      << endLog;
1140
1141             pumpData.attribData[i] = NULL;
1142             pumpData.attribPtr [i] = NULL;
1143             continue;
1144         }
1145     }
1146
1147     // Length handling. Special case: no length given
1148
1149     UInt32 curlen;
1150     UInt32 nprims;
1151
1152     // no lengths? use all available data for the first type
1153     if(lengths == NULL)
1154     {
1155         if(types->size() != 1)
1156         {
1157             SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1158                      << "No lengths, but more than one type?!"
1159                      << endLog;
1160             return;
1161         }
1162
1163         nprims = 1;
1164
1165         if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
1166         {
1167             curlen = (*propIdx)[0]->size32();
1168         }
1169         else
1170         {
1171             curlen = (*prop)[0]->size32();
1172         }
1173     }
1174     else
1175     {
1176         nprims = types->size32();
1177         lengths->getValue(curlen, 0);
1178     }
1179
1180     // global attribs?
1181     for(Int16 i = 0; i < nattrib; ++i)
1182     {
1183         if(pumpData.attribData[i]         != NULL &&
1184            pumpData.attribPtr [i]->size() == 1      )
1185         {
1186             attribFunc[i](i, pumpData.attribData[i]);
1187             pumpData.attribData[i] = NULL;
1188         }
1189     }
1190
1191     UInt32 vertindex = 0;
1192
1193     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
1194     {
1195         // Single Indexed
1196
1197         GeoIntegralProperty *index       = (*propIdx)[0];
1198         const UInt8         *indexData   = index->getData();
1199         GLenum               indexFormat = index->getFormat();
1200         UInt32               indexStride =
1201             index->getStride() ? index->getStride() : index->getFormatSize() *
1202             index->getDimension();
1203
1204         index->activate(pEnv, 0);
1205
1206         if(index->isInVBO(pEnv))
1207         {
1208             indexData = NULL;
1209         }
1210
1211         for(UInt32 primindex = 0; primindex < nprims; ++primindex)
1212         {
1213             if(primindex < lengths->size())
1214                 curlen = lengths->getValue<UInt32>(primindex);
1215
1216             if(curlen > 0)
1217             {
1218                 glDrawElements(types->getValue<UInt16>(primindex),
1219                                curlen,
1220                                indexFormat,
1221                                indexData + vertindex * indexStride);
1222
1223                 vertindex += curlen;
1224             }
1225         }
1226
1227         index->deactivate(pEnv, 0);
1228     }
1229     else
1230     {
1231         // Non-indexed
1232         for(UInt32 primindex = 0; primindex < nprims; ++primindex)
1233         {
1234             if(primindex < lengths->size())
1235                 curlen = lengths->getValue<UInt32>(primindex);
1236
1237             if(curlen > 0)
1238             {
1239                 glDrawArrays(types->getValue<UInt16>(primindex), vertindex,
1240                              curlen);
1241                 vertindex += curlen;
1242             }
1243         }
1244     }
1245 }
1246
1247 bool GeoSplitVertexArrayPumpGroup::masterAttribGeoSetupPumpFull(
1248           DrawEnv                     *pEnv,
1249     const GeoIntegralProperty         *lengths,
1250     const GeoIntegralProperty         *types,
1251     const Geometry::MFPropertiesType  *prop,
1252     const Geometry::MFPropIndicesType *propIdx,
1253           bool                         withFallback)
1254 {
1255 #ifdef DEBUG_WHICH_PUMP
1256     static bool bPrinted = false;
1257
1258     if(bPrinted == false)
1259     {
1260         fprintf(stderr,
1261                 "GeoSplitVertexArrayPumpGroup::masterAttribGeoSetupPumpFull\n");
1262         bPrinted = true;
1263     }
1264 #endif
1265
1266     // Setup: get all the data
1267     PumpData       pumpData;
1268
1269     pumpData.lengths = lengths;
1270     pumpData.types   = types;
1271     pumpData.prop    = prop;
1272     pumpData.propIdx = propIdx;
1273
1274     UInt16 nattrib = prop->size32();
1275
1276     for(UInt16 i = 0; i < nattrib; ++i)
1277     {
1278         if(pumpGLSetup(pumpData, i) == false)
1279             continue;
1280     }
1281
1282     // we need positions
1283     if(pumpData.attribPtr[0]              == NULL ||
1284        pumpData.attribPtr[0]->getUseVBO() == false)
1285     {
1286 #ifdef DEBUG_WHICH_PUMP
1287         static bool bPrinted1 = false;
1288
1289         if(bPrinted1 == false)
1290         {
1291 #endif
1292         if(withFallback == false)
1293         {
1294             SWARNING << "GeoSplitVertexArrayPumpGroup::masterAttribGeoPump: "
1295                      << "No positions, or positions not in vbo." << endLog;
1296         }
1297 #ifdef DEBUG_WHICH_PUMP
1298             bPrinted1 = true;
1299         }
1300 #endif
1301         return false;
1302     }
1303
1304     for(Int16 i = nattrib - 1; i >= 0; --i)
1305     {
1306         if(pumpData.attribPtr[i]         != NULL &&
1307            pumpData.attribPtr[i]->size() != 1     )
1308         {
1309             pumpData.attribPtr[i]->activate(pEnv, i + 16); // XXX HACK
1310         }
1311     }
1312
1313     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
1314     {
1315         (*propIdx)[0]->activate(pEnv, 0);
1316     }
1317
1318     return true;
1319 }
1320
1321 void GeoSplitVertexArrayPumpGroup::masterAttribGeoJustDrawPump(
1322     DrawEnv                     *pEnv,
1323     const GeoIntegralProperty         *lengths,
1324     const GeoIntegralProperty         *types,
1325     const Geometry::MFPropertiesType  *prop,
1326     const Geometry::MFPropIndicesType *propIdx,
1327           UInt32                       uiNumInstances)
1328 {
1329 #ifdef DEBUG_WHICH_PUMP
1330     static bool bPrinted = false;
1331
1332     if(bPrinted == false)
1333     {
1334         fprintf(stderr,
1335                 "GeoSplitVertexArrayPumpGroup::masterAttribGeoJustDrawPump\n");
1336         bPrinted = true;
1337     }
1338 #endif
1339
1340     Window *win = pEnv->getWindow();
1341
1342     // check for empty geometry
1343     if(types == NULL || types->size() == 0)
1344         return;
1345
1346     if(!pumpInternalSetup(types,   true))
1347         return;
1348     if(!pumpInternalSetup(lengths, false))
1349         return;
1350
1351     attribPumpFunc attribFunc[Geometry::MaxAttribs];
1352     PumpData       pumpData;
1353
1354     pumpData.lengths = lengths;
1355     pumpData.types   = types;
1356     pumpData.prop    = prop;
1357     pumpData.propIdx = propIdx;
1358
1359     UInt16 nattrib = prop->size32();
1360
1361     for(UInt16 i = 0; i < nattrib; ++i)
1362     {
1363         if(pumpGLSetup(pumpData, i) == false)
1364             continue;
1365
1366         UInt16 formatIdx = pumpData.attribPtr[i]->getFormat   () - formatBase;
1367         UInt16 dimIdx    = pumpData.attribPtr[i]->getDimension() - 1;
1368
1369 #if !defined(OSG_USE_OGLES_PROTOS) && !defined(OSG_USE_OGL3_PROTOS) && \
1370     !defined(OSG_USE_OGL4_PROTOS)
1371         UInt32 funcId    = Window::invalidFunctionID;
1372
1373         if(pumpData.attribPtr[i]->getNormalize() == true)
1374         {
1375             funcId = normAttribPumpFuncIDs[formatIdx][dimIdx];
1376
1377             if(funcId == Window::invalidFunctionID)
1378             {
1379                 SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1380                          << "Invalid pump function for property " << i
1381                          << " type " << pumpData.attribPtr[i]->getDimension()
1382                          << "D " << formatNames[formatIdx] << " (normalizing)."
1383                          << endLog;
1384
1385                 pumpData.attribData[i] = NULL;
1386                 pumpData.attribPtr [i] = NULL;
1387                 continue;
1388             }
1389         }
1390         else
1391         {
1392             funcId = attribPumpFuncIDs[formatIdx][dimIdx];
1393
1394             if(funcId == Window::invalidFunctionID)
1395             {
1396                 SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1397                          << "Invalid pump function for property " << i
1398                          << " type " << pumpData.attribPtr[i]->getDimension()
1399                          << "D " << formatNames[formatIdx]
1400                          << endLog;
1401
1402                 pumpData.attribData[i] = NULL;
1403                 pumpData.attribPtr [i] = NULL;
1404                 continue;
1405             }
1406         }
1407
1408         attribFunc[i] = reinterpret_cast<attribPumpFunc>(
1409             win->getFunction(funcId));
1410
1411 #else
1412         if(pumpData.attribPtr[i]->getNormalize() == true)
1413         {
1414             attribFunc[i] = attribNormPumpFuncs[formatIdx][dimIdx];
1415         }
1416         else
1417         {
1418             attribFunc[i] = attribPumpFuncs[formatIdx][dimIdx];
1419         }
1420 #endif
1421
1422         if(attribFunc[i] == NULL)
1423         {
1424             SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1425                      << "Extension function for property " << i
1426                      << " type " << pumpData.attribPtr[i]->getDimension()
1427                      << "D " << formatNames[formatIdx]
1428                      << " not supported by Window " << win
1429                      << endLog;
1430
1431             pumpData.attribData[i] = NULL;
1432             pumpData.attribPtr [i] = NULL;
1433             continue;
1434         }
1435     }
1436
1437     // Length handling. Special case: no length given
1438
1439     UInt32 curlen;
1440     UInt32 nprims;
1441
1442     // no lengths? use all available data for the first type
1443     if(lengths == NULL)
1444     {
1445         if(types->size() != 1)
1446         {
1447             SWARNING << "GeoVertexArrayPumpGroup::masterAttribGeoPump: "
1448                      << "No lengths, but more than one type?!"
1449                      << endLog;
1450             return;
1451         }
1452
1453         nprims = 1;
1454
1455         if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
1456         {
1457             curlen = (*propIdx)[0]->size32();
1458         }
1459         else
1460         {
1461             curlen = (*prop)[0]->size32();
1462         }
1463     }
1464     else
1465     {
1466         nprims = types->size32();
1467         lengths->getValue(curlen, 0);
1468     }
1469
1470     // global attribs?
1471     for(Int16 i = 0; i < nattrib; ++i)
1472     {
1473         if(pumpData.attribData[i]         != NULL &&
1474            pumpData.attribPtr [i]->size() == 1      )
1475         {
1476             attribFunc[i](i, pumpData.attribData[i]);
1477             pumpData.attribData[i] = NULL;
1478         }
1479     }
1480
1481     UInt32 vertindex = 0;
1482
1483     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
1484     {
1485         // Single Indexed
1486
1487         GeoIntegralProperty *index       = (*propIdx)[0];
1488         const UInt8         *indexData   = index->getData();
1489         GLenum               indexFormat = index->getFormat();
1490         UInt32               indexStride =
1491             index->getStride() ? index->getStride() : index->getFormatSize() *
1492                                                       index->getDimension();
1493
1494 #if 0
1495         index->activate(pEnv, 0);
1496
1497         if(index->isInVBO(pEnv))
1498         {
1499 #endif
1500             indexData = NULL;
1501 #if 0
1502         }
1503 #endif
1504
1505         if(uiNumInstances > 1)
1506         {
1507             OSGGETGLFUNCBYID_GL3_ES(glDrawElementsInstanced,
1508                                     osgGlDrawElementsInstanced,
1509                                     Geometry::getFuncIdDrawElementsInstanced(),
1510                                     win);
1511
1512             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
1513             {
1514                 if(primindex < lengths->size())
1515                     curlen = lengths->getValue<UInt32>(primindex);
1516
1517                 if(curlen > 0)
1518                 {
1519                     osgGlDrawElementsInstanced(
1520                         types->getValue<UInt16>(primindex),
1521                         curlen,
1522                         indexFormat,
1523                         indexData + vertindex * indexStride,
1524                         uiNumInstances                     );
1525
1526                     vertindex += curlen;
1527                 }
1528             }
1529         }
1530         else
1531         {
1532             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
1533             {
1534                 if(primindex < lengths->size())
1535                     curlen = lengths->getValue<UInt32>(primindex);
1536
1537                 if(curlen > 0)
1538                 {
1539                     glDrawElements(types->getValue<UInt16>(primindex),
1540                                curlen,
1541                                indexFormat,
1542                                indexData + vertindex * indexStride);
1543
1544                     vertindex += curlen;
1545                 }
1546             }
1547         }
1548
1549 #if 0
1550         index->deactivate(pEnv, 0);
1551 #endif
1552     }
1553     else
1554     {
1555         if(uiNumInstances > 1)
1556         {
1557             OSGGETGLFUNCBYID_GL3_ES(glDrawArraysInstanced,
1558                                     osgGlDrawArraysInstanced,
1559                                     Geometry::getFuncIdDrawArraysInstanced(),
1560                                     win);
1561
1562             // Non-indexed
1563             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
1564             {
1565                 if(primindex < lengths->size())
1566                     curlen = lengths->getValue<UInt32>(primindex);
1567
1568                 if(curlen > 0)
1569                 {
1570                     osgGlDrawArraysInstanced(
1571                         types->getValue<UInt16>(primindex),
1572                         vertindex,
1573                         curlen,
1574                         uiNumInstances                    );
1575
1576                     vertindex += curlen;
1577                 }
1578             }
1579         }
1580         else
1581         {
1582             // Non-indexed
1583             for(UInt32 primindex = 0; primindex < nprims; ++primindex)
1584             {
1585                 if(primindex < lengths->size())
1586                     curlen = lengths->getValue<UInt32>(primindex);
1587
1588                 if(curlen > 0)
1589                 {
1590                     glDrawArrays(types->getValue<UInt16>(primindex), vertindex,
1591                                  curlen);
1592                     vertindex += curlen;
1593                 }
1594             }
1595         }
1596     }
1597 }
1598
1599 bool GeoSplitVertexArrayPumpGroup::masterAttribGeoShutdownPump(
1600           DrawEnv                     *pEnv,
1601     const GeoIntegralProperty         *lengths,
1602     const GeoIntegralProperty         *types,
1603     const Geometry::MFPropertiesType  *prop,
1604     const Geometry::MFPropIndicesType *propIdx)
1605 {
1606 #ifdef DEBUG_WHICH_PUMP
1607     static bool bPrinted = false;
1608
1609     if(bPrinted == false)
1610     {
1611         fprintf(stderr,
1612                 "GeoSplitVertexArrayPumpGroup::masterAttribGeoShutdownPump\n");
1613         bPrinted = true;
1614     }
1615 #endif
1616
1617     // Setup: get all the data
1618     PumpData       pumpData;
1619
1620     pumpData.lengths = lengths;
1621     pumpData.types   = types;
1622     pumpData.prop    = prop;
1623     pumpData.propIdx = propIdx;
1624
1625     UInt16 nattrib = prop->size32();
1626
1627     for(UInt16 i = 0; i < nattrib; ++i)
1628     {
1629         if(pumpGLSetup(pumpData, i) == false)
1630             continue;
1631     }
1632
1633     // we need positions
1634     if(pumpData.attribPtr[0]              == NULL ||
1635        pumpData.attribPtr[0]->getUseVBO() == false)
1636     {
1637 #ifdef DEBUG_WHICH_PUMP
1638         static bool bPrinted1 = false;
1639
1640         if(bPrinted1 == false)
1641         {
1642 #endif
1643         SWARNING << "GeoSplitVertexArrayPumpGroup::masterAttribGeoPump: "
1644                  << "No positions." << endLog;
1645
1646 #ifdef DEBUG_WHICH_PUMP
1647             bPrinted1 = true;
1648         }
1649 #endif
1650         return false;
1651     }
1652
1653     for(Int16 i = nattrib - 1; i >= 0; --i)
1654     {
1655         if(pumpData.attribPtr[i]         != NULL &&
1656            pumpData.attribPtr[i]->size() != 1     )
1657         {
1658             pumpData.attribPtr[i]->deactivate(pEnv, i + 16); // XXX HACK
1659         }
1660     }
1661
1662     if(propIdx->size() != 0 && (*propIdx)[0] != NULL)
1663     {
1664         (*propIdx)[0]->deactivate(pEnv, 0);
1665     }
1666
1667     return true;
1668 }
1669
1670 OSG_END_NAMESPACE
1671