DtGlBuffer.h

Go to the documentation of this file.

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

#pragma once

#include <string>

#include <vrvGraphicsUtils/vrvGraphicsUtils.h>
#include <vrvGraphicsUtils/DtBufferType.h>
#include <vrvGraphicsUtils/DtUsage.h>
#include <vrvGraphicsUtils/DtCpuAccess.h>

#include <iostream>

namespace makVrv
{
   class DT_DLL_VRVGRAPHICSUTILS DtGlBuffer
   {
   public:
      DtGlBuffer(const char * name, DtBufferType type, DtUsage usage, DtCpuAccess accessType, bool hasStagingBuffer);

      virtual ~DtGlBuffer();

   private:
      DtGlBuffer(const DtGlBuffer &other) = delete;
      DtGlBuffer &operator=(const DtGlBuffer &other) = delete;

   public:

      virtual void tearDown(void);

      virtual unsigned int releaseHandle(void);

      virtual bool updateBuffer(const int sizeToTransferInBytes, const void* data);

      virtual bool updateBuffer(const int offsetInBytes, const int sizeToTransferInBytes, const void* data);

      virtual void clearBuffer(unsigned int clearValue);

      virtual void bind() const;
      virtual void unbind() const;


      virtual unsigned char* stagingBuffer(void) const;

      virtual unsigned char* stagingBufferWithSize(unsigned int requestedSizeInBytes);

      virtual void syncStagingBufferToGpu(unsigned int offset, unsigned int sizeInBytes);

      virtual void syncStagingBufferToGpu();

      virtual bool bufferSubData(unsigned int offset, unsigned int sizeInBytes, const void *data);


      virtual void resetStagingBuffer();

      virtual int sizeInBytes(void) const;

      virtual const unsigned int handle(void) const;

      virtual void setResizeMultiplier(float rmul);

      virtual void setUseIncrementalUpdate(bool incrementalUpdate);

      virtual bool useIncrementalUpdate();

      virtual float resizeMultiplier();

      unsigned int type(void) const;

      virtual uint64_t gpuResidentAddress();

      virtual const void* mapForReading(void) const;

      virtual void unMap(void) const;

      template <class T>
      void printContents(std::ostream& outputStream, const std::string& strNumPrefix, const std::string& strValPrefix) const
      {
         if (myHandle == 0)
         {
            return;
         }
         const T* pRepType = (const T*)(mapForReading());
         if (pRepType)
         {
            const size_t numOfRepTypes = sizeInBytes() / sizeof(T);
            outputStream << strNumPrefix << numOfRepTypes << std::endl;
            for (int i = 0; i < numOfRepTypes; ++i)
            {
               outputStream << strValPrefix <<"[" << i << "]: "<< pRepType[i] << std::endl;
            }
         }
         unMap();
      }

   protected:

      virtual bool createAndBindBuffer();

      virtual int calculateNewSize(int requestedNewSizeInBytes);

   protected:

      std::string myName;
      unsigned int myHandle;
      unsigned int myType;
      int mySizeInBytes;
      float myResizeMultiplier;
      unsigned char* myStagingBuffer;
      bool myHasStagingBuffer;
      DtUsage myUsage;
      DtCpuAccess myAccessType;

      bool myUseIncrementalUpdate;
      int myLastBufferTransferOffset;
      uint64_t myResidentAddress;
      bool myIsResident;

      mutable bool myMutableIsMapped;
   };

}