vtkCompositePolyDataMapper.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 vtkCompositePolyDataMapper_h
#define vtkCompositePolyDataMapper_h
 
#include "vtkPolyDataMapper.h"
 
#include "vtkDeprecation.h"         // for VTK_DEPRECATED_IN_9_3_0
#include "vtkRenderingCoreModule.h" // for export macro
#include "vtkStateStorage.h"        // for ivar
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
 
#include <array>  // for ColorResult. Remove when double* GetBlockColor gets removed.
#include <memory> // for unique_ptr
#include <vector> // for return
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkCompositePolyDataMapperDelegator;
class vtkCompositeDataDisplayAttributes;
class vtkCompositeDataSet;
class vtkDataObjectTreeIterator;
class vtkInformation;
class vtkPolyData;
class vtkRenderer;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkCompositePolyDataMapper : public vtkPolyDataMapper
{
public:
  static vtkCompositePolyDataMapper* New();
  vtkTypeMacro(vtkCompositePolyDataMapper, vtkPolyDataMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Render(vtkRenderer* renderer, vtkActor* actor) override;
 
 
  double* GetBounds() VTK_SIZEHINT(6) override;
  void GetBounds(double bounds[6]) override { this->Superclass::GetBounds(bounds); }
 
  void ShallowCopy(vtkAbstractMapper* mapper) override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
 
  bool HasOpaqueGeometry() override;
  bool HasTranslucentPolygonalGeometry() override;
 
 
  void SetCompositeDataDisplayAttributes(vtkCompositeDataDisplayAttributes* attributes);
  vtkCompositeDataDisplayAttributes* GetCompositeDataDisplayAttributes();
 
 
  void SetBlockVisibility(unsigned int index, bool visible);
  bool GetBlockVisibility(unsigned int index);
  void RemoveBlockVisibility(unsigned int index);
  void RemoveBlockVisibilities();
 
 
  void SetBlockColor(unsigned int index, const double color[3]);
  void SetBlockColor(unsigned int index, double r, double g, double b)
  {
    double color[3] = { r, g, b };
    this->SetBlockColor(index, color);
  }
  VTK_DEPRECATED_IN_9_3_0("Use void GetBlockColor(unsigned int index, double color[3])")
  double* GetBlockColor(unsigned int index);
  void GetBlockColor(unsigned int index, double color[3]);
  void RemoveBlockColor(unsigned int index);
  void RemoveBlockColors();
 
 
  void SetBlockOpacity(unsigned int index, double opacity);
  double GetBlockOpacity(unsigned int index);
  void RemoveBlockOpacity(unsigned int index);
  void RemoveBlockOpacities();
 
 
  void SetBlockScalarMode(unsigned int index, int value);
  int GetBlockScalarMode(unsigned int index);
  void RemoveBlockScalarMode(unsigned int index);
  void RemoveBlockScalarModes();
 
 
  void SetBlockArrayAccessMode(unsigned int index, int value);
  int GetBlockArrayAccessMode(unsigned int index);
  void RemoveBlockArrayAccessMode(unsigned int index);
  void RemoveBlockArrayAccessModes();
 
 
  void SetBlockArrayComponent(unsigned int index, int value);
  int GetBlockArrayComponent(unsigned int index);
  void RemoveBlockArrayComponent(unsigned int index);
  void RemoveBlockArrayComponents();
 
 
  void SetBlockArrayId(unsigned int index, int value);
  int GetBlockArrayId(unsigned int index);
  void RemoveBlockArrayId(unsigned int index);
  void RemoveBlockArrayIds();
 
 
  void SetBlockArrayName(unsigned int index, const std::string& value);
  std::string GetBlockArrayName(unsigned int index);
  void RemoveBlockArrayName(unsigned int index);
  void RemoveBlockArrayNames();
 
 
  void SetBlockFieldDataTupleId(unsigned int index, vtkIdType value);
  vtkIdType GetBlockFieldDataTupleId(unsigned int index);
  void RemoveBlockFieldDataTupleId(unsigned int index);
  void RemoveBlockFieldDataTupleIds();
 
 
  vtkSetMacro(ColorMissingArraysWithNanColor, bool);
  vtkGetMacro(ColorMissingArraysWithNanColor, bool);
  vtkBooleanMacro(ColorMissingArraysWithNanColor, bool);
 
 
  using vtkAlgorithm::SetInputArrayToProcess;
  void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, const char* name) override;
  void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, int fieldAttributeType) override;
  void SetInputArrayToProcess(int idx, vtkInformation* info) override;
 
  std::vector<vtkPolyData*> GetRenderedList();
 
  void ProcessSelectorPixelBuffers(
    vtkHardwareSelector* sel, std::vector<unsigned int>& pixeloffsets, vtkProp* prop) override;
 
  void SetVBOShiftScaleMethod(int method) override;
 
  void SetPauseShiftScale(bool pauseShiftScale) override;
 
  vtkMTimeType GetMTime() override;
 
 
  vtkSetStringMacro(PointIdArrayName);
  vtkGetStringMacro(PointIdArrayName);
  vtkSetStringMacro(CellIdArrayName);
  vtkGetStringMacro(CellIdArrayName);
 
 
  vtkSetStringMacro(ProcessIdArrayName);
  vtkGetStringMacro(ProcessIdArrayName);
 
 
  vtkSetStringMacro(CompositeIdArrayName);
  vtkGetStringMacro(CompositeIdArrayName);
 
protected:
  vtkCompositePolyDataMapper();
  ~vtkCompositePolyDataMapper() override;
 
  MapperHashType InsertPolyData(vtkPolyData* polydata, const unsigned int& flatIndex);
 
  vtkExecutive* CreateDefaultExecutive() override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  virtual vtkCompositePolyDataMapperDelegator* CreateADelegator();
 
  virtual void PreRender(const std::vector<vtkSmartPointer<vtkCompositePolyDataMapperDelegator>>&,
    vtkRenderer*, vtkActor*)
  {
  }
 
  virtual void PostRender(const std::vector<vtkSmartPointer<vtkCompositePolyDataMapperDelegator>>&,
    vtkRenderer*, vtkActor*)
  {
  }
 
  vtkPolyDataMapper::MapperHashType GenerateHash(vtkPolyData* polydata) override;
 
  virtual vtkDataObjectTreeIterator* MakeAnIterator(vtkCompositeDataSet* dataset);
 
  void ComputeBounds() override;
 
  bool RecursiveHasTranslucentGeometry(vtkDataObject* dobj, unsigned int& flat_index);
 
  void BuildRenderValues(
    vtkRenderer* renderer, vtkActor* actor, vtkDataObject* dobj, unsigned int& flat_index);
 
  vtkNew<vtkPolyDataMapper> PrototypeMapper;
 
  vtkSmartPointer<vtkCompositeDataDisplayAttributes> CompositeAttributes;
 
  bool ColorMissingArraysWithNanColor = false;
 
  vtkTimeStamp BoundsMTime;
 
  // additional picking indirection
  char* PointIdArrayName = nullptr;
  char* CellIdArrayName = nullptr;
  char* ProcessIdArrayName = nullptr;
  char* CompositeIdArrayName = nullptr;
 
  vtkStateStorage TranslucentState;
  bool HasTranslucentGeometry = false;
  vtkStateStorage RenderValuesState;
  vtkStateStorage TempState;
  vtkTimeStamp DelegatorMTime;
 
private:
  vtkCompositePolyDataMapper(const vtkCompositePolyDataMapper&) = delete;
  void operator=(const vtkCompositePolyDataMapper&) = delete;
 
  std::array<double, 3> ColorResult = {};
 
  class vtkInternals;
  std::unique_ptr<vtkInternals> Internals;
};
 
VTK_ABI_NAMESPACE_END
#endif