Source/System/NodeCores/Groups/Misc/OSGInline.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include <cstdlib>
  40 #include <cstdio>
  41
  42 #include <boost/bind.hpp>
  43
  44 #include "OSGConfig.h"
  45
  46 #include "OSGInline.h"
  47 #include "OSGSceneFileHandler.h"
  48 #include "OSGOSGSceneFileType.h"
  49 #include "OSGRenderAction.h"
  50 #include "OSGGraphOpSeq.h"
  51
  52 OSG_USING_NAMESPACE
  53
  54 // Documentation for this class is emited in the
  55 // OSGInlineBase.cpp file.
  56 // To modify it, please change the .fcd file (OSGInline.fcd) and
  57 // regenerate the base file.
  58
  59 /*-------------------------------------------------------------------------*/
  60 /*                               Sync                                      */
  61
  62 void Inline::changed(ConstFieldMaskArg whichField,
  63                      UInt32            origin,
  64                      BitVector         details)
  65 {
  66     Inherited::changed(whichField, origin, details);
  67 }
  68
  69 /*-------------------------------------------------------------------------*/
  70 /*                               Dump                                      */
  71
  72 void Inline::dump(      UInt32    OSG_CHECK_ARG(uiIndent),
  73                   const BitVector OSG_CHECK_ARG(bvFlags )) const
  74 {
  75     SLOG << "Dump Inline NI" << std::endl;
  76 }
  77
  78 /*-------------------------------------------------------------------------*/
  79 /*                            Constructors                                 */
  80
  81 Inline::Inline(void) :
  82     Inherited()
  83 {
  84 }
  85
  86 Inline::Inline(const Inline &source) :
  87     Inherited(source)
  88 {
  89 }
  90
  91 /*-------------------------------------------------------------------------*/
  92 /*                             Destructor                                  */
  93
  94 Inline::~Inline(void)
  95 {
  96 }
  97
  98
  99 /*-------------------------------------------------------------------------*/
 100 /*                                Init                                     */
 101
 102 void Inline::initMethod(InitPhase ePhase)
 103 {
 104     Inherited::initMethod(ePhase);
 105
 106     if(ePhase == TypeObject::SystemPost)
 107     {
 108         RenderAction::registerEnterDefault(
 109             Inline::getClassType(),
 110             reinterpret_cast<Action::Callback>(&Inline::renderEnter));
 111     }
 112 }
 113
 114 void Inline::postOSGLoading(FileContextAttachment * const pContext)
 115 {
 116     Inherited::postOSGLoading(pContext);
 117
 118     UInt32 i = 0;
 119
 120     for(; i < _mfUrl.size(); ++i)
 121     {
 122         std::string szFilenameResolved =
 123             SceneFileHandler::the()->getPathHandler()->findFile(
 124                 _mfUrl[i].c_str());
 125
 126
 127         SceneFileHandler::the()->getPathHandler()->pushState();
 128
 129         // could be a real url with a relative inline path.
 130         if(szFilenameResolved.empty() == true)
 131         {
 132             szFilenameResolved = _mfUrl[i];
 133         }
 134
 135         SceneFileHandler::the()->getPathHandler()->setBaseFile(
 136             szFilenameResolved.c_str());
 137
 138         std::string szFName =
 139             SceneFileHandler::the()->getPathHandler()->extractFilename(
 140                 _mfUrl[i].c_str());
 141
 142         GraphOpSeqRefPtr pGraphOp = NULL;
 143
 144         if(_sfGraphOp.getValue().compare("none") == 0)
 145         {
 146             // leave it NULL
 147         }
 148         else if(_sfGraphOp.getValue().compare("default") == 0)
 149         {
 150             pGraphOp = SceneFileHandler::the()->getDefaultGraphOp();
 151         }
 152         else
 153         {
 154             pGraphOp = GraphOpSeq::create(_sfGraphOp.getValue());
 155         }
 156
 157         std::string urlExt;
 158
 159         if(_mfOptions.size() != 0)
 160         {
 161             boost::filesystem::path urlPath(_mfUrl[i]);
 162             urlExt = OSGBP2STR(urlPath.extension());
 163
 164             if(urlExt.empty() == false)
 165             {
 166                 SceneFileHandler::the()->pushOptions(urlExt);
 167
 168                 for(UInt32 j = 0; j < _mfOptions.size(); ++j)
 169                 {
 170                     SizeT uiSplit = _mfOptions[j].find('=');
 171
 172                     if(uiSplit != std::string::npos)
 173                     {
 174                         std::string name  = _mfOptions[j].substr(0,
 175                                                                  uiSplit    );
 176                         std::string value = _mfOptions[j].substr(uiSplit + 1);
 177
 178                         SceneFileHandler::the()->setOption(urlExt,
 179                                                            name,
 180                                                            value );
 181                     }
 182                 }
 183             }
 184         }
 185
 186         NodeUnrecPtr pFile = SceneFileHandler::the()->read(
 187             szFName.c_str(),
 188             pGraphOp,
 189             NULL,
 190             false);
 191
 192         if(pFile == NULL)
 193         {
 194             pFile = SceneFileHandler::the()->read(
 195                 szFilenameResolved.c_str(),
 196                 pGraphOp,
 197                 NULL,
 198                 false);
 199
 200             if(pFile == NULL)
 201             {
 202                 pFile = SceneFileHandler::the()->read(
 203                     _mfUrl[i].c_str(),
 204                     pGraphOp,
 205                     NULL,
 206                     false);
 207             }
 208         }
 209
 210         if(_mfOptions.size() != 0 && urlExt.empty() == false)
 211             SceneFileHandler::the()->popOptions(urlExt);
 212
 213         if(pFile != NULL)
 214         {
 215             pFile->addChangedFunctor(
 216                 boost::bind(&Inline::rootChanged, this, _1, _2, _3),
 217                 "");
 218
 219             setRoot(pFile);
 220
 221             SceneFileHandler::the()->getPathHandler()->popState();
 222
 223             break;
 224         }
 225         else
 226         {
 227             SWARNING << "could not read "
 228                      << _mfUrl[i]
 229                      << std::endl;
 230         }
 231
 232         SceneFileHandler::the()->getPathHandler()->popState();
 233     }
 234
 235     if(i == _mfUrl.size() && _sfRoot.getValue() != NULL)
 236     {
 237         _sfRoot.getValue()->subChangedFunctor(
 238             boost::bind(&Inline::rootChanged, this, _1, _2, _3));
 239
 240         setRoot(NULL);
 241     }
 242 }
 243
 244 void Inline::moveRootTo(Node *pTarget)
 245 {
 246     if(pTarget == NULL)
 247         return;
 248
 249     NodeUnrecPtr pInlineRoot = this->getRoot();
 250
 251     this->setRoot(NULL);
 252
 253     pTarget->addChild(pInlineRoot);
 254
 255 }
 256
 257 Node *Inline::getRoot(void) const
 258 {
 259     return Inherited::getRoot();
 260 }
 261
 262 Action::ResultE Inline::renderEnter(Action *action)
 263 {
 264     RenderAction *a = dynamic_cast<RenderAction *>(action);
 265
 266     a->useNodeList();
 267
 268     if(a->isVisible(this->getRoot()))
 269         a->addNode(this->getRoot());
 270
 271     return Action::Continue;
 272 }
 273
 274 void Inline::adjustVolume(Volume &volume)
 275 {
 276     if(getRoot() != NULL)
 277     {
 278         getRoot()->updateVolume();
 279
 280         volume.extendBy(getRoot()->getVolume());
 281     }
 282 }
 283
 284 void Inline::rootChanged(FieldContainer    *pFC,
 285                          ConstFieldMaskArg  whichField,
 286                          UInt32             origin    )
 287 {
 288     if(0x0000 != (whichField & Node::VolumeFieldMask))
 289     {
 290         this->invalidateVolume();
 291     }
 292 }
 293
 294 void Inline::resolveLinks(void)
 295 {
 296     if(_sfRoot.getValue() != NULL)
 297     {
 298         _sfRoot.getValue()->subChangedFunctor(
 299             boost::bind(&Inline::rootChanged, this, _1, _2, _3));
 300     }
 301
 302     Inherited::resolveLinks();
 303 }