Source/Contrib/ComplexSceneManager/Helper/OSGCSMStatisticsForeground.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 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  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGCSMStatisticsForeground.h"
  49 #include "OSGSimpleStatisticsForeground.h"
  50
  51 #include "OSGRenderAction.h"
  52 #include "OSGPointLight.h"
  53 #include "OSGSpotLight.h"
  54 #include "OSGDirectionalLight.h"
  55
  56 OSG_BEGIN_NAMESPACE
  57
  58 // Documentation for this class is emitted in the
  59 // OSGCSMStatisticsForegroundBase.cpp file.
  60 // To modify it, please change the .fcd file (OSGCSMStatisticsForeground.fcd)
  61 // and regenerate the base file.
  62
  63 /***************************************************************************\
  64  *                           Class variables                               *
  65 \***************************************************************************/
  66
  67 /***************************************************************************\
  68  *                           Class methods                                 *
  69 \***************************************************************************/
  70
  71 void CSMStatisticsForeground::initMethod(InitPhase ePhase)
  72 {
  73     Inherited::initMethod(ePhase);
  74
  75     if(ePhase == TypeObject::SystemPost)
  76     {
  77     }
  78 }
  79
  80
  81 /***************************************************************************\
  82  *                           Instance methods                              *
  83 \***************************************************************************/
  84
  85 /*-------------------------------------------------------------------------*\
  86  -  private                                                                 -
  87 \*-------------------------------------------------------------------------*/
  88
  89 /*----------------------- constructors & destructors ----------------------*/
  90
  91 CSMStatisticsForeground::CSMStatisticsForeground(void) :
  92      Inherited(    ),
  93     _pStatFG  (NULL)
  94 {
  95 }
  96
  97 CSMStatisticsForeground::CSMStatisticsForeground(
  98     const CSMStatisticsForeground &source) :
  99
 100      Inherited(source),
 101     _pStatFG  (NULL  )
 102 {
 103 }
 104
 105 CSMStatisticsForeground::~CSMStatisticsForeground(void)
 106 {
 107 }
 108
 109 void CSMStatisticsForeground::draw(DrawEnv *)
 110 {
 111 }
 112
 113 void CSMStatisticsForeground::addElement(
 114           SimpleStatisticsForeground *pStatFG,
 115     const std::string                &szStatObj,
 116     const std::string                &szStatElem,
 117     const std::string                &szFormat  )
 118 {
 119 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 120     if(szStatObj.compare("Text") == 0)
 121     {
 122         if(szStatElem.compare("freetext") == 0)
 123         {
 124             pStatFG->addText(szFormat.c_str());
 125         }
 126         else
 127         {
 128             fprintf(stderr, "Unknown stat elem %s for %s\n",
 129                     szStatElem.c_str(),
 130                     szStatObj.c_str());
 131         }
 132     }
 133     else if(szStatObj.compare("RenderAction") == 0)
 134     {
 135         if(szStatElem.compare("statDrawTime") == 0)
 136         {
 137             pStatFG->addElement(RenderAction::statDrawTime,
 138                                 szFormat.c_str());
 139         }
 140         else if(szStatElem.compare("statTravTime") == 0)
 141         {
 142             pStatFG->addElement(RenderAction::statTravTime,
 143                                 szFormat.c_str());
 144         }
 145         else if(szStatElem.compare("statNMatrices") == 0)
 146         {
 147             pStatFG->addElement(RenderAction::statNMatrices,
 148                                 szFormat.c_str());
 149         }
 150         else if(szStatElem.compare("statNStates") == 0)
 151         {
 152             pStatFG->addElement(RenderAction::statNStates,
 153                                 szFormat.c_str());
 154         }
 155         else if(szStatElem.compare("statNChunks") == 0)
 156         {
 157             pStatFG->addElement(RenderAction::statNChunks,
 158                                 szFormat.c_str());
 159         }
 160         else if(szStatElem.compare("statNShaders") == 0)
 161         {
 162             pStatFG->addElement(RenderAction::statNShaders,
 163                                 szFormat.c_str());
 164         }
 165         else if(szStatElem.compare("statNShaderParams") == 0)
 166         {
 167             pStatFG->addElement(RenderAction::statNShaderParams,
 168                                 szFormat.c_str());
 169         }
 170         else
 171         {
 172             fprintf(stderr, "Unknown stat elem %s for %s\n",
 173                     szStatElem.c_str(),
 174                     szStatObj.c_str());
 175         }
 176     }
 177     else if(szStatObj.compare("PointLight") == 0)
 178     {
 179         if(szStatElem.compare("statNPointLights") == 0)
 180         {
 181             pStatFG->addElement(PointLight::statNPointLights,
 182                                 szFormat.c_str());
 183         }
 184         else
 185         {
 186             fprintf(stderr, "Unknown stat elem %s for %s\n",
 187                     szStatElem.c_str(),
 188                     szStatObj.c_str());
 189         }
 190     }
 191     else if(szStatObj.compare("DirectionalLight") == 0)
 192     {
 193         if(szStatElem.compare("statNDirectionalLights") == 0)
 194         {
 195             pStatFG->addElement(DirectionalLight::statNDirectionalLights,
 196                                 szFormat.c_str());
 197         }
 198         else
 199         {
 200             fprintf(stderr, "Unknown stat elem %s for %s\n",
 201                     szStatElem.c_str(),
 202                     szStatObj.c_str());
 203         }
 204     }
 205     else if(szStatObj.compare("SpotLight") == 0)
 206     {
 207         if(szStatElem.compare("statNSpotLights") == 0)
 208         {
 209             pStatFG->addElement(SpotLight::statNSpotLights,
 210                                 szFormat.c_str());
 211         }
 212         else
 213         {
 214             fprintf(stderr, "Unknown stat elem %s for %s\n",
 215                     szStatElem.c_str(),
 216                     szStatObj.c_str());
 217         }
 218     }
 219     else if(szStatObj.compare("Drawable") == 0)
 220     {
 221         if(szStatElem.compare("statNTriangles") == 0)
 222         {
 223             pStatFG->addElement(Drawable::statNTriangles,
 224                                 szFormat.c_str());
 225         }
 226         else if(szStatElem.compare("statNLines") == 0)
 227         {
 228             pStatFG->addElement(Drawable::statNLines,
 229                                 szFormat.c_str());
 230         }
 231         else if(szStatElem.compare("statNPoints") == 0)
 232         {
 233             pStatFG->addElement(Drawable::statNPoints,
 234                                 szFormat.c_str());
 235         }
 236         else if(szStatElem.compare("statNVertices") == 0)
 237         {
 238             pStatFG->addElement(Drawable::statNVertices,
 239                                 szFormat.c_str());
 240         }
 241         else if(szStatElem.compare("statNPrimitives") == 0)
 242         {
 243             pStatFG->addElement(Drawable::statNPrimitives,
 244                                 szFormat.c_str());
 245         }
 246         else if(szStatElem.compare("statNGeoBytes") == 0)
 247         {
 248             pStatFG->addElement(Drawable::statNGeoBytes,
 249                                 szFormat.c_str());
 250         }
 251         else if(szStatElem.compare("statNDrawFunctors") == 0)
 252         {
 253             pStatFG->addElement(Drawable::statNDrawFunctors,
 254                                 szFormat.c_str());
 255         }
 256         else
 257         {
 258             fprintf(stderr, "Unknown stat elem %s for %s\n",
 259                     szStatElem.c_str(),
 260                     szStatObj.c_str());
 261         }
 262     }
 263     else if(szStatObj.compare("TextureObjChunk") == 0)
 264     {
 265         if(szStatElem.compare("statNTextures") == 0)
 266         {
 267             pStatFG->addElement(TextureObjChunk::statNTextures,
 268                                 szFormat.c_str());
 269         }
 270         else if(szStatElem.compare("statNTexBytes") == 0)
 271         {
 272             pStatFG->addElement(TextureObjChunk::statNTexBytes,
 273                                 szFormat.c_str());
 274         }
 275         else
 276         {
 277             fprintf(stderr, "Unknown stat elem %s for %s\n",
 278                     szStatElem.c_str(),
 279                     szStatObj.c_str());
 280         }
 281     }
 282     else if(szStatObj.compare("ChangeList") == 0)
 283     {
 284         if(szStatElem.compare("statNChangedStoreSize") == 0)
 285         {
 286             pStatFG->addElement(ChangeList::statNChangedStoreSize,
 287                                 szFormat.c_str());
 288         }
 289         else if(szStatElem.compare("statNCreatedStoreSize") == 0)
 290         {
 291             pStatFG->addElement(ChangeList::statNCreatedStoreSize,
 292                                 szFormat.c_str());
 293         }
 294         else if(szStatElem.compare("statNUnCommittedStoreSize") == 0)
 295         {
 296             pStatFG->addElement(ChangeList::statNUnCommittedStoreSize,
 297                                 szFormat.c_str());
 298         }
 299         else if(szStatElem.compare("statNPoolSize") == 0)
 300         {
 301             pStatFG->addElement(ChangeList::statNPoolSize,
 302                                 szFormat.c_str());
 303         }
 304         else
 305         {
 306             fprintf(stderr, "Unknown stat elem %s for %s\n",
 307                     szStatElem.c_str(),
 308                     szStatObj.c_str());
 309         }
 310     }
 311     else if(szStatObj.compare("Partition") == 0)
 312     {
 313         if(szStatElem.compare("statCullTestedNodes") == 0)
 314         {
 315             pStatFG->addElement(RenderPartition::statCullTestedNodes,
 316                                 szFormat.c_str());
 317         }
 318         else if(szStatElem.compare("statCulledNodes") == 0)
 319         {
 320             pStatFG->addElement(RenderPartition::statCulledNodes,
 321                                 szFormat.c_str());
 322         }
 323         else
 324         {
 325             fprintf(stderr, "Unknown stat elem %s for %s\n",
 326                     szStatElem.c_str(),
 327                     szStatObj.c_str());
 328         }
 329     }
 330     else
 331     {
 332         fprintf(stderr, "Unknown stat object %s\n",
 333                 szStatObj.c_str());
 334     }
 335 #endif
 336 }
 337
 338 bool CSMStatisticsForeground::init(CSMWindow *pCSMWin)
 339 {
 340 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 341     SimpleStatisticsForegroundUnrecPtr pStatFG =
 342         OSG::SimpleStatisticsForeground::create();
 343
 344     pStatFG->setActive (this->getActive ());
 345     pStatFG->setSize   (this->getSize   ());
 346     pStatFG->setColor  (this->getColor  ());
 347     pStatFG->setBgColor(this->getBgColor());
 348
 349     _pStatFG = pStatFG;
 350
 351     if(_mfElements.size() != 0)
 352     {
 353         std::string szSep("::");
 354
 355         for(SizeT i = 0; i < _mfElements.size(); ++i)
 356         {
 357             SizeT uiPos = _mfElements[i].rfind(szSep);
 358
 359             if(uiPos != std::string::npos)
 360             {
 361                 std::string szElem   = _mfElements[i].substr(0,
 362                                                              uiPos            );
 363                 std::string szFormat = _mfElements[i].substr(uiPos + 2,
 364                                                              std::string::npos);
 365
 366                 if(szElem.size() == 0 || szFormat.size() == 0)
 367                     continue;
 368
 369                 uiPos = szElem.rfind(szSep);
 370
 371                 if(uiPos != std::string::npos)
 372                 {
 373                     std::string szStatObj  = szElem.substr(0,
 374                                                            uiPos            );
 375                     std::string szStatElem = szElem.substr(uiPos + 2,
 376                                                            std::string::npos);
 377
 378                     if(szStatObj.size() == 0 || szStatElem.size() == 0)
 379                         continue;
 380
 381                     addElement(pStatFG,
 382                                szStatObj,
 383                                szStatElem,
 384                                szFormat  );
 385                 }
 386             }
 387         }
 388     }
 389
 390 //    pStatFG->addElement(RenderAction::statDrawTime, "Draw FPS: %r.3f");
 391 //    pStatFG->addElement(RenderAction::statDrawTime, "DrawTime: %.3f s");
 392 #endif
 393
 394     return true;
 395 }
 396
 397 StatisticsForeground *CSMStatisticsForeground::getOSGForeground(void)
 398 {
 399     return _pStatFG;
 400 }
 401
 402 void CSMStatisticsForeground::resolveLinks(void)
 403 {
 404     _pStatFG = NULL;
 405
 406     Inherited::resolveLinks();
 407 }
 408
 409 /*----------------------------- class specific ----------------------------*/
 410
 411 void CSMStatisticsForeground::changed(ConstFieldMaskArg whichField,
 412                                       UInt32            origin,
 413                                       BitVector         details)
 414 {
 415     Inherited::changed(whichField, origin, details);
 416 }
 417
 418 void CSMStatisticsForeground::dump(      UInt32    ,
 419                                    const BitVector ) const
 420 {
 421     SLOG << "Dump CSMStatisticsForeground NI" << std::endl;
 422 }
 423
 424 OSG_END_NAMESPACE