vtkPixelBufferObject.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkPixelBufferObject.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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 vtkPixelBufferObject_h
#define vtkPixelBufferObject_h
 
#include "vtkObject.h"
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkWeakPointer.h"            // needed for vtkWeakPointer.
 
class vtkRenderWindow;
class vtkOpenGLExtensionManager;
 
class VTKRENDERINGOPENGL2_EXPORT vtkPixelBufferObject : public vtkObject
{
public:
  // Usage values.
  enum
  {
    StreamDraw = 0,
    StreamRead,
    StreamCopy,
    StaticDraw,
    StaticRead,
    StaticCopy,
    DynamicDraw,
    DynamicRead,
    DynamicCopy,
    NumberOfUsages
  };
 
  static vtkPixelBufferObject* New();
  vtkTypeMacro(vtkPixelBufferObject, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetContext(vtkRenderWindow* context);
  vtkRenderWindow* GetContext();
 
 
  vtkGetMacro(Usage, int);
  vtkSetMacro(Usage, int);
 
 
  bool Upload1D(int type, void* data, unsigned int numtuples, int comps, vtkIdType increment)
  {
    unsigned int newdims[3];
    newdims[0] = numtuples;
    newdims[1] = 1;
    newdims[2] = 1;
    vtkIdType newinc[3];
    newinc[0] = increment;
    newinc[1] = 0;
    newinc[2] = 0;
    return this->Upload3D(type, data, newdims, comps, newinc, 0, nullptr);
  }
 
 
  bool Upload2D(int type, void* data, unsigned int dims[2], int comps, vtkIdType increments[2])
  {
    unsigned int newdims[3];
    newdims[0] = dims[0];
    newdims[1] = dims[1];
    newdims[2] = 1;
    vtkIdType newinc[3];
    newinc[0] = increments[0];
    newinc[1] = increments[1];
    newinc[2] = 0;
    return this->Upload3D(type, data, newdims, comps, newinc, 0, nullptr);
  }
 
  bool Upload3D(int type, void* data, unsigned int dims[3], int comps, vtkIdType increments[3],
    int components, int* componentList);
 
 
  vtkGetMacro(Type, int);
  vtkSetMacro(Type, int);
 
 
  vtkGetMacro(Components, int);
  vtkSetMacro(Components, int);
 
 
  vtkGetMacro(Size, unsigned int);
  vtkSetMacro(Size, unsigned int);
  void SetSize(unsigned int nTups, int nComps);
 
 
  vtkGetMacro(Handle, unsigned int);
 
 
  bool Download1D(int type, void* data, unsigned int dim, int numcomps, vtkIdType increment)
  {
    unsigned int newdims[3];
    newdims[0] = dim;
    newdims[1] = 1;
    newdims[2] = 1;
    vtkIdType newincrements[3];
    newincrements[0] = increment;
    newincrements[1] = 0;
    newincrements[2] = 0;
    return this->Download3D(type, data, newdims, numcomps, newincrements);
  }
 
 
  bool Download2D(int type, void* data, unsigned int dims[2], int numcomps, vtkIdType increments[2])
  {
    unsigned int newdims[3];
    newdims[0] = dims[0];
    newdims[1] = dims[1];
    newdims[2] = 1;
    vtkIdType newincrements[3];
    newincrements[0] = increments[0];
    newincrements[1] = increments[1];
    newincrements[2] = 0;
    return this->Download3D(type, data, newdims, numcomps, newincrements);
  }
 
  bool Download3D(
    int type, void* data, unsigned int dims[3], int numcomps, vtkIdType increments[3]);
 
  void BindToPackedBuffer() { this->Bind(PACKED_BUFFER); }
 
  void BindToUnPackedBuffer() { this->Bind(UNPACKED_BUFFER); }
 
  void UnBind();
 
  void* MapPackedBuffer() { return this->MapBuffer(PACKED_BUFFER); }
 
  void* MapPackedBuffer(int type, unsigned int numtuples, int comps)
  {
    return this->MapBuffer(type, numtuples, comps, PACKED_BUFFER);
  }
 
  void* MapPackedBuffer(unsigned int numbytes) { return this->MapBuffer(numbytes, PACKED_BUFFER); }
 
  void* MapUnpackedBuffer() { return this->MapBuffer(UNPACKED_BUFFER); }
 
  void* MapUnpackedBuffer(int type, unsigned int numtuples, int comps)
  {
    return this->MapBuffer(type, numtuples, comps, UNPACKED_BUFFER);
  }
 
  void* MapUnpackedBuffer(unsigned int numbytes)
  {
    return this->MapBuffer(numbytes, UNPACKED_BUFFER);
  }
 
  void UnmapUnpackedBuffer() { this->UnmapBuffer(UNPACKED_BUFFER); }
 
  void UnmapPackedBuffer() { this->UnmapBuffer(PACKED_BUFFER); }
 
  // PACKED_BUFFER for download APP<-PBO
  // UNPACKED_BUFFER for upload APP->PBO
  enum BufferType
  {
    UNPACKED_BUFFER = 0,
    PACKED_BUFFER
  };
 
  void Bind(BufferType buffer);
 
 
  void* MapBuffer(int type, unsigned int numtuples, int comps, BufferType mode);
  void* MapBuffer(unsigned int numbytes, BufferType mode);
  void* MapBuffer(BufferType mode);
 
  void UnmapBuffer(BufferType mode);
 
  void Allocate(int vtkType, unsigned int numtuples, int comps, BufferType mode);
 
  void Allocate(unsigned int nbytes, BufferType mode);
 
  void ReleaseMemory();
 
  static bool IsSupported(vtkRenderWindow* renWin);
 
protected:
  vtkPixelBufferObject();
  ~vtkPixelBufferObject() override;
 
  bool LoadRequiredExtensions(vtkRenderWindow* renWin);
 
  void CreateBuffer();
 
  void DestroyBuffer();
 
  int Usage;
  unsigned int BufferTarget; // GLenum
  int Type;
  int Components;
  unsigned int Size;
  vtkWeakPointer<vtkRenderWindow> Context;
  unsigned int Handle;
 
private:
  vtkPixelBufferObject(const vtkPixelBufferObject&) = delete;
  void operator=(const vtkPixelBufferObject&) = delete;
};
 
#endif