SAIFunctions.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 __SAIFUNCTIONS_H__
#define __SAIFUNCTIONS_H__
 
 
#include <H3D/H3DApi.h>
#include <H3D/H3DTypes.h>
#include <H3D/Node.h>
#include <H3D/X3DGroupingNode.h>
#include <H3D/X3D.h>
#include <H3D/MFNode.h>
#include <H3D/MFString.h>
 
#include <vector>
 
namespace H3D{ 
 
  class Scene;
  namespace SAI {
 
 
    class H3DAPI_API SAIError: public H3DUtil::Exception::H3DException {
    public:
      typedef enum {
        SAI_BROWSER_UNAVAILABLE,
 
        SAI_CONNECTION_ERROR,
 
        SAI_DISPOSED,
 
        SAI_IMPORTED_NODE,
 
        SAI_INSUFFICIENT_CAPABILITIES,
 
        SAI_INVALID_ACCESS_TYPE,
 
        SAI_INVALID_BROWSER,
        
        SAI_INVALID_DOCUMENT,
 
        SAI_INVALID_EXECUTION_CONTEXT,
 
        SAI_INVALID_FIELD,
 
        SAI_INVALID_NAME,
 
        SAI_INVALID_NODE,
 
        SAI_INVALID_OPERATION_TIMING,
 
        SAI_INVALID_URL,
 
        SAI_INVALID_X3D,
 
        SAI_NODE_IN_USE,
        
        SAI_NODE_NOT_AVAILABLE,
 
        SAI_NOT_SHARED,
 
        SAI_NOT_SUPPORTED,
 
        SAI_URL_UNAVAILABLE
      } ErrorType;
 
      SAIError( ErrorType _type,
        const string &_message = "" ) : 
        H3DUtil::Exception::H3DException( _message ),
        type(_type) {}
 
      inline ErrorType getErrorType() const {
        return type; 
      }
 
      inline const string & getErrorMessage() const {
        return message; 
      }
 
    protected:
      ErrorType type;
    };
 
    struct H3DAPI_API DOMNode {
 
    };
 
    
    struct H3DAPI_API ExecutionContext: public H3DUtil::RefCountedClass {
      ExecutionContext( bool _clean_up = false ) :
        clean_up( _clean_up ) {
        DEFNODES_DEBUG_NAME( named_nodes, "SAI::ExecutionContext::named_nodes")
        DEFNODES_DEBUG_NAME( exported_nodes, "SAI::ExecutionContext::exported_nodes")
        AUTOREF_DEBUG_NAME( root_node, "SAI::ExecutionContext::root_node")
 
        instances.push_back( this );
      }
 
      virtual ~ExecutionContext() {
        instances.remove( this );
      }
 
      static list< ExecutionContext * > instances;
 
      static void cleanUp() {
        for( list< ExecutionContext * >::iterator i = instances.begin();
             i != instances.end(); i++ ) {
          if( (*i)->clean_up ) {
            (*i)->root_node.reset( NULL );
            (*i)->named_nodes.clear();
            (*i)->exported_nodes.clear();
            (*i)->protos.clear();
            (*i)->world_url = "";
          }
        }
      }
      
      //const string &getSpecificationVersion();
      //const string &getEncoding();
 
      //      const ProfileInfo &getProfileInfo();
      // const ComponentInfo      
      // ...
 
      /*      X3DRoute *addRoute( Node *from_node, const string &from_field,
        Node *to_node, const string &to_field ) { return NULL;}
      
      void deleteRoute( X3DRoute * ){}
      */
      Node *createNode( const string &node_name );
      // Returns a new MFNode object with all the root nodes. Ownership of
      // new object is given to the caller.
      MFNode *getRootNodes();
      /*
      Node *createProto( const string &node_name ){return NULL;}
 
      Node *getImportedNode( const string &node_name ) { return NULL;}
      void updateImportedNode( const string &node_name, Node * ){}
      void removeImportedNode( const string &node_name ){}
 
      Node *getNamedNode( const string &node_name ) {return NULL; }
      void updateNamedNode( const string &node_name, Node * ) {}
      void removeNamedNode( const string &node_name ) {} */
 
      AutoRef< X3DGroupingNode > root_node;
      X3D::DEFNodes named_nodes;
      X3D::DEFNodes exported_nodes;
      X3D::PrototypeVector protos;
      string world_url;
      bool clean_up;
    };
 
    struct H3DAPI_API SAIScene: public ExecutionContext {
      //      void setMetaData( const string &key, const string &value );
      //      string getMetaData( const string &key );
      
      //      const string &getSpecificationVersion();
 
      //      Node *getExportedNode( const string &node_name );
      //      void updateExportedNode( const string &node_name, Node * );
      //      void removeExportedNode( const string &node_name );
      
    };
 
 
    //struct H3DAPI_API X3DField {
      
    //  Field *field;
    //};
    
    struct H3DAPI_API ComponentInfo {
      string   name;
      H3DUInt32 level;
      string title;
      string providerUrl;
    };
 
    struct ProfileInfo {
      string   name;
      H3DUInt32 level;
      string   title;
      string   providerUrl;
      vector< ComponentInfo > components;
    };
 
    class H3DAPI_API Browser {
    public:
      Browser( Scene *s );
 
      inline string getName() {
        return name;
      }
 
      inline void setName( const string &n) {
        name = n;
      }
 
      inline string getVersion() {
        return version;
      }
 
      inline void setVersion( const string &n) {
        version = n;
      }
 
    H3DFloat getCurrentSpeed();
    
    H3DFloat getCurrentFrameRate();
    
    const std::vector< ProfileInfo > &getSupportedProfiles();
 
    const ProfileInfo &getProfile( const string &profile );
 
    const std::vector< ComponentInfo > &getSupportedComponents();
 
    const ComponentInfo &getComponent( const string &component,
                                       H3DUInt32 level );
 
    ExecutionContext *getExecutionContext();
 
    SAIScene *createScene( ProfileInfo *pi = NULL,
                        const vector< ComponentInfo > &cis = 
                        std::vector< ComponentInfo>() );
 
    void replaceWorld( SAIScene *scene );
 
    SAIScene *importDocument( DOMNode *node );
 
    void loadURL( const string &url,
                  const std::vector< string > &property_list = 
                  std::vector< string >() );
 
    void setDescription( const string &description );
 
    SAIScene *createX3DFromString( const string &s );
 
    SAIScene *createX3DFromStream( const istream &s );
 
    SAIScene *createX3DFromURL( MFString *urls );
 
    //void updateControl( 
    //    registerBrowserInterest
 
 
 
    const vector< string > &getRenderingProperties();
 
    const vector< string > &getBrowserProperties();
 
    void nextViewpoint( H3DInt32 layer = 0 );
    void previousViewpoint( H3DInt32 layer = 0 );
    void firstViewpoint( H3DInt32 layer = 0 );
    void lastViewpoint( H3DInt32 layer = 0 );
 
    void print( const string &s );
 
    void dispose();
 
 
    protected:
    string name, version;
    AutoRef< SAIScene > SAI_scene; 
    Scene *scene;
    };
  }
}
 
#endif