SoDB.h

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Paul S. Strauss (MMM yyyy)
** Modified by : Nick Thompson (MMM yyyy)
** Modified by : Gavin Bell (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef _SO_DB_
#define _SO_DB_
 
#include <Inventor/SoType.h>
#include <Inventor/SbTime.h>
#include <Inventor/threads/SbThread.h>
#include <Inventor/threads/SbThreadLocalStorage.h>
 
#ifndef LIBRARYBUILD
// uneeded header be kept for application built compatibility
#include <Inventor/sensors/SoSensorManager.h>
#include <Inventor/SbPList.h>
#include <Inventor/SoPreferences.h>
#endif
 
class SbPList;
class SoBase;
class SoSFRealTime;
class SoGroup;
class SoSeparator;
class SoInput;
class SoPath;
class SoNode;
class SoField;
class SbColor;
class SoGlobalField;
class SoSensorManager;
class SoTimerSensor;
class SoSensor;
class SoSystemTimer;
 
#ifdef _WIN32
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
#include <Inventor/SoInventorLibName.h>
 
#include <Inventor/SoModule.h>
SO_MODULE_HEADER(SoInventor, __INVENTORDLL)
 
#if defined(_WIN32)
// Detect compilation that uses any form of /clr
#if ((_MANAGED == 1) || (_M_CEE == 1))
#if defined(SO_MODULE_CHECK)
static SoModuleCheck myModule((bool)_SECURE_SCL);
#endif
#elif !defined HIDDEN_FROM_DOC && !defined(LIBRARYBUILD)
static SoModuleCheck myModule((bool)_SECURE_SCL);
#endif /* (_MANAGED == 1) || (_M_CEE == 1) */
#endif /* _WIN32 */
 
#if defined SO_VERSION_DEPRECATED_ERROR && !defined(LIBRARYBUILD)
static SoModuleCheck soVersionDeprecatedErrorCheck(SO_VERSION_DEPRECATED_ERROR);
#endif
 
typedef void SoDBHeaderCB(void *userData, SoInput *in);
 
//
//  Class: SoDB
//
//  Inventor database class.  This class maintains all the global
//  information necessary for reading and writing, naming classes, and
//  so on. All public methods on this class are static - users should
//  never explicitly create instances of this class. Initialization of
//  the database class causes a global instance to be created.
//
 
class  SoDB {
 
 public:
 
SoDEPRECATED enum
  RenderCacheMode {
    COMPILE,
    COMPILE_AND_EXECUTE,
    AUTO_RENDER_CACHE
  };
 
  static void init();
 
  static void finish();
 
#if 1             SoDEPRECATED
  static void threadInit();
#endif 
  static void setSystemTimer(SoSystemTimer* timer);
 
  static SbBool read(SoInput *in, SoNode *&rootNode);
 
  static SbBool read(SoInput *in, SoPath *&path);
 
  static SoSeparator *readAll(SoInput *in);
 
  static SbBool registerHeader(const SbString &headerString,
                               SbBool isBinary,
                               float ivVersion,
                               SoDBHeaderCB *preCB,
                               SoDBHeaderCB *postCB,
                               void *userData = NULL);
  static SbBool getHeaderData(const SbString &string,
                              SbBool &isBinary,
                              float &ivVersion,
                              SoDBHeaderCB *&preCB,
                              SoDBHeaderCB *&postCB,
                              void *&userData,
                              SbBool substringOK = FALSE);
  static int getNumHeaders();
 
  static SbString getHeaderString(int i);
 
  static SbBool isValidHeader(const char *testString);
 
  static SoField *createGlobalField(const SbName &name, SoType type);
 
  static SoField *getGlobalField(const SbName &name);
 
  static void renameGlobalField(const SbName &oldName, const SbName &newName);
 
  static void setRealTimeInterval(const SbTime &deltaT);
 
  static const SbTime &getRealTimeInterval();
 
  static void setDelaySensorTimeout(const SbTime &t);
 
  static const SbTime &getDelaySensorTimeout();
 
  static void processEvents();
 
  static int doSelect(int nfds, fd_set *readfds, fd_set *writefds,
                      fd_set *exceptfds, struct timeval *userTimeOut);
 
#if 1             SoDEPRECATED
  static SbBool isMultiThread();
#endif 
  static void writelock();
 
  static void writeunlock();
 
  static void readlock();
 
  static void readunlock();
 
#if 1             SoDEPRECATED
  static void setNumRenderCaches( int /*num*/ )
  {}
#endif 
#if 1             SoDEPRECATED
  static int  getNumRenderCaches()
  { return s_numRenderCaches; }
#endif 
#if 1             SoDEPRECATED
  static void setRenderCacheMode( RenderCacheMode mode );
#endif 
#if 1             SoDEPRECATED
  static RenderCacheMode getRenderCacheMode();
#endif 
  static SbTime getCurrentTime();
 
  static bool addPlugin( const SbString& fileName );
 
  static bool removePlugin( const SbString& fileName );
 
  static const std::vector<SbString>& getLoadedPlugins();
 
  static const std::vector<SbString>& getUnloadedPlugins();
 
  static bool addPluginsDirectory( const SbString& dirName );
 
  static bool removePluginsDirectory( const SbString& dirName );
 
  static const std::vector<SbString>& getPluginsDirectories();
 
SoEXTENDER_Documented public:
  static void addConverter(SoType fromField, SoType toField,
                           SoType converterEngine);
 
  static SoType getConverter(SoType fromField, SoType toField);
 
  static void removeConverter(SoType fromField, SoType toField);
 
  static void setIvTuneAllowed(SbBool ivTuneAllowed);
 
  static SbBool getIvTuneAllowed();
 
private:
 
#ifdef _WIN32
  static long openRegistryKey(const SbBool readOnlyFlag=FALSE);
 
  static long getRegistryKeyValue(LPTSTR keyName,
                             LPTSTR lpValueName, // address of name of value to query
                             LPDWORD lpType,     // address of buffer for value type
                             LPBYTE lpData,      // address of data buffer
                             LPDWORD lpcbData,   // address of data buffer size
                             const SbBool readOnlyFlag=FALSE // readOnly access if TRUE
                             );
 
  static long closeRegistryKey();
 
#endif //_WIN32
 
 private:
 
#if 1             SoDEPRECATED
  static void threadFinish();
#endif 
  // The following two functions are internal-only for now because we do
  // not have a reliable cross-platform implementation of trylock for a
  // read-write lock.
 
  // Provides a global try-write-lock mutex (see threads/SbThreadRWMutex.h)
  static SbBool trywritelock();
 
  // Provides a global try-read-lock mutex (see threads/SbThreadRWMutex.h)
  static SbBool tryreadlock();
 
  // Get ptr to global RWMutex for use with autolock
  // just an alias to SoInventorBase::getGlobalMutex()
  static SbThreadRWMutex *getGlobalMutex()
  { return SoInventorBase::getGlobalMutex(); }
 
  // Accesses sensor manager
  static SoSensorManager *getSensorManager();
 
  // Accesses UNLOCK sensor manager
  static SoSensorManager *getUnlockSensorManager();
 
  // Returns TRUE if database is initialized for the current thread.
  static bool isInitialized();
 
  // Returns FALSE if pick culling has been disabled
  static SbBool getPickCullingEnabled()
    { return m_pickCullingEnabled; }
 
  static const char* profileName;
 
  // This is called when some instance begins or ends a notification
  // process. It increments or decrements a counter of notifications
  // in progress. When the counter reaches 0, all priority 0
  // (immediate) delay queue sensors are triggered. By doing this,
  // all notification has a chance to finish before any evaluation
  // (due to data sensors, primarily) takes place.
  static void startNotify();
  static SbBool isNotifying();
  static void endNotify();
 
  // Enables/disables realTime sensor processing
  static void enableRealTimeSensor(SbBool enable);
 
  // Reads a base of any type, returning a pointer to it. Returns
  // FALSE on error.
  static SbBool read(SoInput *in, SoBase *&base);
 
  static SbBool m_readingAll;
 
  // Returns a copy of the path to the SoInput file (dirname).
  // If in does not contain a filename or if in is NULL, returns an empty string.
  // Returns empty string on error.
  static SbString getDirNameFromFullFileName(SoInput *in);
 
  // Flag to control use of valid names
  static SbBool useNameCompat;
 
  // Returns the threadId of the first thread that called SoDB::init()
  // it is usefull for nodes that do not support Multi-thread
  static SbThreadId_t getMainThreadId();
 
  static bool isInMainThread();
 
  // OpenInventor Java internal usage only
  static void resetMainThreadId();
 
  // remove a header String previously added by calling registerHeader()
  static SbBool unregisterHeader(const SbString &headerString);
 
  // Two-Way synchronization between a field and a GlobalField.
  template <class T> static void
  syncFieldGlobaly( T& field, const SbName& name )
  {
    T* globalField = static_cast<T*>( getGlobalField( name ) );
    if ( !globalField )
    {
      globalField = static_cast<T*>( createGlobalField( name, T::getClassTypeId() ) );
      globalField->setValue( field.getValue() );
    }
    field.connectFrom( globalField );
    field.setOnValueChangedCallback( [name]( SoField* _field ) {
      T* field = static_cast<T*>( _field );
      T* globalField = static_cast<T*>( getGlobalField( name ) );
      if ( globalField && ( *field != *globalField ) )
        *globalField = *field;
    } );
  }
 
  // declare TLS class
  SB_THREAD_TLS_HEADER();
 
 private:
#ifdef _WIN32
  // Key used by openRegistryKey, getRegistryKeyValue, and closeRegistryKey
  static HKEY s_vsgRegistryKeys;
#endif
 
    SoDB();
    virtual ~SoDB();
 
  // Protects notification
  static SbThreadMutex *notifyMutex;
 
  // Used to read all graphs and paths from the Open Inventor file
  // specified by the given SoInput.
  static SoGroup *internalReadAll(SoInput *, SoGroup *);
 
  // Reads the graph from the external file specified by the given SoInput.
  // This returns NULL if nothing is read.
  static SoSeparator *readAllFromInputReaders(SoInput *in);
 
  // Flag to control what time is used
  static SbBool useGlobalFieldTime;
 
  // Store if OpenGL/RenderRngine must be init/fiish
  // OIV_NOTUSEGPU SoPreference
  static bool s_notUseGPU;
 
  // Struct that contains all the information about the Global Database
  class SoGlobalDBInfos
  {
  public:
    // Constructor (allocate the sensorManager)
    SoGlobalDBInfos();
 
    // Init members that depends on node/field
    void init();
    // Cleanup members that depends on node/field
    void cleanup();
 
    // Destructor
    ~SoGlobalDBInfos();
 
    SoSensorManager* m_sensorManager;
    SoGlobalField* m_globalField;
    SoTimerSensor* m_realTimeSensor;
    SoSFRealTime *m_realTime;
    bool m_isInit;
  };
 
  // Thread local storage struct declaration
  struct MTstruct
  {
    SoGlobalDBInfos* globalDBInfos;
  };
 
  // get access to global database info
  // depending on the OIV mode used it is local to Thread or
  // global to all thread
  static SoGlobalDBInfos* getGlobalDBInfos();
 
  // WARNING: this static vars should never be access directly
  // always use getGlobalDBInfos() accessor
  static SoGlobalDBInfos* s_globalInfos;
 
  // How many current notifications
  static int notifyCount;
 
  static void realTimeSensorCallback(void *data, SoSensor *sensor);
 
  // List of valid header strings, and their corresponding callbacks
  static SbPList *headerList;
 
  // This dictionary stores field conversion engine types. The key
  // is created by mangling the types of the two fields to convert
  // from. The dictionary maps the key to the type of the conversion
  // engine.
  static SbDict *conversionDict;
 
  // Returns a conversionDict key from the two given field type id's.
  static uint32_t getConversionKey(SoType fromField, SoType toField);
 
  static void iv2_1PreCallback(void *userData, SoInput *in);
  static void iv2_0PreCallback(void *userData, SoInput *in);
  static void iv1_0PreCallback(void *userData, SoInput *in);
  static void iv2_0PostCallback(void *userData, SoInput *in);
  static void iv1_0PostCallback(void *userData, SoInput *in);
 
  // Global maximum number of render caches per node
  // (used by nodes that create OpenGL display lists or texture objects)
  static int s_numRenderCaches;
  static SbBool m_ivTuneAllowed;
 
  // Render cache creation mode
  // (used by nodes that create OpenGL display lists)
  static RenderCacheMode s_renderCacheMode;
 
  static SbBool m_pickCullingEnabled;
 
  static int s_initRefCount;
 
  static SbThreadId_t m_mainThreadId;
 
  static bool internalInit();
 
  friend class SoGlobalField;
  friend class SoVRMLDB;
  friend class SoVRMLInline;
};
 
#if defined(_WIN32)
#pragma warning( pop )
#endif
 
#endif /* _SO_DB_ */