Source/System/Material/Base/OSGMaterialMapFields.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 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 "OSGFieldContainer.h"
  44 #include "OSGMaterialMapFields.h"
  45 #include "OSGPrimeMaterial.h"
  46 #include "OSGContainerPtrFuncs.h"
  47
  48 #include "OSGTypeBasePredicates.h"
  49 #include "OSGReflexiveContainerTypePredicates.h"
  50 #include "OSGMapHelper.h"
  51
  52 #include "OSGSField.ins"
  53
  54
  55 OSG_BEGIN_NAMESPACE
  56
  57 OSG_FIELD_DLLEXPORT_DEF1(SField, MaterialMap)
  58
  59
  60 const FieldType &GetSFieldHandle<SFMaterialPtrMap>::getType(void) const
  61 {
  62     return SFMaterialPtrMap::getClassType();
  63 }
  64
  65 const FieldType &EditSFieldHandle<SFMaterialPtrMap>::getType(void) const
  66 {
  67     return SFMaterialPtrMap::getClassType();
  68 }
  69
  70 SizeT FieldTraits<MaterialMap>::getBinSize(const MaterialMap &aMap)
  71 {
  72     // number of elements in map + binding and pointer id for each element
  73     MaterialMap::const_iterator mapIt  = aMap.begin();
  74     MaterialMap::const_iterator mapEnd = aMap.end  ();
  75
  76     SizeT uiKeySize = 0;
  77
  78     for(;mapIt != mapEnd; ++mapIt)
  79     {
  80         std::vector<std::string> vKeyList;
  81
  82         KeyPool::the()->keyToStringList(mapIt->first, vKeyList);
  83
  84         std::vector<std::string>::const_iterator kIt  = vKeyList.begin();
  85         std::vector<std::string>::const_iterator kEnd = vKeyList.end  ();
  86
  87         uiKeySize += sizeof(UInt32);
  88
  89         for(; kIt != kEnd; ++kIt)
  90         {
  91             uiKeySize += FieldTraits<std::string>::getBinSize(*kIt);
  92         }
  93     }
  94
  95     return sizeof(UInt32) + aMap.size() * sizeof(UInt32) + uiKeySize;
  96 }
  97
  98 void FieldTraits<MaterialMap>::copyToBin(      BinaryDataHandler &pMem,
  99                                          const MaterialMap       &aMap )
 100 {
 101     MaterialMap::const_iterator mapIt  = aMap.begin();
 102     MaterialMap::const_iterator mapEnd = aMap.end  ();
 103
 104     UInt32         numPublicObjects = UInt32(aMap.size());
 105     UInt32         fcId;
 106
 107     pMem.putValue(numPublicObjects);
 108
 109     for(; mapIt != mapEnd; ++mapIt)
 110     {
 111         std::vector<std::string> vKeyList;
 112
 113         KeyPool::the()->keyToStringList(mapIt->first, vKeyList);
 114
 115         std::vector<std::string>::const_iterator kIt  = vKeyList.begin();
 116         std::vector<std::string>::const_iterator kEnd = vKeyList.end  ();
 117
 118         UInt32 uiNumKeys = UInt32(vKeyList.size());
 119
 120         pMem.putValue(uiNumKeys);
 121
 122         for(; kIt != kEnd; ++kIt)
 123         {
 124             FieldTraits<std::string>::copyToBin(pMem, *kIt);
 125         }
 126
 127         fcId  = mapIt->second->getId();
 128
 129         pMem.putValue(fcId);
 130     }
 131 }
 132
 133 void FieldTraits<MaterialMap>::copyFromBin(BinaryDataHandler &pMem,
 134                                            MaterialMap       &aMap )
 135 {
 136     PrimeMaterial  *matPtr;
 137     MaterialMapKey  key  = KeyPool::the()->getDefault();
 138     UInt32          fcId;
 139     UInt32          uiNumObjects;
 140
 141     pMem.getValue(uiNumObjects);
 142
 143     MaterialMap::const_iterator mapIt  = aMap.begin();
 144     MaterialMap::const_iterator mapEnd = aMap.end  ();
 145
 146     for(; mapIt != mapEnd; ++mapIt)
 147     {
 148         if((*mapIt).second != NULL)
 149         {
 150             Thread::getCurrentChangeList()->addDelayedSubRef<
 151             UnrecordedRefCountPolicy>((*mapIt).second);
 152         }
 153     }
 154
 155     aMap.clear();
 156
 157
 158     for(UInt32 i = 0; i < uiNumObjects; ++i)
 159     {
 160         UInt32 uiNumKeys;
 161
 162         pMem.getValue(uiNumKeys);
 163
 164         for(UInt32 j = 0; j < uiNumKeys; ++j)
 165         {
 166             std::string tmpString;
 167
 168             FieldTraits<std::string>::copyFromBin(pMem, tmpString);
 169
 170             MaterialMapKey tmpKey = KeyPool::the()->getAuto(tmpString.c_str());
 171
 172             key |= tmpKey;
 173         }
 174
 175         pMem.getValue(fcId);
 176
 177         matPtr = dynamic_cast<PrimeMaterial *>(
 178             FieldContainerFactory::the()->getMappedContainer(fcId));
 179
 180         if(matPtr != NULL)
 181         {
 182             UnrecordedRefCountPolicy::addRef(matPtr);
 183
 184             aMap.insert(MaterialMap::value_type(key, matPtr));
 185         }
 186     }
 187 }
 188
 189 void EditSFieldHandle<SFMaterialPtrMap>::add(
 190           FieldContainer *rhs,
 191     const std::string    &szBindings)
 192 {
 193     PrimeMaterial *pVal = dynamic_cast<PrimeMaterial *>(rhs);
 194     KeyType        oKey = 0x0000;
 195
 196     if(pVal == NULL)
 197     {
 198         MapHelper *pMHelper = dynamic_cast<MapHelper *>(rhs);
 199
 200         if(pMHelper != NULL)
 201         {
 202             pVal = dynamic_cast<PrimeMaterial *>(pMHelper->getContainer());
 203
 204             const MapHelper::MFKeysType *pKeys = pMHelper->getMFKeys();
 205
 206             if(pKeys->empty() == false)
 207             {
 208                 KeyType tmpKey = KeyPool::the()->getDefault();
 209
 210                 for(UInt32 i = 0; i < pKeys->size(); ++i)
 211                 {
 212                     const std::string &szKey = pMHelper->getKeys(i);
 213
 214                     tmpKey = KeyPool::the()->getAuto(szKey.c_str());
 215
 216                     oKey |= tmpKey;
 217                 }
 218             }
 219         }
 220     }
 221     else
 222     {
 223         if(szBindings.empty() == false)
 224         {
 225             oKey = KeyPool::the()->getAuto(szBindings.c_str());
 226         }
 227     }
 228
 229     if(rhs != NULL && pVal == NULL)
 230         return;
 231
 232
 233     // for whatever reason VS2003 does not like == NULL
 234     if(_fAddMethod)
 235     {
 236         _fAddMethod(pVal, oKey);
 237     }
 238 }
 239
 240 void EditSFieldHandle<SFMaterialPtrMap>::traverse(TraverseCallback oCallback)
 241 {
 242     const SFMaterialPtrMap *pMap = static_cast<SFMaterialPtrMap *>(_pField);
 243
 244     if(oCallback && pMap != NULL)
 245     {
 246         MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 247         MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 248
 249         for(; mapIt != mapEnd; ++mapIt)
 250         {
 251             oCallback(mapIt->second);
 252         }
 253     }
 254 }
 255
 256 void EditSFieldHandle<SFMaterialPtrMap>::flatten(MapList &vList)
 257 {
 258     vList.clear();
 259
 260     const SFMaterialPtrMap *pMap = static_cast<SFMaterialPtrMap *>(_pField);
 261
 262     if(pMap != NULL)
 263     {
 264         MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 265         MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 266
 267         for(; mapIt != mapEnd; ++mapIt)
 268         {
 269             ListEntry tmpEntry;
 270
 271             KeyPool::the()->keyToStringList(mapIt->first,
 272                                             tmpEntry.first);
 273
 274             tmpEntry.second = mapIt->second;
 275
 276             vList.push_back(tmpEntry);
 277         }
 278     }
 279 }
 280
 281 void EditSFieldHandle<SFMaterialPtrMap>::flatten(ContainerList &vList)
 282 {
 283     vList.clear();
 284
 285     const SFMaterialPtrMap *pMap = static_cast<SFMaterialPtrMap *>(_pField);
 286
 287     if(pMap != NULL)
 288     {
 289         MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 290         MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 291
 292         for(; mapIt != mapEnd; ++mapIt)
 293         {
 294             vList.push_back(mapIt->second);
 295         }
 296     }
 297 }
 298
 299 bool EditSFieldHandle<SFMaterialPtrMap>::loadFromBin(
 300     BinaryDataHandler        *pMem,
 301     UInt32                    uiNumElements,
 302     bool                      hasBindingInfo,
 303     std::vector<UInt16>      &vBindings,
 304     std::vector<UInt32>      &vIds          )
 305 {
 306     SFMaterialPtrMap *pMap = static_cast<SFMaterialPtrMap *>(_pField);
 307
 308     if(pMap == NULL)
 309         return true;
 310
 311     MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 312     MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 313
 314     for(; mapIt != mapEnd; ++mapIt)
 315     {
 316         if((*mapIt).second != NULL)
 317         {
 318             Thread::getCurrentChangeList()->addDelayedSubRef<
 319             UnrecordedRefCountPolicy>((*mapIt).second);
 320         }
 321     }
 322
 323     pMap->getValue().clear();
 324
 325
 326     UInt32 fcId;
 327
 328     union
 329     {
 330         PrimeMaterial *pointerVal;
 331         UIntPointer    uiVal;
 332     } tmpEntry;
 333
 334     for(UInt32 i = 0; i < uiNumElements; ++i)
 335     {
 336         MaterialMapKey  key  = KeyPool::the()->getDefault();
 337         UInt32          uiNumKeys;
 338
 339         pMem->getValue(uiNumKeys);
 340
 341         for(UInt32 j = 0; j < uiNumKeys; ++j)
 342         {
 343             std::string tmpString;
 344
 345             FieldTraits<std::string>::copyFromBin(*pMem, tmpString);
 346
 347             MaterialMapKey tmpKey = KeyPool::the()->getAuto(tmpString.c_str());
 348
 349             key |= tmpKey;
 350         }
 351
 352         pMem->getValue(fcId);
 353
 354         tmpEntry.uiVal = fcId;
 355
 356         pMap->getValue().insert(MaterialMap::value_type(key,
 357                                                         tmpEntry.pointerVal));
 358     }
 359
 360     UInt16 uiCount = 0;
 361
 362     MaterialMap::iterator mapWIt = pMap->getValue().begin();
 363                           mapEnd = pMap->getValue().end  ();
 364
 365     for(; mapWIt != mapEnd; ++mapWIt, ++uiCount)
 366     {
 367         tmpEntry.pointerVal = mapWIt->second;
 368
 369         vIds     .push_back(tmpEntry.uiVal);
 370         vBindings.push_back(uiCount       );
 371
 372         mapWIt->second = NULL;
 373     }
 374
 375     return true;
 376 }
 377
 378 void EditSFieldHandle<SFMaterialPtrMap>::fillFrom(
 379     const std::vector<UInt16>      &vBindings,
 380     const std::vector<UInt32>      &vIds,
 381     const std::map<UInt32, UInt32> &mIdMap       )
 382 {
 383     SFMaterialPtrMap *pMap = static_cast<SFMaterialPtrMap *>(_pField);
 384
 385     if(pMap == NULL)
 386         return;
 387
 388     MaterialMap::iterator       mapIt  = pMap->getValue().begin();
 389     MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 390
 391     std::vector<UInt32        >::const_iterator idIt    = vIds.begin();
 392     std::map   <UInt32, UInt32>::const_iterator imapIt;
 393     std::map   <UInt32, UInt32>::const_iterator imapEnd = mIdMap.end();
 394
 395     OSG_ASSERT(vIds     .size() == pMap->getValue().size() &&
 396                vBindings.size() == pMap->getValue().size()  );
 397
 398     PrimeMaterial *pMat = NULL;
 399
 400     for(; mapIt != mapEnd; ++mapIt, ++idIt)
 401     {
 402         imapIt  = mIdMap.find(*idIt);
 403
 404         if(imapIt != imapEnd)
 405         {
 406             pMat = dynamic_cast<PrimeMaterial *>(
 407                 FieldContainerFactory::the()->getContainer(imapIt->second));
 408
 409             UnrecordedRefCountPolicy::addRef(pMat);
 410         }
 411         else
 412         {
 413             pMat = NULL;
 414         }
 415
 416         mapIt->second = pMat;
 417     }
 418 }
 419
 420
 421 void EditSFieldHandle<SFMaterialPtrMap>::cloneValues(
 422           GetFieldHandlePtr  pSrc,
 423     const TypePtrVector     &shareTypes,
 424     const TypePtrVector     &ignoreTypes,
 425     const TypeIdVector      &shareGroupIds,
 426     const TypeIdVector      &ignoreGroupIds) const
 427 {
 428     SFMaterialPtrMap::GetHandlePtr pGetHandle =
 429         boost::dynamic_pointer_cast<
 430             SFMaterialPtrMap::GetHandle>(pSrc);
 431
 432     if(pGetHandle == NULL || pGetHandle->isValid() == false)
 433         return;
 434
 435     const SFMaterialPtrMap &pAttMap = **pGetHandle;
 436
 437     MaterialMap::const_iterator mapIt  = pAttMap.getValue().begin();
 438     MaterialMap::const_iterator mapEnd = pAttMap.getValue().end();
 439
 440     for(; mapIt != mapEnd; ++mapIt)
 441     {
 442         PrimeMaterialUnrecPtr att = mapIt->second;
 443         MaterialMapKey        key = mapIt->first;
 444
 445         if(att != NULL)
 446         {
 447             const FieldContainerType &attType = att->getType();
 448
 449             // test if att type should NOT be ignored
 450             if(!TypePredicates::typeInGroupIds (ignoreGroupIds.begin(),
 451                                                 ignoreGroupIds.end(),
 452                                                 attType                ) &&
 453                !TypePredicates::typeDerivedFrom(ignoreTypes.begin(),
 454                                                 ignoreTypes.end(),
 455                                                 attType                )   )
 456             {
 457                 // test if att should cloned
 458                 if(!TypePredicates::typeInGroupIds (shareGroupIds.begin(),
 459                                                     shareGroupIds.end(),
 460                                                     attType               ) &&
 461                    !TypePredicates::typeDerivedFrom(shareTypes.begin(),
 462                                                     shareTypes.end(),
 463                                                     attType               )   )
 464                 {
 465                     att = dynamic_pointer_cast<PrimeMaterial>(
 466                         OSG::deepClone(att, shareTypes,    ignoreTypes,
 467                                             shareGroupIds, ignoreGroupIds));
 468                 }
 469             }
 470         }
 471
 472         if(_fAddMethod)
 473         {
 474             _fAddMethod(att, key);
 475         }
 476     }
 477 }
 478
 479
 480 void GetSFieldHandle<SFMaterialPtrMap>::traverse(TraverseCallback oCallback)
 481 {
 482     SFMaterialPtrMap const *pMap =
 483         static_cast<SFMaterialPtrMap const *>(_pField);
 484
 485     if(oCallback && pMap != NULL)
 486     {
 487         MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 488         MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 489
 490         for(; mapIt != mapEnd; ++mapIt)
 491         {
 492             oCallback(mapIt->second);
 493         }
 494     }
 495 }
 496
 497 void GetSFieldHandle<SFMaterialPtrMap>::flatten(MapList &vList)
 498 {
 499     vList.clear();
 500
 501     SFMaterialPtrMap const *pMap =
 502         static_cast<SFMaterialPtrMap const *>(_pField);
 503
 504     if(pMap != NULL)
 505     {
 506         MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 507         MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 508
 509         for(; mapIt != mapEnd; ++mapIt)
 510         {
 511             ListEntry   tmpEntry;
 512
 513             KeyPool::the()->keyToStringList(mapIt->first,
 514                                             tmpEntry.first);
 515
 516             tmpEntry.second = mapIt->second;
 517
 518             vList.push_back(tmpEntry);
 519         }
 520     }
 521 }
 522
 523 void GetSFieldHandle<SFMaterialPtrMap>::flatten(ContainerList &vList)
 524 {
 525     vList.clear();
 526
 527     SFMaterialPtrMap const *pMap =
 528         static_cast<SFMaterialPtrMap const *>(_pField);
 529
 530     if(pMap != NULL)
 531     {
 532         MaterialMap::const_iterator mapIt  = pMap->getValue().begin();
 533         MaterialMap::const_iterator mapEnd = pMap->getValue().end  ();
 534
 535         for(; mapIt != mapEnd; ++mapIt)
 536         {
 537             vList.push_back(mapIt->second);
 538         }
 539     }
 540 }
 541
 542 #if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
 543
 544 DataType FieldTraits<MaterialMap>::_type(
 545     "MaterialMap",
 546     "FieldContainerPtrMap");
 547
 548 OSG_FIELDTRAITS_GETTYPE(MaterialMap)
 549
 550 #endif // !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
 551
 552 OSG_END_NAMESPACE