DtOsgFileCache.h

Go to the documentation of this file.

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


#pragma once
#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgReferencedCollection.h>
#include <vrvCore/DtFileCache.h>
#include <vrvUtil/signalslib.h>
#include <osgDB/ReaderWriter>

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

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

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

   class DT_DLL_VRVOSG DtOsgFileCache : public DtFileCache
   {
   public:      

      friend class DtOsgFileCacheCreator;

      virtual ~DtOsgFileCache();

      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 encodeOptionsString(const LoadFileOptions& loadFileOptions, 
         osgDB::ReaderWriter::Options& options) const;

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

      DtMetaFileManager* metaFileManager();
   
      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 (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;

      class TextureCollection : public osg::Referenced
      {
      public:
         union KeyType
         {
            unsigned short key;
            struct
            {                        
               unsigned int min : 4;
               unsigned int max : 4;
               unsigned int wrap_s : 4;
               unsigned int wrap_t : 4;
            };
         };

         // \Returns trush if the entire texture collection should be flushed.
         bool flush()
         {
            TextureList replacementList;

            TextureList::iterator i = myTextures.begin();
            TextureList::iterator e = myTextures.end();
            for(;i != e;++i)
            {
               if(i->second->referenceCount() > 1)
               {
                  replacementList.push_back(*i);
               }
            }
            if(replacementList.size() != myTextures.size())
            {
               myTextures.swap(replacementList);
            }
            return myTextures.size() == 0;
         }

         void releaseGLObjects()
         {
            TextureList::iterator i = myTextures.begin();
            TextureList::iterator e = myTextures.end();
            for(;i != e;++i)
            {
               i->second->releaseGLObjects();
            }
         }

         bool findTexture(unsigned int minFilter, unsigned int magFilter,
            unsigned int wrapS, unsigned wrapT, osg::ref_ptr<osg::Texture>& texture)
         {
            KeyType k;
            k.min = ((minFilter ^ 0x2600) & 0x3) + ((minFilter ^ 0x2600) >> 7);
            k.max = ((magFilter ^ 0x2600) & 0x3) + ((magFilter ^ 0x2600) >> 7);
            k.wrap_s = (wrapS & 0x0F) | ((wrapS & 0x10) >> 3);
            k.wrap_t = (wrapT & 0x0F) | ((wrapT & 0x10) >> 3);

            TextureList::iterator i = myTextures.begin();
            TextureList::iterator e = myTextures.end();
            for(;i != e;++i)
            {
               if(i->first.key == k.key)
               {
                  texture = i->second;
                  return true;
               }
            }
            return false;
         }

         void addTexture(osg::Texture* texture)
         {
            KeyTexturePair pair;

            pair.first.min = ((texture->getFilter(osg::Texture::MIN_FILTER) ^ 0x2600) & 0x3) +
               ((texture->getFilter(osg::Texture::MIN_FILTER) ^ 0x2600) >> 7);

            pair.first.max = ((texture->getFilter(osg::Texture::MAG_FILTER) ^ 0x2600) & 0x3) +
               ((texture->getFilter(osg::Texture::MAG_FILTER) ^ 0x2600) >> 7);

            pair.first.wrap_s = (texture->getWrap(osg::Texture::WRAP_S) & 0x0F) |
               ((texture->getWrap(osg::Texture::WRAP_S) & 0x10) >> 3);

            pair.first.wrap_t = (texture->getWrap(osg::Texture::WRAP_T) & 0x0F) |
               ((texture->getWrap(osg::Texture::WRAP_T) & 0x10) >> 3);
            pair.second = texture;
            myTextures.push_back(pair);
         }

         typedef std::pair<KeyType,osg::ref_ptr<osg::Texture> > KeyTexturePair;
         typedef std::vector<KeyTexturePair> TextureList;
         TextureList myTextures;
      };


      const DtOsgShaderManager& shaderManager(void) const
      {
         return myShaderManager;
      }

      DtOsgShaderManager& shaderManager(void)
      {
         return myShaderManager;
      }

      const DtOsgShaderFilesCache& shaderFilesCache(void) const
      {
         return myShaderFilesCache;
      }

      DtEffectControllerFactory& effectControllerFactory(void) const
      {
         return myEffectControllerFactory;
      }

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

      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 ts_flushInstancingCache( bool multipass,
         bool flushNodes, bool flushTextures, bool flushImages);

      DtOsgFileCache(DtDe& de);

      std::string ts_buildAcceleratedFilename( const std::string& filePathIn,
         const std::string& cachedDir,
         const std::string& cachedExtension) const;

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

      bool shouldSaveFile( const std::string& filename);

      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& filename, const LoadFileOptions& options) const;
      
      virtual void updateGlobalOptions();

      virtual void slot_onDdsFlipChanged(bool flip);

      virtual void slot_instancingChanged(bool enabled);

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

      DtOsgReferencedCollection<osg::Node> myNodeCollection;
      DtOsgReferencedCollection<TextureCollection> myTextureCollection;
      DtOsgReferencedCollection<osg::Image> myImageCollection;

      unsigned int myMaxFlushTextureCount;
      unsigned int myMaxFlushNodeCount;
      unsigned int myMaxFlushImageCount;

      boost::mutex myRelativePathMutex;
      RelativePathCache myRelativePathCache;
      DtMeifConverter* myImageCompressor;
      DtMetaFileManager* myMetaFileManager;

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

      //mutex for protecting against setUserValue threading issues.
      boost::mutex myImageUserValueMutex;
   };

   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>