DtOsgFileCache.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 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 <tbb/spin_rw_mutex.h>

#include <atomic>
#include <unordered_map>

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 bool getOrLoadTexture( DtTextureInterface* textureWrapper, const std::string& filename,
         const DtFileCache::LoadFileOptions& loadFileOptions ) override;

      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::signalslib::signal<void (osg::Node*, const std::string& origFileName,
         const std::string& actualFileName)> signal_nodeFileLoaded;

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

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

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

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

      boost::signalslib::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() const;
      
      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);

      virtual int numNodes() const;

      virtual int numTextures() const;

      virtual int numImages() const;
   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 void compressCdbImage( osg::Image* image, const LoadFileOptions& loadFileOptions, const std::string& ext, const std::string& acceleratedFilename,
         const std::string& zipTextureName, const std::string& fileToLoad, bool loadAccelerated, bool writeAcceleratedFile, DtCVMarkerSeries& objectCreation );

      virtual void setKeysForCdbImage( osg::Image* image, const std::string& acceleratedFilename, const std::string& absoluteInputFilename,
         const std::string& zipTextureName, const std::string& fileToLoad );

      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, bool generateDDS = false );

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

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

      // ********* CDB sensor FX functions and structure (below) ********** 
      
      struct color2DArray
      {
         osg::Vec4f myRGB1;
         osg::Vec4f myRGB2;
      };

      typedef std::map<unsigned int, color2DArray> mcodColorMap;

      struct baseMaterial
      {
         std::string myBaseMat;
         float myWeight;
      };
      typedef std::vector<baseMaterial> materialListType;
      std::map<unsigned int, materialListType> materialMap;

      struct primarySubstrateInfo
      {
         primarySubstrateInfo()
         {
         }
         primarySubstrateInfo(const materialListType& baseMaterialList)
            :myBaseMaterialList(baseMaterialList)
         {
         }
         materialListType myBaseMaterialList;
         color2DArray myMcodColors;
      };

      virtual std::string getRasterMaterialFilename(const std::string& modelFilename);

      virtual void readCdbRasterMaterialFile(const std::string& modelMaterialFile, mcodColorMap& mcodMap, const std::string& mcodCDBMaterialString);

      virtual void createCdbEmatImages(mcodColorMap& mcodMap, const std::string& fileToLoad, const osg::Image* cdbMaterialImage, osg::Image* imageEmat2, osg::Image* imageEmat3);

      virtual bool processRasterMaterialCreateEmat(osgDB::ReaderWriter::ReadResult& rasterMaterial, const std::string& optionString, const std::string& fileToLoad, 
         osg::ref_ptr<osg::Image>& imageEmat2, osg::ref_ptr<osg::Image>& imageEmat3);
       
      virtual void compressCdbEmatImage( osg::Image* imageEmat, const std::string& ext, const LoadFileOptions& loadFileOptions, const std::string& cdbZipFile, 
         const std::string& zipTextureName, bool cacheCDB, bool writeAcceleratedFile, DtCVMarkerSeries& objectCreation );

      // ********* CDB sensor FX functions and structure (above) ********** 

   protected:
      
      typedef std::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;
      
      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;
      DtSignalConnectionManager myConnections;

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

      // CDB specific driver 
      osgDB::ReaderWriter* myFltDriver;
      osgDB::ReaderWriter* myFltCdbDriver;
      osgDB::ReaderWriter* myMedfDriver;
      // CDB specific driver 
      osgDB::ReaderWriter* myRgbDriver;
      osgDB::ReaderWriter* myTiffDriver;
      osgDB::ReaderWriter* myMeifDriver;
      osgDB::ReaderWriter* myCDBZipDriver;
   };

   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>