BufferState.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_interop_BufferState_h
#define vtk_m_interop_BufferState_h
 
//gl headers needs to be buffer anything to do with buffer's
#include <vtkm/interop/internal/BufferTypePicker.h>
#include <vtkm/interop/internal/OpenGLHeaders.h>
 
#include <vtkm/internal/ExportMacros.h>
 
#include <memory>
 
namespace vtkm
{
namespace interop
{
 
namespace internal
{
 
VTKM_SILENCE_WEAK_VTABLE_WARNING_START
 
class TransferResource
{
public:
  virtual ~TransferResource() {}
};
 
VTKM_SILENCE_WEAK_VTABLE_WARNING_END
}
 
class BufferState
{
public:
  BufferState(GLuint& gLHandle)
    : OpenGLHandle(&gLHandle)
    , BufferType(GL_INVALID_VALUE)
    , SizeOfActiveSection(0)
    , CapacityOfBuffer(0)
    , DefaultGLHandle(0)
    , Resource()
  {
  }
 
  BufferState(GLuint& gLHandle, GLenum type)
    : OpenGLHandle(&gLHandle)
    , BufferType(type)
    , SizeOfActiveSection(0)
    , CapacityOfBuffer(0)
    , DefaultGLHandle(0)
    , Resource()
  {
  }
 
  BufferState()
    : OpenGLHandle(nullptr)
    , BufferType(GL_INVALID_VALUE)
    , SizeOfActiveSection(0)
    , CapacityOfBuffer(0)
    , DefaultGLHandle(0)
    , Resource()
  {
    this->OpenGLHandle = &this->DefaultGLHandle;
  }
 
  ~BufferState()
  {
    //don't delete this as it points to user memory, or stack allocated
    //memory inside this object instance
    this->OpenGLHandle = nullptr;
  }
 
  GLuint* GetHandle() const { return this->OpenGLHandle; }
 
  bool HasType() const { return this->BufferType != GL_INVALID_VALUE; }
 
  GLenum GetType() const { return this->BufferType; }
 
  void SetType(GLenum type) { this->BufferType = type; }
 
  template <typename T>
  void DeduceAndSetType(T t)
  {
    this->BufferType = vtkm::interop::internal::BufferTypePicker(t);
  }
 
  vtkm::Int64 GetSize() const { return this->SizeOfActiveSection; }
 
  //Set the size of buffer in bytes
  //This will always needs to be <= the capacity of the buffer
  //Note: This call should only be used internally by vtk-m
  void SetSize(vtkm::Int64 size) { this->SizeOfActiveSection = size; }
 
  vtkm::Int64 GetCapacity() const { return this->CapacityOfBuffer; }
 
  // Helper function to compute when we should resize  the capacity of the
  // buffer
  bool ShouldRealloc(vtkm::Int64 desiredSize) const
  {
    const bool haveNotEnoughRoom = this->GetCapacity() < desiredSize;
    const bool haveTooMuchRoom = this->GetCapacity() > (desiredSize * 2);
    return (haveNotEnoughRoom || haveTooMuchRoom);
  }
 
  //Set the capacity of buffer in bytes
  //The capacity of a buffer can be larger than the active size of buffer
  //Note: This call should only be used internally by vtk-m
  void SetCapacity(vtkm::Int64 capacity) { this->CapacityOfBuffer = capacity; }
 
  //Note: This call should only be used internally by vtk-m
  vtkm::interop::internal::TransferResource* GetResource() { return this->Resource.get(); }
 
  //Note: This call should only be used internally by vtk-m
  void SetResource(vtkm::interop::internal::TransferResource* resource)
  {
    this->Resource.reset(resource);
  }
 
private:
  // BufferState doesn't support copy or move semantics
  BufferState(const BufferState&) = delete;
  void operator=(const BufferState&) = delete;
 
  GLuint* OpenGLHandle;
  GLenum BufferType;
  vtkm::Int64 SizeOfActiveSection; //must be Int64 as size can be over 2billion
  vtkm::Int64 CapacityOfBuffer;    //must be Int64 as size can be over 2billion
  GLuint DefaultGLHandle;
  std::unique_ptr<vtkm::interop::internal::TransferResource> Resource;
};
}
}
 
#endif //vtk_m_interop_BufferState_h