Inventor/SoDB.h

Go to the documentation of this file.

/*=======================================================================
 * 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-2020 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 SoVRMLGroup;
class SoVRMLPROTODef;
class SbColor;
class SoGlobalField;
class SoSensorManager;
class SoTimerSensor;
class SoSensor;
class SoSystemTimer;

#ifdef _WIN32
#pragma warning( push )
#pragma warning(disable:4251)
#endif

#include <Inventor/SoModule.h>
SO_MODULE_HEADER(SoInventor, __INVDLL)

#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:

  enum RenderCacheMode {
    COMPILE,
    COMPILE_AND_EXECUTE,
    AUTO_RENDER_CACHE
  };

  static void init();

  static void finish();

  // Thread initialization routine.
  // It should be called as the first line of a new thread starting
  // routine, though it can be safely called several times by a
  // same thread. It should as well be called by all threads, if
  // one thread requests more local storage and other threads will
  // want to access the corresponding local storage. threadInit
  // should be called instead of init.
  static void threadInit();

  static void setSystemTimer(SoSystemTimer* timer);

#if 1             SoDEPRECATED
  static const char *getVersion();
#endif 
  static SbBool read(SoInput *in, SoNode *&rootNode);

  static SbBool read(SoInput *in, SoPath *&path);

  static SoSeparator *readAll(SoInput *in);

#if 1             SoDEPRECATED
  static SoVRMLGroup *readAllVRML(SoInput *in);
#endif 
  SoNONUNICODE static SbBool readPROTOFromFile(SoInput *in, char *name,
                                  SoVRMLPROTODef *&protoDef);


  static SbBool readPROTOFromFile(SoInput *in, const SbString& name,
                                  SoVRMLPROTODef *&protoDef);

  static void createRoute(SoNode *pFromNode, const char *fromEventOutName,
                          SoNode *pInNode,   const char *toEventInName);
  static void removeRoute(SoNode *pFromNode, const char *fromEventOutName,
                          SoNode *pInNode,   const char *toEventInName);

  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);

  static SbBool isMultiThread();

  static void writelock();

  static void writeunlock();

  static void readlock();

  static void readunlock();

  static void setNumRenderCaches( int num )
  { s_numRenderCaches = num; }

  static int  getNumRenderCaches()
  { return s_numRenderCaches; }

  static void setRenderCacheMode( RenderCacheMode mode );

  static RenderCacheMode getRenderCacheMode();

  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();

#if 1             SoDEPRECATED
  static void prioritizeChildrenCaching(SbBool onOff);
SoDEPRECATED
  static SbBool isPrioritizedChildrenCaching();
#endif 
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);

#if 1             SoDEPRECATED
  static float getLicensingVersionNumber();
SoDEPRECATED
  static int LicenseCheck( const char* productName, float version,
                           const char* licenseString = NULL,
                           SbBool printWarning = TRUE, char** errReport = NULL );
#endif 
  static void setIvTuneAllowed(SbBool ivTuneAllowed);

  static SbBool getIvTuneAllowed();

private:

#if 1             SoDEPRECATED
  static inline int TGSLicenseCheck(const char *productName, float version,
                             const char *licenseString = NULL,
                             SbBool printWarning = TRUE)
  { return LicenseCheck(productName, version, licenseString, printWarning, NULL); }

#endif 
#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();

#if 1             SoDEPRECATED
  static long openTGSRegistryKey(SbBool flag=FALSE)
  { return SoDB::openRegistryKey(flag); }
SoDEPRECATED
  static long getTGSKeyValue(LPTSTR keyName, LPTSTR lpValueName, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData, SbBool flag=FALSE)
  { return SoDB::getRegistryKeyValue(keyName, lpValueName, lpType, lpData, lpcbData, flag); }
SoDEPRECATED
  static long closeTGSRegistryKey()
  { return SoDB::closeRegistryKey(); }

#endif 
#endif //_WIN32

 private:

  static void threadFinish();

  // 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();

  //  Return whether mutexs should be created.
  static SbBool shouldCreateMutex();

  // 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
  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);

  // Internal usage for OIV Java
  static SoTimerSensor *getRealTimeSensor();

  // Internal usage for OIV Java
  static void restoreRealTimeSensorCB();

  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();

  // 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 or VRML 2.0 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;

  // Returned by getVersion()
  static const char *s_versionString;

  // 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 SbBool m_cacheChildrenFirst;

  static int s_initRefCount;

  static SbThreadId_t m_mainThreadId;

  static bool internalInit();

  friend class SoGlobalField;
};

#if defined(_WIN32)
#pragma warning( pop )
#endif

#endif /* _SO_DB_ */

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/