vtkOpenGLBatchedPolyDataMapper.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 vtkOpenGLBatchedPolyDataMapper_h
#define vtkOpenGLBatchedPolyDataMapper_h

#include "vtkOpenGLPolyDataMapper.h"

#include "vtkColor.h"                                  // class uses vtkColor
#include "vtkNew.h"                                    // for ivar
#include "vtkOpenGLCompositePolyDataMapperDelegator.h" // for struct BatchElement
#include "vtkRenderingOpenGL2Module.h"                 // for export macro
#include "vtkSmartPointer.h"                           // for arg
#include "vtk_glad.h"                                  // for OpenGL defs

#include <cstdint> // for std::uintptr_t
#include <memory>  // for shared_ptr

VTK_ABI_NAMESPACE_BEGIN
class vtkCompositePolyDataMapper;
class vtkPolyData;

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


  using BatchElement = vtkOpenGLCompositePolyDataMapperDelegator::BatchElement;
  using GLBatchElement = vtkOpenGLCompositePolyDataMapperDelegator::GLBatchElement;
  void AddBatchElement(unsigned int flatIndex, BatchElement&& batchElement);
  BatchElement* GetBatchElement(vtkPolyData* polydata);
  void ClearBatchElements();

  std::vector<vtkPolyData*> GetRenderedList() const;
  void SetParent(vtkCompositePolyDataMapper* parent);

  void RenderPieceStart(vtkRenderer* renderer, vtkActor* actor) override;
  void RenderPiece(vtkRenderer* renderer, vtkActor* actor) override;
  void UnmarkBatchElements();
  void ClearUnmarkedBatchElements();

  void ProcessSelectorPixelBuffers(
    vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;

  virtual void ProcessCompositePixelBuffers(vtkHardwareSelector* sel, vtkProp* prop,
    GLBatchElement* glBatchElement, std::vector<unsigned int>& mypixels);

  vtkMTimeType GetMTime() override;

protected:
  vtkOpenGLBatchedPolyDataMapper();
  ~vtkOpenGLBatchedPolyDataMapper() override;

  void RenderPieceDraw(vtkRenderer* renderer, vtkActor* actor) override;
  void UpdateCameraShiftScale(vtkRenderer* renderer, vtkActor* actoror) override;

  void DrawIBO(vtkRenderer* renderer, vtkActor* actoror, int primType, vtkOpenGLHelper& CellBO,
    GLenum mode, int pointSize);

  virtual void SetShaderValues(
    vtkShaderProgram* prog, GLBatchElement* glBatchElement, size_t primOffset);

  void UpdateShaders(vtkOpenGLHelper& cellBO, vtkRenderer* renderer, vtkActor* actor) override;

  void ReplaceShaderColor(
    std::map<vtkShader::Type, vtkShader*> shaders, vtkRenderer* renderer, vtkActor* actor) override;

  bool GetNeedToRebuildBufferObjects(vtkRenderer* renderer, vtkActor* actor) override;

  void BuildBufferObjects(vtkRenderer* renderer, vtkActor* actor) override;
  virtual void AppendOneBufferObject(vtkRenderer* renderer, vtkActor* actor,
    GLBatchElement* glBatchElement, vtkIdType& vertexOffset, std::vector<unsigned char>& colors,
    std::vector<float>& norms);

  void BuildSelectionIBO(
    vtkPolyData* poly, std::vector<unsigned int> (&indices)[4], vtkIdType offset) override;

  int CanUseTextureMapForColoring(vtkDataObject*) override;

  std::vector<texinfo> GetTextures(vtkActor* actor) override;

  // Reference to CPDM
  vtkCompositePolyDataMapper* Parent = nullptr;
  // Maps an address of a vtkPolyData to its rendering attributes.
  std::map<std::uintptr_t, std::unique_ptr<GLBatchElement>> VTKPolyDataToGLBatchElement;
  std::map<unsigned int, std::uintptr_t> FlatIndexToPolyData;
  // Index arrays for vert, line, poly, strip, edge, stripedge
  std::vector<unsigned int> IndexArray[PrimitiveEnd];
  // Whether primitive IDs are used
  bool PrimIDUsed;
  // Whether override color is used for a vtkPolyData
  bool OverideColorUsed;
  // Reference to the current selector.
  vtkHardwareSelector* CurrentSelector;
  // used by the hardware selector
  std::vector<std::vector<unsigned int>> PickPixels;
  // cached array map
  std::map<vtkAbstractArray*, vtkDataArray*> ColorArrayMap;

private:
  vtkOpenGLBatchedPolyDataMapper(const vtkOpenGLBatchedPolyDataMapper&) = delete;
  void operator=(const vtkOpenGLBatchedPolyDataMapper&) = delete;

  vtkSmartPointer<vtkOpenGLTexture> BlockTexturePrototype;
};

VTK_ABI_NAMESPACE_END
#endif