vtkOpenGLBufferObject.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkOpenGLBufferObject_h
#define vtkOpenGLBufferObject_h
 
#include "vtkObject.h"
#include "vtkRenderingOpenGL2Module.h" // for export macro
#include <cstddef>                     // for ptrdiff_t
#include <string>                      // used for std::string
#include <vector>                      // used for method args
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;
class vtkDataArray;
class vtkPoints;
 
class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLBufferObject : public vtkObject
{
public:
  static vtkOpenGLBufferObject* New();
  vtkTypeMacro(vtkOpenGLBufferObject, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum ObjectType
  {
    ArrayBuffer,
    ElementArrayBuffer,
    TextureBuffer
  };
  enum ObjectUsage
  {
    StreamDraw,
    StreamRead,
    StreamCopy,
    StaticDraw,
    StaticRead,
    StaticCopy,
    DynamicDraw,
    DynamicRead,
    DynamicCopy
  };
  ObjectType GetType() const;
 
  void SetType(ObjectType value);
 
  ObjectUsage GetUsage() const;
 
  void SetUsage(ObjectUsage value);
 
  int GetHandle() const;
 
  bool IsReady() const { return this->Dirty == false; }
 
  void FlagBufferAsDirty() { this->Dirty = true; }
 
  bool GenerateBuffer(ObjectType type);
 
  template <class T>
  bool Upload(const T& array, ObjectType type);
  template <class T>
  bool UploadRange(const T& array, ptrdiff_t offset, ObjectType type);
  // non vector version
  template <class T>
  bool Upload(const T* array, size_t numElements, ObjectType type);
  template <class T>
  bool UploadRange(const T* array, ptrdiff_t offset, size_t numElements, ObjectType type);
  bool Allocate(size_t size, ObjectType type, ObjectUsage usage);
 
  size_t GetSize();
 
  template <class T>
  bool Download(T* array, size_t numElements);
  template <class T>
  bool DownloadRange(T* array, ptrdiff_t offset, size_t numElements);
 
  bool Bind();
 
  bool BindShaderStorage(int index);
 
  bool Release();
 
  // Description:
  // Release any graphics resources that are being consumed by this class.
  void ReleaseGraphicsResources();
 
  std::string GetError() const { return Error; }
 
protected:
  vtkOpenGLBufferObject();
  ~vtkOpenGLBufferObject() override;
  bool Dirty;
  std::string Error;
 
  bool UploadInternal(const void* buffer, size_t size, ObjectType objectType);
  bool UploadRangeInternal(
    const void* buffer, ptrdiff_t offset, ptrdiff_t size, ObjectType objectType);
 
private:
  bool DownloadRangeInternal(void* buffer, ptrdiff_t offset, size_t size);
 
  vtkOpenGLBufferObject(const vtkOpenGLBufferObject&) = delete;
  void operator=(const vtkOpenGLBufferObject&) = delete;
  struct Private;
  Private* Internal;
};
 
template <class T>
inline bool vtkOpenGLBufferObject::Upload(
  const T& array, vtkOpenGLBufferObject::ObjectType objectType)
{
  if (array.empty())
  {
    this->Error = "Refusing to upload empty array.";
    return false;
  }
 
  return this->UploadInternal(&array[0], array.size() * sizeof(typename T::value_type), objectType);
}
 
template <class T>
inline bool vtkOpenGLBufferObject::Upload(
  const T* array, size_t numElements, vtkOpenGLBufferObject::ObjectType objectType)
{
  if (!array)
  {
    this->Error = "Refusing to upload empty array.";
    return false;
  }
  return this->UploadInternal(array, numElements * sizeof(T), objectType);
}
 
template <class T>
inline bool vtkOpenGLBufferObject::UploadRange(
  const T& array, ptrdiff_t offset, vtkOpenGLBufferObject::ObjectType objectType)
{
  if (array.empty())
  {
    this->Error = "Refusing to upload empty array.";
    return false;
  }
 
  return this->UploadRangeInternal(
    &array[0], offset, array.size() * sizeof(typename T::value_type), objectType);
}
template <class T>
inline bool vtkOpenGLBufferObject::UploadRange(const T* array, ptrdiff_t offset, size_t numElements,
  vtkOpenGLBufferObject::ObjectType objectType)
{
  if (!array)
  {
    this->Error = "Refusing to upload empty array.";
    return false;
  }
  return this->UploadRangeInternal(array, offset, numElements * sizeof(T), objectType);
}
 
template <class T>
inline bool vtkOpenGLBufferObject::Download(T* array, size_t numElements)
{
  return this->DownloadRangeInternal(array, 0, numElements * sizeof(T));
}
 
template <class T>
inline bool vtkOpenGLBufferObject::DownloadRange(T* array, ptrdiff_t offset, size_t numElements)
{
  return this->DownloadRangeInternal(array, offset, numElements * sizeof(T));
}
 
VTK_ABI_NAMESPACE_END
#endif