Scene.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __SCENE_H__
#define __SCENE_H__
 
#include <H3D/X3DChildNode.h>
#include <H3D/H3DWindowNode.h>
#include <H3D/SAIFunctions.h>
#include <H3D/ShadowCaster.h>
#include <H3D/NvidiaGraphicsOptions.h>
#include <string>
 
 
// HAPI includes
#include <H3DUtil/Threads.h>
#include <vector>
 
 
 
namespace H3D {
 
  class H3DAPI_API Scene : public Node {
  public:
 
    #ifdef HAVE_PROFILER
    // profiledResult structure
    class profiledResultData
    {
      private:
      pthread_t thread_id;
      std::string profiled_result_string;
      std::string thread_debug_string;
      public:
      void setResult(pthread_t id,std::string result_profile)
      {
        if(!result_profile.empty())
          {this->thread_id=id;this->profiled_result_string=result_profile;}
      }
      void setResult(pthread_t id,std::string result_profile, std::string result_thread_debug)
      {
        if(!result_profile.empty())
        {
          this->thread_id=id;
          this->profiled_result_string=result_profile;
          this->thread_debug_string=result_thread_debug;
        }
      }
      void setThread_debug(std::string result){this->thread_debug_string=result;}
      bool isEmpty(){return this->profiled_result_string.empty()&&this->thread_debug_string.empty();}
      pthread_t getId(){return thread_id;}
      std::string getResult();
      //std::string getString(){return profiled_result_string;}
    };
    #endif
#ifdef HAVE_NVAPI
    typedef TypedSFNode< NvidiaGraphicsOptions > SFNvidiaGraphicsOptions;
    static string nvidia_graphics_options_file_url;
#endif // HAVE_NVAPI
 
    typedef TypedMFNode< H3DWindowNode > MFWindow;
    typedef TypedSFNode< X3DChildNode > SFChildNode;
 
    Scene( Inst< SFChildNode > _sceneRoot   = 0,
           Inst< MFWindow    > _window      = 0,
           Inst< SFFloat     > _frameRate   = 0
#ifdef HAVE_PROFILER
           ,
           Inst< MFString     > _profiledResult   = 0 
#endif
           ,Inst< SFFloat     > _maxFrameRate= 0
#ifdef HAVE_NVAPI
           ,
           Inst< SFNvidiaGraphicsOptions > _nvidiaGraphicsOptions = 0
#endif // HAVE_NVAPI
           );
 
    ~Scene();
 
    inline TraverseInfo * getLastTraverseInfo() {
      return last_traverseinfo;
    }
 
    void setActive( bool _active ) {
      active = _active;
    }
 
    inline bool isActive() {
      return active;
    }
 
    virtual void idle();
 
    void loadSceneRoot( const string &url );
 
    void setSceneRoot( SAI::SAIScene *scene_info );
 
    inline SAI::Browser *getSAIBrowser() {
      return &SAI_browser;
    }
 
    ShadowCaster *getDefaultShadowCaster() {
      return shadow_caster.get();
    }
    
#ifdef HAVE_GLUT
    static void mainLoop();
#endif
 
    H3DUniquePtr< SFChildNode > sceneRoot;
 
    H3DUniquePtr< MFWindow >  window;
 
    H3DUniquePtr< SFFloat >  frameRate;
 
    H3DUniquePtr< SFFloat >  maxFrameRate;
#ifdef HAVE_PROFILER
    H3DUniquePtr< MFString > profiledResult;
    
    Scene::profiledResultData H3D_scene_result;
    Scene::profiledResultData haptic_result;
    Scene::profiledResultData H3D_sofa_result;
 
    bool outputonce ;
    std::string generateProfileResult();
 
    struct ProfileNodeResult {
      Node* node;
      H3DTime render_time;
      H3DTime traverse_time;
 
      H3DTime render_time_last;
      H3DTime traverse_time_last;
    };
    static bool compareRenderTime ( const ProfileNodeResult& lhs, const ProfileNodeResult& rhs ) { return lhs.render_time > rhs.render_time; }
    static bool compareTraverseTime( const ProfileNodeResult& lhs, const ProfileNodeResult& rhs ) { return lhs.traverse_time > rhs.traverse_time; }
 
    typedef std::vector < ProfileNodeResult > ProfileNodeResultVec;
    std::string exclusive_times_string;
    H3DTime exclusive_times_update_time;
 
    void computeExclusiveTimes( Node& _node, ProfileNodeResultVec& _result );
#endif
    static H3DUniquePtr< SFTime > time;
    //static SFTime *time;
  
    static set< Scene* > scenes;
 
#ifdef HAVE_NVAPI
    H3DUniquePtr<SFNvidiaGraphicsOptions> nvidiaGraphicsOptions;
#endif // HAVE_NVAPI
 
    static H3DNodeDatabase database;
 
    typedef enum {
      CALLBACK_DONE,
      CALLBACK_CONTINUE
    } CallbackCode;
 
    typedef CallbackCode (*CallbackFunc)(void *data); 
 
    static void addCallback( CallbackFunc func, void *data ) {
      callback_lock.lock();
      callbacks.push_back( make_pair( func, data ) );
      callback_lock.unlock();
    }
 
 
    struct ProgramSetting {
    ProgramSetting( Field *_field,
                    const string &_name = "",
                    const string &_section = ""):
        field( _field ),
        name( _name ),
        section( _section ) {}
        
 
      Field *field;
      string name;
      string section;
 
    };
 
    typedef std::list< ProgramSetting > ProgramSettings;
 
    static void addProgramSetting( Field *field,
                                   const string &name = "",
                                   const string &section = "Main settings");
 
    static bool removeProgramSetting( const string &name,
                                      const string &section = "Main settings" );
 
    static bool removeProgramSetting( Field *field );
 
    static Field *getProgramSetting( const string &name,
                                     const string &section = "Main settings" );
 
    typedef ProgramSettings::iterator SettingsIterator;
 
    static SettingsIterator programSettingsBegin();
 
    static SettingsIterator programSettingsEnd();
 
    typedef enum {
      ADD_SETTING,
      REMOVE_SETTING
    } ProgramSettingsEvent;
 
    typedef void (*ProgramSettingsCallbackFunc)( ProgramSettingsEvent event,
                                                 const ProgramSetting &settings, 
                                                 void *data); 
 
    typedef std::pair< ProgramSettingsCallbackFunc, void * > ProgramSettingsCallbackId;
 
    static ProgramSettingsCallbackId addProgramSettingsCallback( ProgramSettingsCallbackFunc func, 
                                                          void *data );
 
    static bool removeProgramSettingsCallback( ProgramSettingsCallbackId id );
 
    static void clearProgramSettingsCallbacks();
 
    static H3D::Node* findChildNode(H3D::X3DGroupingNode *group, const std::string &nodeType, const std::string &nodeName="");
 
    static H3D::Node* findNodeType(H3D::Node *node, const std::string &nodeType, const std::string &nodeName="" );
 
    typedef std::map < Node*, AutoRefVector<Node> > NodeParentsMap;
    typedef std::map < std::string,std::vector < std::string > > SearchFieldNameMap;
    typedef std::vector < std::string > StringVec;
 
    template < typename NodeType >
    static void findNodes ( 
      Node& _node,
      AutoRefVector<NodeType>& _result, 
      const std::string& _nodeName= "",
      NodeParentsMap* _parentMap= NULL,
      SearchFieldNameMap* _searchFieldNames= NULL,
      StringVec* _typeNames= NULL,
      bool _exactNodeName= true,
      bool _verbose= false,
      Node* _parent= NULL,
      StringVec* _ignoreTraverseNodeTypeNames= NULL ) {
 
      // if the node type name is in the ignore list we have nothing to do with this node
      if ( _ignoreTraverseNodeTypeNames &&
           find ( _ignoreTraverseNodeTypeNames->begin(), _ignoreTraverseNodeTypeNames->end(), _node.getTypeName() ) != _ignoreTraverseNodeTypeNames->end() ) {
          // We should not search this node type at all
          return;
      }
 
      if ( _typeNames == NULL || 
            find ( _typeNames->begin(), _typeNames->end(), _node.getTypeName() ) != _typeNames->end() ) {
        if ( NodeType* n= dynamic_cast < NodeType* > ( &_node ) ) {
          const std::string& node_name= n->getName();
          if ( _nodeName.empty() || 
               ( ( _exactNodeName && _nodeName == node_name) ||
                 (!_exactNodeName && node_name.find ( _nodeName ) != std::string::npos ) ) ) {
            _result.push_back ( n );
            if ( _parentMap && _parent ) {
              (*_parentMap)[n].push_back ( _parent );
            }
          }
        }
      }
 
      // get field names to search, if empty search all
      std::vector<std::string> field_names;
      if ( _searchFieldNames ) {
        SearchFieldNameMap::iterator i= _searchFieldNames->find ( _node.getTypeName() );
        if ( i != _searchFieldNames->end() ) {
          field_names= (*i).second;
        } else {
          // We should not search this node type at all
          return;
        }
      }
 
      // Iterate over all fields and recurse into children
      H3DNodeDatabase* db= H3DNodeDatabase::lookupNodeInstance( &_node );
 
      for( H3DNodeDatabase::FieldDBConstIterator i = db->fieldDBBegin();
           db->fieldDBEnd() != i; ++i ) {
        Field *f = i.getField( &_node ); 
   
        if( f ) {
          if ( f->getAccessType() != Field::INPUT_ONLY ) {
            if ( _searchFieldNames ) {
              if ( find ( field_names.begin(), field_names.end(), f->getName() ) == field_names.end() ) {
                // This field should be skipped
                continue;
              }
            }
 
            if ( SFNode* sf_node= dynamic_cast< SFNode * >( f ) ) {
              Node* c= sf_node->getValue();
              if ( c ) {
                if ( _verbose ) {
                  Console(LogLevel::Error) << "Node::findNodes(): " << _node.getName() << " -> " << f->getName() << endl;
                }
                findNodes ( *c, _result, _nodeName, _parentMap, _searchFieldNames, _typeNames, _exactNodeName, _verbose, &_node, _ignoreTraverseNodeTypeNames );
              }
            } else if ( MFNode* mf_node= dynamic_cast< MFNode * >( f ) ) {
              const NodeVector& children= mf_node->getValue();
              for ( NodeVector::const_iterator j = children.begin(); j != children.end(); ++j ) {
                Node* c= *j;
                if ( c ) {
                  if ( _verbose ) {
                    Console(LogLevel::Error) << "Node::findNodes(): " << _node.getName() << " -> " << f->getName() << endl;
                  }
                  findNodes ( *c, _result, _nodeName, _parentMap, _searchFieldNames, _typeNames, _exactNodeName, _verbose, &_node, _ignoreTraverseNodeTypeNames );
                }
              }
            }
          }
        }
      }
    }
    
  protected:
    SAI::Browser SAI_browser;
 
    static H3DUtil::MutexLock callback_lock;
 
    static ProgramSettings program_settings;
 
    typedef std::list< std::pair< CallbackFunc, void * > > CallbackList;
    typedef std::list< std::pair< ProgramSettingsCallbackFunc, void * > > ProgramSettingsCallbackList;
    // A list of the callback functions to run.
    static CallbackList callbacks;
    static ProgramSettingsCallbackList program_settings_callbacks;
    
    class EventSink: public Field {
    public:
      EventSink() {
        setName( "Scene::eventSink" ); 
      }
      ~EventSink(){
    }  
    protected:
      virtual void update();
    };
   
  public:
    static H3DUniquePtr<EventSink> eventSink;
 
  private:
    bool active;
    // the time of the start of the last loop.
    TimeStamp last_time;
    // the TraverseInfo instance from the previous scenegraph loop.
    TraverseInfo *last_traverseinfo;
    // Reference to shadow caster used to cast shadows for shapes
    // in scene graph.
    AutoRef< ShadowCaster > shadow_caster;
 
#ifdef HAVE_NVAPI
    static bool NVOptions_applied;
#endif // HAVE_NVAPI
 
    H3DTime last_unused_texture_check;
  public:
    static void removeCallback(void *data ) {
      callback_lock.lock();
      for( CallbackList::iterator i = callbacks.begin(); i != callbacks.end(); ++i ) {
        if( (*i).second == data ) {
          callbacks.erase( i );
          break;
        }
      }
      callback_lock.unlock();
    }
  };
}
 
#endif