DtOsgFileCache.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtOsgReferencedCollection.h>
#include <vrvOsg/DtTextureCollection.h>
#include <vrvOsg/DtEffectControllerContainer.h>
#include <vrvOsg/DtEffectControllerShaderCache.h>

#include <vrvCore/DtFileCache.h>

#include <vrvUtil/DtConcurrencyViewerMacros.h>
#include <vrvUtil/signalslib.h>

#include <osgDB/ReaderWriter>

#define _WINSOCKAPI_
#include <boost/signals2.hpp>

#include <tbb/atomic.h>
#include <tbb/spin_rw_mutex.h>

namespace osg
{
   class Drawable;
   class GraphicsContext;
   class Node;
   class Texture;
   class Object;
}

namespace makVrv
{
   class DtMeifConverter;
   class DtMetaFileManager;
   class DtOsgShaderManager;
   class DtOsgShaderFilesCache;
   class DtEffectControllerFactory;
   class DtReadFileCallback;
   class DtModelDefinition;

   class DT_DLL_VRVOSG DtOsgFileCache : public DtFileCache
   {
   public:      

      friend class DtOsgFileCacheCreator;

      virtual ~DtOsgFileCache();

      virtual void initSingletonDependencies();

      virtual void releaseResources()
      {
         releaseResources(0);
      }

      virtual void releaseResources(osg::State* state);

      virtual void setFromRecord( const makArchives::DtCacheSettingsRecord& rec );

      static void optimizeNodeGeometry(osg::Node* node);

      osg::Node* readNodeFile( const std::string& inputFilename,
         const LoadFileOptions& loadFileOptions);

      inline osg::ref_ptr<osg::Node> findNodeFile( const std::string& inputFilename )
      {
         return ts_findNodeFile(inputFilename);
      }

      osg::Image* readImageFile( const std::string& inputFilename, 
         const LoadFileOptions& loadFileOptions);

      virtual osg::Texture* getTextureInstance(const std::string& filePath, 
         osg::Texture::FilterMode minFilter, osg::Texture::FilterMode magFilter,
         osg::Texture::WrapMode s, osg::Texture::WrapMode t,
         const LoadFileOptions&  loadFileOptions);

      virtual void ts_getTextureInstance(const std::string& filePath, 
         osg::Texture::FilterMode minFilter, osg::Texture::FilterMode magFilter,
         osg::Texture::WrapMode s, osg::Texture::WrapMode t,
         const LoadFileOptions&  loadFileOptions, osg::ref_ptr<osg::Texture>& texture);

      virtual void runMergeDuplicateTextureVisitor(osg::Node& node);

      virtual void encodeOptionsString(const LoadFileOptions& loadFileOptions, 
         osgDB::ReaderWriter::Options& options) const;

      virtual void decodeOptions(const osgDB::ReaderWriter::Options& options, 
         LoadFileOptions& loadFileOptions) const;

      DtMetaFileManager* metaFileManager();

      void cleanDataFilePathList(FilePathList& fileList);
   
      boost::signals2::signal<void (osg::Node*, const std::string& origFileName,
         const std::string& actualFileName)> signal_nodeFileLoaded;

      boost::signals2::signal<void (osg::Image*, const std::string& origFileName,
         const std::string& actualFileName)> signal_imageFileLoaded;

      boost::signals2::signal<void(osg::Object*, const std::string& origFileName,
         const std::string& actualFileName)> signal_objectFileLoaded;

      boost::signals2::signal<void (const std::string& filename,
         osgDB::ReaderWriter::ReadResult&,const osgDB::ReaderWriter::Options*)> 
         signal_readNodeCallback;

      boost::signals2::signal<void (const std::string& filename,
         osgDB::ReaderWriter::ReadResult&,const osgDB::ReaderWriter::Options*)> 
         signal_readImageCallback;

      boost::signals2::signal<void(const std::string& filename,
         osgDB::ReaderWriter::ReadResult&, const osgDB::ReaderWriter::Options*)>
         signal_readObjectCallback;

      virtual const DtOsgShaderFilesCache& shaderFilesCache(void) const;

      virtual const std::string& loadShaderSource(const std::string& shaderFile) const;

      virtual std::string ts_getTextureFilePathAndSetNameIfNotSet(const osg::Texture* baseTexture) const;

      virtual void ts_setEffectTextureName(osg::ref_ptr<osg::Texture>& effectTexture, const std::string& validFile) const;

      virtual void ts_setEffectTextureFilterAndHardwareMipMapGen(osg::Texture* effectTexture, osg::Texture::FilterMode minFilter, osg::Texture::FilterMode magFilter, bool hardwareMipMapGen) const;

      virtual void ts_compareAndSwapIgnoreHint(osg::Texture* effectTexture, bool oldVal, bool newVal) const;

      virtual bool ts_checkAndSetIgnoreHint(osg::Object* obj, bool val, const char* hint) const;

      virtual bool ts_ignore(osg::Object* obj, const char* hint) const;

      virtual const DtEffectControllerShaderCache& effectControllerShaderCache(void) const;

      virtual void setNumActivePagerThreads(int active);
      
      virtual int numActivePagerThreads();
      
      virtual int numImageProcessingTasks() const;

      virtual void setNumDiguyWorkerThreads(int num);

      virtual void incrementNumSleepingPagerThreads();

      virtual void decrementNumSleepingPagerThreads();

      virtual DtOsgShaderManager& shaderManager(void);

      virtual const DtOsgShaderManager& shaderManager(void) const;

      virtual void ts_flushInstancingCache(bool multipass,
         bool flushNodes, bool flushTextures, bool flushImages);

   protected:

      friend class DtReadFileCallback;

      virtual osg::ref_ptr<osg::Node> ts_readNodeFile( const std::string& inputFilename, 
         const LoadFileOptions& loadFileOptions, const osg::UserDataContainer *optionsUserData);

      virtual osg::ref_ptr<osg::Node> ts_readCdbNodeFile(const std::string& inputFilename,
         const LoadFileOptions& loadFileOptions, const osg::UserDataContainer *optionsUserData);

      virtual osg::ref_ptr<osg::Node> ts_findNodeFile( const std::string& inputFilename );

      virtual osg::ref_ptr<osg::Image> ts_readImageFile( const std::string& inputFilename, 
         const LoadFileOptions& loadFileOptions,
         const osg::UserDataContainer* optionsUserData =0L);

      virtual osg::ref_ptr<osg::Image> ts_readCdbImageFile(const std::string& inputFilename,
         const LoadFileOptions& loadFileOptions,
         const osg::UserDataContainer* optionsUserData = 0L);

      virtual osg::ref_ptr<osg::Object> ts_readObject(
         const std::string& filename, const osgDB::ReaderWriter::Options* options);

      void ts_encryptImage( const std::string& inputFileName, 
         const std::string& outputFilename, const osgDB::ReaderWriter::Options* options, bool printToConsole);

      bool ts_resolveRelativeFilename( const LoadFileOptions& loadFileOptions,
         std::string& absoluteInputFilename );

      virtual void ts_clearInstancingCache();


      virtual void applyEffectTexture(osg::Node* node, const std::string& extension, 
                                       bool isCdb, osgDB::ReaderWriter::Options* option);

      DtOsgFileCache(DtDe& de);

      virtual bool save(const std::string& origFilename,
         const std::string& cachedFilename, bool optimize);

      bool saveToAcceleratedFile( const std::string& origFileName,
         osg::Node* nodeRef, const std::string& cachedFilename, 
         bool writeExternalReferences);

      virtual void addMetaFlightOptions(std::string& optionsString);

      virtual bool needsShaderGeneration(const std::string& extension, const LoadFileOptions& options) const;
      
      virtual void updateGlobalOptions();

      virtual void slot_onDdsFlipChanged(bool flip);

      virtual void slot_instancingChanged(bool enabled);

      // check if an attrData object is in the cache (only for FLT and CDB)      
      virtual bool getAttrFromLocalCache(const std::string& filename, osg::Object** attrData);

      virtual void writeCacheFile(osg::ref_ptr<osg::Node> node, const std::string& acceleratedFileLocation, DtCVMarkerSeries& series);

      virtual void shadersGeneration(osg::ref_ptr<osg::Node> node, const std::string& fileToLoad);

      virtual void squishImage(const std::string& fileToLoad, const std::string& acceleratedFilename, DtCVMarkerSeries& objectCreation,
                              osg::ref_ptr<osg::Image> image, bool writeAcceleratedFile, bool isCDB);

      virtual void saveImageFilename(const std::string& absoluteInputFilename, osg::Image* image);

      virtual osg::ref_ptr<osg::Image> isImageAlreadyInCache(const std::string& cacheKey, const std::string& inputExtension, const LoadFileOptions& loadFileOptions);

   protected:
      
      typedef boost::unordered_map<std::string,std::string> RelativePathCache;

      DtOsgReferencedCollection<osg::Node> myNodeCollection;
      DtOsgReferencedCollection<DtTextureCollection> myTextureCollection;
      DtOsgReferencedCollection<osg::Image> myImageCollection;
      typedef std::map< std::string, osg::ref_ptr<osg::Object>  > AttrCacheMap;
      AttrCacheMap myAttrCacheMap;
      
      unsigned int myMaxFlushTextureCount;
      unsigned int myMaxFlushNodeCount;
      unsigned int myMaxFlushImageCount;

      tbb::spin_rw_mutex myRelativePathMutex;
      RelativePathCache myRelativePathCache;
      DtMeifConverter* myImageCompressor;
      DtMetaFileManager* myMetaFileManager;

      DtOsgShaderManager& myShaderManager;
      DtOsgShaderFilesCache& myShaderFilesCache;
      DtEffectControllerFactory& myEffectControllerFactory;

      // effect controller shader cache
      DtEffectControllerShaderCache myEffectControllerShaderCache;

      osg::ref_ptr<DtReadFileCallback> myReadFileCallback;

      // determines threading behavior
      int myNumActivePagerThreads;
      tbb::atomic<int> myNumSleepingPagerThreads;
      tbb::atomic<int> myNumDiguyWorkerThreads;
   };

   class DT_DLL_VRVOSG DtOsgFileCacheCreator : public DtFileCacheCreator
   {

   public:

      virtual DtFileCache* create(DtDe& de);

   };
}

// Include the inl to solve a circular dependency problem for gcc
#include <vrvOsg/DtOsgReferencedCollection.inl>