debugDrawerSharedMemoryManager.h

Go to the documentation of this file.

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

#pragma once

#include "vlutil/vlShmPool.h"
#include "simTerrainDrawer/simTerrainDrawerDefines.h"
#include "simTerrainDrawer/debugDrawerNameManager.h"
#include "simTerrainDrawer/debugDrawerGeometryMemory.h"
#include "simTerrainDrawer/debugDrawerSphereMemory.h"
#include "simTerrainDrawer/debugDrawerLineMemory.h"
#include "simTerrainDrawer/debugDrawerTriangleMemory.h"
#include "vlutil/vlString.h"
#include <vector>
#include <boost/shared_ptr.hpp>

class DtDebugDrawerNameManager;
struct DtDebugMemoryBlockHeader;


class DT_DLL_simTerrainDrawer DtDebugDrawerSharedMemoryManager
{
   public:
      typedef DtDebugDrawerNameManager::MemoryType MemoryType;
      typedef DtDebugMemoryBlockHeader DtMemoryHeader;

      class ScopedLock
      {
      public:
         explicit ScopedLock(DtDebugDrawerSharedMemoryManager& manager) : myManager(manager)
         {
            myManager.readLock();
         }

         ~ScopedLock()
         {
            myManager.readUnlock();
         }

      private:
         DtDebugDrawerSharedMemoryManager& myManager;
      };

      class ScopedFrame
      {
      public:
         explicit ScopedFrame(DtDebugDrawerSharedMemoryManager& manager, bool erase = true)
            : myManager(manager)
         {
            myManager.startNewFrame(erase);
         }

         ~ScopedFrame()
         {
            myManager.advanceFrameCount();
         }

      private:
         DtDebugDrawerSharedMemoryManager& myManager;
      };

      friend class ScopedLock;
      friend class ScopedFrame;

      struct DT_DLL_simTerrainDrawer Header
      {
         double lineWidth;
         double alpha;

         Header();
      };

      DtDebugDrawerSharedMemoryManager(unsigned long memorySize=3*10485670);

      virtual ~DtDebugDrawerSharedMemoryManager();

      virtual void init(MemoryType memoryType, bool clearMemory=false);

      virtual void init(std::string tag, bool clearMemory=false,
         MemoryType memoryType=DtDebugDrawerNameManager::DtDebugDrawerSharedMemoryVRFType);

      Header header() const;
      void setHeader(const Header&);

      long getName() const;

      virtual bool push(DtDebugDrawerGeometryMemory* shape);

      virtual void update();


      virtual unsigned long frameCount() const;
      void startNewFrame(bool erase = true);
      void advanceFrameCount();

      virtual unsigned long numEntries() const;

      virtual unsigned long currentSize() const;

      virtual const char* getNext(const char* previousPtr, DtDebugDrawerGeometryMemory** shape);

      virtual std::vector<DtDebugDrawerNameManager::Slot> getMemoryBlockNames();

      virtual bool pointToMemoryBlock(long name);

   protected:
      void readLock();
      void readUnlock();

      unsigned long myMaxSize;

      unsigned long myCurrentSize;

      char* myCurrentMemPtr;

      char* myMemoryPtr;

      DtMemoryHeader* myHeader;

      DtSharedMemoryPoolManager* myManager;
      DtSharedMemoryPoolClient* myClient;
      
      DtDebugDrawerNameManager* myNameManager;

      bool myIsReader;

      long myMemoryName;

      MemoryType myMemoryType;
};

class DT_DLL_simTerrainDrawer DtMultiBufferDebugDrawer
{
public:
   typedef boost::shared_ptr<DtDebugDrawerSharedMemoryManager> BufferPtr;
   typedef std::vector<BufferPtr> BufferVector;

   class DT_DLL_simTerrainDrawer ScopedFrame
   {
   public:
      ScopedFrame(DtMultiBufferDebugDrawer& drawer, bool erase=true);
      ~ScopedFrame();

      bool push(DtDebugDrawerGeometryMemory* shape);

      void update();

   private:
      DtMultiBufferDebugDrawer& myDrawer;
      bool myEraseFlag;
      BufferVector::iterator myCurrentBuffer;
      std::auto_ptr<DtDebugDrawerSharedMemoryManager::ScopedFrame> mySubFrame;
      unsigned long myNumDrawn;
      unsigned long myNumOverflows;
   };

   friend class ScopedFrame;

   DtMultiBufferDebugDrawer(std::string tag,
      unsigned long bufferSize=10485670/2, unsigned long maxBuffers=13);

   DtMultiBufferDebugDrawer(std::string tag, DtDebugDrawerNameManager::MemoryType type,
      unsigned long bufferSize=10485670/2, unsigned long maxBuffers=13);

   DtDebugDrawerSharedMemoryManager::Header header() const;
   void setHeader(const DtDebugDrawerSharedMemoryManager::Header&);

   bool push(DtDebugDrawerGeometryMemory* shape);

   void update();

private:
   std::string myTag;
   DtDebugDrawerSharedMemoryManager::Header myHeader;
   unsigned long myBufferSize;
   BufferVector myBuffers;
   ScopedFrame* myCurrentFrame;
   DtDebugDrawerNameManager::MemoryType myType;
};