DtIndirectTextureProcessor.h

Go to the documentation of this file.

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


#pragma once
#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtIndirectGeometryTextures.h>
#include <vrvOsg/DtOsgThreadingUtils.h>
#include <vrvOsg/DtMeifConverter.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <tbb/atomic.h>

#include <boost/thread/condition_variable.hpp>

#include <string>

namespace makVrv
{
   class DtOsgCullVisitor;
   class DtOsgRenderer;
   class DtGLDeleteObjectManager;
   class DtWindow;
   class DtIndirectTextureProcessor;

   typedef DtVirtualBaseClassCreator<DtIndirectTextureProcessor> DtIndirectTextureProcessorCreator;

   template <>
   inline const char* creatorTypeName<DtIndirectTextureProcessor>(void) { return "DtIndirectTextureProcessorCreator"; }

   class DT_DLL_VRVOSG DtIndirectTextureProcessor : public osg::Referenced
   {
   public:  
      // Inner class for creating a job that runs in the main thread.
      class LoadingJob : public osg::Operation
      {
      public:
         LoadingJob(DtIndirectTextureProcessor * proc);
         virtual ~LoadingJob();

         virtual void operator () (osg::Object * sv);

         virtual void release();

      protected:
         osg::ref_ptr < DtIndirectTextureProcessor> myTextureProcessor;

      };

      virtual ~DtIndirectTextureProcessor();

      friend DtIndirectTextureProcessorCreator;
      
   protected:

      DtIndirectTextureProcessor(DtDe& de);

   private:
      DtIndirectTextureProcessor(const DtIndirectTextureProcessor &other);
      DtIndirectTextureProcessor &operator=(const DtIndirectTextureProcessor &other);

   public:

      virtual void launchTextureLoadsIfNecessary(DtOsgRenderer* renderer);

      virtual void ts_addTexturesToLoad(int beforeTextureIndex, int afterTextureIndex, OsgTexturesArray& textures);

      virtual void ts_addTextureToLoad(osg::Texture* texture);

      virtual unsigned int streamTexturesToGpu(osg::RenderInfo& renderInfo);

      virtual unsigned int texturesUpdatedFrameNum();

      virtual int numTexturesRemaining();
      
      virtual void releaseGLObjects(osg::State* state) const;
      
      virtual void makeTexturesResidentIfNeeded(osg::RenderInfo& renderInfo) const;
      
      virtual bool ts_setCompressionDisabledHint(osg::Image* image, bool val) const;

      virtual bool ts_compressionDisabledHint(osg::Image* image) const;

      virtual void stopWork(); 

      virtual int numTexturesToLoad();
 
      virtual int numTexturesLoading();

      virtual bool inJobQueue();
      
      virtual boost::condition_variable& waitCondition();

      virtual bool inTextureToGCMap(osg::GraphicsContext* gContext, osg::Texture::TextureObject* texObj) const;

   protected:

      // internal
      virtual void addTexturesToLoad(const DtIndirectGeometryTextures* osgGeometryTextures);
      
      virtual void addTextureToLoad( osg::Texture* texture);

      virtual osg::Operation * createJob();

      virtual void collectNewTexturesAcrosssNonSharedContextIds(const osg::RenderInfo& renderInfo, osg::Texture::TextureObject* ts) const;
      virtual void makeNewTexturesAcrosssNonSharedContextIdsResident(osg::GraphicsContext* gc) const;

      virtual void addTextureToGCMap(osg::GraphicsContext* gContext, osg::Texture::TextureObject* texObj) const;

      virtual void slot_windowToBeDestroyed(DtWindow* window);

   protected:

      typedef std::set<osg::ref_ptr<osg::Texture> > SetTextures;

      mutable SetTextures myMutableTexturesToLoad;
      mutable SetTextures myMutableTexturesLoading;
      mutable SetTextures myMutableTexturesLoaded;

      tbb::atomic<bool> myInJobQueue;

      mutable unsigned int myTexturesUpdatedFrameNum;
      unsigned int myLastFrameNumber;
      DtMeifConverter myImageCompressor;
      bool myStopWork;
      mutable OpenThreads::Mutex myWorkMutex;
      boost::condition_variable myWaitCondition;

      typedef std::set<unsigned int> SetNonSharedContextIds;
      typedef std::map<unsigned int, SetNonSharedContextIds>  MapContextIdsToNonSharedContextIds;
      mutable MapContextIdsToNonSharedContextIds myMutableMapContextIdsToNonSharedContextIds;
      mutable OpenThreads::Mutex myMutableTextureResidencyMutex;
      typedef std::map<osg::GraphicsContext*, unsigned int>  MapGCToContextIds;
      mutable MapGCToContextIds myMutableGCToContextIds;

      // Set since each object should have 1 copy of each texture
      typedef std::set<osg::ref_ptr<osg::Texture::TextureObject> > TexturesSet;

      typedef std::map<osg::GraphicsContext*, TexturesSet> MapNonSharedContextIdsToNewTexturesArray;
      mutable MapNonSharedContextIdsToNewTexturesArray myMutableMapNonSharedContextIdsToNewTexturesSet;

      typedef std::map<osg::GraphicsContext*, TexturesSet> MapGCToTexSet;
      mutable MapGCToTexSet myMutableMapGraphicsContextToTexturesSet;

      mutable TexturesSet myMutableAllSeenTextures;

      DtGLDeleteObjectManager* myGLManager;
      DtSignalConnectionManager myConnections;
      DtDe& myDe;
   };

   
}