DtFileCache.h

Go to the documentation of this file.

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


#pragma once
#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/signalslib.h>
#include <boost/unordered_set.hpp>
#include <string>
#include <deque>
#include <map>
#include <tbb/task.h>
#include <vrvUtil/DtSignalConnectionManager.h>

namespace makArchives 
{
   class DtCacheSettingsRecord;
}

namespace makVrv
{
   class DtDe;
   class DtRecordSettingsBackupInterface;
   class DtFileCache;
   class DtTextureInterface;

   class DT_DLL_VRVCORE DtFileCache
   {
   public:

      typedef boost::unordered_set<std::string> ExcludedExtensions;
      typedef std::deque<std::string> FilePathList;

      struct LoadFileOptions
      {         
         FilePathList myDatabasePaths;
         unsigned int myCacheHint;

         std::multimap<std::string,std::string> customOptionStrings;
         std::multimap<std::string, void*> customPluginData;

         std::string myCacheDir;
         std::string myOriginalPath;
         bool myHasNoOptions;
         bool myUseAccelerationCacheFlag;

         bool myInstanceNodesFlag;
         bool myUseMemoryImageCacheFlag;
         bool myInstanceTexturesFlag;
         bool myCompressTexturesFlag;
         bool myUnloadImageDataFlag;

         bool myOptimizeDataFlag;
         int myOptimizeFileLevel;
         bool myFlipDDSTexturesFlag;
         bool myCDBSource;
      };

      friend class DtFileCacheCreator;

      friend class DtDeSharedState;

      virtual ~DtFileCache();

      virtual void init();

      virtual void initSingletonDependencies();

      LoadFileOptions defaultOptions() const;

      virtual bool getCachedNodeFile(const std::string& filePathIn, 
         const FilePathList& paths, std::string& cachedFilePathOut, 
         bool emitError );

      virtual bool getCachedImageFile(const std::string& filePathIn,
         const FilePathList& paths, std::string& cachedFilePathOut, 
         bool emitError);

      virtual void setCachingEnabled(bool flag);

      virtual bool acceleratedCachingEnabled() const;

      virtual void setCompressTextures(bool compress);

      virtual bool compressTexturesEnabled() const;

      virtual void releaseResources();

      virtual void clearAccelerationCache();

      virtual void setInstancingEnabled(bool enabled);

      virtual bool instancingEnabled() const;

      bool clearInstancesOnNewScene() const;

      void setClearInstancesOnNewScene(bool clearInstances);

      void clearInstancingCache();

      void flushInstanceCache(bool multipass,bool flushNodes, 
         bool flushTextures, bool flushImages);

      unsigned int flushCycleCount();

      virtual void ts_clearInstancingCache();

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

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

      virtual void getSplitRecord(std::vector<makArchives::DtCacheSettingsRecord>& rec,
         std::vector<std::string>& fileNames) {};

      virtual void addRecords(makArchives::DtCacheSettingsRecord& recs,
         makArchives::DtCacheSettingsRecord& combinedRec) {};

      void loadDefaults(bool loadOnlyFactorySettings = false);

      void saveAsDefaults();

      void exportSettings(const std::string& fileName);

      void importSettings(const std::string& fileName);

      virtual ExcludedExtensions& excludedExtensions();

      inline bool isExcludedExtension(const std::string& ext) const
      {
         return ts_isExcludedExtension(ext);
      }

      const DtRecordSettingsBackupInterface* settingsBackup() const
      {
         return mySettingsBackup;
      }

      DtRecordSettingsBackupInterface* settingsBackup()
      {
         return mySettingsBackup;
      }
      
      DtDe& getDe() 
      { 
         return myDe; 
      }

      boost::signalslib::signal<void ()> signal_clearInstanceCache;

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

      virtual bool getOrLoadTexture( DtTextureInterface* textureWrapper, const std::string& filename, 
         const DtFileCache::LoadFileOptions& loadFileOptions );

   protected:

      virtual void autoSaveDefaultsIfNeeded();

      virtual bool ts_isExcludedExtension(const std::string& ext) const;

      virtual void addExcludedExtension(const std::string &ext);

      virtual void removeExcludedExtension(const std::string &ext);

      DtFileCache(DtDe& de);

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

      
   protected:

      DtDe& myDe;
      bool myCachingEnabled;
      bool myCompressTextureFlag;
      bool myClearInstancesOnNewSceneFlag;
      bool myInstancingEnabled;
      unsigned int myFlushCycleCount;

      DtSignalConnectionManager myConnectionManager;

      ExcludedExtensions myExcludedExtensionMap;

      DtRecordSettingsBackupInterface* mySettingsBackup;
   };

   class DT_DLL_VRVCORE DtFileCacheCreator : public DtVirtualBaseClass
   {

   public:

      static DtFileCacheCreator& instance(DtDe& theIG);

      static void registerInstance(DtDe& de, DtFileCacheCreator* instance);     

      virtual DtFileCache* create(DtDe& de);

   };

}