vtkDrawTexturedElements.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 vtkDrawTexturedElements_h
#define vtkDrawTexturedElements_h
 
#include "vtkRenderingOpenGL2Module.h" // For export macro
 
#include "vtkNew.h"                             // for ivar
#include "vtkOpenGLArrayTextureBufferAdapter.h" // for ivar
#include "vtkOpenGLTexture.h"                   // for ivar
#include "vtkOpenGLVertexArrayObject.h"         // for ivar
#include "vtkShader.h"                          // for ivar
#include "vtkSmartPointer.h"                    // for ivar
#include "vtkStringToken.h"                     // for passing shader and array names
 
#include <unordered_map>
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkActor;
class vtkDataArray;
class vtkGLSLRuntimeModBase;
class vtkMapper;
class vtkMatrix3x3;
class vtkMatrix4x4;
class vtkOpenGLRenderWindow;
class vtkOpenGLVertexArrayObject;
class vtkOpenGLTexture;
class vtkRenderer;
class vtkScalarsToColors;
class vtkShaderProgram;
class vtkTextureObject;
class vtkWindow;
 
class VTKRENDERINGOPENGL2_EXPORT vtkDrawTexturedElements
{
public:
  vtkDrawTexturedElements();
  virtual ~vtkDrawTexturedElements();

  enum ElementShape
  {
    Point,          
    Line,           
    LineStrip,      
    Triangle,       
    TriangleStrip,  
    TriangleFan,    
    AbstractPatches 
  };

  enum PatchShape
  {
    PatchLine,          
    PatchTriangle,      
    PatchQuadrilateral, 
  };

  vtkShader* GetShader(vtkShader::Type shaderType);

  void BindArrayToTexture(vtkStringToken textureName, vtkDataArray* array, bool asScalars = false);
  void AppendArrayToTexture(
    vtkStringToken textureName, vtkDataArray* array, bool asScalars = false);
  bool UnbindArray(vtkStringToken);

  void BeginArrayRebuild();

  vtkIdType GetNumberOfInstances() { return this->NumberOfInstances; }
  virtual bool SetNumberOfInstances(vtkIdType numberOfInstances);

  vtkIdType GetNumberOfElements() { return this->NumberOfElements; }
  virtual bool SetNumberOfElements(vtkIdType numberOfElements);

  int GetElementType() { return this->ElementType; }
  virtual bool SetElementType(int elementType);

  int GetPatchType() { return this->PatchType; }
  virtual bool SetPatchType(int patchType);

  bool GetIncludeColormap() { return this->IncludeColormap; }
  virtual bool SetIncludeColormap(bool includeColormap);

  void DrawInstancedElements(vtkRenderer* ren, vtkActor* a, vtkMapper* mapper);

  void SetElementIndexBuffer(vtkDataArray* indices);

  void AppendElementIndexBuffer(vtkDataArray* indices);
 
  void ClearElementIndexBuffer();
  bool GetUsesIndexBuffer() const;

  void SetIndexedDrawEnabled(bool enabled);

  void ReleaseResources(vtkWindow* window);

  vtkShaderProgram* GetShaderProgram();

  vtkCollection* GetGLSLModCollection() const;

  static vtkIdType PatchVertexCountFromPrimitive(int element);
 
protected:
  void SetCustomUniforms(vtkRenderer* ren, vtkActor* a);
  void ReadyShaderProgram(vtkRenderer* ren);
  void ReportUnsupportedLineWidth(float width, float maxWidth, vtkMapper* mapper);
  void PreDraw(vtkRenderer* ren, vtkActor* a, vtkMapper* mapper);
  void DrawInstancedElementsImpl(vtkRenderer* ren, vtkActor* a, vtkMapper* mapper);
  void PostDraw(vtkRenderer* ren, vtkActor* a, vtkMapper* mapper);
 
  using ShaderMap = std::map<vtkShader::Type, vtkShader*>;
  struct Internal;

  Internal* P{ nullptr };
  vtkIdType FirstVertexId{ 0 };
  vtkIdType NumberOfInstances{ 1 };
  vtkIdType NumberOfElements{ 1 };
  int ElementType{ ElementShape::TriangleStrip };
  int PatchType{ PatchShape::PatchTriangle };
  bool IncludeColormap{ true };
  std::unordered_map<vtkStringToken, vtkOpenGLArrayTextureBufferAdapter> Arrays;
  ShaderMap Shaders;
  vtkSmartPointer<vtkShaderProgram> ShaderProgram;
  bool ShaderProgramBuilt{ false };
  vtkNew<vtkOpenGLVertexArrayObject> VAO;
  vtkNew<vtkOpenGLTexture> ColorTextureGL;
  vtkNew<vtkCollection> GLSLMods;
 
private:
  vtkDrawTexturedElements(const vtkDrawTexturedElements&) = delete;
  void operator=(const vtkDrawTexturedElements&) = delete;
};
 
VTK_ABI_NAMESPACE_END
 
#endif // vtkDrawTexturedElements_h
 
// Need to skip header testing since we do not inherit vtkObject:
// VTK-HeaderTest-Exclude: vtkDrawTexturedElements.h