vtkOpenGLLowMemoryPolyDataMapper.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 vtkOpenGLLowMemoryPolyDataMapper_h
#define vtkOpenGLLowMemoryPolyDataMapper_h
 
#include "vtkPolyDataMapper.h"
 
#include "vtkCellGraphicsPrimitiveMap.h" // For CellTypeMapperOffsets
#include "vtkDrawTexturedElements.h"     // For parent helper class
#include "vtkHardwareSelector.h"         // For ivar
#include "vtkOpenGLShaderDeclaration.h"  // For ivar
#include "vtkRenderingOpenGL2Module.h"   // For export macro
#include "vtkShaderProgram.h"            // For vtkWeakPtr<vtkShaderProgram>
#include "vtkWeakPtr.h"                  // For vtkWeakPtr
#include "vtkWrappingHints.h"            // For VTK_MARSHALAUTO
 
#include <array>   // for array
#include <set>     // for set
#include <utility> // for pair
#include <vector>  // for TextureInfo
 
VTK_ABI_NAMESPACE_BEGIN
class vtkGenericOpenGLResourceFreeCallback;
class vtkOpenGLLowMemoryCellTypeAgent;
class vtkOpenGLLowMemoryVerticesAgent;
class vtkOpenGLLowMemoryLinesAgent;
class vtkOpenGLLowMemoryPolygonsAgent;
class vtkOverrideAttribute;
class vtkShaderProgram;
 
class VTKRENDERINGOPENGL2_EXPORT VTK_MARSHALAUTO vtkOpenGLLowMemoryPolyDataMapper
  : public vtkPolyDataMapper
#ifndef __VTK_WRAP__
  , public vtkDrawTexturedElements
#endif
{
public:
  static vtkOpenGLLowMemoryPolyDataMapper* New();
  VTK_NEWINSTANCE
  static vtkOverrideAttribute* CreateOverrideAttributes();
  vtkTypeMacro(vtkOpenGLLowMemoryPolyDataMapper, vtkPolyDataMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void ShallowCopy(vtkAbstractMapper* m) override;

  MapperHashType GenerateHash(vtkPolyData* polydata) override;

  vtkIdType GetMaximumNumberOfTriangles(vtkRenderer* ren) override;
 
  vtkPolyData* CurrentInput = nullptr;
  void RenderPiece(vtkRenderer* renderer, vtkActor* actor) override;
  virtual void RenderPieceStart(vtkRenderer* renderer, vtkActor* actor);
  virtual void RenderPieceDraw(vtkRenderer* renderer, vtkActor* actor);
  virtual void RenderPieceFinish(vtkRenderer* renderer, vtkActor* actor);

  void ReleaseGraphicsResources(vtkWindow*) override;
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkGetMacro(PopulateSelectionSettings, bool);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void SetPopulateSelectionSettings(bool v) { this->PopulateSelectionSettings = v; }
  void SetVBOShiftScaleMethod(int method) override;

  bool GetSupportsSelection() override { return true; }


  vtkSetMacro(UseIndexedRendering, bool);
  vtkGetMacro(UseIndexedRendering, bool);
  vtkBooleanMacro(UseIndexedRendering, bool);

  virtual void ResetModsToDefault();
  void AddMod(const std::string& className);
  void AddMods(const std::vector<std::string>& classNames);
  void RemoveMod(const std::string& className);
  void RemoveAllMods();

  void MapDataArrayToVertexAttribute(const char* vertexAttributeName, const char* dataArrayName,
    int fieldAssociation, int componentno = -1) override;
 
  // This method will Map the specified data array for use as
  // a texture coordinate for texture tname. The actual
  // attribute will be named tname_coord so as to not
  // conflict with the texture sampler definition which will
  // be tname.
  void MapDataArrayToMultiTextureAttribute(const char* tname, const char* dataArrayName,
    int fieldAssociation, int componentno = -1) override;

  void RemoveVertexAttributeMapping(const char* vertexAttributeName) override;

  void RemoveAllVertexAttributeMappings() override;

  void ProcessSelectorPixelBuffers(
    vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;
 
protected:
  vtkOpenGLLowMemoryPolyDataMapper();
  ~vtkOpenGLLowMemoryPolyDataMapper() override;
 
  enum class ShaderColorSourceAttribute
  {
    // Color is obtained by mapping point scalar array. shader will interpolate colors.
    Point,
    // Color is obtained by mapping cell scalar array. entire cell will have the same color.
    Cell,
    // Similar to `Point`, in addition, mapper already interpolated the scalars and provided a
    // ColorTextureCoordinate and a ColorTexture.
    PointTexture,
    // The color of the entire geometry is specified by the actor's vtkProperty instance.
    Uniform
  };
 
  enum class ShaderNormalSourceAttribute
  {
    // Uses point normals.
    Point,
    // Uses cell normals.
    Cell,
    // Shader computes a normal for the provoking vertex and passes it down to fragment shader.
    Primitive
  };
 
  ShaderColorSourceAttribute DetermineShaderColorSource(vtkPolyData* mesh);
  ShaderNormalSourceAttribute DetermineShaderNormalSource(vtkActor* actor, vtkPolyData* mesh);
 
  void MapDataArray(const char* vertexAttributeName, const char* dataArrayName,
    const char* texturename, int fieldAssociation, int componentno);
  bool IsUpToDate(vtkRenderer* renderer, vtkActor* actor);
  bool IsShaderUpToDate(vtkRenderer* renderer, vtkActor* actor);
  virtual bool IsDataObjectUpToDate();
  virtual bool IsShaderColorSourceUpToDate(vtkActor* actor);
  virtual bool IsShaderNormalSourceUpToDate(vtkActor* actor);
  void DeleteTextureBuffers();
  virtual bool BindArraysToTextureBuffers(vtkRenderer* renderer, vtkActor* actor,
    vtkCellGraphicsPrimitiveMap::CellTypeMapperOffsets& offsets);
  void InstallArrayTextureShaderDeclarations();
  virtual void UpdateShaders(vtkRenderer* renderer, vtkActor* actor);
  void ReplaceShaderValues(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderPosition(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderNormal(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  virtual void ReplaceShaderColor(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderImplementationCustomUniforms(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderPointSize(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderWideLines(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderEdges(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderSelection(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderTCoord(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void ReplaceShaderClip(
    vtkRenderer* renderer, vtkActor* actor, std::string& vsSource, std::string& fsSource);
  void SetShaderParameters(vtkRenderer* renderer, vtkActor* actor);
  // compute and set the maximum point and cell ID used in selection
  void UpdateMaximumPointCellIds(vtkRenderer* ren, vtkActor* actor);
 
  bool GetCoordShiftAndScaleEnabled();
  int GetCoordShiftAndScaleMethod();
  void SetShiftValues(double x, double y, double z);
  void SetScaleValues(double x, double y, double z);
  void ComputeShiftScale(vtkRenderer* renderer, vtkActor* actor, vtkDataArray* arrays);
  void ComputeCameraBasedShiftScale(vtkRenderer* renderer, vtkActor* actor, vtkPolyData* mesh);
  void ComputeShiftScaleTransform(vtkRenderer* renderer, vtkActor* actor);
  virtual void UpdateShiftScale(vtkRenderer* renderer, vtkActor* actor);
 
  virtual vtkDataArray* GetColors(vtkPolyData* mesh);
  vtkDataArray* GetPointNormals(vtkPolyData* mesh);
  vtkDataArray* GetPointTangents(vtkPolyData* mesh);
  vtkDataArray* GetTextureCoordinates(vtkPolyData* mesh);
  vtkDataArray* GetColorTextureCoordinates(vtkPolyData* mesh);
  vtkDataArray* GetCellNormals(vtkPolyData* mesh);
 
  using TextureInfo = std::pair<vtkTexture*, std::string>;
  bool HaveTextures(vtkActor* actor);
  unsigned int GetNumberOfTextures(vtkActor* actor);
  virtual std::vector<TextureInfo> GetTextures(vtkActor* actor);
  std::pair<std::string, std::string> GetTextureCoordinateAndSamplerBufferNames(const char* tname);
 
  void UpdatePBRStateCache(vtkRenderer* renderer, vtkActor* actor);
  void UpdateGLSLMods(vtkRenderer* renderer, vtkActor* actor);
 
  class ExtraAttributeValue
  {
  public:
    std::vector<std::string> DataArrayNames;
    int FieldAssociation;
    int ComponentNumber;
    std::string TextureName;
  };
  std::map<std::string, ExtraAttributeValue> ExtraAttributes;

  ShaderColorSourceAttribute ShaderColorSource = ShaderColorSourceAttribute::Uniform;
  ShaderNormalSourceAttribute ShaderNormalSource = ShaderNormalSourceAttribute::Primitive;

  std::vector<std::string> ModNames;
  std::set<std::string> ModNamesUnique;

  using GLSLAttributeType = vtkOpenGLShaderDeclaration::GLSLAttributeType;
  using GLSLDataType = vtkOpenGLShaderDeclaration::GLSLDataType;
  using GLSLPrecisionType = vtkOpenGLShaderDeclaration::GLSLPrecisionType;
  using GLSLQualifierType = vtkOpenGLShaderDeclaration::GLSLQualifierType;
  std::vector<vtkOpenGLShaderDeclaration> ShaderDecls;

  vtkNew<vtkInformation> LastRenderPassInfo;
  int LastSelectionState = vtkHardwareSelector::MIN_KNOWN_PASS - 1;
  vtkTimeStamp RenderTimeStamp;
  vtkTimeStamp SelectionStateTimeStamp;
  vtkTimeStamp ShaderBuildTimeStamp;
  vtkTimeStamp ShiftScaleTimeStamp;

  std::array<double, 3> ShiftValues;
  std::array<double, 3> ScaleValues;
  bool CoordinateShiftAndScaleInUse = false;
  vtkNew<vtkTransform> SSInverseTransform; // Inverse transform which can undo shift + scale.
  vtkNew<vtkMatrix4x4> SSMatrix;           // Transpose of the above inverse transform.
 
  struct CellGroupInformation
  {
    vtkCellGraphicsPrimitiveMap::CellTypeMapperOffsets Offsets;
    vtkIdType NumberOfElements = 0;
    bool CanRender = false;
    bool UsesEdgeValueBuffer = false;
    bool UsesCellMapBuffer = false;
    friend std::ostream& operator<<(std::ostream& os, const CellGroupInformation& cg)
    {
      os << cg.Offsets << '\n'
         << "NumberOfElements: " << cg.NumberOfElements << '\n'
         << "CanRender: " << cg.CanRender << '\n'
         << "UsesEdgeValueBuffer: " << cg.UsesEdgeValueBuffer << '\n'
         << "UsesCellMapBuffer: " << cg.UsesCellMapBuffer << '\n';
      return os;
    }
  };

  struct PrimitiveInformation
  {
    std::unique_ptr<vtkOpenGLLowMemoryCellTypeAgent> Agent;
    std::function<vtkCellGraphicsPrimitiveMap::PrimitiveDescriptor(vtkPolyData*)> GeneratorFunction;
    std::vector<CellGroupInformation> CellGroups;
  };
  std::array<PrimitiveInformation, 4> Primitives;

  bool UseIndexedRendering = true;
  bool DrawingVertices = false;
  bool HasColors = false;
  bool HasTangents = false;
  bool HasPointNormals = false;
  bool HasCellNormals = false;
  bool HasPointTextureCoordinates = false;
  // if set to true, tcoords will be passed to the
  // VBO even if the mapper knows of no texture maps
  // normally tcoords are only added to the VBO if the
  // mapper has identified a texture map as well.
  bool ForceTextureCoordinates = false;

  vtkOpenGLTexture* InternalColorTexture = nullptr;

  bool PopulateSelectionSettings = true;
  bool PointPicking = false;

  bool HasAnisotropy = false;
  bool HasClearCoat = false;
  bool UsesNormalMap = false;
  bool UsesCoatNormalMap = false;
  bool UsesRotationMap = false;
  vtkTimeStamp PBRStateTimeStamp;

  bool ShouldUseIndexedRendering(vtkRenderer* renderer, vtkActor* actor,
    const CellGroupInformation& cellGroup, int numberOfPointsPerPrimitive,
    int numberOfPseudoPrimitivesPerElement, bool inVertexVisibilityPass) const;

  struct UniformLocations
  {
    // SetShaderParameters
    int ViewportDimensions = -1;
    int LineWidth = -1;
    int RenderPointsAsSpheres = -1;
    int RenderLinesAsTubes = -1;
    int PointPicking = -1;
    int VertexColor = -1;
    int EdgeColor = -1;
    int EdgeOpacity = -1;
    int EdgeVisibility = -1;
    int Wireframe = -1;
    int EdgeWidth = -1;
    int CameraParallel = -1;
    int ZCalcR = -1;
    int ZCalcS = -1;
    int NumClipPlanes = -1;
    int ClipPlanes = -1;
    int MapperIndex = -1;
    // cell-type agent
    int CellType = -1;
    int EnableLights = -1;
    int VertexPass = -1;
    int PrimitiveSize = -1;
    int PointCount = -1;
    int PointSize = -1;
    int CellIdOffset = -1;
    int VertexIdOffset = -1;
    int EdgeValueBufferOffset = -1;
    int PointIdOffset = -1;
    int PrimitiveIdOffset = -1;
    int UsesCellMap = -1;
    int UsesEdgeValues = -1;
    int UseIndexedPointId = -1;
  } UniformLocs;
  vtkWeakPtr<vtkShaderProgram> CachedLocProgram;
  unsigned int CachedLocLinkCount = 0;
  void UpdateUniformLocations();
 
private:
  vtkOpenGLLowMemoryPolyDataMapper(const vtkOpenGLLowMemoryPolyDataMapper&) = delete;
  void operator=(const vtkOpenGLLowMemoryPolyDataMapper&) = delete;
  friend class vtkOpenGLLowMemoryCellTypeAgent;
  friend class vtkOpenGLLowMemoryVerticesAgent;
  friend class vtkOpenGLLowMemoryLinesAgent;
  friend class vtkOpenGLLowMemoryPolygonsAgent;
 
  vtkNew<vtkMatrix4x4> TempMatrix4;
};
 
#define vtkOpenGLLowMemoryPolyDataMapper_OVERRIDE_ATTRIBUTES                                       \
  vtkOpenGLLowMemoryPolyDataMapper::CreateOverrideAttributes()
VTK_ABI_NAMESPACE_END
#endif // vtkOpenGLLowMemoryPolyDataMapper_h