vtkOpenGLArrayTextureBufferCache.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 vtkOpenGLArrayTextureBufferCache_h
#define vtkOpenGLArrayTextureBufferCache_h

#include "vtkObject.h"
#include "vtkOpenGLBufferObject.h"     // for entry ivar
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkSmartPointer.h"           // for entry ivars
#include "vtkTextureObject.h"          // for entry ivar

#include <cstddef> // for std::size_t
#include <cstdint> // for std::uint64_t
#include <map>     // for cache map
#include <memory>  // for shared_ptr
#include <tuple>   // for composite key

VTK_ABI_NAMESPACE_BEGIN
class vtkDataArray;
class vtkWindow;

class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLArrayTextureBufferCache : public vtkObject
{
public:
  static vtkOpenGLArrayTextureBufferCache* New();
  vtkTypeMacro(vtkOpenGLArrayTextureBufferCache, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  struct Entry
  {
    vtkSmartPointer<vtkDataArray> Array;
    vtkSmartPointer<vtkTextureObject> Texture;
    vtkSmartPointer<vtkOpenGLBufferObject> Buffer;
    vtkMTimeType UploadTime = 0;
    std::uint64_t LastAccess = 0;
  };

  std::shared_ptr<Entry> GetTextureBuffer(
    vtkDataArray* array, bool scalarComponents, bool integerTexture);

  std::size_t GetNumberOfCachedTextureBuffers() const { return this->Cache.size(); }

  unsigned long GetCPUMemorySize() const;


  vtkSetMacro(MaximumCacheSize, std::size_t);
  vtkGetMacro(MaximumCacheSize, std::size_t);

  std::size_t GetCurrentCacheSize() const;

  void RemoveUnusedTextureBuffers(vtkWindow* window);

  std::size_t RemoveTextureBuffer(vtkDataArray* array, vtkWindow* window);

  void ReleaseGraphicsResources(vtkWindow* window);

protected:
  vtkOpenGLArrayTextureBufferCache();
  ~vtkOpenGLArrayTextureBufferCache() override;

  static std::size_t GetEntrySize(const Entry& entry);

  static bool EntryIsPinned(const Entry& entry);

  static void ReleaseEntry(Entry& entry, vtkWindow* window);

  using Key = std::tuple<vtkDataArray*, bool, bool>;
  std::map<Key, std::shared_ptr<Entry>> Cache;

  std::size_t MaximumCacheSize = 256 * 1024 * 1024;
  std::uint64_t AccessCounter = 0;

private:
  vtkOpenGLArrayTextureBufferCache(const vtkOpenGLArrayTextureBufferCache&) = delete;
  void operator=(const vtkOpenGLArrayTextureBufferCache&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif