OpenSG: OSGProxyGroup.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 #include <stdlib.h>
00040 #include <stdio.h>
00041 #include <sstream>
00042 #include <fstream>
00043 
00044 #include <OSGConfig.h>
00045 
00046 #include <OSGAction.h>
00047 #include <OSGDrawAction.h>
00048 #include <OSGCamera.h>
00049 #include <OSGRenderAction.h>
00050 #include <OSGSceneFileHandler.h>
00051 #include <OSGVolumeDraw.h>
00052 #include <OSGSceneFileHandler.h>
00053 
00054 #include "OSGProxyGroup.h"
00055 
00056 OSG_USING_NAMESPACE
00057 
00069 /*-------------------------------------------------------------------------*/
00070 /*                               Sync                                      */
00071 
00072 void ProxyGroup::changed(BitVector whichField, UInt32 origin)
00073 {
00074     if(whichField & (UrlFieldMask))
00075     {
00076         if(getAbsoluteUrl().empty())
00077         {
00078             PathHandler *ph = SceneFileHandler::the().getPathHandler();
00079             beginEditCP(ProxyGroupPtr(this),ProxyGroup::AbsoluteUrlFieldMask);
00080             if(ph) 
00081                 getAbsoluteUrl() = ph->findFile(getUrl().c_str());
00082             if(getAbsoluteUrl().empty())
00083                 getAbsoluteUrl() = getUrl();
00084             endEditCP(ProxyGroupPtr(this),ProxyGroup::AbsoluteUrlFieldMask);
00085             setState(NOT_LOADED);
00086         }
00087     }
00088     if(whichField & (
00089            StateFieldMask|
00090            UrlFieldMask|
00091            VolumeFieldMask))
00092     {
00093         for(UInt32 i = 0; i < _parents.size(); i++)
00094         {
00095             _parents[i]->invalidateVolume();
00096         }
00097     }
00098     Inherited::changed(whichField, origin);
00099 }
00100 
00101 /*-------------------------------------------------------------------------*/
00102 /*                               Dump                                      */
00103 
00104 void ProxyGroup::dump(      UInt32    OSG_CHECK_ARG(uiIndent), 
00105                        const BitVector OSG_CHECK_ARG(bvFlags )) const
00106 {
00107     SLOG << "Dump ProxyGroup NI" << std::endl;
00108 }
00109 
00110 /*-------------------------------------------------------------------------*/
00111 /*                            Constructors                                 */
00112 
00113 ProxyGroup::ProxyGroup(void) :
00114     Inherited()
00115 {
00116 }
00117 
00118 ProxyGroup::ProxyGroup(const ProxyGroup &source) :
00119     Inherited(source)
00120 {
00121 }
00122 
00123 /*-------------------------------------------------------------------------*/
00124 /*                             Destructor                                  */
00125 
00126 ProxyGroup::~ProxyGroup(void)
00127 {
00128     if(getRoot() != NullFC)
00129     {
00130         subRefCP(getRoot());
00131         setRoot(NullFC);
00132     }
00133 }
00134 
00139 void ProxyGroup::adjustVolume( Volume & volume )
00140 {
00141     volume.setValid();
00142     volume.setEmpty();
00143 
00144     if(getEnabled() == false)
00145         return;
00146 
00147     if(getState() == LOADED && getRoot() != NullFC)
00148     {
00149         volume.extendBy(getRoot()->getVolume());
00150     }
00151     else
00152     {
00153         volume.extendBy(getVolume());
00154     }
00155 }
00156 
00157 /*-------------------------------------------------------------------------*/
00158 /*                                Draw                                     */
00159 
00165 Action::ResultE ProxyGroup::draw(Action *action)
00166 {
00167     DrawActionBase *da        = dynamic_cast<DrawActionBase *>(action);
00168 
00169     if(getEnabled()     == false)
00170         return Action::Continue;
00171 
00172     if(getState() == NOT_LOADED)
00173         startLoading();
00174 
00175     if(getState() == LOAD_THREAD_FINISHED)
00176     {
00177         ProxyGroupPtr ptr(this);
00178             
00179         if(_loadedRoot != NullFC)
00180         {
00181             _loadThread=NULL;
00182             beginEditCP(ptr,RootFieldMask);
00183             if(getRoot() != NullFC)
00184                 subRefCP(getRoot());
00185             setRoot(_loadedRoot);
00186             getRoot()->invalidateVolume();
00187             getRoot()->updateVolume();
00188             endEditCP(ptr,RootFieldMask);
00189             addRefCP(getRoot());
00190             beginEditCP(ptr,StateFieldMask);
00191             setState(LOADED);
00192             endEditCP(ptr,StateFieldMask);
00193             da->getActNode()->invalidateVolume();
00194             da->getActNode()->updateVolume();
00195         }
00196         else
00197         {
00198             SWARNING << "failed to load " << getAbsoluteUrl() << std::endl;
00199             beginEditCP(ptr,StateFieldMask);
00200             setState(LOAD_ERROR);
00201             endEditCP(ptr,StateFieldMask);
00202         }
00203     }
00204 
00205     if(getState() == LOADED)
00206     {
00207         da->useNodeList();
00208         if(da->isVisible(getRoot().getCPtr()))
00209             da->addNode(getRoot());
00210     }
00211     else
00212     {
00213         if(da->getActNode()->getNChildren() == 0)
00214         {
00215             Color3f col;
00216             col.setValuesRGB(.5,.3,0);            
00217             dropVolume(da, da->getActNode(), col);
00218         }
00219     }
00220 
00221     // thread cleanup
00222     if(_loadThread && _loadQueue.empty())
00223     {
00224         printf("join\n");
00225         BaseThread::join(_loadThread);
00226         _loadThread = NULL;
00227     }
00228 
00229     return Action::Continue;
00230 }
00231 
00232 /*-------------------------------------------------------------------------*/
00233 /*                               loading                                   */
00234 
00238 void ProxyGroup::startLoading(void)
00239 {
00240     ProxyGroupPtr ptr(this);
00241 
00242     if(getConcurrentLoad() == false)
00243     {
00244         if(getInline().size() == 0)
00245         {
00246             _loadedRoot = SceneFileHandler::the().read(getAbsoluteUrl().c_str());
00247         }
00248         else
00249         {
00250             std::stringstream tmpStream(std::ios_base::in|
00251                                         std::ios_base::out|
00252                                         std::ios_base::binary);
00253             tmpStream.write((char*)(&getInline()[0]),getInline().size());
00254             _loadedRoot = SceneFileHandler::the().read(tmpStream, "osb");
00255         }
00256         beginEditCP(ptr,StateFieldMask);
00257         setState(LOAD_THREAD_FINISHED);
00258         endEditCP(ptr,StateFieldMask);
00259     }
00260     else
00261     {
00262         if(_loadLock == NULL)
00263         {
00264             _loadLock=Lock::get("ProxyGroupLoadLock");
00265         }
00266 
00267         _loadLock->aquire();
00268         
00269         bool noThread=_loadQueue.empty();
00270         
00271         _loadQueue.push(ptr);
00272         beginEditCP(ptr,StateFieldMask);
00273         setState(LOAD_THREAD_RUNNING);
00274         endEditCP(ptr,StateFieldMask);
00275         
00276         _loadLock->release();
00277         
00278         if(noThread)
00279         {
00280             if(_loadThread)
00281                 BaseThread::join(_loadThread);
00282             _loadThread=dynamic_cast<Thread *>(ThreadManager::the()
00283                                                ->getThread(NULL));
00284             _loadThread->runFunction( loadProc, 
00285                                       Thread::getAspect(),
00286                                       NULL );
00287         }
00288     }
00289 }
00290 
00291 /*-------------------------------------------------------------------------*/
00292 /*                               Init                                      */
00293 
00294 void ProxyGroup::initMethod (void)
00295 {
00296     DrawAction::registerEnterDefault( 
00297         getClassType(),
00298         osgTypedMethodFunctor2BaseCPtrRef<
00299             Action::ResultE,
00300             ProxyGroupPtr  ,
00301             CNodePtr        ,
00302             Action         *>(&ProxyGroup::draw));
00303 
00304     RenderAction::registerEnterDefault(
00305         getClassType(),
00306         osgTypedMethodFunctor2BaseCPtrRef<
00307             Action::ResultE,
00308             ProxyGroupPtr  ,
00309             CNodePtr        ,
00310             Action         *>(&ProxyGroup::draw));
00311 }
00312 
00313 
00314 void ProxyGroup::loadProc(void *)
00315 {
00316     bool stopThread=false;
00317     ProxyGroupPtr g;
00318 
00319     _loadLock->aquire();
00320     g=_loadQueue.front();
00321     _loadLock->release();
00322     while(!stopThread)
00323     {
00324         if(g->getInline().size() == 0) 
00325         {
00326             g->_loadedRoot=SceneFileHandler::the().read(g->getAbsoluteUrl().c_str());
00327         }
00328         else
00329         {
00330             std::stringstream tmpStream(std::ios_base::in|
00331                                         std::ios_base::out|
00332                                         std::ios_base::binary);
00333             tmpStream.write((char*)(&g->getInline()[0]),g->getInline().size());
00334             g->_loadedRoot = SceneFileHandler::the().read(tmpStream, "osb");
00335         }
00336         beginEditCP(g,StateFieldMask);
00337         g->setState(LOAD_THREAD_FINISHED);
00338         endEditCP(g,StateFieldMask);
00339         
00340         _loadLock->aquire();
00341         _loadQueue.pop();
00342         if(_loadQueue.empty())
00343             stopThread=true;
00344         else
00345             g=_loadQueue.front();
00346         _loadLock->release();
00347     }
00348 }
00349 
00350 ThreadBase                 *ProxyGroup::_loadThread=NULL;
00351 std::queue<ProxyGroupPtr>   ProxyGroup::_loadQueue=std::queue<ProxyGroupPtr>();
00352 Lock                       *ProxyGroup::_loadLock=NULL;
00353 
00354 /*-------------------------------------------------------------------------*/
00355 /*                              cvs id's                                   */
00356 
00357 #ifdef __sgi
00358 #pragma set woff 1174
00359 #endif
00360 
00361 #ifdef OSG_LINUX_ICC
00362 #pragma warning( disable : 177 )
00363 #endif
00364 
00365 namespace
00366 {
00367     static Char8 cvsid_cpp[] = "@(#)$Id: OSGProxyGroup.cpp,v 1.22 2002/06/30 05:04:22 vossg Exp $";
00368     static Char8 cvsid_hpp[] = OSGPROXYGROUP_HEADER_CVSID;
00369     static Char8 cvsid_inl[] = OSGPROXYGROUP_INLINE_CVSID;
00370 }
00371 
00372     
00373