DtOsgShapeCache.h

Go to the documentation of this file.

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


#pragma once
#include <vrvOsg/vrvOsg.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <osg/ref_ptr>
#include <osg/PrimitiveSet>
#include <unordered_map>
#include <functional>
#include <boost/functional/hash.hpp>

namespace osg
{
   class Drawable;
}

namespace makVrv
{

   class DT_DLL_VRVOSG DtOsgShapeCache : public DtVirtualBaseClass
   {
   public:

      static DtOsgShapeCache& instance(DtDe& de);

      DtOsgShapeCache();

      virtual ~DtOsgShapeCache();

      enum ShapeType
      {
         ShadedCube,
         ShadedCylinder,
      };

      void releaseResources();

      void ts_clearInstancingCache();

      osg::Drawable* getShapeInstance(ShapeType,unsigned int faceCount);

      osg::DrawElementsUInt* getCircularIndexBuffer(unsigned int vertexCount, 
         unsigned int firstIndex, unsigned int indexStep);

   protected:

      virtual osg::Drawable* createShapeInstance(ShapeType,unsigned int faceCount);

      struct ShapeKey
      {
         ShapeType type;
         unsigned int faceCount;

         bool operator == (const ShapeKey& other) const
         {
            return type == other.type && faceCount == other.faceCount;
         }
      };

      struct ShapeKey_hash : std::unary_function<ShapeKey, std::size_t>
      {
         std::size_t operator()(ShapeKey const& p) const
         {
            std::size_t seed = 0;
            boost::hash_combine(seed, p.type);
            boost::hash_combine(seed, p.faceCount);
            return seed;
         }
      };

      //Use map rather than unordered_map due to hash difficulties.
      typedef std::unordered_map<ShapeKey, osg::ref_ptr<osg::Drawable>,
         ShapeKey_hash  > ShapeMap;
      ShapeMap myShapeMap;


      struct IndexBufferKey
      {
         unsigned int count;
         unsigned int initial;
         unsigned int step;

         bool operator == (const IndexBufferKey& other) const
         {
            return count == other.count && initial == other.initial &&
               step == other.step;
         }
      };


      struct IndexBufferKey_hash : std::unary_function<IndexBufferKey, std::size_t>
      {
         std::size_t operator()(IndexBufferKey const& p) const
         {
            std::size_t seed = 0;
            boost::hash_combine(seed, p.count);
            boost::hash_combine(seed, p.initial);
            boost::hash_combine(seed, p.step);
            return seed;
         }
      };

      typedef std::unordered_map<IndexBufferKey, osg::ref_ptr<osg::DrawElementsUInt>,
         IndexBufferKey_hash > IndexBufferMap;
      IndexBufferMap myIndexBufferMap;

   };
}