Source/System/FileIO/WRL/OSGVRMLFile.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  * 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 // AMZ disabled for now.
  40
  41 #include <cstdlib>
  42 #include <cstdio>
  43
  44 #include "OSGConfig.h"
  45
  46 #include <iostream>
  47
  48 #include "OSGVRMLFile.h"
  49
  50 #include "OSGFieldType.h"
  51 #include "OSGMathMFields.h"
  52 #include "OSGMathSFields.h"
  53 #include "OSGVecMFields.h"
  54 #include "OSGVecSFields.h"
  55
  56
  57 #include "OSGAction.h"
  58 #include "OSGMaterial.h"
  59 #include "OSGMaterialGroup.h"
  60 #include "OSGNameAttachment.h"
  61
  62 #include "OSGGroup.h"
  63
  64 #include "OSGBlendChunk.h"
  65 #include "OSGTextureObjChunk.h"
  66 #include "OSGTextureEnvChunk.h"
  67 #include "OSGFieldConnector.h"
  68
  69
  70 #include "OSGSceneFileHandler.h"
  71
  72 //#define OSG_DEBUG_VRML
  73
  74 OSG_BEGIN_NAMESPACE
  75
  76 /*! \class OSG::VRMLFile
  77  */
  78
  79 /*! \var OSG::VRMLFile::PushNames
  80     Option to push the name attachments for entities that can not have a
  81     NameAttachment in OpenSG to their respective parent.
  82
  83     This is currently only implemented for MaterialChunks and only sets the
  84     name on the containing ChunkMaterial if that does not have a name of its
  85     own.
  86  */
  87
  88 OSG::Time startTime = 0.;
  89 OSG::Time useTime   = 0.;
  90 OSG::Time findTime  = 0.;
  91
  92 /*-------------------------------------------------------------------------*/
  93 /*                            Constructors                                 */
  94
  95 VRMLFile::VRMLFile(void) :
  96     Inherited(),
  97
  98     _pSceneRootNode     (NULL),
  99
 100     _pCurrNodeHelper(NULL),
 101     _sNodeHelpers   (),
 102
 103     _pCurrentFC       (NULL  ),
 104     _pCurrentFieldFC  (NULL  ),
 105     _pCurrentField    (      ),
 106     _pCurrentFieldDesc(NULL  ),
 107
 108     _fcStack  (),
 109     _fStack   (),
 110     _fdStack  (),
 111
 112     _nameFCMap    ()
 113 {
 114     Self::setReferenceHeader("#VRML V2.0 ");
 115
 116     initIntExtFieldTypeMapper();
 117     initExtIntFieldTypeMapper();
 118 }
 119
 120 /*-------------------------------------------------------------------------*/
 121 /*                             Destructor                                  */
 122
 123 VRMLFile::~VRMLFile(void)
 124 {
 125 }
 126
 127 /*-------------------------------------------------------------------------*/
 128 /*                           Skel Replacements                             */
 129
 130 NodeTransitPtr VRMLFile::scanStream(std::istream &iStream)
 131 {
 132     startTime = getSystemTime();
 133
 134     _pSceneRootNode      = NULL;
 135     _pCurrentFC          = NULL;
 136
 137     _nameFCMap.clear();
 138
 139 #ifdef OSG_DEBUG_VRML
 140     VRMLNodeHelper::resetIndent();
 141 #endif
 142
 143     if(iStream)
 144     {
 145         Inherited::scanStream(iStream);
 146     }
 147
 148     SceneFileHandler::the()->updateReadProgress(100);
 149
 150     NodeTransitPtr returnValue(_pSceneRootNode);
 151
 152     _pSceneRootNode      = NULL;
 153     _pCurrentFC          = NULL;
 154
 155     FINFO(("Full Time : %lf | Use Time %lf\n",
 156             getSystemTime() - startTime,
 157             useTime));
 158
 159     return returnValue;
 160 }
 161
 162 bool VRMLFile::checkHeader(void)
 163 {
 164     return true;
 165 }
 166
 167 void VRMLFile::handleError(void *pSelf, const Char8 *szErrorText)
 168 {
 169     Inherited::handleError(pSelf, szErrorText);
 170     // on an error we destroy the incomplete scene.
 171
 172 #if 0
 173     if(_pSceneRootNode != NULL)
 174     {
 175         _pSceneRootNode = NULL;
 176     }
 177 #endif
 178 }
 179
 180 void VRMLFile::beginNode(const Char8     *szNodeTypename,
 181                          const Char8     *szNodename,
 182                          const BitVector  bvLocalFlags  )
 183 {
 184     SceneFileHandler::the()->updateReadProgress();
 185
 186     FieldContainerUnrecPtr pNewNode;
 187
 188 #ifdef OSG_DEBUG_VRML
 189     indentLog(VRMLNodeHelper::getIndent(), PINFO);
 190     PINFO << "Begin Node " << szNodeTypename << std::endl;
 191
 192     VRMLNodeHelper::incIndent();
 193 #endif
 194
 195     VRMLNodeHelper *pOldHelper = _pCurrNodeHelper;
 196
 197     _pCurrNodeHelper = findNodeHelper(szNodeTypename);
 198
 199     _sNodeHelpers.push(_pCurrNodeHelper);
 200
 201     if(_pCurrNodeHelper == NULL)
 202     {
 203         std::string szTmp = "Unknow node type '#";
 204
 205         szTmp += szNodeTypename;
 206         szTmp += "#";
 207
 208         Inherited::handleError(this, szTmp.c_str());
 209
 210         return;
 211     }
 212
 213     _pCurrNodeHelper->reset();
 214
 215     pNewNode = _pCurrNodeHelper->beginNode( szNodeTypename,
 216                                             szNodename,
 217                                            _pCurrentFC);
 218
 219
 220     if(szNodename != NULL)
 221     {
 222         if(pNewNode != NULL)
 223         {
 224             std::string szKey = szNodename;
 225
 226             AttachmentContainer *pAttC =
 227                 dynamic_pointer_cast<AttachmentContainer>(pNewNode);
 228
 229             if(pAttC != NULL)
 230             {
 231                 setName(pAttC, szKey);
 232             }
 233
 234             // amz - I removed the map checks that's more spec conform.
 235             // From the spec:
 236             // If multiple nodes are given the same name,
 237             // each USE statement refers to the closest node with the given
 238             // name preceding it
 239             // in either the VRML file or prototype definition.
 240
 241             //NameContainerMap::iterator mIt = _nameFCMap.find(szKey);
 242             //if(mIt == _nameFCMap.end())
 243             {
 244                 _nameFCMap[szKey] = pNewNode;
 245             }
 246 //            else
 247 //            {
 248 //                PWARNING << "Did not add fieldContainer with name "
 249 //                         << szKey
 250 //                         << " a second time"
 251 //                         << std::endl;
 252 //            }
 253
 254         }
 255     }
 256
 257     if(pOldHelper != NULL)
 258     {
 259         pOldHelper->setContainerFieldValue( pNewNode,
 260                                            _pCurrentFieldDesc,
 261                                            _pCurrentFieldFC  );
 262     }
 263
 264     _pCurrentFC = pNewNode;
 265
 266     _fcStack.push(_pCurrentFC);
 267
 268     if(_fcStack.size() == 1)
 269     {
 270         Node *pNode = dynamic_cast<Node *>(_pCurrentFC.get());
 271
 272         if(pNode != NULL)
 273         {
 274             if(_pSceneRootNode == NULL)
 275             {
 276                 _pSceneRootNode = Node::create();
 277
 278                 _pSceneRootNode->setCore(Group::create());
 279             }
 280
 281             _pSceneRootNode->addChild(pNode);
 282         }
 283     }
 284 }
 285
 286 void VRMLFile::endNode(void)
 287 {
 288     SceneFileHandler::the()->updateReadProgress();
 289
 290     if(_pCurrNodeHelper == NULL)
 291     {
 292 #ifdef OSG_DEBUG_VRML
 293         VRMLNodeHelper::decIndent();
 294
 295         indentLog(VRMLNodeHelper::getIndent(), PINFO);
 296         PINFO << "End Node " << std::endl;
 297 #endif
 298
 299         _sNodeHelpers.pop();
 300
 301         if(_sNodeHelpers.size() != 0)
 302         {
 303             _pCurrNodeHelper = _sNodeHelpers.top();
 304         }
 305         else
 306         {
 307             _pCurrNodeHelper = NULL;
 308         }
 309
 310         return;
 311     }
 312
 313     _pCurrNodeHelper->endNode(_pCurrentFC);
 314
 315     _sNodeHelpers.pop();
 316
 317     if(_sNodeHelpers.size() != 0)
 318     {
 319         _pCurrNodeHelper = _sNodeHelpers.top();
 320     }
 321     else
 322     {
 323         _pCurrNodeHelper = NULL;
 324     }
 325
 326     if(_pCurrentFC != NULL)
 327     {
 328         if(_pCurrentFC->getType().isNode() == true)
 329         {
 330             Node *pNode = dynamic_cast<Node *>(_pCurrentFC.get());
 331
 332             if(pNode->getCore() == NULL)
 333             {
 334                 pNode->setCore(Group::create());
 335             }
 336         }
 337     }
 338
 339     _fcStack.pop();
 340
 341     if(_fcStack.size() != 0)
 342     {
 343         _pCurrentFC = _fcStack.top();
 344     }
 345     else
 346     {
 347         _pCurrentFC = NULL;
 348     }
 349
 350     if(_pCurrentFieldDesc != NULL)
 351     {
 352         _pCurrentFieldFC = _pCurrentFC;
 353     }
 354 #ifdef OSG_DEBUG_VRML
 355     VRMLNodeHelper::decIndent();
 356
 357     indentLog(VRMLNodeHelper::getIndent(), PINFO);
 358     PINFO << "End Node " << std::endl;
 359 #endif
 360 }
 361
 362 void VRMLFile::beginScript(const Char8 *szNodename)
 363 {
 364     beginNode("Script", szNodename, TypeTraits<BitVector>::BitsClear);
 365 }
 366
 367 void VRMLFile::endScript(void)
 368 {
 369     endNode();
 370 }
 371
 372 void VRMLFile::beginField(const Char8  *szFieldname,
 373                           const UInt32  OSG_VRML_ARG(uiFieldTypeId))
 374 {
 375     if(szFieldname == NULL)
 376         return;
 377
 378 #ifdef OSG_DEBUG_VRML
 379     indentLog(VRMLNodeHelper::getIndent(), PINFO);
 380     PINFO << "VRMLFile::beginField : looking for "
 381           << szFieldname
 382           << " ("
 383           << uiFieldTypeId
 384           << " | "
 385           << _pCurrentField
 386           << " | "
 387           << _pCurrentFieldDesc
 388           << ") "
 389           << ScanParseSkel::OSGmfNode
 390           << std::endl;
 391
 392     VRMLNodeHelper::incIndent();
 393 #endif
 394
 395     _fStack .push(_pCurrentField    );
 396     _fdStack.push(_pCurrentFieldDesc);
 397 }
 398
 399 void VRMLFile::endField(void)
 400 {
 401     _fStack.pop();
 402
 403     if(_fStack.size() != 0)
 404     {
 405         _pCurrentField = _fStack.top();
 406     }
 407     else
 408     {
 409         _pCurrentField.reset();
 410     }
 411
 412
 413     _fdStack.pop();
 414
 415     if(_fdStack.size() != 0)
 416     {
 417         _pCurrentFieldDesc = _fdStack.top();
 418     }
 419     else
 420     {
 421         _pCurrentFieldDesc = NULL;
 422     }
 423
 424 #ifdef OSG_DEBUG_VRML
 425     VRMLNodeHelper::decIndent();
 426
 427     indentLog(VRMLNodeHelper::getIndent(), PINFO);
 428     PINFO << "VRMLFile::endField " << std::endl;
 429 #endif
 430 }
 431
 432
 433 void VRMLFile::addFieldValue(const Char8 *szFieldVal)
 434 {
 435     if(_pCurrNodeHelper != NULL)
 436     {
 437         _pCurrNodeHelper->addFieldValue(_pCurrentField,
 438                                         _pCurrentFieldDesc,
 439                                         szFieldVal);
 440     }
 441 }
 442
 443 void VRMLFile::addImageValue(Image *pImage)
 444 {
 445     if(_pCurrNodeHelper != NULL)
 446     {
 447         _pCurrNodeHelper->addImageValue(_pCurrentField,
 448                                         _pCurrentFieldDesc,
 449                                          pImage           );
 450     }
 451 }
 452
 453 void VRMLFile::beginProto(const Char8 *szProtoname)
 454 {
 455     Inherited::beginProto(szProtoname);
 456
 457     _pCurrNodeHelper = Inherited::_pCurrentHelper;
 458 }
 459
 460 void VRMLFile::endProtoInterface(void)
 461 {
 462     Inherited::endProtoInterface();
 463 }
 464
 465 void VRMLFile::endProto(void)
 466 {
 467     Inherited::endProto();
 468
 469     if(_sNodeHelpers.size() != 0)
 470     {
 471         _pCurrNodeHelper = _sNodeHelpers.top();
 472     }
 473 }
 474
 475
 476 void VRMLFile::beginFieldDecl(const Char8  *szFieldType,
 477                               const UInt32  uiFieldTypeId,
 478                               const Char8  *szFieldName)
 479 {
 480     Inherited::beginFieldDecl(szFieldType, uiFieldTypeId, szFieldName);
 481
 482     getFieldType(szFieldName);
 483
 484     beginField(szFieldName, uiFieldTypeId);
 485 }
 486
 487 void VRMLFile::endFieldDecl(void)
 488 {
 489     Inherited::endFieldDecl();
 490
 491     endField();
 492 }
 493
 494
 495 UInt32 VRMLFile::getFieldType(const Char8 *szFieldname)
 496 {
 497     UInt32   returnValue = 0;
 498
 499     if(_pCurrNodeHelper == NULL)
 500         return returnValue;
 501
 502     if(szFieldname == NULL)
 503         return returnValue;
 504
 505     _pCurrentFieldFC   = NULL;
 506     _pCurrentField.reset();
 507     _pCurrentFieldDesc = NULL;
 508
 509     _pCurrNodeHelper->getFieldAndDesc(_pCurrentFC,
 510                                        szFieldname,
 511                                       _pCurrentFieldFC,
 512                                       _pCurrentField,
 513                                       _pCurrentFieldDesc);
 514
 515     if(_pCurrentFieldDesc != NULL)
 516         returnValue = _pCurrentFieldDesc->getFieldType().getId();
 517
 518 #ifdef OSG_DEBUG_VRML
 519     indentLog(VRMLNodeHelper::getIndent(), PINFO);
 520     PINFO << "VRMLFile::getFieldType : Got Field and type "
 521           << returnValue        << " "
 522           << _pCurrentField     << " "
 523           << _pCurrentFieldDesc << " ";
 524
 525     if(_pCurrentFieldDesc != NULL)
 526         PINFO << _pCurrentFieldDesc->getFieldType().getName() << std::endl;
 527     else
 528         PINFO << std::endl;
 529 #endif
 530
 531     return returnValue;
 532 }
 533
 534 void VRMLFile::use(const Char8 *szName)
 535 {
 536     SceneFileHandler::the()->updateReadProgress();
 537     Time beginUse = getSystemTime();
 538
 539     FieldContainerUnrecPtr pUsedFC;
 540
 541     // try to find a container with the given name attachment
 542
 543 #ifdef OSG_DEBUG_VRML
 544     indentLog(VRMLNodeHelper::getIndent(), PINFO);
 545     PINFO << "VRMLFile::use : looking for "
 546           << szName
 547           << std::endl;
 548
 549     VRMLNodeHelper::incIndent();
 550 #endif
 551
 552     pUsedFC = findReference(szName);
 553
 554     if(pUsedFC == NULL)
 555     {
 556         PWARNING << "No fieldContainer with name found to use"
 557                  << szName
 558                  << std::endl;
 559     }
 560     else
 561     {
 562         // assign nodepointer to current sf|mf field
 563
 564         if(_pCurrNodeHelper != NULL)
 565         {
 566             if(pUsedFC->getType().isNode())
 567             {
 568                 Node *pRootNode = dynamic_pointer_cast<Node>(pUsedFC);
 569
 570                 pUsedFC = cloneTree(pRootNode);
 571             }
 572
 573             _pCurrNodeHelper->setContainerFieldValue( pUsedFC,
 574                                                      _pCurrentFieldDesc,
 575                                                      _pCurrentFieldFC  );
 576         }
 577     }
 578
 579 #ifdef OSG_DEBUG_VRML
 580     VRMLNodeHelper::decIndent();
 581 #endif
 582
 583     useTime += (getSystemTime() - beginUse);
 584 }
 585
 586 void VRMLFile::addRoute(const Char8  *szOutNodename,
 587                         const Char8  *szOutFieldname,
 588                         const Char8  *szInNodename,
 589                         const Char8  *szInFieldname )
 590 {
 591     if(szOutNodename == NULL || szOutFieldname == NULL ||
 592        szInNodename  == NULL || szInFieldname  == NULL  )
 593     {
 594         FWARNING(("addRoute missing params\n"));
 595     }
 596
 597     FieldContainer *pSrcNode = findReference(szOutNodename);
 598     FieldContainer *pDstNode = findReference(szInNodename);
 599
 600     AttachmentContainer *pSrc = dynamic_cast<AttachmentContainer *>(pSrcNode);
 601     AttachmentContainer *pDst = dynamic_cast<AttachmentContainer *>(pDstNode);
 602
 603     if(pSrc == NULL)
 604     {
 605         FWARNING(("Unknow src node %s\n", szOutNodename));
 606         return;
 607     }
 608
 609     if(pDstNode == NULL)
 610     {
 611         FWARNING(("Unknow dst node %s\n", szInNodename));
 612         return;
 613     }
 614
 615     VRMLGenericAtt *pSrcAtt = dynamic_cast<VRMLGenericAtt *>(
 616         pSrc->findAttachment(VRMLGenericAtt::getClassType()));
 617
 618     VRMLGenericAtt *pDstAtt = NULL;
 619
 620     if(pDst != NULL)
 621     {
 622         pDstAtt = dynamic_cast<VRMLGenericAtt *>(
 623             pDst->findAttachment(VRMLGenericAtt::getClassType()));
 624     }
 625
 626     if(pSrcAtt == NULL)
 627     {
 628         Node *pNode = dynamic_cast<Node *>(pSrc);
 629
 630         if(pNode != NULL && pNode->getCore() != NULL)
 631         {
 632             pSrcAtt = dynamic_cast<VRMLGenericAtt *>(
 633                 pNode->getCore()->findAttachment(
 634                     VRMLGenericAtt::getClassType()));
 635         }
 636     }
 637
 638     if(pDstAtt == NULL)
 639     {
 640         Node *pNode = dynamic_cast<Node *>(pDst);
 641
 642         if(pNode != NULL && pNode->getCore() != NULL)
 643         {
 644             pDstAtt = dynamic_cast<VRMLGenericAtt *>(
 645                 pNode->getCore()->findAttachment(
 646                     VRMLGenericAtt::getClassType()));
 647         }
 648     }
 649
 650
 651     std::string szOutFName = szOutFieldname;
 652     std::string szInFName  = szInFieldname;
 653
 654
 655     std::string::size_type uiPos = szOutFName.rfind(std::string("_changed"));
 656
 657
 658     if(uiPos != std::string::npos)
 659     {
 660         szOutFName.erase(uiPos, std::string::npos);
 661     }
 662
 663     uiPos = szInFName.find(std::string("set_"));
 664
 665     if(uiPos != std::string::npos)
 666     {
 667         szInFName.erase(uiPos, uiPos + 4);
 668     }
 669
 670
 671     if(pSrcAtt != NULL)
 672     {
 673         VRMLNodeHelper *pHelper = findNodeHelper(
 674             pSrcAtt->getVrmlNodeTypename().c_str());
 675
 676         if(pHelper != NULL)
 677         {
 678             pHelper->mapFieldname(pSrcAtt->getVrmlNodeTypename(), szOutFName);
 679         }
 680     }
 681
 682     if(pSrcAtt != NULL)
 683     {
 684         VRMLNodeHelper *pHelper = findNodeHelper(
 685             pDstAtt->getVrmlNodeTypename().c_str());
 686
 687         if(pHelper != NULL)
 688         {
 689             pHelper->mapFieldname(pDstAtt->getVrmlNodeTypename(), szInFName);
 690         }
 691     }
 692
 693     addConnection(pSrc,     szOutFName.c_str(),
 694                   pDstNode, szInFName .c_str());
 695 }
 696
 697 /*-------------------------------------------------------------------------*/
 698 /*                          Helper                                         */
 699
 700 void VRMLFile::scanStandardPrototypes(const Char8  *szFilename)
 701 {
 702 #ifdef OSG_DEBUG_VRML
 703     VRMLNodeHelper::resetIndent();
 704 #endif
 705
 706     preStandardProtos();
 707     scanFile(szFilename);
 708     postStandardProtos();
 709 }
 710
 711 #if 0
 712 static Action::ResultE modifyMaterial(Node * const node)
 713 {
 714     MaterialGroup *mg = dynamic_cast<MaterialGroup *>(node->getCore());
 715
 716     if(mg == NULL)
 717         return Action::Continue;
 718
 719     ChunkMaterial *cmat = dynamic_cast<ChunkMaterial *>(mg->getMaterial());
 720
 721     if(cmat == NULL)
 722         return Action::Continue;
 723
 724     TextureObjChunk *texc =
 725         dynamic_cast<TextureObjChunk *>(
 726             cmat->find(TextureObjChunk::getClassType()));
 727
 728     if(texc == NULL)
 729         return Action::Continue;
 730
 731     MaterialChunk *matc =
 732         dynamic_cast<MaterialChunk *>(
 733             cmat->find(MaterialChunk::getClassType()));
 734
 735     TextureEnvChunkUnrecPtr texe =
 736         dynamic_cast<TextureEnvChunk *>(
 737             cmat->find(TextureEnvChunk::getClassType()));
 738
 739     if(texe == NULL)
 740     {
 741         texe = TextureEnvChunk::create();
 742         cmat->addChunk(texe);
 743     }
 744
 745     if(matc == NULL)
 746     {
 747         // no material chunk so we use the replace mode.
 748         texe->setEnvMode(GL_REPLACE);
 749         return Action::Continue;
 750     }
 751
 752     if(matc != NULL)
 753     {
 754         Image *img = texc->getImage();
 755
 756         texe->setEnvMode(GL_MODULATE);
 757
 758         if(img != NULL && img->getBpp() > 2)
 759         {
 760             // for color textures the texture replaces only the diffuse part.
 761             matc->setDiffuse(Color4f(1.0f, 1.0f, 1.0f, 1.0f));
 762         }
 763
 764
 765         // check for textures with alpha
 766         if(!matc->isTransparent()         &&
 767             img                   != NULL &&
 768             img->getBpp()         ==    4   )
 769         {
 770             BlendChunkUnrecPtr blendc =
 771                 dynamic_cast<BlendChunk *>(
 772                     cmat->find(BlendChunk::getClassType()));
 773
 774             if(blendc == NULL)
 775             {
 776                 blendc = OSG::BlendChunk::create();
 777
 778                 blendc->setSrcFactor (GL_SRC_ALPHA);
 779                 blendc->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
 780
 781                 cmat->addChunk(blendc);
 782             }
 783         }
 784     }
 785
 786     return Action::Continue;
 787 }
 788 #endif
 789
 790 /*-------------------------------------------------------------------------*/
 791 /*                           Member                                        */
 792
 793 void VRMLFile::initIntExtFieldTypeMapper(void)
 794 {
 795     Self::setIntExtMapping(SFBool::getClassType().getId(),
 796                            ScanParseSkel::OSGsfBool);
 797
 798     Self::setIntExtMapping(SFColor3f::getClassType().getId(),
 799                            ScanParseSkel::OSGsfColor);
 800
 801     Self::setIntExtMapping(SFReal32::getClassType().getId(),
 802                            ScanParseSkel::OSGsfFloat);
 803
 804     Self::setIntExtMapping(SFUnrecImagePtr::getClassType().getId(),
 805                            ScanParseSkel::OSGsfImage);
 806
 807     Self::setIntExtMapping(SFInt32::getClassType().getId(),
 808                            ScanParseSkel::OSGsfInt32);
 809
 810     Self::setIntExtMapping(SFGLenum::getClassType().getId(),
 811                            ScanParseSkel::OSGsfString);
 812
 813
 814     Self::setIntExtMapping(SFQuaternion::getClassType().getId(),
 815                            ScanParseSkel::OSGsfRotation);
 816
 817     Self::setIntExtMapping(SFString::getClassType().getId(),
 818                            ScanParseSkel::OSGsfString);
 819
 820     Self::setIntExtMapping(SFTime::getClassType().getId(),
 821                            ScanParseSkel::OSGsfTime);
 822
 823     Self::setIntExtMapping(SFVec2f::getClassType().getId(),
 824                            ScanParseSkel::OSGsfVec2f);
 825
 826     Self::setIntExtMapping(SFVec2s::getClassType().getId(),
 827                            ScanParseSkel::OSGsfVec2i);
 828
 829     Self::setIntExtMapping(SFVec3f::getClassType().getId(),
 830                            ScanParseSkel::OSGsfVec3f);
 831
 832
 833
 834     Self::setIntExtMapping(MFColor3f::getClassType().getId(),
 835                            ScanParseSkel::OSGmfColor);
 836
 837     Self::setIntExtMapping(MFReal32::getClassType().getId(),
 838                            ScanParseSkel::OSGmfFloat);
 839
 840     Self::setIntExtMapping(MFInt32::getClassType().getId(),
 841                            ScanParseSkel::OSGmfInt32);
 842
 843     Self::setIntExtMapping(MFGLenum::getClassType().getId(),
 844                            ScanParseSkel::OSGmfString);
 845
 846     Self::setIntExtMapping(MFQuaternion::getClassType().getId(),
 847                            ScanParseSkel::OSGmfRotation);
 848
 849     Self::setIntExtMapping(MFString::getClassType().getId(),
 850                            ScanParseSkel::OSGmfString);
 851
 852     Self::setIntExtMapping(MFTime::getClassType().getId(),
 853                            ScanParseSkel::OSGmfTime);
 854
 855     Self::setIntExtMapping(MFVec3f::getClassType().getId(),
 856                            ScanParseSkel::OSGmfVec3f);
 857
 858     Self::setIntExtMapping(MFVec2f::getClassType().getId(),
 859                            ScanParseSkel::OSGmfVec2f);
 860
 861
 862     Self::setIntExtMapping(SFUnrecFieldContainerPtr::getClassType().getId(),
 863                            ScanParseSkel::OSGsfNode);
 864
 865     Self::setIntExtMapping(MFUnrecFieldContainerPtr::getClassType().getId(),
 866                            ScanParseSkel::OSGmfNode);
 867
 868     Self::setIntExtMapping(SFUnrecNodePtr::getClassType().getId(),
 869                            ScanParseSkel::OSGsfNode);
 870
 871     Self::setIntExtMapping(MFUnrecChildNodePtr::getClassType().getId(),
 872                            ScanParseSkel::OSGmfNode);
 873
 874     /* To Base Type Mappings */
 875
 876     Self::setIntExtMapping(SFUInt8::getClassType().getId(),
 877                            ScanParseSkel::OSGsfInt32);
 878
 879     Self::setIntExtMapping(MFUInt8::getClassType().getId(),
 880                            ScanParseSkel::OSGmfInt32);
 881
 882     Self::setIntExtMapping(SFUInt32::getClassType().getId(),
 883                            ScanParseSkel::OSGsfInt32);
 884
 885     Self::setIntExtMapping(MFUInt32::getClassType().getId(),
 886                            ScanParseSkel::OSGmfInt32);
 887
 888     /* To Node Mappings */
 889
 890     Self::setIntExtMapping(SFUnrecNodeCorePtr::getClassType().getId(),
 891                            ScanParseSkel::OSGsfNode);
 892
 893     Self::setIntExtMapping(SFUnrecMaterialPtr::getClassType().getId(),
 894                            ScanParseSkel::OSGsfNode);
 895
 896     // AMZ
 897 #if 0
 898     Self::setIntExtMapping(SFGeoPTypesPtr::getClassType().getId(),
 899                            ScanParseSkel::OSGsfNode);
 900
 901     Self::setIntExtMapping(SFGeoIndicesPtr::getClassType().getId(),
 902                            ScanParseSkel::OSGsfNode);
 903
 904     Self::setIntExtMapping(SFGeoPLengthsPtr::getClassType().getId(),
 905                            ScanParseSkel::OSGsfNode);
 906
 907     Self::setIntExtMapping(SFGeoColorsPtr::getClassType().getId(),
 908                            ScanParseSkel::OSGsfNode);
 909
 910     Self::setIntExtMapping(SFGeoPositionsPtr::getClassType().getId(),
 911                            ScanParseSkel::OSGsfNode);
 912
 913     Self::setIntExtMapping(SFGeoNormalsPtr::getClassType().getId(),
 914                            ScanParseSkel::OSGsfNode);
 915
 916     Self::setIntExtMapping(SFGeoTexCoordsPtr::getClassType().getId(),
 917                            ScanParseSkel::OSGsfNode);
 918 #endif
 919     Self::setIntExtMapping(MFUnrecStateChunkPtr::getClassType().getId(),
 920                            ScanParseSkel::OSGmfNode);
 921
 922     //SFAttachmentMap
 923     Self::setIntExtMapping(SFAttachmentPtrMap::getClassType().getId(),
 924                            ScanParseSkel::OSGmfNode);
 925
 926     /* extended types */
 927
 928     Self::setIntExtMapping(SFMatrix::getClassType().getId(),
 929                            ScanParseSkel::OSGsfMatrix);
 930
 931     Self::setIntExtMapping(SFPnt3f::getClassType().getId(),
 932                            ScanParseSkel::OSGsfPnt3f);
 933
 934     Self::setIntExtMapping(MFPnt3f::getClassType().getId(),
 935                            ScanParseSkel::OSGmfPnt3f);
 936 }
 937
 938
 939 void VRMLFile::initExtIntFieldTypeMapper(void)
 940 {
 941     Self::setExtIntMapping(ScanParseSkel::OSGsfBool,
 942                            SFBool::getClassType().getId());
 943
 944     Self::setExtIntMapping(ScanParseSkel::OSGsfColor,
 945                            SFColor3f::getClassType().getId());
 946
 947     Self::setExtIntMapping(ScanParseSkel::OSGsfFloat,
 948                            SFReal32::getClassType().getId());
 949
 950 /*
 951     Self::setExtIntMapping(SFImage::getClassType().getId(),
 952                      ScanParseSkel::OSGsfInt32);
 953                      */
 954
 955     Self::setExtIntMapping(ScanParseSkel::OSGsfImage,
 956                            SFUnrecImagePtr::getClassType().getId());
 957
 958     Self::setExtIntMapping(ScanParseSkel::OSGsfInt32,
 959                            SFInt32::getClassType().getId());
 960
 961
 962     Self::setExtIntMapping(ScanParseSkel::OSGsfRotation,
 963                            SFQuaternion::getClassType().getId());
 964
 965     Self::setExtIntMapping(ScanParseSkel::OSGsfString,
 966                            SFString::getClassType().getId());
 967
 968     Self::setExtIntMapping(ScanParseSkel::OSGsfTime,
 969                            SFTime::getClassType().getId());
 970
 971     Self::setExtIntMapping(ScanParseSkel::OSGsfVec2f,
 972                            SFVec2f::getClassType().getId());
 973
 974     Self::setExtIntMapping(ScanParseSkel::OSGsfVec2i,
 975                            SFVec2s::getClassType().getId());
 976
 977     Self::setExtIntMapping(ScanParseSkel::OSGsfVec3f,
 978                            SFVec3f::getClassType().getId());
 979
 980
 981
 982     Self::setExtIntMapping(ScanParseSkel::OSGmfColor,
 983                            MFColor3f::getClassType().getId());
 984
 985     Self::setExtIntMapping(ScanParseSkel::OSGmfFloat,
 986                            MFReal32::getClassType().getId());
 987
 988     Self::setExtIntMapping(ScanParseSkel::OSGmfInt32,
 989                            MFInt32::getClassType().getId());
 990
 991     Self::setExtIntMapping(ScanParseSkel::OSGmfRotation,
 992                            MFQuaternion::getClassType().getId());
 993
 994     Self::setExtIntMapping(ScanParseSkel::OSGmfString,
 995                            MFString::getClassType().getId());
 996
 997     Self::setExtIntMapping(ScanParseSkel::OSGmfTime,
 998                            MFTime::getClassType().getId());
 999
1000
1001     Self::setExtIntMapping(ScanParseSkel::OSGmfVec3f,
1002                            MFVec3f::getClassType().getId());
1003
1004     Self::setExtIntMapping(ScanParseSkel::OSGmfVec2f,
1005                            MFVec2f::getClassType().getId());
1006
1007
1008     Self::setExtIntMapping(ScanParseSkel::OSGsfNode,
1009                            SFUnrecFieldContainerPtr::getClassType().getId());
1010
1011     Self::setExtIntMapping(ScanParseSkel::OSGmfNode,
1012                            MFUnrecFieldContainerPtr::getClassType().getId());
1013
1014
1015     /* extended types */
1016
1017     Self::setExtIntMapping(ScanParseSkel::OSGsfMatrix,
1018                            SFMatrix::getClassType().getId());
1019
1020     Self::setExtIntMapping(ScanParseSkel::OSGsfPnt3f,
1021                            SFPnt3f::getClassType().getId());
1022
1023     Self::setExtIntMapping(ScanParseSkel::OSGmfPnt3f,
1024                            MFPnt3f::getClassType().getId());
1025 }
1026
1027 /* remove this, if there is a general methode to find containers */
1028 FieldContainer *VRMLFile::findFCByName(const Char8 *szName,
1029                                              Node  *pNode)
1030 {
1031     MFUnrecNodePtr::const_iterator i;
1032
1033     FieldContainer *pFC       = NULL;
1034
1035 #if 0
1036     Name           *pNodename = NULL;
1037     NodeCore       *pCore     = NULL;
1038     // check if name matches nodename
1039
1040     pNodename =
1041         dynamic_cast<NamePtr>(
1042             pNode->findAttachment(Name::getClassType().getGroupId()));
1043
1044     if(pNodename != NullFC)
1045     {
1046         if(strcmp(szName, pNodename->getFieldPtr()->getValue().c_str())==0)
1047             return pNode;
1048     }
1049     // check if name matches corename
1050
1051     pCore = pNode->getCore();
1052
1053     if(pCore != NullFC)
1054     {
1055         pNodename = dynamic_cast<NamePtr>(
1056             pCore->findAttachment(Name::getClassType().getGroupId()));
1057
1058         if(pNodename != NullFC)
1059         {
1060             if(strcmp(szName, pNodename->getFieldPtr()->getValue().c_str())==0)
1061                 return pCore;
1062         }
1063     }
1064
1065     // matching for children
1066     for(i  = pNode->getMFChildren()->begin();
1067         i != pNode->getMFChildren()->end();
1068         i++)
1069     {
1070         pFC = findFCByName(szName, *i);
1071
1072         if(pFC != NullFC)
1073         {
1074             return pFC;
1075         }
1076     }
1077 #endif
1078
1079     return pFC;
1080 }
1081
1082 FieldContainer *VRMLFile::findReference(const Char8 *szName)
1083 {
1084     // search reference in this file
1085     FieldContainer            *returnValue = NULL;
1086
1087     std::string                szKey       = szName;
1088
1089     NameContainerMap::iterator mIt         = _nameFCMap.find(szKey);
1090
1091     if(mIt != _nameFCMap.end())
1092     {
1093         returnValue = mIt->second;
1094     }
1095     else
1096     {
1097         returnValue = findFCByName(szName, _pSceneRootNode);
1098     }
1099
1100     return returnValue;
1101 }
1102
1103
1104 #include "OSGVRMLProtos.inl"
1105
1106 OSG_END_NAMESPACE