DtIndirectUvOffsetManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtIndirectManager.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvGraphicsUtils/DtReusableMemoryVector.h>
#include <vrvGraphicsUtils/DtVector2.h>

#include <vrvIndirectRendering/DtIndirectAnnotationAndUvOffset.h>

#include <unordered_map>

namespace osg
{
class State;
}

namespace makVrv
{
   class DtInstanceContainer;
   class DtDe;
   class DtGlBuffer;

   class DtIndirectUvOffsetManager;

   typedef DtVirtualBaseClassCreator<DtIndirectUvOffsetManager, DtInstanceContainer&> DtIndirectUvOffsetManagerCreator;

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

   class DT_DLL_VRVOSG DtIndirectUvOffsetManager : public DtIndirectManager
   {
   public:

      typedef std::map<std::string, unsigned int> AnnotationToUvOffsetMap;
      typedef std::map<int, AnnotationToUvOffsetMap> MapIntToAnnotationToUvOffsetMap;

      struct MultiplierAndTrackSide
      {
      public:
         MultiplierAndTrackSide();
      public:
         Vector2_32 myMultiplier;
         int mySide; // left, right, none

      };
      typedef std::unordered_map<int, MultiplierAndTrackSide> ScrollableUvOffsetIdsAndMultipliers;
      typedef std::unordered_map< int, ScrollableUvOffsetIdsAndMultipliers > MapInstancesToScrollableUvOffsetIds;

      //Simple data struct for holding 2 floats for the uv offset
      struct UvOffset
      {
         float uOffset;
         float vOffset;
      };

   public:
      friend DtIndirectUvOffsetManagerCreator;

      virtual ~DtIndirectUvOffsetManager();
   protected:
      DtIndirectUvOffsetManager(DtDe& de, DtInstanceContainer& container);

   private:
      DtIndirectUvOffsetManager() = delete;
      DtIndirectUvOffsetManager(const DtIndirectUvOffsetManager &other) = delete;
      DtIndirectUvOffsetManager &operator=(const DtIndirectUvOffsetManager &other) = delete;
   
   public:
      virtual void addUvOffsetAnnotations(int perGeomInstanceIndex, int size, const AnnotationToUvOffsetMap& annotationToUvOffsetMap, const ScrollableUvOffsetIdsAndMultipliers& scrollableUvOffsetIds, int instanceId);

      virtual void addUvOffsetAnnotation(int perGeomInstanceIndex, unsigned int uvOffsetStartId);

      virtual void removeUvOffsets(int instanceId);

      virtual void setUvOffset(const std::string& annotation, int instanceId, float uOffset, float vOffset);

      virtual void scrollUv(int instanceId, const std::tuple<float, float, float>& uvSpeeds);

      virtual void annotationAndUvOffsets(int instanceId, std::vector<DtIndirectAnnotationAndUvOffset>& annotations) const;

      virtual void setPureSignalBasedUvOffsets(bool val);

      virtual bool pureSignalBasedUvOffsets(void) const;

      virtual void processUvOffsets(void);

      virtual void releaseGLObjects(osg::State* state) const;

      virtual const DtGlBuffer* gpuUvOffsetBuffer(void) const;

   protected:

      virtual void updateUvOffsetBufferIfNecessary(void);

      virtual void deleteBuffers(void);

      virtual void tearDownBuffers(void) const;
      
   protected:

      MapIntToAnnotationToUvOffsetMap myMapIntToAnnotationToUvOffsetMap;
      MapInstancesToScrollableUvOffsetIds myMapInstancesToScrollableUvOffsetIds;

      mutable bool myMutableUvOffsetsDirty;

      //Simple operator for initializing the UVOffsets to 0
      struct UvOffsetInitializer
      {
         void operator()(UvOffset& info);
      };

      //which parent switches of this geometry are turned off 
      //(so if this is 0 then all switches are turned on and the geometry should be visible)
      typedef DtReusableMemoryVector<UvOffset, UvOffsetInitializer> VectorUvOffsets;
      VectorUvOffsets myVectorUvOffsets;

      DtGlBuffer* myGpuUvOffsetBuffer;

      bool myPureSignalBasedSwitches;
   };

}