OpenSG: OSGVRMLFile.cpp Source File

00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
00006  *                                                                           *
00007  *                            www.opensg.org                                 *
00008  *                                                                           *
00009  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
00010  *                                                                           *
00011 \*---------------------------------------------------------------------------*/
00012 /*---------------------------------------------------------------------------*\
00013  *                                License                                    *
00014  *                                                                           *
00015  * This library is free software; you can redistribute it and/or modify it   *
00016  * under the terms of the GNU Library General Public License as published    *
00017  * by the Free Software Foundation, version 2.                               *
00018  *                                                                           *
00019  * This library is distributed in the hope that it will be useful, but       *
00020  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
00022  * Library General Public License for more details.                          *
00023  *                                                                           *
00024  * You should have received a copy of the GNU Library General Public         *
00025  * License along with this library; if not, write to the Free Software       *
00026  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
00027  *                                                                           *
00028 \*---------------------------------------------------------------------------*/
00029 /*---------------------------------------------------------------------------*\
00030  *                                Changes                                    *
00031  *                                                                           *
00032  *                                                                           *
00033  *                                                                           *
00034  *                                                                           *
00035  *                                                                           *
00036  *                                                                           *
00037 \*---------------------------------------------------------------------------*/
00038 
00039 #define OSG_COMPILEVRMLLOADERINST
00040 
00041 #include <stdlib.h>
00042 #include <stdio.h>
00043 
00044 #include "OSGConfig.h"
00045 
00046 #include <iostream>
00047 
00048 #include "OSGVRMLFile.h"
00049 
00050 #include <OSGFieldType.h>
00051 
00052 #include <OSGSFSysTypes.h>
00053 #include <OSGMFSysTypes.h>
00054 
00055 #include <OSGSFBaseTypes.h>
00056 #include <OSGMFBaseTypes.h>
00057 
00058 #include <OSGSFMathTypes.h>
00059 #include <OSGMFMathTypes.h>
00060 
00061 #include <OSGSFVecTypes.h>
00062 #include <OSGMFVecTypes.h>
00063 
00064 #include <OSGMFFieldContainerTypes.h>
00065 #include <OSGSFFieldContainerTypes.h>
00066 
00067 #include <OSGImageFields.h>
00068 
00069 #include <OSGGeoProperty.h>
00070 #include <OSGTime.h>
00071 
00072 #include <OSGSimpleAttachments.h>
00073 
00074 #include <OSGChunkMaterial.h>
00075 #include <OSGMaterialChunk.h>
00076 #include <OSGMaterialGroup.h>
00077 #include <OSGTextureChunk.h>
00078 #include <OSGImage.h>
00079 
00080 #include <OSGSceneFileHandler.h>
00081 
00082 //#define OSG_DEBUG_VRML
00083 
00084 OSG_USING_NAMESPACE
00085 
00089 #ifndef __sgi
00090 template OSG_SYSTEMLIB_DLLMAPPING
00091 class ScanParseFieldTypeMapper<ScanParseSkel>;
00092 template OSG_SYSTEMLIB_DLLMAPPING
00093 class VRMLNodeFactory<ScanParseFieldTypeMapper<ScanParseSkel> >;
00094 #endif
00095 
00096 OSG::Time startTime = 0.;
00097 OSG::Time useTime   = 0.;
00098 OSG::Time findTime  = 0.;
00099 
00100 /*-------------------------------------------------------------------------*/
00101 /*                            Constructors                                 */
00102 
00103 VRMLFile::VRMLFile(void) :
00104     Inherited(),
00105 
00106 //    _pRootNode         (NullFC),
00107     _pSceneRootNode     (NullFC),
00108 
00109     _pLightRoot         (NullFC),
00110     _pCurrentGlobalLight(NullFC),
00111 
00112     _pCurrNodeDesc(NULL),
00113     _sNodeDescs   (),
00114 
00115     _pCurrentFC       (NullFC),
00116     _pCurrentField    (NULL),
00117     _pCurrentFieldDesc(NULL),
00118 
00119     _fcStack  (),
00120     _fStack   (),
00121     _fdStack  (),
00122 
00123     _bvChanged    (),
00124     _sChangedStack(),
00125 
00126     _nameFCMap  (),
00127     _nameDescMap()
00128 {
00129     Self::setReferenceHeader("#VRML V2.0 ");
00130 
00131     initIntExtFieldTypeMapper();
00132     initExtIntFieldTypeMapper();
00133 
00134     _bvChanged.first  = 0;
00135     _bvChanged.second = 0;
00136 }
00137 
00138 /*-------------------------------------------------------------------------*/
00139 /*                             Destructor                                  */
00140 
00141 VRMLFile::~VRMLFile(void)
00142 {
00143 }
00144 
00145 /*-------------------------------------------------------------------------*/
00146 /*                           Skel Replacements                             */
00147 
00148 void VRMLFile::scanStream(std::istream &is)
00149 {
00150     startTime = getSystemTime();
00151 
00152 //    _pRootNode           = NullFC;
00153     _pSceneRootNode      = NullFC;
00154     _pLightRoot          = NullFC;
00155     _pCurrentGlobalLight = NullFC;
00156 
00157     _nameFCMap.clear();
00158 
00159 #ifdef OSG_DEBUG_VRML
00160     VRMLNodeDesc::resetIndent();
00161 #endif
00162 
00163     if(is)
00164     {
00165         Inherited::scanStream(is);
00166     }
00167 
00168     SceneFileHandler::the().updateReadProgress(100);
00169 
00170     FINFO(("Full Time : %lf | Use Time %lf\n",
00171             getSystemTime() - startTime,
00172             useTime));
00173 }
00174 
00175 void VRMLFile::scanFile(const Char8 *szFilename)
00176 {
00177     startTime = getSystemTime();
00178 
00179 //    _pRootNode           = NullFC;
00180     _pSceneRootNode      = NullFC;
00181     _pLightRoot          = NullFC;
00182     _pCurrentGlobalLight = NullFC;
00183 
00184     _nameFCMap.clear();
00185 
00186 #ifdef OSG_DEBUG_VRML
00187     VRMLNodeDesc::resetIndent();
00188 #endif
00189 
00190     if(szFilename != NULL)
00191     {
00192         Inherited::scanFile(szFilename);
00193     }
00194 
00195     SceneFileHandler::the().updateReadProgress(100);
00196 
00197     FINFO(("Full Time : %lf | Use Time %lf\n",
00198             getSystemTime() - startTime,
00199             useTime));
00200 }
00201 
00202 void VRMLFile::handleError(const Char8 *szErrorText)
00203 {
00204     Inherited::handleError(szErrorText);
00205     // on an error we destroy the incomplete scene.
00206     if(_pSceneRootNode != NullFC)
00207     {
00208         subRefCP(_pSceneRootNode);
00209         _pSceneRootNode = NullFC;
00210     }
00211 }
00212 
00213 void VRMLFile::beginNode(const Char8 *szNodeTypename,
00214                          const Char8 *szNodename)
00215 {
00216     SceneFileHandler::the().updateReadProgress();
00217     FieldContainerPtr pNewNode;
00218 
00219     _pCurrNodeDesc = findNodeDesc(szNodeTypename);
00220 
00221     if(_pCurrNodeDesc == NULL)
00222         return;
00223 
00224     _sNodeDescs.push(_pCurrNodeDesc);
00225 
00226     _pCurrNodeDesc->reset();
00227 
00228     pNewNode = _pCurrNodeDesc->beginNode(szNodeTypename,
00229                                          szNodename,
00230                                          _pCurrentFC);
00231 
00232 #ifdef OSG_DEBUG_VRML
00233     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00234     PINFO << "Begin Node " << szNodeTypename << std::endl;
00235 
00236     VRMLNodeDesc::incIndent();
00237 #endif
00238 
00239     if(szNodename != NULL)
00240     {
00241         if(pNewNode != NullFC)
00242         {
00243             if(pNewNode->getType().isNode() == true)
00244             {
00245 #ifdef OSG_DEBUG_VRML
00246                 indentLog(VRMLNodeDesc::getIndent(), PINFO);
00247                 PINFO << "Node named : " << szNodename << std::endl;
00248 #endif
00249 
00250                 NodePtr pNode     = NodePtr::dcast(pNewNode);
00251                 NamePtr pNodename = Name::create();
00252 
00253                 beginEditCP(pNodename);
00254                 beginEditCP(pNode,Node::AttachmentsFieldMask);
00255 
00256                 pNodename->getFieldPtr()->getValue().assign(szNodename);
00257                 pNode->addAttachment(pNodename);
00258 
00259                 endEditCP(pNode,Node::AttachmentsFieldMask);
00260                 endEditCP(pNodename);
00261 
00262                 NameContainerMap::iterator mIt =
00263                     _nameFCMap.find(IDStringLink(szNodename));
00264 
00265                 // amz - I removed the map checks that's more spec conform.
00266                 // From the spec:
00267                 // If multiple nodes are given the same name,
00268                 // each USE statement refers to the closest node with the given name preceding it
00269                 // in either the VRML file or prototype definition.
00270                 
00271                 //if(mIt == _nameFCMap.end())
00272                 {
00273                     _nameFCMap[IDString(szNodename)] = pNewNode;
00274 
00275 #ifdef OSG_DEBUG_VRML
00276                     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00277                     PINFO << "Fieldcontainer " << szNodename
00278                           << " added to map " << std::endl;
00279 #endif
00280                 }
00281             }
00282             else if(pNewNode->getType().isNodeCore() == true)
00283             {
00284 #ifdef OSG_DEBUG_VRML
00285                 indentLog(VRMLNodeDesc::getIndent(), PINFO);
00286                 PINFO << "Nodecore named : " << szNodename << std::endl;
00287 #endif
00288                 NodeCorePtr pNodeCore = NodeCorePtr::dcast(pNewNode);
00289                 NamePtr     pNodename = Name::create();
00290 
00291                 beginEditCP(pNodename);
00292                 beginEditCP(pNodeCore,NodeCore::AttachmentsFieldMask);
00293 
00294                 pNodename->getFieldPtr()->getValue().assign(szNodename);
00295                 pNodeCore->addAttachment(pNodename);
00296 
00297                 endEditCP(pNodeCore,NodeCore::AttachmentsFieldMask);
00298                 endEditCP(pNodename);
00299 
00300                 NameContainerMap::iterator mIt =
00301                     _nameFCMap.find(IDStringLink(szNodename));
00302 
00303                 //if(mIt == _nameFCMap.end())
00304                 {
00305                     _nameFCMap[IDString(szNodename)] = pNewNode;
00306 
00307 #ifdef OSG_DEBUG_VRML
00308                     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00309                     PINFO << "Fieldcontainer " << szNodename
00310                           << " added to map " << std::endl;
00311 #endif
00312                 }
00313             }
00314             else
00315             {
00316                 // could be a material and material names a quite usefull ;-)
00317                 AttachmentContainerPtr pAC = AttachmentContainerPtr::dcast(pNewNode);
00318                 if(pAC != NullFC)
00319                 {
00320                     NamePtr pNodename = Name::create();
00321 
00322                     beginEditCP(pNodename);
00323                     beginEditCP(pAC, AttachmentContainer::AttachmentsFieldMask);
00324                         pNodename->getFieldPtr()->getValue().assign(szNodename);
00325                         pAC->addAttachment(pNodename);
00326                     endEditCP(pAC, AttachmentContainer::AttachmentsFieldMask);
00327                     endEditCP(pNodename);
00328                 }
00329 
00330 #ifdef OSG_DEBUG_VRML
00331                 indentLog(VRMLNodeDesc::getIndent(), PINFO);
00332                 PINFO << "Fieldcontainer " << szNodeTypename
00333                       << " is neither node nor nodecore " << std::endl;
00334 #endif
00335 
00336                 NameContainerMap::iterator mIt =
00337                     _nameFCMap.find(IDStringLink(szNodename));
00338 
00339                 //if(mIt == _nameFCMap.end())
00340                 {
00341                     _nameFCMap[IDString(szNodename)] = pNewNode;
00342 
00343 #ifdef OSG_DEBUG_VRML
00344                     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00345                     PINFO << "Fieldcontainer " << szNodename
00346                           << " added to map " << std::endl;
00347 #endif
00348                 }
00349 
00350             }
00351 
00352             _nameDescMap[IDString(szNodename)] = _pCurrNodeDesc;
00353 
00354 #ifdef OSG_DEBUG_VRML
00355             indentLog(VRMLNodeDesc::getIndent(), PINFO);
00356             PINFO << "Desc for "
00357                   << szNodename
00358                   << " added to map "
00359                   << std::endl;
00360 #endif
00361         }
00362         else
00363         {
00364 #ifdef OSG_DEBUG_VRML
00365             indentLog(VRMLNodeDesc::getIndent(), PINFO);
00366             PINFO << "Fieldcontainer "
00367                   << szNodeTypename
00368                   << "is empty, save on end "
00369                   << std::endl;
00370 #endif
00371 
00372             if(_pCurrNodeDesc != NULL)
00373                 _pCurrNodeDesc->setOnEndSave(szNodename);
00374 
00375             _nameDescMap[IDString(szNodename)] = _pCurrNodeDesc;
00376 
00377 #ifdef OSG_DEBUG_VRML
00378             indentLog(VRMLNodeDesc::getIndent(), PINFO);
00379             PINFO << "Desc for "
00380                   << szNodename
00381                   << " added to map "
00382                   << std::endl;
00383 #endif
00384         }
00385     }
00386 
00387     setContainerFieldValue(pNewNode);
00388 
00389     _pCurrentFC = pNewNode;
00390 
00391     _fcStack.push(_pCurrentFC);
00392 
00393     if(_fcStack.size() == 1)
00394     {
00395         NodePtr pNode = NodePtr::dcast(_pCurrentFC);
00396 
00397         if(_pSceneRootNode == NullFC)
00398         {
00399             GroupPtr pGroup = Group::create();
00400 
00401             _pSceneRootNode = Node::create();
00402 
00403             beginEditCP(_pSceneRootNode, Node::CoreFieldMask);
00404             {
00405                 _pSceneRootNode->setCore(pGroup);
00406             }
00407             endEditCP  (_pSceneRootNode, Node::CoreFieldMask);
00408         }
00409 
00410         beginEditCP(_pSceneRootNode, Node::ChildrenFieldMask);
00411         {
00412             _pSceneRootNode->addChild(pNode);
00413         }
00414         endEditCP  (_pSceneRootNode, Node::ChildrenFieldMask);
00415     }
00416 
00417     _sChangedStack.push(_bvChanged);
00418 
00419     _bvChanged.first  = 0;
00420     _bvChanged.second = 0;
00421 }
00422 
00423 void VRMLFile::endNode(void)
00424 {
00425     SceneFileHandler::the().updateReadProgress();
00426     if(_pCurrNodeDesc == NULL)
00427     {
00428 #ifdef OSG_DEBUG_VRML
00429         VRMLNodeDesc::decIndent();
00430 
00431         indentLog(VRMLNodeDesc::getIndent(), PINFO);
00432         PINFO << "End Node " << std::endl;
00433 #endif
00434         return;
00435     }
00436 
00437     _pCurrNodeDesc->endNode(_pCurrentFC);
00438 
00439     if(_pCurrNodeDesc->getOnEndSave() == true)
00440     {
00441         SLOG << "Fieldcontainer " <<  _pCurrNodeDesc->getSavename()
00442              << " on end Save " << std::endl;
00443 
00444         NameContainerMap::iterator mIt =
00445             _nameFCMap.find(IDStringLink(_pCurrNodeDesc->getSavename()));
00446 
00447         if(mIt == _nameFCMap.end())
00448         {
00449             _nameFCMap[IDString(_pCurrNodeDesc->getSavename())] =
00450                 _pCurrNodeDesc->getSaveFieldContainer();
00451 
00452             SLOG << "Fieldcontainer " << _pCurrNodeDesc->getSavename()
00453                  << " added to map " << std::endl;
00454         }
00455 
00456         _pCurrNodeDesc->clearOnEndSave();
00457     }
00458 
00459     _sNodeDescs.pop();
00460 
00461     if(_sNodeDescs.size() != 0)
00462     {
00463         _pCurrNodeDesc = _sNodeDescs.top();
00464     }
00465     else
00466     {
00467         _pCurrNodeDesc = NULL;
00468         _pCurrentField = NULL;
00469     }
00470 
00471     if(_pCurrentFC != NullFC)
00472     {
00473         if(_pCurrentFC->getType().isNode() == true)
00474         {
00475             NodePtr pNode = NodePtr::dcast(_pCurrentFC);
00476 
00477             if(pNode->getCore() == NullFC)
00478             {
00479                 GroupPtr pGroup = Group::create();
00480 
00481                 beginEditCP(pNode, Node::CoreFieldMask);
00482                 pNode->setCore(pGroup);
00483                 endEditCP(pNode, Node::CoreFieldMask);
00484             }
00485 
00486             endEditCP(pNode->getCore(),
00487                       _bvChanged.first,
00488                       ChangedOrigin::Abstract         |
00489                       ChangedOrigin::AbstrIgnoreCore  |
00490                       ChangedOrigin::AbstrIgnoreChild |
00491                       ChangedOrigin::AbstrCheckValid );
00492         }
00493 
00494         endEditCP(_pCurrentFC,
00495                    _bvChanged.first,
00496                    ChangedOrigin::Abstract         |
00497                    ChangedOrigin::AbstrIgnoreCore  |
00498                    ChangedOrigin::AbstrIgnoreChild |
00499                    ChangedOrigin::AbstrCheckValid );
00500     }
00501 
00502     _fcStack.pop();
00503 
00504     if(_fcStack.size() != 0)
00505     {
00506         _pCurrentFC = _fcStack.top();
00507     }
00508     else
00509     {
00510         _pCurrentFC = NullFC;
00511     }
00512 
00513     if(_sChangedStack.size() != 0)
00514     {
00515         _bvChanged = _sChangedStack.top();
00516     }
00517     else
00518     {
00519         _bvChanged.first  = 0;
00520         _bvChanged.second = 0;
00521     }
00522 
00523     _sChangedStack.pop();
00524 
00525 #ifdef OSG_DEBUG_VRML
00526     VRMLNodeDesc::decIndent();
00527 
00528     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00529     PINFO << "End Node " << std::endl;
00530 #endif
00531 }
00532 
00533 void VRMLFile::beginScript(const Char8 *szNodename)
00534 {
00535     beginNode("Script", szNodename);
00536 }
00537 
00538 void VRMLFile::endScript(void)
00539 {
00540     endNode();
00541 }
00542 
00543 void VRMLFile::beginField(const Char8  *szFieldname,
00544                           const UInt32  OSG_VRML_ARG(uiFieldTypeId))
00545 {
00546     if(szFieldname == NULL)
00547         return;
00548 
00549 #ifdef OSG_DEBUG_VRML
00550     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00551     PINFO << "VRMLFile::beginField : looking for "
00552           << szFieldname
00553           << " ("
00554           << uiFieldTypeId
00555           << " | "
00556           << _pCurrentField
00557           << " | "
00558           << _pCurrentFieldDesc
00559           << ")"
00560           << std::endl;
00561 
00562     VRMLNodeDesc::incIndent();
00563 #endif
00564 
00565     if(_pCurrentFieldDesc != NULL)
00566     {
00567         NodeCorePtr pCore;
00568         NodePtr     pNode;
00569 
00570         if(_pCurrentFC != NullFC)
00571         {
00572             beginEditCP(_pCurrentFC,
00573 //                         FieldBits::AllFields,
00574                         _pCurrentFieldDesc->getFieldMask(),
00575                          ChangedOrigin::Abstract         |
00576                          ChangedOrigin::AbstrIgnoreCore  |
00577                          ChangedOrigin::AbstrIgnoreChild |
00578                          ChangedOrigin::AbstrCheckValid  );
00579 
00580             if(_pCurrentFC->getType().isNode())
00581             {
00582                 pNode = NodePtr::dcast(_pCurrentFC);
00583 
00584                 pCore = pNode->getCore();
00585 
00586                 beginEditCP( pCore,
00587 //                            FieldBits::AllFields,
00588                             _pCurrentFieldDesc->getFieldMask(),
00589                              ChangedOrigin::Abstract         |
00590                              ChangedOrigin::AbstrIgnoreCore  |
00591                              ChangedOrigin::AbstrIgnoreChild |
00592                              ChangedOrigin::AbstrCheckValid);
00593             }
00594 
00595             _bvChanged.first |= _pCurrentFieldDesc->getFieldMask();
00596         }
00597     }
00598 
00599     _fStack.push (_pCurrentField);
00600     _fdStack.push(_pCurrentFieldDesc);
00601 }
00602 
00603 void VRMLFile::endField(void)
00604 {
00605     _fStack.pop();
00606 
00607     if(_fStack.size() != 0)
00608     {
00609         _pCurrentField = _fStack.top();
00610     }
00611     else
00612     {
00613         _pCurrentField = NULL;
00614     }
00615 
00616 
00617     if(_pCurrentFieldDesc != NULL)
00618     {
00619         NodeCorePtr pCore;
00620         NodePtr     pNode;
00621 
00622         if(_pCurrentFC != NullFC)
00623         {
00624 #if 0
00625             endEditCP(_pCurrentFC,
00626 //                       FieldBits::AllFields,
00627                       _pCurrentFieldDesc->getFieldMask(),
00628                        ChangedOrigin::Abstract         |
00629                        ChangedOrigin::AbstrIgnoreCore  |
00630                        ChangedOrigin::AbstrIgnoreChild |
00631                        ChangedOrigin::AbstrCheckValid  );
00632 #endif
00633 
00634             if(_pCurrentFC->getType().isNode())
00635             {
00636                 pNode = NodePtr::dcast(_pCurrentFC);
00637 
00638                 pCore = pNode->getCore();
00639 
00640 #if 0
00641                 endEditCP( pCore,
00642 //                           FieldBits::AllFields,
00643                           _pCurrentFieldDesc->getFieldMask(),
00644                            ChangedOrigin::Abstract         |
00645                            ChangedOrigin::AbstrIgnoreCore  |
00646                            ChangedOrigin::AbstrIgnoreChild |
00647                            ChangedOrigin::AbstrCheckValid  );
00648 #endif
00649             }
00650         }
00651     }
00652 
00653     _fdStack.pop();
00654 
00655     if(_fdStack.size() != 0)
00656     {
00657         _pCurrentFieldDesc = _fdStack.top();
00658     }
00659     else
00660     {
00661         _pCurrentFieldDesc = NULL;
00662     }
00663 
00664 #ifdef OSG_DEBUG_VRML
00665     VRMLNodeDesc::decIndent();
00666 
00667     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00668     PINFO << "VRMLFile::endField " << std::endl;
00669 #endif
00670 }
00671 
00672 
00673 void VRMLFile::addFieldValue(const Char8 *szFieldVal)
00674 {
00675     Inherited::addFieldValue(szFieldVal);
00676 
00677     if(_pCurrNodeDesc != NULL)
00678     {
00679         _pCurrNodeDesc->addFieldValue(_pCurrentField, szFieldVal);
00680     }
00681 }
00682 
00683 void VRMLFile::beginFieldDecl(const Char8  *szFieldType,
00684                               const UInt32  uiFieldTypeId,
00685                               const Char8  *szFieldName)
00686 {
00687     Inherited::beginFieldDecl(szFieldType, uiFieldTypeId, szFieldName);
00688 
00689 
00690     if(_pCurrNodeDesc == 0)
00691         return;
00692 
00693     if(szFieldName == NULL)
00694         return;
00695 
00696     _pCurrentField     = NULL;
00697     _pCurrentFieldDesc = NULL;
00698 
00699     _pCurrNodeDesc->getFieldAndDesc(_pCurrentFC,
00700                                      szFieldName,
00701                                     _pCurrentField,
00702                                     _pCurrentFieldDesc);
00703 }
00704 
00705 
00706 UInt32 VRMLFile::getFieldType(const Char8 *szFieldname)
00707 {
00708     UInt32   returnValue = 0;
00709 
00710     if(_pCurrNodeDesc == 0)
00711         return returnValue;
00712 
00713     if(szFieldname == NULL)
00714         return returnValue;
00715 
00716     _pCurrentField     = NULL;
00717     _pCurrentFieldDesc = NULL;
00718 
00719     _pCurrNodeDesc->getFieldAndDesc(_pCurrentFC,
00720                                      szFieldname,
00721                                     _pCurrentField,
00722                                     _pCurrentFieldDesc);
00723 
00724     if(_pCurrentField != NULL)
00725         returnValue = _pCurrentField->getType().getId();
00726 
00727 #ifdef OSG_DEBUG_VRML
00728     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00729     PINFO << "VRMLFile::getFieldType : Got Field and type "
00730           << returnValue        << " "
00731           << _pCurrentField     << " "
00732           << _pCurrentFieldDesc << " ";
00733 
00734     if(_pCurrentField != NULL)
00735         PINFO << _pCurrentField->getType().getName() << std::endl;
00736     else
00737         PINFO << std::endl;
00738 #endif
00739 
00740     return returnValue;
00741 }
00742 
00743 void VRMLFile::use(const Char8 *szName)
00744 {
00745     SceneFileHandler::the().updateReadProgress();
00746     Time beginUse = getSystemTime();
00747 
00748     FieldContainerPtr pUsedFC;
00749 
00750     // try to find a container with the given name attachment
00751 
00752 #ifdef OSG_DEBUG_VRML
00753     indentLog(VRMLNodeDesc::getIndent(), PINFO);
00754     PINFO << "VRMLFile::use : looking for "
00755           << szName
00756           << std::endl;
00757 
00758     VRMLNodeDesc::incIndent();
00759 #endif
00760 
00761 
00762 
00763     pUsedFC = findReference(szName);
00764 
00765     if(pUsedFC == NullFC)
00766     {
00767         PWARNING << "No fieldContainer with name found to use"
00768                  << szName
00769                  << std::endl;
00770     }
00771     else
00772     {
00773         // assign nodepointer to current sf|mf field
00774 
00775         VRMLNodeDesc *pDesc = NULL;
00776 
00777         NameDescriptionMap::iterator mIt         =
00778             _nameDescMap.find(IDStringLink(szName));
00779 
00780         if(mIt != _nameDescMap.end())
00781         {
00782             pDesc = mIt->second;
00783         }
00784 
00785         if(pUsedFC->getType().isNode())
00786         {
00787             NodePtr pRootNode = NodePtr::dcast(pUsedFC);
00788 
00789             pUsedFC = cloneTree(pRootNode);
00790         }
00791 
00792         if(pDesc != NULL)
00793         {
00794             if(pDesc->use(pUsedFC) == false)
00795             {
00796                 setContainerFieldValue(pUsedFC);
00797             }
00798         }
00799         else
00800         {
00801             setContainerFieldValue(pUsedFC);
00802         }
00803     }
00804 
00805 #ifdef OSG_DEBUG_VRML
00806     VRMLNodeDesc::decIndent();
00807 #endif
00808 
00809     useTime += (getSystemTime() - beginUse);
00810 }
00811 
00812 /*-------------------------------------------------------------------------*/
00813 /*                          Helper                                         */
00814 
00815 void VRMLFile::scanStandardPrototypes(const Char8  *szFilename)
00816 {
00817 #ifdef OSG_DEBUG_VRML
00818     VRMLNodeDesc::resetIndent();
00819 #endif
00820 
00821     preStandardProtos();
00822     scanFile(szFilename);
00823     postStandardProtos();
00824 
00825 //    dumpTable();
00826 }
00827 
00828 void VRMLFile::createStandardPrototypes(void)
00829 {
00830 #ifdef OSG_DEBUG_VRML
00831     VRMLNodeDesc::resetIndent();
00832 #endif
00833 
00834     preStandardProtos();
00835 
00836 #if 0
00837 PROTO Anchor [
00838     eventIn      MFNode   addChildren
00839     eventIn      MFNode   removeChildren
00840     exposedField MFNode   children        []
00841     exposedField SFString description     ""
00842     exposedField MFString parameter       []
00843     exposedField MFString url             []
00844     field        SFVec3f  bboxCenter      0 0 0
00845     field        SFVec3f  bboxSize        -1 -1 -1
00846     ] { }
00847 #endif
00848 
00849  beginProto   ("Anchor");
00850  {
00851      beginEventInDecl     ("MFNode", Self::OSGmfNode, "addChildren");
00852      endEventDecl         ();
00853 
00854      beginEventInDecl     ("MFNode", Self::OSGmfNode, "removeChildren");
00855      endEventDecl         ();
00856 
00857      beginExposedFieldDecl("MFNode",   Self::OSGmfNode,   "children");
00858      endExposedFieldDecl  ();
00859 
00860      beginExposedFieldDecl("SFString", Self::OSGsfString, "description");
00861      endExposedFieldDecl  ();
00862 
00863      beginExposedFieldDecl("MFString", Self::OSGmfString, "parameter");
00864      endExposedFieldDecl  ();
00865 
00866      beginExposedFieldDecl("MFString", Self::OSGmfString, "url");
00867      endExposedFieldDecl  ();
00868 
00869      beginFieldDecl       ("SFVec3f",  Self::OSGsfVec3f, "bboxCenter");
00870      addFieldValue        ("0 0 0");
00871      endFieldDecl         ();
00872 
00873      beginFieldDecl       ("SFVec3f",  Self::OSGsfVec3f, "bboxSize");
00874      addFieldValue        ("-1 -1 -1");
00875      endFieldDecl         ();
00876  }
00877  endProto     ();
00878 
00879 
00880 #if 0
00881 PROTO Appearance [
00882   exposedField SFNode material          NULL
00883   exposedField SFNode texture           NULL
00884   exposedField SFNode textureTransform  NULL
00885 ] { }
00886 #endif
00887 
00888  beginProto("Appearance");
00889  {
00890      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "material");
00891 //     addFieldValue         ("NULL");
00892      endExposedFieldDecl  ();
00893 
00894      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "texture");
00895 //     addFieldValue         ("NULL");
00896      endExposedFieldDecl  ();
00897 
00898      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "textureTransform");
00899 //     addFieldValue         ("NULL");
00900      endExposedFieldDecl  ();
00901  }
00902  endProto  ();
00903 
00904 #if 0
00905 PROTO AudioClip [
00906   exposedField   SFString description  ""
00907   exposedField   SFBool   loop         FALSE
00908   exposedField   SFFloat  pitch        1.0
00909   exposedField   SFTime   startTime    0
00910   exposedField   SFTime   stopTime     0
00911   exposedField   MFString url          []
00912   eventOut       SFTime   duration_changed
00913   eventOut       SFBool   isActive
00914 ] { }
00915 #endif
00916 
00917  beginProto("AudioClip");
00918  {
00919      beginExposedFieldDecl("SFString", Self::OSGsfString, "description");
00920      addFieldValue        ("");
00921      endExposedFieldDecl  ();
00922 
00923      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "loop");
00924      addFieldValue        ("FALSE");
00925      endExposedFieldDecl  ();
00926 
00927      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "pitch");
00928      addFieldValue        ("1.0");
00929      endExposedFieldDecl  ();
00930 
00931      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "startTime");
00932      addFieldValue        ("0");
00933      endExposedFieldDecl  ();
00934 
00935      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "stopTime");
00936      addFieldValue        ("0");
00937      endExposedFieldDecl  ();
00938 
00939      beginExposedFieldDecl("MFString", Self::OSGmfString, "url");
00940      endExposedFieldDecl  ();
00941 
00942      beginEventOutDecl      ("SFTime", Self::OSGsfTime, "duration_changed");
00943      endEventDecl           ();
00944 
00945      beginEventOutDecl      ("SFBool", Self::OSGsfBool, "isActive");
00946      endEventDecl           ();
00947  }
00948  endProto  ();
00949 
00950 #if 0
00951 PROTO Background [
00952   eventIn      SFBool   set_bind
00953   exposedField MFFloat  groundAngle  []
00954   exposedField MFColor  groundColor  []
00955   exposedField MFString backUrl      []
00956   exposedField MFString bottomUrl    []
00957   exposedField MFString frontUrl     []
00958   exposedField MFString leftUrl      []
00959   exposedField MFString rightUrl     []
00960   exposedField MFString topUrl       []
00961   exposedField MFFloat  skyAngle     []
00962   exposedField MFColor  skyColor     [ 0 0 0  ]
00963   eventOut     SFBool   isBound
00964 ] { }
00965 #endif
00966 
00967  beginProto("Background");
00968  {
00969      beginEventInDecl       ("SFBool", Self::OSGsfBool, "set_bind");
00970      endEventDecl           ();
00971 
00972      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "groundAngle");
00973      endExposedFieldDecl  ();
00974 
00975      beginExposedFieldDecl("MFColor", Self::OSGmfColor, "groundColor");
00976      endExposedFieldDecl  ();
00977 
00978      beginExposedFieldDecl("MFString", Self::OSGmfString, "backUrl");
00979      endExposedFieldDecl  ();
00980 
00981      beginExposedFieldDecl("MFString", Self::OSGmfString, "bottomUrl");
00982      endExposedFieldDecl  ();
00983 
00984      beginExposedFieldDecl("MFString", Self::OSGmfString, "frontUrl");
00985      endExposedFieldDecl  ();
00986 
00987      beginExposedFieldDecl("MFString", Self::OSGmfString, "leftUrl");
00988      endExposedFieldDecl  ();
00989 
00990      beginExposedFieldDecl("MFString", Self::OSGmfString, "rightUrl");
00991      endExposedFieldDecl  ();
00992 
00993      beginExposedFieldDecl("MFString", Self::OSGmfString, "topUrl");
00994      endExposedFieldDecl  ();
00995 
00996      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "skyAngle");
00997      endExposedFieldDecl  ();
00998 
00999      beginExposedFieldDecl("MFColor", Self::OSGmfColor, "skyColor");
01000      addFieldValue        ("0 0 0");
01001      endExposedFieldDecl  ();
01002 
01003      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isBound");
01004      endEventDecl         ();
01005  }
01006  endProto  ();
01007 
01008 
01009 #if 0
01010 PROTO Billboard [
01011   eventIn      MFNode   addChildren
01012   eventIn      MFNode   removeChildren
01013   exposedField SFVec3f  axisOfRotation  0 1 0
01014   exposedField MFNode   children        []
01015   field        SFVec3f  bboxCenter      0 0 0
01016   field        SFVec3f  bboxSize        -1 -1 -1
01017 ] { }
01018 #endif
01019 
01020  beginProto("Billboard");
01021  {
01022      beginEventInDecl     ("MFNode", Self::OSGmfNode, "addChildren");
01023      endEventDecl         ();
01024 
01025      beginEventInDecl     ("MFNode", Self::OSGmfNode, "removeChildren");
01026      endEventDecl         ();
01027 
01028      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "axisOfRotation");
01029      addFieldValue        ("0 1 0");
01030      endExposedFieldDecl  ();
01031 
01032      beginExposedFieldDecl("MFNode", Self::OSGmfNode, "children");
01033      endExposedFieldDecl  ();
01034 
01035      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxCenter");
01036      addFieldValue        ("0 0 0");
01037      endFieldDecl         ();
01038 
01039      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxSize");
01040      addFieldValue        ("-1 -1 -1");
01041      endFieldDecl         ();
01042  }
01043  endProto  ();
01044 
01045 #if 0
01046 PROTO Box [
01047   field    SFVec3f size  2 2 2
01048 ] { }
01049 #endif
01050 
01051  beginProto("Box");
01052  {
01053      beginFieldDecl("SFVec3f", Self::OSGsfVec3f, "size");
01054      addFieldValue ("2 2 2");
01055      endFieldDecl  ();
01056  }
01057  endProto  ();
01058 
01059 #if 0
01060 PROTO Collision [
01061   eventIn      MFNode   addChildren
01062   eventIn      MFNode   removeChildren
01063   exposedField MFNode   children        []
01064   exposedField SFBool   collide         TRUE
01065   field        SFVec3f  bboxCenter      0 0 0
01066   field        SFVec3f  bboxSize        -1 -1 -1
01067   field        SFNode   proxy           NULL
01068   eventOut     SFTime   collideTime
01069 ] { }
01070 #endif
01071 
01072  beginProto("Collision");
01073  {
01074      beginEventInDecl      ("MFNode", Self::OSGmfNode, "addChildren");
01075      endEventDecl          ();
01076 
01077      beginEventInDecl      ("MFNode", Self::OSGmfNode, "removeChildren");
01078      endEventDecl          ();
01079 
01080      beginExposedFieldDecl("MFNode", Self::OSGmfNode, "children");
01081      endExposedFieldDecl  ();
01082 
01083      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "collide");
01084      addFieldValue        ("TRUE");
01085      endExposedFieldDecl  ();
01086 
01087      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxCenter");
01088      addFieldValue        ("0 0 0");
01089      endFieldDecl         ();
01090 
01091      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxSize");
01092      addFieldValue        ("-1 -1 -1");
01093      endFieldDecl         ();
01094 
01095      beginFieldDecl       ("SFNode", Self::OSGsfNode, "proxy");
01096      endFieldDecl         ();
01097 
01098      beginEventOutDecl      ("SFTime", OSGsfTime, "collideTime");
01099      endEventDecl           ();
01100  }
01101  endProto  ();
01102 
01103 #if 0
01104 PROTO Color [
01105   exposedField MFColor color     []
01106 ] { }
01107 #endif
01108 
01109  beginProto("Color");
01110  {
01111      beginExposedFieldDecl("MFColor", Self::OSGmfColor, "color");
01112      endExposedFieldDecl  ();
01113  }
01114  endProto  ();
01115 
01116 #if 0
01117 PROTO ColorInterpolator [
01118   eventIn      SFFloat set_fraction
01119   exposedField MFFloat key       []
01120   exposedField MFColor keyValue  []
01121   eventOut     SFColor value_changed
01122 ] { }
01123 #endif
01124 
01125  beginProto("ColorInterpolator");
01126  {
01127      beginEventInDecl     ("SFFloat", OSGsfFloat, "set_fraction");
01128      endEventDecl         ();
01129 
01130      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "key");
01131      endExposedFieldDecl  ();
01132 
01133      beginExposedFieldDecl("MFColor", Self::OSGmfColor, "keyValue");
01134      endExposedFieldDecl  ();
01135 
01136      beginEventOutDecl    ("SFColor", Self::OSGsfColor, "value_changed");
01137      endEventDecl         ();
01138  }
01139  endProto  ();
01140 
01141 #if 0
01142 PROTO Cone [
01143   field     SFFloat   bottomRadius 1
01144   field     SFFloat   height       2
01145   field     SFBool    side         TRUE
01146   field     SFBool    bottom       TRUE
01147 ] { }
01148 #endif
01149 
01150  beginProto("Cone");
01151  {
01152      beginFieldDecl("SFFloat", Self::OSGsfFloat, "bottomRadius");
01153      addFieldValue ("1");
01154      endFieldDecl  ();
01155 
01156      beginFieldDecl("SFFloat", Self::OSGsfFloat, "height");
01157      addFieldValue ("2");
01158      endFieldDecl  ();
01159 
01160      beginFieldDecl("SFBool", Self::OSGsfBool, "side");
01161      addFieldValue ("TRUE");
01162      endFieldDecl  ();
01163 
01164      beginFieldDecl("SFBool", Self::OSGsfBool, "bottom");
01165      addFieldValue ("TRUE");
01166      endFieldDecl  ();
01167  }
01168  endProto  ();
01169 
01170 #if 0
01171 PROTO Coordinate [
01172   exposedField MFVec3f point  []
01173 ] { }
01174 #endif
01175 
01176  beginProto("Coordinate");
01177  {
01178      beginExposedFieldDecl("MFVec3f", Self::OSGmfVec3f, "point");
01179      endExposedFieldDecl  ();
01180  }
01181  endProto  ();
01182 
01183 #if 0
01184 PROTO CoordinateInterpolator [
01185   eventIn      SFFloat set_fraction
01186   exposedField MFFloat key       []
01187   exposedField MFVec3f keyValue  []
01188   eventOut     MFVec3f value_changed
01189 ] { }
01190 #endif
01191 
01192  beginProto("CoordinateInterpolator");
01193  {
01194      beginEventInDecl     ("SFFloat", Self::OSGsfFloat, "set_fraction");
01195      endEventDecl         ();
01196 
01197      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "key");
01198      endExposedFieldDecl  ();
01199 
01200      beginExposedFieldDecl("MFVec3f", Self::OSGmfVec3f, "keyValue");
01201      endExposedFieldDecl  ();
01202 
01203      beginEventOutDecl    ("MFVec3f", Self::OSGmfVec3f, "value_changed");
01204      endEventDecl         ();
01205  }
01206  endProto  ();
01207 
01208 #if 0
01209 PROTO Cylinder [
01210   field    SFBool    bottom  TRUE
01211   field    SFFloat   height  2
01212   field    SFFloat   radius  1
01213   field    SFBool    side    TRUE
01214   field    SFBool    top     TRUE
01215 ] { }
01216 #endif
01217 
01218  beginProto("Cylinder");
01219  {
01220      beginFieldDecl("SFBool", Self::OSGsfBool, "bottom");
01221      addFieldValue ("TRUE");
01222      endFieldDecl  ();
01223 
01224      beginFieldDecl("SFFloat", Self::OSGsfFloat, "height");
01225      addFieldValue ("2");
01226      endFieldDecl  ();
01227 
01228      beginFieldDecl("SFFloat", Self::OSGsfFloat, "radius");
01229      addFieldValue ("1");
01230      endFieldDecl  ();
01231 
01232      beginFieldDecl("SFBool", Self::OSGsfBool, "side");
01233      addFieldValue ("TRUE");
01234      endFieldDecl  ();
01235 
01236      beginFieldDecl("SFBool", Self::OSGsfBool, "top");
01237      addFieldValue ("TRUE");
01238      endFieldDecl  ();
01239  }
01240  endProto  ();
01241 
01242 #if 0
01243 PROTO CylinderSensor [
01244   exposedField SFBool     autoOffset TRUE
01245   exposedField SFFloat    diskAngle  0.262
01246   exposedField SFBool     enabled    TRUE
01247   exposedField SFFloat    maxAngle   -1
01248   exposedField SFFloat    minAngle   0
01249   exposedField SFFloat    offset     0
01250   eventOut     SFBool     isActive
01251   eventOut     SFRotation rotation_changed
01252   eventOut     SFVec3f    trackPoint_changed
01253 ] { }
01254 #endif
01255 
01256  beginProto("CylinderSensor");
01257  {
01258      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "autoOffset");
01259      addFieldValue        ("TRUE");
01260      endExposedFieldDecl  ();
01261 
01262      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "diskAngle");
01263      addFieldValue        ("0.262");
01264      endExposedFieldDecl  ();
01265 
01266      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
01267      addFieldValue        ("TRUE");
01268      endExposedFieldDecl  ();
01269 
01270      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "maxAngle");
01271      addFieldValue        ("-1");
01272      endExposedFieldDecl  ();
01273 
01274      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "minAngle");
01275      addFieldValue        ("0");
01276      endExposedFieldDecl  ();
01277 
01278      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "offset");
01279      addFieldValue        ("0");
01280      endExposedFieldDecl  ();
01281 
01282      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive");
01283      endEventDecl         ();
01284 
01285      beginEventOutDecl    ("SFRotation",
01286                            Self::OSGsfRotation,
01287                            "rotation_changed");
01288      endEventDecl         ();
01289 
01290      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "trackPoint_changed");
01291      endEventDecl         ();
01292  }
01293  endProto  ();
01294 
01295 #if 0
01296 PROTO DirectionalLight [
01297   exposedField SFFloat ambientIntensity  0
01298   exposedField SFColor color             1 1 1
01299   exposedField SFVec3f direction         0 0 -1
01300   exposedField SFFloat intensity         1
01301   exposedField SFBool  on                TRUE
01302 ] { }
01303 #endif
01304 
01305  beginProto("DirectionalLight");
01306  {
01307      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "ambientIntensity");
01308      addFieldValue        ("0");
01309      endExposedFieldDecl  ();
01310 
01311      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "color");
01312      addFieldValue        ("1 1 1");
01313      endExposedFieldDecl  ();
01314 
01315      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "direction");
01316      addFieldValue        ("0 0 -1");
01317      endExposedFieldDecl  ();
01318 
01319      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "intensity");
01320      addFieldValue        ("1");
01321      endExposedFieldDecl  ();
01322 
01323      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "on");
01324      addFieldValue        ("TRUE");
01325      endExposedFieldDecl  ();
01326  }
01327  endProto  ();
01328 
01329 #if 0
01330 PROTO ElevationGrid [
01331   eventIn      MFFloat  set_height
01332   exposedField SFNode   color             NULL
01333   exposedField SFNode   normal            NULL
01334   exposedField SFNode   texCoord          NULL
01335   field        SFBool   ccw               TRUE
01336   field        SFBool   colorPerVertex    TRUE
01337   field        SFFloat  creaseAngle       0
01338   field        MFFloat  height            []
01339   field        SFBool   normalPerVertex   TRUE
01340   field        SFBool   solid             TRUE
01341   field        SFInt32  xDimension        0
01342   field        SFFloat  xSpacing          0.0
01343   field        SFInt32  zDimension        0
01344   field        SFFloat  zSpacing          0.0
01345 
01346 ] { }
01347 #endif
01348 
01349  beginProto("ElevationGrid");
01350  {
01351      beginEventInDecl     ("MFFloat", Self::OSGmfFloat, "set_height");
01352      endEventDecl         ();
01353 
01354      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "color");
01355 //     addFieldValue        ("NULL");
01356      endExposedFieldDecl  ();
01357 
01358      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "normal");
01359 //     addFieldValue        ("NULL");
01360      endExposedFieldDecl  ();
01361 
01362      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "texCoord");
01363 //     addFieldValue        ("NULL");
01364      endExposedFieldDecl  ();
01365 
01366      beginFieldDecl       ("SFBool", Self::OSGsfBool, "ccw");
01367      addFieldValue        ("TRUE");
01368      endFieldDecl         ();
01369 
01370      beginFieldDecl       ("SFBool", Self::OSGsfBool, "colorPerVertex");
01371      addFieldValue        ("TRUE");
01372      endFieldDecl         ();
01373 
01374      beginFieldDecl       ("SFFloat", Self::OSGsfFloat, "creaseAngle");
01375      addFieldValue        ("0");
01376      endFieldDecl         ();
01377 
01378      beginFieldDecl       ("MFFloat", Self::OSGmfFloat, "height");
01379      endFieldDecl         ();
01380 
01381      beginFieldDecl       ("SFBool", Self::OSGsfBool, "normalPerVertex");
01382      addFieldValue        ("TRUE");
01383      endFieldDecl         ();
01384 
01385      beginFieldDecl       ("SFBool", Self::OSGsfBool, "solid");
01386      addFieldValue        ("TRUE");
01387      endFieldDecl         ();
01388 
01389      beginFieldDecl       ("SFInt32", Self::OSGsfInt32, "xDimension");
01390      addFieldValue        ("0");
01391      endFieldDecl         ();
01392 
01393      beginFieldDecl       ("SFFloat", Self::OSGsfFloat, "xSpacing");
01394      addFieldValue        ("0.0");
01395      endFieldDecl         ();
01396 
01397      beginFieldDecl       ("SFInt32", Self::OSGsfInt32, "zDimension");
01398      addFieldValue        ("0");
01399      endFieldDecl         ();
01400 
01401      beginFieldDecl       ("SFFloat", Self::OSGsfFloat, "zSpacing");
01402      addFieldValue        ("0.0");
01403      endFieldDecl         ();
01404  }
01405  endProto  ();
01406 
01407 #if 0
01408 PROTO Extrusion [
01409   eventIn MFVec2f    set_crossSection
01410   eventIn MFRotation set_orientation
01411   eventIn MFVec2f    set_scale
01412   eventIn MFVec3f    set_spine
01413   field   SFBool     beginCap         TRUE
01414   field   SFBool     ccw              TRUE
01415   field   SFBool     convex           TRUE
01416   field   SFFloat    creaseAngle      0
01417   field   MFVec2f    crossSection     [ 1 1, 1 -1, -1 -1, -1 1, 1 1 ]
01418   field   SFBool     endCap           TRUE
01419   field   MFRotation orientation      0 0 1 0
01420   field   MFVec2f    scale            1 1
01421   field   SFBool     solid            TRUE
01422   field   MFVec3f    spine            [ 0 0 0, 0 1 0 ]
01423 ] { }
01424 #endif
01425 
01426  beginProto("Extrusion");
01427  {
01428      beginEventInDecl("MFVec2f", Self::OSGmfVec2f, "set_crossSection");
01429      endEventDecl    ();
01430      beginEventInDecl("MFRotation", Self::OSGmfRotation, "set_orientation");
01431      endEventDecl    ();
01432 
01433      beginEventInDecl("MFVec2f", Self::OSGmfVec2f, "set_scale");
01434      endEventDecl    ();
01435 
01436      beginEventInDecl("MFVec3f", Self::OSGmfVec3f, "set_spine");
01437      endEventDecl    ();
01438 
01439      beginFieldDecl("SFBool", Self::OSGsfBool, "beginCap");
01440      addFieldValue ("TRUE");
01441      endFieldDecl  ();
01442 
01443      beginFieldDecl("SFBool", Self::OSGsfBool, "ccw");
01444      addFieldValue ("TRUE");
01445      endFieldDecl  ();
01446 
01447      beginFieldDecl("SFBool", Self::OSGsfBool, "convex");
01448      addFieldValue ("TRUE");
01449      endFieldDecl  ();
01450 
01451      beginFieldDecl("SFFloat", Self::OSGsfFloat, "creaseAngle");
01452      addFieldValue ("0");
01453      endFieldDecl  ();
01454 
01455      beginFieldDecl("MFVec2f", Self::OSGmfVec2f, "crossSection");
01456      endFieldDecl  ();
01457 
01458      beginFieldDecl("SFBool", Self::OSGsfBool, "endCap");
01459      addFieldValue ("TRUE");
01460      endFieldDecl  ();
01461 
01462      beginFieldDecl("MFRotation", Self::OSGmfRotation, "orientation");
01463      endFieldDecl  ();
01464 
01465      beginFieldDecl("MFVec2f", Self::OSGmfVec2f, "scale");
01466      endFieldDecl  ();
01467 
01468      beginFieldDecl("SFBool", Self::OSGsfBool, "solid");
01469      addFieldValue ("TRUE");
01470      endFieldDecl  ();
01471 
01472      beginFieldDecl("MFVec3f", Self::OSGmfVec3f, "spine");
01473      endFieldDecl  ();
01474  }
01475  endProto  ();
01476 
01477 #if 0
01478 PROTO Fog [
01479   exposedField SFColor  color            1 1 1
01480   exposedField SFString fogType          "LINEAR"
01481   exposedField SFFloat  visibilityRange  0
01482   eventIn      SFBool   set_bind
01483   eventOut     SFBool   isBound
01484 ] { }
01485 #endif
01486 
01487  beginProto("Fog");
01488  {
01489      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "color");
01490      addFieldValue        ("1 1 1");
01491      endExposedFieldDecl  ();
01492 
01493      beginExposedFieldDecl("SFString", Self::OSGsfString, "fogType");
01494      addFieldValue        ("LINEAR");
01495      endExposedFieldDecl  ();
01496 
01497      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "visibilityRange");
01498      addFieldValue        ("0");
01499      endExposedFieldDecl  ();
01500 
01501      beginEventInDecl     ("SFBool", Self::OSGsfBool, "set_bind");
01502      endEventDecl         ();
01503 
01504      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isBound");
01505      endEventDecl         ();
01506  }
01507  endProto  ();
01508 
01509 #if 0
01510 PROTO FontStyle [
01511   field SFString family     "SERIF"
01512   field SFBool   horizontal  TRUE
01513   field MFString justify     "BEGIN"
01514   field SFString language    ""
01515   field SFBool   leftToRight TRUE
01516   field SFFloat  size       1.0
01517   field SFFloat  spacing     1.0
01518   field SFString style       "PLAIN"
01519   field SFBool   topToBottom TRUE
01520 ] { }
01521 #endif
01522 
01523  beginProto("FontStyle");
01524  {
01525      beginFieldDecl("SFString", Self::OSGsfString, "family");
01526      addFieldValue ("SERIF");
01527      endFieldDecl  ();
01528 
01529      beginFieldDecl("SFBool", Self::OSGsfBool, "horizontal");
01530      addFieldValue ("TRUE");
01531      endFieldDecl  ();
01532 
01533      beginFieldDecl("MFString", Self::OSGmfString, "justify");
01534      addFieldValue ("BEGIN");
01535      endFieldDecl  ();
01536 
01537      beginFieldDecl("SFString", Self::OSGsfString, "language");
01538      addFieldValue ("");
01539      endFieldDecl  ();
01540 
01541      beginFieldDecl("SFBool", Self::OSGsfBool, "leftToRight");
01542      addFieldValue ("TRUE");
01543      endFieldDecl  ();
01544 
01545      beginFieldDecl("SFFloat", Self::OSGsfFloat, "size");
01546      addFieldValue ("1.0");
01547      endFieldDecl  ();
01548 
01549      beginFieldDecl("SFFloat", Self::OSGsfFloat, "spacing");
01550      addFieldValue ("1.0");
01551      endFieldDecl  ();
01552 
01553      beginFieldDecl("SFString", Self::OSGsfString, "style");
01554      addFieldValue ("PLAIN");
01555      endFieldDecl  ();
01556 
01557      beginFieldDecl("SFBool", Self::OSGsfBool, "topToBottom");
01558      addFieldValue ("TRUE");
01559      endFieldDecl  ();
01560  }
01561  endProto   ();
01562 
01563 #if 0
01564 PROTO Group [
01565   eventIn      MFNode  addChildren
01566   eventIn      MFNode  removeChildren
01567   exposedField MFNode  children   []
01568   field        SFVec3f bboxCenter 0 0 0
01569   field        SFVec3f bboxSize   -1 -1 -1
01570 ] { }
01571 #endif
01572 
01573  beginProto("Group");
01574  {
01575      beginEventInDecl     ("MFNode", Self::OSGmfNode, "addChildren");
01576      endEventDecl         ();
01577 
01578      beginEventInDecl     ("MFNode", Self::OSGmfNode, "removeChildren");
01579      endEventDecl         ();
01580 
01581      beginExposedFieldDecl("MFNode", Self::OSGmfNode, "children");
01582      endExposedFieldDecl  ();
01583 
01584      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxCenter");
01585      addFieldValue        ("0 0 0");
01586      endFieldDecl         ();
01587 
01588      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxSize");
01589      addFieldValue        ("-1 -1 -1");
01590      endFieldDecl         ();
01591  }
01592  endProto  ();
01593 
01594 #if 0
01595 PROTO ImageTexture [
01596   exposedField MFString url     []
01597   field        SFBool   repeatS TRUE
01598   field        SFBool   repeatT TRUE
01599 ] { }
01600 #endif
01601 
01602  beginProto("ImageTexture");
01603  {
01604      beginExposedFieldDecl("MFString", Self::OSGmfString, "url");
01605      endExposedFieldDecl  ();
01606 
01607      beginFieldDecl       ("SFBool", Self::OSGsfBool, "repeatS");
01608      addFieldValue        ("TRUE");
01609      endFieldDecl         ();
01610 
01611      beginFieldDecl       ("SFBool", Self::OSGsfBool, "repeatT");
01612      addFieldValue        ("TRUE");
01613      endFieldDecl         ();
01614  }
01615  endProto  ();
01616 
01617 #if 0
01618 PROTO IndexedFaceSet [
01619   eventIn       MFInt32 set_colorIndex
01620   eventIn       MFInt32 set_coordIndex
01621   eventIn       MFInt32 set_normalIndex
01622   eventIn       MFInt32 set_texCoordIndex
01623   exposedField  SFNode  color             NULL
01624   exposedField  SFNode  coord             NULL
01625   exposedField  SFNode  normal            NULL
01626   exposedField  SFNode  texCoord          NULL
01627   field         SFBool  ccw               TRUE
01628   field         MFInt32 colorIndex        []
01629   field         SFBool  colorPerVertex    TRUE
01630   field         SFBool  convex            TRUE
01631   field         MFInt32 coordIndex        []
01632   field         SFFloat creaseAngle       0
01633   field         MFInt32 normalIndex       []
01634   field         SFBool  normalPerVertex   TRUE
01635   field         SFBool  solid             TRUE
01636   field         MFInt32 texCoordIndex     []
01637 ] { }
01638 #endif
01639 
01640  beginProto("IndexedFaceSet");
01641  {
01642      beginEventInDecl       ("MFInt32", Self::OSGmfInt32, "set_colorIndex");
01643      endEventDecl           ();
01644 
01645      beginEventInDecl       ("MFInt32", Self::OSGmfInt32, "set_coordIndex");
01646      endEventDecl           ();
01647 
01648      beginEventInDecl       ("MFInt32", Self::OSGmfInt32, "set_normalIndex");
01649      endEventDecl           ();
01650 
01651      beginEventInDecl       ("MFInt32", Self::OSGmfInt32, "set_texCoordIndex");
01652      endEventDecl           ();
01653 
01654      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "color");
01655 //     addFieldValue        ("NULL");
01656      endExposedFieldDecl  ();
01657 
01658      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "coord");
01659 //     addFieldValue        ("NULL");
01660      endExposedFieldDecl  ();
01661 
01662      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "normal");
01663 //     addFieldValue        ("NULL");
01664      endExposedFieldDecl  ();
01665 
01666      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "texCoord");
01667 //     addFieldValue        ("NULL");
01668      endExposedFieldDecl  ();
01669 
01670      beginFieldDecl       ("SFBool", Self::OSGsfBool, "ccw");
01671      addFieldValue        ("TRUE");
01672      endFieldDecl         ();
01673 
01674      beginFieldDecl       ("MFInt32", Self::OSGmfInt32, "colorIndex");
01675      endFieldDecl         ();
01676 
01677      beginFieldDecl       ("SFBool", Self::OSGsfBool, "colorPerVertex");
01678      addFieldValue        ("TRUE");
01679      endFieldDecl         ();
01680 
01681      beginFieldDecl       ("SFBool", Self::OSGsfBool, "convex");
01682      addFieldValue        ("TRUE");
01683      endFieldDecl         ();
01684 
01685      beginFieldDecl       ("MFInt32", Self::OSGmfInt32, "coordIndex");
01686      endFieldDecl         ();
01687 
01688      beginFieldDecl       ("SFFloat", Self::OSGsfFloat, "creaseAngle");
01689      addFieldValue        ("0");
01690      endFieldDecl         ();
01691 
01692      beginFieldDecl       ("MFInt32", Self::OSGmfInt32, "normalIndex");
01693      endFieldDecl         ();
01694 
01695      beginFieldDecl       ("SFBool",  Self::OSGsfBool, "normalPerVertex");
01696      addFieldValue        ("TRUE");
01697      endFieldDecl         ();
01698 
01699      beginFieldDecl       ("SFBool",  Self::OSGsfBool, "solid");
01700      addFieldValue        ("TRUE");
01701      endFieldDecl         ();
01702 
01703      beginFieldDecl       ("MFInt32", Self::OSGmfInt32, "texCoordIndex");
01704      endFieldDecl();
01705  }
01706  endProto  ();
01707 
01708 #if 0
01709 PROTO IndexedLineSet [
01710   eventIn       MFInt32 set_colorIndex
01711   eventIn       MFInt32 set_coordIndex
01712   exposedField  SFNode  color             NULL
01713   exposedField  SFNode  coord             NULL
01714   field         MFInt32 colorIndex        []
01715   field         SFBool  colorPerVertex    TRUE
01716   field         MFInt32 coordIndex        []
01717 ] { }
01718 #endif
01719 
01720  beginProto("IndexedLineSet");
01721  {
01722      beginEventInDecl     ("MFInt32", Self::OSGmfInt32, "set_colorIndex");
01723      endEventDecl         ();
01724 
01725      beginEventInDecl     ("MFInt32", Self::OSGmfInt32, "set_coordIndex");
01726      endEventDecl         ();
01727 
01728      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "color");
01729 //     addFieldValue        ("NULL");
01730      endExposedFieldDecl  ();
01731 
01732      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "coord");
01733 //     addFieldValue        ("NULL");
01734      endExposedFieldDecl  ();
01735 
01736      beginFieldDecl       ("MFInt32", Self::OSGmfInt32, "colorIndex");
01737      endFieldDecl         ();
01738 
01739      beginFieldDecl       ("SFBool", Self::OSGsfBool, "colorPerVertex");
01740      addFieldValue        ("TRUE");
01741      endFieldDecl         ();
01742 
01743      beginFieldDecl       ("MFInt32", Self::OSGmfInt32, "coordIndex");
01744      endFieldDecl         ();
01745  }
01746  endProto  ();
01747 
01748 #if 0
01749 PROTO Inline [
01750   exposedField MFString url        []
01751   field        SFVec3f  bboxCenter 0 0 0
01752   field        SFVec3f  bboxSize   -1 -1 -1
01753 ] { }
01754 #endif
01755 
01756  beginProto("Inline");
01757  {
01758      beginExposedFieldDecl("MFString", Self::OSGmfString, "url");
01759      endExposedFieldDecl  ();
01760 
01761      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxCenter");
01762      addFieldValue        ("0 0 0");
01763      endFieldDecl         ();
01764 
01765      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxSize");
01766      addFieldValue        ("-1 -1 -1");
01767      endFieldDecl         ();
01768  }
01769  endProto  ();
01770 
01771 #if 0
01772 PROTO LOD [
01773   exposedField MFNode  level    []
01774   field        SFVec3f center   0 0 0
01775   field        MFFloat range    []
01776 ] { }
01777 #endif
01778 
01779  beginProto("LOD");
01780  {
01781      beginExposedFieldDecl("MFNode", Self::OSGmfNode, "level");
01782      endExposedFieldDecl  ();
01783 
01784      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "center");
01785      addFieldValue        ("0 0 0");
01786      endFieldDecl         ();
01787 
01788      beginFieldDecl       ("MFFloat", Self::OSGmfFloat, "range");
01789      endFieldDecl         ();
01790  }
01791  endProto  ();
01792 
01793 #if 0
01794 PROTO Material [
01795   exposedField SFFloat ambientIntensity  0.2
01796   exposedField SFColor diffuseColor      0.8 0.8 0.8
01797   exposedField SFColor emissiveColor     0 0 0
01798   exposedField SFFloat shininess         0.2
01799   exposedField SFColor specularColor     0 0 0
01800   exposedField SFFloat transparency      0
01801 ] { }
01802 #endif
01803 
01804  beginProto("Material");
01805  {
01806      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "ambientIntensity");
01807      addFieldValue        ("0.2");
01808      endExposedFieldDecl  ();
01809 
01810      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "diffuseColor");
01811      addFieldValue        ("0.8 0.8 0.8");
01812      endExposedFieldDecl  ();
01813 
01814      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "emissiveColor");
01815      addFieldValue        ("0 0 0");
01816      endExposedFieldDecl  ();
01817 
01818      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "shininess");
01819      addFieldValue        ("0.2");
01820      endExposedFieldDecl  ();
01821 
01822      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "specularColor");
01823      addFieldValue        ("0 0 0");
01824      endExposedFieldDecl  ();
01825 
01826      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "transparency");
01827      addFieldValue        ("0");
01828      endExposedFieldDecl  ();
01829  }
01830  endProto  ();
01831 
01832 #if 0
01833 PROTO MovieTexture [
01834   exposedField SFBool   loop       FALSE
01835   exposedField SFFloat  speed      1
01836   exposedField SFTime   startTime  0
01837   exposedField SFTime   stopTime   0
01838   exposedField MFString url       []
01839   field        SFBool   repeatS    TRUE
01840   field        SFBool   repeatT    TRUE
01841   eventOut     SFFloat  duration_changed
01842   eventOut     SFBool   isActive
01843 ] { }
01844 #endif
01845 
01846  beginProto("MovieTexture");
01847  {
01848      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "loop");
01849      addFieldValue        ("FALSE");
01850      endExposedFieldDecl  ();
01851 
01852      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "speed");
01853      addFieldValue        ("1");
01854      endExposedFieldDecl  ();
01855 
01856      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "startTime");
01857      addFieldValue        ("0");
01858      endExposedFieldDecl  ();
01859 
01860      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "stopTime");
01861      addFieldValue        ("0");
01862      endExposedFieldDecl  ();
01863 
01864      beginExposedFieldDecl("MFString", Self::OSGmfString, "url");
01865      endExposedFieldDecl  ();
01866 
01867      beginFieldDecl       ("SFBool", Self::OSGsfBool, "repeatS");
01868      addFieldValue        ("TRUE");
01869      endFieldDecl         ();
01870 
01871      beginFieldDecl       ("SFBool", Self::OSGsfBool, "repeatT");
01872      addFieldValue        ("TRUE");
01873      endFieldDecl         ();
01874 
01875      beginEventOutDecl    ("SFFloat", Self::OSGsfFloat, "duration_changed");
01876      endEventDecl         ();
01877 
01878      beginEventOutDecl    ("SFBool",  Self::OSGsfBool,  "isActive");
01879      endEventDecl         ();
01880  }
01881  endProto  ();
01882 
01883 #if 0
01884 PROTO NavigationInfo [
01885   eventIn      SFBool   set_bind
01886   exposedField MFFloat  avatarSize       [ 0.25, 1.6, 0.75 ]
01887   exposedField SFBool   headlight        TRUE
01888   exposedField SFFloat  speed            1.0
01889   exposedField MFString type             "WALK"
01890   exposedField SFFloat  visibilityLimit  0.0
01891   eventOut     SFBool   isBound
01892 ] { }
01893 #endif
01894 
01895  beginProto("NavigationInfo");
01896  {
01897      beginEventInDecl     ("SFBool", Self::OSGsfBool, "set_bind");
01898      endEventDecl         ();
01899 
01900      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "avatarSize");
01901      addFieldValue        ("0.25");
01902      addFieldValue        ("1.6 ");
01903      addFieldValue        ("0.75");
01904      endExposedFieldDecl  ();
01905 
01906      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "headlight");
01907      addFieldValue        ("TRUE");
01908      endExposedFieldDecl  ();
01909 
01910      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "speed");
01911      addFieldValue        ("1.0");
01912      endExposedFieldDecl  ();
01913 
01914      beginExposedFieldDecl("MFString", Self::OSGmfString, "type");
01915      addFieldValue        ("WALK");
01916      endExposedFieldDecl  ();
01917 
01918      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "visibilityLimit");
01919      addFieldValue        ("0.0");
01920      endExposedFieldDecl  ();
01921 
01922      beginEventOutDecl      ("SFBool", Self::OSGsfBool, "isBound");
01923      endEventDecl           ();
01924  }
01925  endProto  ();
01926 
01927 #if 0
01928 PROTO Normal [
01929   exposedField MFVec3f vector []
01930 ] { }
01931 #endif
01932 
01933  beginProto("Normal");
01934  {
01935      beginExposedFieldDecl("MFVec3f", Self::OSGmfVec3f, "vector");
01936      endExposedFieldDecl  ();
01937  }
01938  endProto  ();
01939 
01940 #if 0
01941 PROTO NormalInterpolator [
01942   eventIn      SFFloat set_fraction
01943   exposedField MFFloat key       []
01944   exposedField MFVec3f keyValue  []
01945   eventOut     MFVec3f value_changed
01946 ] { }
01947 #endif
01948 
01949  beginProto("NormalInterpolator");
01950  {
01951      beginEventInDecl     ("SFFloat", Self::OSGsfFloat, "set_fraction");
01952      endEventDecl         ();
01953 
01954      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "key");
01955      endExposedFieldDecl  ();
01956 
01957      beginExposedFieldDecl("MFVec3f", Self::OSGmfVec3f, "keyValue");
01958      endExposedFieldDecl  ();
01959 
01960      beginEventOutDecl    ("MFVec3f",  Self::OSGmfVec3f, "value_changed");
01961      endEventDecl         ();
01962  }
01963  endProto  ();
01964 
01965 #if 0
01966 PROTO OrientationInterpolator [
01967   eventIn      SFFloat    set_fraction
01968   exposedField MFFloat    key       []
01969   exposedField MFRotation keyValue  []
01970   eventOut     SFRotation value_changed
01971 ] { }
01972 #endif
01973 
01974  beginProto("OrientationInterpolator");
01975  {
01976      beginEventInDecl     ("SFFloat", Self::OSGsfFloat, "set_fraction");
01977      endEventDecl         ();
01978 
01979      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "key");
01980      endExposedFieldDecl  ();
01981 
01982      beginExposedFieldDecl("MFRotation", Self::OSGmfRotation, "keyValue");
01983      endExposedFieldDecl  ();
01984 
01985      beginEventOutDecl    ("SFRotation", Self::OSGsfRotation, "value_changed");
01986      endEventDecl         ();
01987  }
01988  endProto  ();
01989 
01990 #if 0
01991 PROTO PixelTexture [
01992   exposedField SFImage  image      0 0 0
01993   field        SFBool   repeatS    TRUE
01994   field        SFBool   repeatT    TRUE
01995 ] { }
01996 #endif
01997 
01998  beginProto("PixelTexture");
01999  {
02000      beginExposedFieldDecl("SFImage", Self::OSGsfImage, "image");
02001 //     addFieldValue        ("0 0 0");
02002      endExposedFieldDecl  ();
02003 
02004      beginFieldDecl       ("SFBool", Self::OSGsfBool, "repeatS");
02005      addFieldValue        ("TRUE");
02006      endFieldDecl         ();
02007 
02008      beginFieldDecl       ("SFBool", Self::OSGsfBool, "repeatT");
02009      addFieldValue        ("TRUE");
02010      endFieldDecl         ();
02011  }
02012  endProto  ();
02013 
02014 #if 0
02015 PROTO PlaneSensor [
02016   exposedField SFBool  autoOffset  TRUE
02017   exposedField SFBool  enabled     TRUE
02018   exposedField SFVec2f maxPosition -1 -1
02019   exposedField SFVec2f minPosition 0 0
02020   exposedField SFVec3f offset      0 0 0
02021   eventOut     SFBool  isActive
02022   eventOut     SFVec3f trackPoint_changed
02023   eventOut     SFVec3f translation_changed
02024 ] { }
02025 #endif
02026 
02027  beginProto("PlaneSensor");
02028  {
02029      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "autoOffset");
02030      addFieldValue        ("TRUE");
02031      endExposedFieldDecl  ();
02032 
02033      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
02034      addFieldValue        ("TRUE");
02035      endExposedFieldDecl  ();
02036 
02037      beginExposedFieldDecl("SFVec2f", Self::OSGsfVec2f, "maxPosition");
02038      addFieldValue        ("-1 -1");
02039      endExposedFieldDecl  ();
02040 
02041      beginExposedFieldDecl("SFVec2f", Self::OSGsfVec2f, "minPosition");
02042      addFieldValue        ("0 0");
02043      endExposedFieldDecl  ();
02044 
02045      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "offset");
02046      addFieldValue        ("0 0 0");
02047      endExposedFieldDecl  ();
02048 
02049      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive");
02050      endEventDecl         ();
02051 
02052      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "trackPoint_changed");
02053      endEventDecl         ();
02054 
02055      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "translation_changed");
02056      endEventDecl         ();
02057  }
02058  endProto  ();
02059 
02060 
02061 #if 0
02062 PROTO PointLight [
02063   exposedField SFFloat ambientIntensity  0
02064   exposedField SFVec3f attenuation       1 0 0
02065   exposedField SFColor color             1 1 1
02066   exposedField SFFloat intensity         1
02067   exposedField SFVec3f location          0 0 0
02068   exposedField SFBool  on                TRUE
02069   exposedField SFFloat radius            100
02070 ] { }
02071 #endif
02072 
02073  beginProto("PointLight");
02074  {
02075      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "ambientIntensity");
02076      addFieldValue        ("0");
02077      endExposedFieldDecl  ();
02078 
02079      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "attenuation");
02080      addFieldValue        ("1 0 0");
02081      endExposedFieldDecl  ();
02082 
02083      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "color");
02084      addFieldValue        ("1 1 1");
02085      endExposedFieldDecl  ();
02086 
02087      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "intensity");
02088      addFieldValue        ("1");
02089      endExposedFieldDecl  ();
02090 
02091      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "location");
02092      addFieldValue        ("0 0 0");
02093      endExposedFieldDecl  ();
02094 
02095      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "on");
02096      addFieldValue        ("TRUE");
02097      endExposedFieldDecl  ();
02098 
02099      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "radius");
02100      addFieldValue        ("100");
02101      endExposedFieldDecl  ();
02102  }
02103  endProto  ();
02104 
02105 #if 0
02106 PROTO PointSet [
02107   exposedField  SFNode  color      NULL
02108   exposedField  SFNode  coord      NULL
02109 ] { }
02110 #endif
02111 
02112  beginProto("PointSet");
02113  {
02114      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "color");
02115 //     addFieldValue        ("NULL");
02116      endFieldDecl         ();
02117 
02118      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "coord");
02119 //     addFieldValue        ("NULL");
02120      endFieldDecl         ();
02121  }
02122  endProto  ();
02123 
02124 #if 0
02125 PROTO PositionInterpolator [
02126   eventIn      SFFloat set_fraction
02127   exposedField MFFloat key       []
02128   exposedField MFVec3f keyValue  []
02129   eventOut     SFVec3f value_changed
02130 ] { }
02131 #endif
02132 
02133  beginProto("PositionInterpolator");
02134  {
02135      beginEventInDecl     ("SFFloat", Self::OSGsfFloat, "set_fraction");
02136      endEventDecl         ();
02137 
02138      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "key");
02139      endExposedFieldDecl();
02140 
02141      beginExposedFieldDecl("MFVec3f", Self::OSGmfVec3f, "keyValue");
02142      endExposedFieldDecl  ();
02143 
02144      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "value_changed");
02145      endEventDecl         ();
02146  }
02147  endProto  ();
02148 
02149 #if 0
02150 PROTO ProximitySensor [
02151   exposedField SFVec3f    center      0 0 0
02152   exposedField SFVec3f    size        0 0 0
02153   exposedField SFBool     enabled     TRUE
02154   eventOut     SFBool     isActive
02155   eventOut     SFVec3f    position_changed
02156   eventOut     SFRotation orientation_changed
02157   eventOut     SFTime     enterTime
02158   eventOut     SFTime     exitTime
02159 ] { }
02160 #endif
02161 
02162  beginProto("ProximitySensor");
02163  {
02164      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "center");
02165      addFieldValue        ("0 0 0");
02166      endExposedFieldDecl  ();
02167 
02168      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "size");
02169      addFieldValue        ("0 0 0");
02170      endExposedFieldDecl  ();
02171 
02172      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
02173      addFieldValue        ("TRUE");
02174      endExposedFieldDecl  ();
02175 
02176      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive");
02177      endEventDecl         ();
02178 
02179      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "position_changed");
02180      endEventDecl         ();
02181 
02182      beginEventOutDecl    ("SFRotation",
02183                            Self::OSGsfRotation,
02184                            "orientation_changed");
02185      endEventDecl         ();
02186 
02187      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "enterTime");
02188      endEventDecl         ();
02189 
02190      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "exitTime");
02191      endEventDecl         ();
02192  }
02193  endProto  ();
02194 
02195 #if 0
02196 PROTO ScalarInterpolator [
02197   eventIn      SFFloat set_fraction
02198   exposedField MFFloat key       []
02199   exposedField MFFloat keyValue  []
02200   eventOut     SFFloat value_changed
02201 ] { }
02202 #endif
02203 
02204  beginProto("ScalarInterpolator");
02205  {
02206      beginEventInDecl     ("SFFloat", Self::OSGsfFloat, "set_fraction");
02207      endEventDecl         ();
02208 
02209      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "key");
02210      endExposedFieldDecl  ();
02211 
02212      beginExposedFieldDecl("MFFloat", Self::OSGmfFloat, "keyValue");
02213      endExposedFieldDecl  ();
02214 
02215      beginEventOutDecl    ("SFFloat", Self::OSGsfFloat, "value_changed");
02216      endEventDecl         ();
02217  }
02218  endProto  ();
02219 
02220 #if 0
02221 PROTO Script [
02222   exposedField MFString url           [ ]
02223   field        SFBool   directOutput  FALSE
02224   field        SFBool   mustEvaluate  FALSE
02225 ] { }
02226 #endif
02227 
02228  beginProto("Script");
02229  {
02230      beginExposedFieldDecl("MFString", Self::OSGmfString, "url");
02231      endExposedFieldDecl  ();
02232 
02233      beginFieldDecl       ("SFBool", Self::OSGsfBool, "directOutput");
02234      addFieldValue        ("FALSE");
02235      endFieldDecl         ();
02236 
02237      beginFieldDecl       ("SFBool", Self::OSGsfBool, "mustEvaluate");
02238      addFieldValue        ("FALSE");
02239      endFieldDecl         ();
02240  }
02241  endProto  ();
02242 
02243 #if 0
02244 PROTO Shape [
02245   field SFNode appearance NULL
02246   field SFNode geometry   NULL
02247 ] { }
02248 #endif
02249 
02250  beginProto("Shape");
02251  {
02252      beginFieldDecl("SFNode", Self::OSGsfNode, "appearance");
02253 //     addFieldValue ("NULL");
02254      endFieldDecl  ();
02255 
02256      beginFieldDecl("SFNode", Self::OSGsfNode, "geometry");
02257 //     addFieldValue ("NULL");
02258      endFieldDecl  ();
02259  }
02260  endProto  ();
02261 
02262 #if 0
02263 PROTO Sound [
02264   exposedField SFVec3f  direction     0 0 1
02265   exposedField SFFloat  intensity     1
02266   exposedField SFVec3f  location      0 0 0
02267   exposedField SFFloat  maxBack       10
02268   exposedField SFFloat  maxFront      10
02269   exposedField SFFloat  minBack       1
02270   exposedField SFFloat  minFront      1
02271   exposedField SFFloat  priority      0
02272   exposedField SFNode   source        NULL
02273   field        SFBool   spatialize    TRUE
02274 ] { }
02275 #endif
02276 
02277  beginProto("Sound");
02278  {
02279      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "direction");
02280      addFieldValue        ("0 0 1");
02281      endExposedFieldDecl  ();
02282 
02283      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "intensity");
02284      addFieldValue        ("1");
02285      endExposedFieldDecl  ();
02286 
02287      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "location");
02288      addFieldValue        ("0 0 0");
02289      endExposedFieldDecl  ();
02290 
02291      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "maxBack");
02292      addFieldValue        ("10");
02293      endExposedFieldDecl  ();
02294 
02295      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "maxFront");
02296      addFieldValue        ("10");
02297      endExposedFieldDecl  ();
02298 
02299      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "minBack");
02300      addFieldValue        ("1");
02301      endExposedFieldDecl  ();
02302 
02303      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "minFront");
02304      addFieldValue        ("1");
02305      endExposedFieldDecl  ();
02306 
02307      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "priority");
02308      addFieldValue        ("0");
02309      endExposedFieldDecl  ();
02310 
02311      beginExposedFieldDecl("SFNode", Self::OSGsfNode, "source");
02312 //     addFieldValue        ("NULL");
02313      endExposedFieldDecl  ();
02314 
02315      beginFieldDecl       ("SFBool", Self::OSGsfBool, "spatialize");
02316      addFieldValue        ("TRUE");
02317      endFieldDecl         ();
02318  }
02319  endProto  ();
02320 
02321 #if 0
02322 PROTO Sphere [
02323   field SFFloat radius  1
02324 ] { }
02325 #endif
02326 
02327  beginProto("Sphere");
02328  {
02329      beginFieldDecl("SFFloat", Self::OSGsfFloat, "radius");
02330      addFieldValue ("1");
02331      endFieldDecl  ();
02332  }
02333  endProto  ();
02334 
02335 #if 0
02336 PROTO SphereSensor [
02337   exposedField SFBool     autoOffset TRUE
02338   exposedField SFBool     enabled    TRUE
02339   exposedField SFRotation offset     0 1 0 0
02340   eventOut     SFBool     isActive
02341   eventOut     SFRotation rotation_changed
02342   eventOut     SFVec3f    trackPoint_changed
02343 ] { }
02344 #endif
02345 
02346  beginProto("SphereSensor");
02347  {
02348      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "autoOffset");
02349      addFieldValue        ("TRUE");
02350      endExposedFieldDecl  ();
02351 
02352      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
02353      addFieldValue        ("TRUE");
02354      endExposedFieldDecl  ();
02355 
02356      beginExposedFieldDecl("SFRotation", Self::OSGsfRotation, "offset");
02357      addFieldValue        ("0 1 0 0");
02358      endExposedFieldDecl  ();
02359 
02360      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive");
02361      endEventDecl         ();
02362 
02363      beginEventOutDecl    ("SFRotation",
02364                            Self::OSGsfRotation,
02365                            "rotation_changed");
02366      endEventDecl         ();
02367 
02368      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "trackPoint_changed");
02369      endEventDecl         ();
02370  }
02371  endProto  ();
02372 
02373 #if 0
02374 PROTO SpotLight [
02375   exposedField SFFloat ambientIntensity  0
02376   exposedField SFVec3f attenuation       1 0 0
02377   exposedField SFFloat beamWidth         1.570796
02378   exposedField SFColor color             1 1 1
02379   exposedField SFFloat cutOffAngle       0.785398
02380   exposedField SFVec3f direction         0 0 -1
02381   exposedField SFFloat intensity         1
02382   exposedField SFVec3f location          0 0 0
02383   exposedField SFBool  on                TRUE
02384   exposedField SFFloat radius            100
02385 ] { }
02386 #endif
02387 
02388  beginProto("SpotLight");
02389  {
02390      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "ambientIntensity");
02391      addFieldValue        ("0");
02392      endExposedFieldDecl  ();
02393 
02394      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "attenuation");
02395      addFieldValue        ("1 0 0");
02396      endExposedFieldDecl  ();
02397 
02398      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "beamWidth");
02399      addFieldValue        ("1.570796");
02400      endExposedFieldDecl  ();
02401 
02402      beginExposedFieldDecl("SFColor", Self::OSGsfColor, "color");
02403      addFieldValue        ("1 1 1");
02404      endExposedFieldDecl  ();
02405 
02406      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "cutOffAngle");
02407      addFieldValue        ("0.785398");
02408      endExposedFieldDecl  ();
02409 
02410      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "direction");
02411      addFieldValue        ("0 0 -1");
02412      endExposedFieldDecl  ();
02413 
02414      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "intensity");
02415      addFieldValue        ("1");
02416      endExposedFieldDecl  ();
02417 
02418      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "location");
02419      addFieldValue        ("0 0 0");
02420      endExposedFieldDecl  ();
02421 
02422      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "on");
02423      addFieldValue        ("TRUE");
02424      endExposedFieldDecl  ();
02425 
02426      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "radius");
02427      addFieldValue        ("100");
02428      endExposedFieldDecl  ();
02429  }
02430  endProto  ();
02431 
02432 #if 0
02433 PROTO Switch [
02434   exposedField    MFNode  choice      []
02435   exposedField    SFInt32 whichChoice -1
02436 ] { }
02437 #endif
02438 
02439  beginProto("Switch");
02440  {
02441      beginExposedFieldDecl("MFNode", Self::OSGmfNode, "choice");
02442      endExposedFieldDecl  ();
02443 
02444      beginExposedFieldDecl("SFInt32", Self::OSGsfInt32, "whichChoice");
02445      addFieldValue        ("-1");
02446      endExposedFieldDecl  ();
02447  }
02448  endProto  ();
02449 
02450 #if 0
02451 PROTO Text [
02452   exposedField  MFString string    []
02453   field         SFNode   fontStyle NULL
02454   field         MFFloat  length    []
02455   field         SFFloat  maxExtent 0.0
02456 ] { }
02457 #endif
02458 
02459  beginProto("Text");
02460  {
02461      beginExposedFieldDecl("MFString", Self::OSGmfString, "string");
02462      endExposedFieldDecl  ();
02463 
02464      beginFieldDecl       ("SFNode", Self::OSGsfNode, "fontStyle");
02465 //     addFieldValue        ("NULL");
02466      endFieldDecl         ();
02467 
02468      beginFieldDecl       ("MFFloat", Self::OSGmfFloat, "length");
02469      endFieldDecl         ();
02470 
02471      beginFieldDecl       ("SFFloat", Self::OSGsfFloat, "maxExtent");
02472      addFieldValue        ("0.0");
02473      endFieldDecl         ();
02474  }
02475  endProto  ();
02476 
02477 #if 0
02478 PROTO TextureCoordinate [
02479   exposedField MFVec2f point []
02480 ] { }
02481 #endif
02482 
02483  beginProto("TextureCoordinate");
02484  {
02485      beginExposedFieldDecl("MFVec2f", Self::OSGmfVec2f, "point");
02486      endExposedFieldDecl  ();
02487  }
02488  endProto  ();
02489 
02490 #if 0
02491 PROTO TextureTransform [
02492   exposedField SFVec2f center      0 0
02493   exposedField SFFloat rotation    0
02494   exposedField SFVec2f scale       1 1
02495   exposedField SFVec2f translation 0 0
02496 ] { }
02497 #endif
02498 
02499  beginProto("TextureTransform");
02500  {
02501      beginExposedFieldDecl("SFVec2f", Self::OSGsfVec2f, "center");
02502      addFieldValue        ("0 0");
02503      endExposedFieldDecl  ();
02504 
02505      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "rotation");
02506      addFieldValue        ("0");
02507      endExposedFieldDecl  ();
02508 
02509      beginExposedFieldDecl("SFVec2f", Self::OSGsfVec2f, "scale");
02510      addFieldValue        ("1 1");
02511      endExposedFieldDecl  ();
02512 
02513      beginExposedFieldDecl("SFVec2f", Self::OSGsfVec2f, "translation");
02514      addFieldValue        ("0 0");
02515      endExposedFieldDecl  ();
02516  }
02517  endProto  ();
02518 
02519 #if 0
02520 PROTO TimeSensor [
02521   exposedField SFTime   cycleInterval 1
02522   exposedField SFBool   enabled       TRUE
02523   exposedField SFBool   loop          FALSE
02524   exposedField SFTime   startTime     0
02525   exposedField SFTime   stopTime      0
02526   eventOut     SFTime   cycleTime
02527   eventOut     SFFloat  fraction_changed
02528   eventOut     SFBool   isActive
02529   eventOut     SFTime   time
02530 ] { }
02531 #endif
02532 
02533  beginProto("TimeSensor");
02534  {
02535      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "cycleInterval");
02536      addFieldValue        ("1");
02537      endExposedFieldDecl  ();
02538 
02539      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
02540      addFieldValue        ("TRUE");
02541      endExposedFieldDecl  ();
02542 
02543      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "loop");
02544      addFieldValue        ("FALSE");
02545      endExposedFieldDecl  ();
02546 
02547      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "startTime");
02548      addFieldValue        ("0");
02549      endExposedFieldDecl  ();
02550 
02551      beginExposedFieldDecl("SFTime", Self::OSGsfTime, "stopTime");
02552      addFieldValue        ("0");
02553      endExposedFieldDecl  ();
02554 
02555      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "cycleTime");
02556      endEventDecl         ();
02557 
02558      beginEventOutDecl    ("SFFloat", Self::OSGsfFloat, "fraction_changed");
02559      endEventDecl         ();
02560 
02561      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive");
02562      endEventDecl         ();
02563 
02564      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "time");
02565      endEventDecl         ();
02566  }
02567  endProto  ();
02568 
02569 #if 0
02570 PROTO TouchSensor [
02571   exposedField SFBool  enabled TRUE
02572   eventOut     SFVec3f hitNormal_changed
02573   eventOut     SFVec3f hitPoint_changed
02574   eventOut     SFVec2f hitTexCoord_changed
02575   eventOut     SFBool  isActive
02576   eventOut     SFBool  isOver
02577   eventOut     SFTime  touchTime
02578 ] { }
02579 #endif
02580 
02581  beginProto("TouchSensor");
02582  {
02583      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
02584      addFieldValue        ("TRUE");
02585      endExposedFieldDecl  ();
02586 
02587      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "hitNormal_changed");
02588      endEventDecl         ();
02589 
02590      beginEventOutDecl    ("SFVec3f", Self::OSGsfVec3f, "hitPoint_changed");
02591      endEventDecl         ();
02592 
02593      beginEventOutDecl    ("SFVec2f", Self::OSGsfVec2f, "hitTexCoord_changed");
02594      endEventDecl         ();
02595 
02596      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive");
02597      endEventDecl         ();
02598 
02599      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isOver");
02600      endEventDecl         ();
02601 
02602      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "touchTime");
02603      endEventDecl         ();
02604  }
02605  endProto  ();
02606 
02607 #if 0
02608 PROTO Transform [
02609   eventIn      MFNode      addChildren
02610   eventIn      MFNode      removeChildren
02611   exposedField SFVec3f     center           0 0 0
02612   exposedField MFNode      children         []
02613   exposedField SFRotation  rotation         0 0 1  0
02614   exposedField SFVec3f     scale            1 1 1
02615   exposedField SFRotation  scaleOrientation 0 0 1  0
02616   exposedField SFVec3f     translation      0 0 0
02617   field        SFVec3f     bboxCenter       0 0 0
02618   field        SFVec3f     bboxSize         -1 -1 -1
02619 ] { }
02620 #endif
02621 
02622  beginProto("Transform");
02623  {
02624      beginEventInDecl     ("MFNode", Self::OSGsfNode, "addChildren");
02625      endEventDecl         ();
02626 
02627      beginEventInDecl     ("MFNode", Self::OSGsfNode, "removeChildren");
02628      endEventDecl         ();
02629 
02630      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "center");
02631      addFieldValue        ("0 0 0");
02632      endExposedFieldDecl  ();
02633 
02634      beginExposedFieldDecl("MFNode", Self::OSGmfNode, "children");
02635      endExposedFieldDecl  ();
02636 
02637      beginExposedFieldDecl("SFRotation", Self::OSGsfRotation, "rotation");
02638      addFieldValue        ("0 0 1  0");
02639      endExposedFieldDecl  ();
02640 
02641      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "scale");
02642      addFieldValue        ("1 1 1");
02643      endExposedFieldDecl  ();
02644 
02645      beginExposedFieldDecl("SFRotation", Self::OSGsfRotation, "scaleOrientation");
02646      addFieldValue        ("0 0 1  0");
02647      endExposedFieldDecl  ();
02648 
02649      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "translation");
02650      addFieldValue        ("0 0 0");
02651      endExposedFieldDecl  ();
02652 
02653      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxCenter");
02654      addFieldValue        ("0 0 0");
02655      endFieldDecl         ();
02656 
02657      beginFieldDecl       ("SFVec3f", Self::OSGsfVec3f, "bboxSize");
02658      addFieldValue        ("-1 -1 -1");
02659      endFieldDecl         ();
02660  }
02661  endProto  ();
02662 
02663 #if 0
02664 PROTO Viewpoint [
02665   eventIn      SFBool     set_bind
02666   exposedField SFFloat    fieldOfView    0.785398
02667   exposedField SFBool     jump           TRUE
02668   exposedField SFRotation orientation    0 0 1  0
02669   exposedField SFVec3f    position       0 0 10
02670   field        SFString   description    ""
02671   eventOut     SFTime     bindTime
02672   eventOut     SFBool     isBound
02673 ] { }
02674 #endif
02675 
02676  beginProto("Viewpoint");
02677  {
02678      beginEventInDecl     ("SFBool", Self::OSGsfBool, "set_bind");
02679      endEventDecl         ();
02680 
02681      beginExposedFieldDecl("SFFloat", Self::OSGsfFloat, "fieldOfView");
02682      addFieldValue        ("0.785398");
02683      endExposedFieldDecl  ();
02684 
02685      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "jump");
02686      addFieldValue        ("TRUE");
02687      endExposedFieldDecl  ();
02688 
02689      beginExposedFieldDecl("SFRotation", Self::OSGsfRotation, "orientation");
02690      addFieldValue        ("0 0 1  0");
02691      endExposedFieldDecl  ();
02692 
02693      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "position");
02694      addFieldValue        ("0 0 10");
02695      endExposedFieldDecl  ();
02696 
02697      beginFieldDecl       ("SFString", Self::OSGsfString, "description");
02698      addFieldValue        ("");
02699      endFieldDecl         ();
02700 
02701      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "bindTime");
02702      endEventDecl         ();
02703 
02704      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isBound" );
02705      endEventDecl         ();
02706  }
02707  endProto  ();
02708 
02709 #if 0
02710 PROTO VisibilitySensor [
02711   exposedField SFVec3f center   0 0 0
02712   exposedField SFBool  enabled  TRUE
02713   exposedField SFVec3f size     0 0 0
02714   eventOut     SFTime  enterTime
02715   eventOut     SFTime  exitTime
02716   eventOut     SFBool  isActive
02717 ] { }
02718 #endif
02719 
02720  beginProto("VisibilitySensor");
02721  {
02722      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "center");
02723      addFieldValue        ("0 0 0");
02724      endExposedFieldDecl  ();
02725 
02726      beginExposedFieldDecl("SFBool", Self::OSGsfBool, "enabled");
02727      addFieldValue        ("TRUE");
02728      endExposedFieldDecl  ();
02729 
02730      beginExposedFieldDecl("SFVec3f", Self::OSGsfVec3f, "size");
02731      addFieldValue        ("0 0 0");
02732      endExposedFieldDecl  ();
02733 
02734      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "enterTime");
02735      endEventDecl         ();
02736 
02737      beginEventOutDecl    ("SFTime", Self::OSGsfTime, "exitTime" );
02738      endEventDecl         ();
02739 
02740      beginEventOutDecl    ("SFBool", Self::OSGsfBool, "isActive" );
02741      endEventDecl         ();
02742  }
02743  endProto  ();
02744 
02745 #if 0
02746 PROTO WorldInfo [
02747   field MFString info  []
02748   field SFString title ""
02749 ] { }
02750 #endif
02751 
02752  beginProto("WorldInfo");
02753  {
02754      beginFieldDecl("MFString", Self::OSGmfString, "info");
02755      endFieldDecl  ();
02756 
02757      beginFieldDecl("SFString", Self::OSGsfString, "title");
02758      addFieldValue("");
02759      endFieldDecl();
02760  }
02761  endProto  ();
02762 
02763  postStandardProtos();
02764 
02765 }
02766 
02767 static Action::ResultE modifyMaterial(NodePtr& node)
02768 {   
02769     MaterialGroupPtr mg = MaterialGroupPtr::dcast(node->getCore());
02770     
02771     if(mg == NullFC)
02772         return Action::Continue; 
02773     
02774     ChunkMaterialPtr cmat = ChunkMaterialPtr::dcast(mg->getMaterial());
02775     
02776     if(cmat == NullFC)
02777         return Action::Continue; 
02778     
02779     TextureChunkPtr texc = TextureChunkPtr::dcast(cmat->find(TextureChunk::getClassType()));
02780     
02781     if(texc == NullFC)
02782         return Action::Continue;
02783     
02784     MaterialChunkPtr matc = MaterialChunkPtr::dcast(cmat->find(MaterialChunk::getClassType()));
02785     
02786     if(matc == NullFC)
02787     {
02788         // no material chunk so we use the replace mode.
02789         beginEditCP(texc, TextureChunk::EnvModeFieldMask);
02790             texc->setEnvMode(GL_REPLACE);
02791         endEditCP(texc, TextureChunk::EnvModeFieldMask);
02792         return Action::Continue;
02793     }
02794     
02795     if(matc != NullFC)
02796     {
02797         ImagePtr img = texc->getImage();
02798         
02799         beginEditCP(texc, TextureChunk::EnvModeFieldMask);
02800             texc->setEnvMode(GL_MODULATE);
02801         endEditCP(texc, TextureChunk::EnvModeFieldMask);
02802         if(img != NullFC && img->getBpp() > 2)
02803         {
02804             // for color textures the texture replaces only the diffuse part.
02805             beginEditCP(matc, MaterialChunk::DiffuseFieldMask);
02806                 matc->setDiffuse(Color4f(1.0f, 1.0f, 1.0f, 1.0f));
02807             endEditCP(matc, MaterialChunk::DiffuseFieldMask);
02808         }
02809         
02810         
02811         // check for textures with alpha
02812         if(!matc->isTransparent() && img != NullFC &&
02813            img->getBpp() == 4)
02814         {
02815             BlendChunkPtr blendc = BlendChunkPtr::dcast(cmat->find(BlendChunk::getClassType()));
02816             if(blendc == NullFC)
02817             {
02818                 blendc = OSG::BlendChunk::create();
02819 
02820                 beginEditCP(blendc, BlendChunk::SrcFactorFieldMask |
02821                                     BlendChunk::DestFactorFieldMask);
02822                     blendc->setSrcFactor (GL_SRC_ALPHA);
02823                     blendc->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
02824                 endEditCP(blendc, BlendChunk::SrcFactorFieldMask |
02825                                   BlendChunk::DestFactorFieldMask);
02826     
02827                 beginEditCP(cmat, ChunkMaterial::ChunksFieldMask);
02828                     cmat->addChunk(blendc);
02829                 endEditCP  (cmat, ChunkMaterial::ChunksFieldMask);
02830             }
02831         }
02832     }
02833     
02834     return Action::Continue;
02835 }
02836 
02837 NodePtr VRMLFile::getRoot(void)
02838 {
02839     // now walk through all materials and modify them.
02840     if(_pSceneRootNode != NullFC)
02841     {
02842         traverse(_pSceneRootNode, osgTypedFunctionFunctor1CPtrRef<Action::ResultE,
02843                  NodePtr>(modifyMaterial));
02844     }
02845     
02846     return _pSceneRootNode;
02847 }
02848 
02849 /*-------------------------------------------------------------------------*/
02850 /*                           Member                                        */
02851 
02852 void VRMLFile::initIntExtFieldTypeMapper(void)
02853 {
02854     Self::setIntExtMapping(SFBool::getClassType().getId(),
02855                            ScanParseSkel::OSGsfBool);
02856 
02857     Self::setIntExtMapping(SFColor3f::getClassType().getId(),
02858                            ScanParseSkel::OSGsfColor);
02859 
02860     Self::setIntExtMapping(SFReal32::getClassType().getId(),
02861                            ScanParseSkel::OSGsfFloat);
02862 
02863     Self::setIntExtMapping(SFImagePtr::getClassType().getId(),
02864                            ScanParseSkel::OSGsfImage);
02865 
02866     Self::setIntExtMapping(SFInt32::getClassType().getId(),
02867                            ScanParseSkel::OSGsfInt32);
02868 
02869     Self::setIntExtMapping(SFGLenum::getClassType().getId(),
02870                            ScanParseSkel::OSGsfInt32);
02871 
02872 
02873     Self::setIntExtMapping(SFQuaternion::getClassType().getId(),
02874                            ScanParseSkel::OSGsfRotation);
02875 
02876     Self::setIntExtMapping(SFString::getClassType().getId(),
02877                            ScanParseSkel::OSGsfString);
02878 
02879     Self::setIntExtMapping(SFTime::getClassType().getId(),
02880                            ScanParseSkel::OSGsfTime);
02881 
02882     Self::setIntExtMapping(SFVec2f::getClassType().getId(),
02883                            ScanParseSkel::OSGsfVec2f);
02884 
02885     Self::setIntExtMapping(SFVec3f::getClassType().getId(),
02886                            ScanParseSkel::OSGsfVec3f);
02887 
02888 
02889 
02890     Self::setIntExtMapping(MFColor3f::getClassType().getId(),
02891                            ScanParseSkel::OSGmfColor);
02892 
02893     Self::setIntExtMapping(MFReal32::getClassType().getId(),
02894                            ScanParseSkel::OSGmfFloat);
02895 
02896     Self::setIntExtMapping(MFInt32::getClassType().getId(),
02897                            ScanParseSkel::OSGmfInt32);
02898 
02899     Self::setIntExtMapping(MFGLenum::getClassType().getId(),
02900                            ScanParseSkel::OSGmfInt32);
02901 
02902     Self::setIntExtMapping(MFQuaternion::getClassType().getId(),
02903                            ScanParseSkel::OSGmfRotation);
02904 
02905     Self::setIntExtMapping(MFString::getClassType().getId(),
02906                            ScanParseSkel::OSGmfString);
02907 
02908     Self::setIntExtMapping(MFTime::getClassType().getId(),
02909                            ScanParseSkel::OSGmfTime);
02910 
02911     Self::setIntExtMapping(MFVec3f::getClassType().getId(),
02912                            ScanParseSkel::OSGmfVec3f);
02913 
02914     Self::setIntExtMapping(MFVec2f::getClassType().getId(),
02915                            ScanParseSkel::OSGmfVec2f);
02916 
02917 
02918     Self::setIntExtMapping(SFNodePtr::getClassType().getId(),
02919                            ScanParseSkel::OSGsfNode);
02920 
02921     Self::setIntExtMapping(MFNodePtr::getClassType().getId(),
02922                            ScanParseSkel::OSGmfNode);
02923 
02924     /* To Base Type Mappings */
02925 
02926     Self::setIntExtMapping(SFUInt8::getClassType().getId(),
02927                            ScanParseSkel::OSGsfInt32);
02928 
02929     Self::setIntExtMapping(MFUInt8::getClassType().getId(),
02930                            ScanParseSkel::OSGmfInt32);
02931 
02932     Self::setIntExtMapping(SFUInt32::getClassType().getId(),
02933                            ScanParseSkel::OSGsfInt32);
02934 
02935     Self::setIntExtMapping(MFUInt32::getClassType().getId(),
02936                            ScanParseSkel::OSGmfInt32);
02937 
02938     /* To Node Mappings */
02939 
02940     Self::setIntExtMapping(SFNodeCorePtr::getClassType().getId(),
02941                            ScanParseSkel::OSGsfNode);
02942 
02943     Self::setIntExtMapping(SFMaterialPtr::getClassType().getId(),
02944                            ScanParseSkel::OSGsfNode);
02945 
02946     Self::setIntExtMapping(SFGeoPTypesPtr::getClassType().getId(),
02947                            ScanParseSkel::OSGsfNode);
02948 
02949     Self::setIntExtMapping(SFGeoIndicesPtr::getClassType().getId(),
02950                            ScanParseSkel::OSGsfNode);
02951 
02952     Self::setIntExtMapping(SFGeoPLengthsPtr::getClassType().getId(),
02953                            ScanParseSkel::OSGsfNode);
02954 
02955     Self::setIntExtMapping(SFGeoColorsPtr::getClassType().getId(),
02956                            ScanParseSkel::OSGsfNode);
02957 
02958     Self::setIntExtMapping(SFGeoPositionsPtr::getClassType().getId(),
02959                            ScanParseSkel::OSGsfNode);
02960 
02961     Self::setIntExtMapping(SFGeoNormalsPtr::getClassType().getId(),
02962                            ScanParseSkel::OSGsfNode);
02963 
02964     Self::setIntExtMapping(SFGeoTexCoordsPtr::getClassType().getId(),
02965                            ScanParseSkel::OSGsfNode);
02966 
02967     Self::setIntExtMapping(MFStateChunkPtr::getClassType().getId(),
02968                            ScanParseSkel::OSGsfNode);
02969 
02970     Self::setIntExtMapping(SFAttachmentMap::getClassType().getId(),
02971                            ScanParseSkel::OSGmfNode);
02972 
02973     Self::setIntExtMapping(SFFieldContainerPtr::getClassType().getId(),
02974                            ScanParseSkel::OSGsfNode);
02975 
02976     /* extended types */
02977 
02978     Self::setIntExtMapping(SFMatrix::getClassType().getId(),
02979                            ScanParseSkel::OSGsfMatrix);
02980 
02981     Self::setIntExtMapping(SFPnt3f::getClassType().getId(),
02982                            ScanParseSkel::OSGsfPnt3f);
02983 
02984     Self::setIntExtMapping(MFPnt3f::getClassType().getId(),
02985                            ScanParseSkel::OSGmfPnt3f);
02986 }
02987 
02988 
02989 void VRMLFile::initExtIntFieldTypeMapper(void)
02990 {
02991     Self::setExtIntMapping(ScanParseSkel::OSGsfBool,
02992                            SFBool::getClassType().getId());
02993 
02994     Self::setExtIntMapping(ScanParseSkel::OSGsfColor,
02995                            SFColor3f::getClassType().getId());
02996 
02997     Self::setExtIntMapping(ScanParseSkel::OSGsfFloat,
02998                            SFReal32::getClassType().getId());
02999 
03000 /*
03001     Self::setExtIntMapping(SFImage::getClassType().getId(),
03002                      ScanParseSkel::OSGsfInt32);
03003                      */
03004 
03005     Self::setExtIntMapping(ScanParseSkel::OSGsfImage,
03006                            SFImagePtr::getClassType().getId());
03007 
03008     Self::setExtIntMapping(ScanParseSkel::OSGsfInt32,
03009                            SFInt32::getClassType().getId());
03010 
03011 
03012     Self::setExtIntMapping(ScanParseSkel::OSGsfRotation,
03013                            SFQuaternion::getClassType().getId());
03014 
03015     Self::setExtIntMapping(ScanParseSkel::OSGsfString,
03016                            SFString::getClassType().getId());
03017 
03018     Self::setExtIntMapping(ScanParseSkel::OSGsfTime,
03019                            SFTime::getClassType().getId());
03020 
03021     Self::setExtIntMapping(ScanParseSkel::OSGsfVec2f,
03022                            SFVec2f::getClassType().getId());
03023 
03024     Self::setExtIntMapping(ScanParseSkel::OSGsfVec3f,
03025                            SFVec3f::getClassType().getId());
03026 
03027 
03028 
03029     Self::setExtIntMapping(ScanParseSkel::OSGmfColor,
03030                            MFColor3f::getClassType().getId());
03031 
03032     Self::setExtIntMapping(ScanParseSkel::OSGmfFloat,
03033                            MFReal32::getClassType().getId());
03034 
03035     Self::setExtIntMapping(ScanParseSkel::OSGmfInt32,
03036                            MFInt32::getClassType().getId());
03037 
03038     Self::setExtIntMapping(ScanParseSkel::OSGmfRotation,
03039                            MFQuaternion::getClassType().getId());
03040 
03041     Self::setExtIntMapping(ScanParseSkel::OSGmfString,
03042                            MFString::getClassType().getId());
03043 
03044     Self::setExtIntMapping(ScanParseSkel::OSGmfTime,
03045                            MFTime::getClassType().getId());
03046 
03047 
03048     Self::setExtIntMapping(ScanParseSkel::OSGmfVec3f,
03049                            MFVec3f::getClassType().getId());
03050 
03051     Self::setExtIntMapping(ScanParseSkel::OSGmfVec2f,
03052                            MFVec2f::getClassType().getId());
03053 
03054 
03055     Self::setExtIntMapping(ScanParseSkel::OSGsfNode,
03056                            SFNodePtr::getClassType().getId());
03057 
03058     Self::setExtIntMapping(ScanParseSkel::OSGmfNode,
03059                            MFNodePtr::getClassType().getId());
03060 
03061     /* extended types */
03062 
03063     Self::setExtIntMapping(ScanParseSkel::OSGsfMatrix,
03064                            SFMatrix::getClassType().getId());
03065 
03066     Self::setExtIntMapping(ScanParseSkel::OSGsfPnt3f,
03067                            SFPnt3f::getClassType().getId());
03068 
03069     Self::setExtIntMapping(ScanParseSkel::OSGmfPnt3f,
03070                            MFPnt3f::getClassType().getId());
03071 }
03072 
03073 /* remove this, if there is a general methode to find containers */
03074 FieldContainerPtr VRMLFile::findFCByName(const Char8  *szName,
03075                                                NodePtr pNode)
03076 {
03077     MFNodePtr::iterator i;
03078 
03079     NamePtr           pNodename;
03080     NodeCorePtr       pCore;
03081     FieldContainerPtr pFC;
03082 
03083     // check if name matches nodename
03084 
03085     pNodename =
03086         NamePtr::dcast(
03087             pNode->findAttachment(Name::getClassType().getGroupId()));
03088 
03089     if(pNodename != NullFC)
03090     {
03091         if(strcmp(szName, pNodename->getFieldPtr()->getValue().c_str())==0)
03092             return pNode;
03093     }
03094     // check if name matches corename
03095 
03096     pCore = pNode->getCore();
03097 
03098     if(pCore != NullFC)
03099     {
03100         pNodename = NamePtr::dcast(
03101             pCore->findAttachment(Name::getClassType().getGroupId()));
03102 
03103         if(pNodename != NullFC)
03104         {
03105             if(strcmp(szName, pNodename->getFieldPtr()->getValue().c_str())==0)
03106                 return pCore;
03107         }
03108     }
03109 
03110     // matching for children
03111     for(i  = pNode->getMFChildren()->begin();
03112         i != pNode->getMFChildren()->end();
03113         i++)
03114     {
03115         pFC = findFCByName(szName, *i);
03116 
03117         if(pFC != NullFC)
03118         {
03119             return pFC;
03120         }
03121     }
03122     return pFC;
03123 }
03124 
03125 FieldContainerPtr VRMLFile::findReference(const Char8 *szName)
03126 {
03127     // search reference in this file
03128     FieldContainerPtr          returnValue = NullFC;
03129 
03130     NameContainerMap::iterator mIt         =
03131         _nameFCMap.find(IDStringLink(szName));
03132 
03133     if(mIt != _nameFCMap.end())
03134     {
03135         returnValue = mIt->second;
03136     }
03137     else
03138     {
03139         returnValue = findFCByName(szName, _pSceneRootNode);
03140 
03141         if(returnValue == NullFC && _pLightRoot != NullFC)
03142         {
03143             returnValue = findFCByName(szName, _pLightRoot);
03144         }
03145     }
03146 
03147     return returnValue;
03148 }
03149 
03150 void VRMLFile::setContainerFieldValue(const FieldContainerPtr &pFC)
03151 {
03152     if(_pCurrentField != NULL  &&
03153         pFC           != NullFC)
03154     {
03155         if(_pCurrentFC   !=   NullFC                        &&
03156            _pCurrentField == _pCurrentFC->getField("children"))
03157         {
03158 #ifdef OSG_DEBUG_VRML
03159             indentLog(VRMLNodeDesc::getIndent(), PINFO);
03160             PINFO << "Add Child "
03161                   << &(*_pCurrentFC)
03162                   << " "
03163                   << &(*pFC)
03164                   << std::endl;
03165 #endif
03166             NodePtr pNode      = NodePtr::dcast(_pCurrentFC);
03167             NodePtr pChildNode = NodePtr::dcast(pFC);
03168 
03169             pNode->addChild(pChildNode);
03170         }
03171         else if(_pCurrentFC   !=   NullFC &&
03172                 _pCurrentField == _pCurrentFC->getField("core"))
03173         {
03174 #ifdef OSG_DEBUG_VRML
03175             indentLog(VRMLNodeDesc::getIndent(), PINFO);
03176             PINFO << "Add Core "
03177                   << &(*_pCurrentFC)
03178                   << " "
03179                   << &(*pFC)
03180                   << std::endl;
03181 #endif
03182 
03183             NodePtr     pNode = NodePtr    ::dcast(_pCurrentFC);
03184             NodeCorePtr pCore = NodeCorePtr::dcast(pFC);
03185 
03186             pNode->setCore(pCore);
03187         }
03188         else if(_pCurrentField->getCardinality() == FieldType::SINGLE_FIELD)
03189         {
03190             ((SFFieldContainerPtr *) _pCurrentField)->setValue(pFC);
03191         }
03192         else if(_pCurrentField->getCardinality() == FieldType::MULTI_FIELD)
03193         {
03194             ((MFFieldContainerPtr *) _pCurrentField)->push_back(pFC);
03195         }
03196     }
03197 }
03198 
03199 
03200 /*-------------------------------------------------------------------------*/
03201 /*                              cvs id's                                   */
03202 
03203 #ifdef __sgi
03204 #pragma set woff 1174
03205 #endif
03206 
03207 #ifdef OSG_LINUX_ICC
03208 #pragma warning( disable : 177 )
03209 #endif
03210 
03211 namespace
03212 {
03213     static Char8 cvsid_cpp[] = "@(#)$Id: $";
03214     static Char8 cvsid_hpp[] = OSGVRMLFILE_HEADER_CVSID;
03215 }