vtkPVRenderView.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPVRenderView_h
#define vtkPVRenderView_h
 
#include "vtkBoundingBox.h" // needed for iVar
#include "vtkNew.h"         // needed for iVar
#include "vtkPVView.h"
#include "vtkParaViewDeprecation.h"
#include "vtkRemotingViewsModule.h" //needed for exports
#include "vtkSmartPointer.h"        // needed for iVar
#include "vtkWeakPointer.h"         // needed for iVar
 
class vtkAlgorithmOutput;
class vtkCamera;
class vtkCameraOrientationWidget;
class vtkCuller;
class vtkExtentTranslator;
class vtkFloatArray;
class vtkFXAAOptions;
class vtkInformationDoubleKey;
class vtkInformationDoubleVectorKey;
class vtkInformationIntegerKey;
class vtkInteractorStyleDrawPolygon;
class vtkInteractorStyleRubberBand3D;
class vtkInteractorStyleRubberBandZoom;
class vtkLegendScaleActor;
class vtkLight;
class vtkLightKit;
class vtkMatrix4x4;
class vtkOrderedCompositingHelper;
class vtkProp;
class vtkPVAxesWidget;
class vtkPVCameraCollection;
class vtkPVCenterAxesActor;
class vtkPVDataRepresentation;
class vtkPVGridAxes3DActor;
class vtkPVHardwareSelector;
class vtkPVInteractorStyle;
class vtkPVMaterialLibrary;
class vtkPVSynchronizedRenderer;
class vtkRenderer;
class vtkRenderViewBase;
class vtkRenderWindow;
class vtkRenderWindowInteractor;
class vtkSkybox;
class vtkTextRepresentation;
class vtkTexture;
class vtkTimerLog;
class vtkWindowToImageFilter;
 
class VTKREMOTINGVIEWS_EXPORT vtkPVRenderView : public vtkPVView
{
  //*****************************************************************
public:
  static vtkPVRenderView* New();
  vtkTypeMacro(vtkPVRenderView, vtkPVView);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum InteractionModes
  {
    INTERACTION_MODE_UNINTIALIZED = -1,
    INTERACTION_MODE_3D = 0,
    INTERACTION_MODE_2D, // not implemented yet.
    INTERACTION_MODE_SELECTION,
    INTERACTION_MODE_ZOOM,
    INTERACTION_MODE_POLYGON
  };
 
 
  virtual void SetInteractionMode(int mode);
  vtkGetMacro(InteractionMode, int);
 
 
  void SetSize(int, int) override;
  void SetPosition(int, int) override;
 
 
  vtkGetObjectMacro(NonCompositedRenderer, vtkRenderer);
 
  enum
  {
    DEFAULT_RENDERER = 0,
    NON_COMPOSITED_RENDERER = 1,
  };
 
  virtual vtkRenderer* GetRenderer(int rendererType = DEFAULT_RENDERER);
 
 
  vtkCamera* GetActiveCamera();
  virtual void SetActiveCamera(vtkCamera*);
 
  vtkRenderWindowInteractor* GetInteractor();
 
  virtual void SetupInteractor(vtkRenderWindowInteractor*);
 
 
  vtkGetObjectMacro(InteractorStyle, vtkPVInteractorStyle);
 
 
  void ResetCamera();
  void ResetCamera(double bounds[6]);
  void ResetCameraScreenSpace(double offsetRatio = 0.9);
  void ResetCameraScreenSpace(double* bounds, double offsetRatio = 0.9);
  // void ResetCameraScreenSpace(double offsetRatio, double bounds[6]);
 
 
  double* ComputeVisibleBounds(vtkPVDataRepresentation* pvrepr) VTK_SIZEHINT(6);
  double LastRepresentationVisibleBounds[6];
 
  void StillRender() override;
 
  void InteractiveRender() override;
 
 
  vtkSetMacro(SuppressRendering, bool);
  vtkGetMacro(SuppressRendering, bool);
  vtkBooleanMacro(SuppressRendering, bool);
 
 
  vtkSetClampMacro(StillRenderImageReductionFactor, int, 1, 20);
  vtkGetMacro(StillRenderImageReductionFactor, int);
 
 
  vtkSetClampMacro(InteractiveRenderImageReductionFactor, int, 1, 20);
  vtkGetMacro(InteractiveRenderImageReductionFactor, int);
 
 
  vtkSetMacro(RemoteRenderingThreshold, double);
  vtkGetMacro(RemoteRenderingThreshold, double);
 
 
  vtkSetMacro(LODRenderingThreshold, double);
  vtkGetMacro(LODRenderingThreshold, double);
 
 
  vtkSetClampMacro(LODResolution, double, 0.0, 1.0);
  vtkGetMacro(LODResolution, double);
 
 
  vtkSetMacro(UseOutlineForLODRendering, bool);
  vtkGetMacro(UseOutlineForLODRendering, bool);
 
  void ConfigureCompressor(const char* configuration);
 
  virtual void ResetCameraClippingRange();
 
 
  void SetUseLightKit(bool enable);
  vtkGetMacro(UseLightKit, bool);
  vtkBooleanMacro(UseLightKit, bool);
 
  void StreamingUpdate(const double view_planes[24]);
  void DeliverStreamedPieces(unsigned int size, unsigned int* representation_ids);
 
  static vtkInformationIntegerKey* USE_LOD();
 
  static vtkInformationDoubleKey* LOD_RESOLUTION();
 
  static vtkInformationIntegerKey* USE_OUTLINE_FOR_LOD();
 
  static vtkInformationIntegerKey* RENDER_EMPTY_IMAGES();
 
  static vtkInformationIntegerKey* NEED_ORDERED_COMPOSITING();
 
  static vtkInformationDoubleVectorKey* VIEW_PLANES();
 
  static vtkInformationRequestKey* REQUEST_STREAMING_UPDATE();
 
  static vtkInformationRequestKey* REQUEST_PROCESS_STREAMED_PIECE();
 
 
  void SelectCells(int region[4], const char* array = nullptr);
  void SelectCells(int region0, int region1, int region2, int region3, const char* array = nullptr)
  {
    int r[4] = { region0, region1, region2, region3 };
    this->SelectCells(r, array);
  }
  void SelectPoints(int region[4], const char* array = nullptr);
  void SelectPoints(int region0, int region1, int region2, int region3, const char* array = nullptr)
  {
    int r[4] = { region0, region1, region2, region3 };
    this->SelectPoints(r, array);
  }
  void Select(int field_association, int region[4], const char* array = nullptr);
 
 
  void SelectPolygonPoints(int* polygon2DArray, vtkIdType arrayLen);
  void SelectPolygonCells(int* polygon2DArray, vtkIdType arrayLen);
  void SelectPolygon(int field_association, int* polygon2DArray, vtkIdType arrayLen);
 
 
  vtkGetObjectMacro(LastSelection, vtkSelection);
 
 
  vtkSetMacro(UseInteractiveRenderingForScreenshots, bool);
  vtkBooleanMacro(UseInteractiveRenderingForScreenshots, bool);
  vtkGetMacro(UseInteractiveRenderingForScreenshots, bool);
 
 
  vtkGetMacro(RemoteRenderingAvailable, bool);
  void RemoteRenderingAvailableOff() { this->RemoteRenderingAvailable = false; }
 
 
  void NVPipeAvailableOn();
  void NVPipeAvailableOff();
 
 
  vtkGetMacro(UsedLODForLastRender, bool);
 
  void InvalidateCachedSelection();
 
 
  static vtkAlgorithmOutput* GetPieceProducer(
    vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
  static vtkAlgorithmOutput* GetPieceProducerLOD(
    vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
  static void SetRedistributionMode(
    vtkInformation* info, vtkPVDataRepresentation* repr, int mode, int port = 0);
  static void SetRedistributionModeToSplitBoundaryCells(
    vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
  static void SetRedistributionModeToDuplicateBoundaryCells(
    vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
  static void SetRedistributionModeToUniquelyAssignBoundaryCells(
    vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
  static void SetGeometryBounds(vtkInformation* info, vtkPVDataRepresentation* repr,
    const double bounds[6], vtkMatrix4x4* transform = nullptr, int port = 0);
  static void SetStreamable(vtkInformation* info, vtkPVDataRepresentation* repr, bool streamable);
  static void SetNextStreamedPiece(
    vtkInformation* info, vtkPVDataRepresentation* repr, vtkDataObject* piece);
  static vtkDataObject* GetCurrentStreamedPiece(
    vtkInformation* info, vtkPVDataRepresentation* repr);
 
 
  enum
  {
    USE_BOUNDS_FOR_REDISTRIBUTION = 0x01,
    DATA_IS_REDISTRIBUTABLE = 0x02,
    USE_DATA_FOR_LOAD_BALANCING = 0x40,
  };
  static void SetOrderedCompositingConfiguration(vtkInformation* info,
    vtkPVDataRepresentation* repr, int config, const double* bounds = nullptr, int port = 0);
 
  void SetMaxClipBounds(double bds[6]);
 
 
  void SetLockBounds(bool nv);
  vtkGetMacro(LockBounds, bool);
 
  static void SetDeliverToAllProcesses(
    vtkInformation* info, vtkPVDataRepresentation* repr, bool clone);
 
  static void SetDeliverToClientAndRenderingProcesses(vtkInformation* info,
    vtkPVDataRepresentation* repr, bool deliver_to_client, bool gather_before_delivery,
    int port = 0);
 
 
  static void SetRequiresDistributedRendering(
    vtkInformation* info, vtkPVDataRepresentation* repr, bool value, bool for_lod = false);
  static void SetRequiresDistributedRenderingLOD(
    vtkInformation* info, vtkPVDataRepresentation* repr, bool value)
  {
    vtkPVRenderView::SetRequiresDistributedRendering(info, repr, value, true);
  }
 
 
  static void SetForceDataDistributionMode(vtkInformation* info, int flag);
  bool IsForceDataDistributionModeSet() const { return this->ForceDataDistributionMode != -1; }
  int GetForceDataDistributionMode() const { return this->ForceDataDistributionMode; }
 
 
  int RegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
  void UnRegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
 
 
  void SetShowAnnotation(bool val);
  vtkSetMacro(UpdateAnnotation, bool);
 
 
  void SetAnnotationColor(double r, double g, double b);
 
  virtual void SetGridAxes3DActor(vtkPVGridAxes3DActor*);
 
  virtual void SetLegendGridActor(vtkLegendScaleActor*);
 
 
  virtual void SetOrientationAxesInteractivity(bool);
  virtual void SetOrientationAxesVisibility(bool);
 
  void SetOrientationAxesLabelColor(double r, double g, double b);
  void SetOrientationAxesOutlineColor(double r, double g, double b);
 
  void SetOrientationAxesXColor(double r, double g, double b);
  void SetOrientationAxesYColor(double r, double g, double b);
  void SetOrientationAxesZColor(double r, double g, double b);
 
  void SetOrientationAxesXVisibility(bool vis);
  void SetOrientationAxesYVisibility(bool vis);
  void SetOrientationAxesZVisibility(bool vis);
 
  void SetOrientationAxesXLabelText(const char* text);
  void SetOrientationAxesYLabelText(const char* text);
  void SetOrientationAxesZLabelText(const char* text);
 
 
  void SetCameraOrientationWidgetVisibility(bool visible);
  void SetCameraOrientationWidgetSize(int size);
  void SetCameraOrientationWidgetPadding(int padding[2]);
  void SetCameraOrientationWidgetAnchor(int anchor);
 
  virtual void SetCenterAxesVisibility(bool);
 
 
  virtual void SetCenterOfRotation(double x, double y, double z);
  virtual void SetRotationFactor(double factor);
 
 
  void SetKeyLightWarmth(double val);
  void SetKeyLightIntensity(double val);
  void SetKeyLightElevation(double val);
  void SetKeyLightAzimuth(double val);
  void SetFillLightWarmth(double val);
  void SetKeyToFillRatio(double val);
  void SetFillLightElevation(double val);
  void SetFillLightAzimuth(double val);
  void SetBackLightWarmth(double val);
  void SetKeyToBackRatio(double val);
  void SetBackLightElevation(double val);
  void SetBackLightAzimuth(double val);
  void SetHeadLightWarmth(double val);
  void SetKeyToHeadRatio(double val);
  void SetMaintainLuminance(int val);
 
 
  vtkSetMacro(UseHiddenLineRemoval, bool);
  virtual void SetUseDepthPeeling(int val);
  virtual void SetUseDepthPeelingForVolumes(bool val);
  virtual void SetMaximumNumberOfPeels(int val);
  virtual void SetBackgroundTexture(vtkTexture* val);
 
 
  vtkSetMacro(UseRenderViewSettingsForBackground, bool);
  vtkGetMacro(UseRenderViewSettingsForBackground, bool);
 
  enum BackgroundMode
  {
    DEFAULT,
    GRADIENT,
    IMAGE,
    SKYBOX,
    STEREO_SKYBOX,
  };
 
 
  vtkSetClampMacro(BackgroundColorMode, int, DEFAULT, STEREO_SKYBOX);
  vtkSetVector3Macro(Background, double);
  vtkGetVector3Macro(Background, double);
  vtkSetVector3Macro(Background2, double);
  vtkGetVector3Macro(Background2, double);
  vtkSetMacro(UseEnvironmentLighting, bool);
 
 
  virtual void SetEnvironmentalBG(double r, double g, double b);
  virtual void SetEnvironmentalBG2(double r, double g, double b);
  virtual void SetEnvironmentalBGTexture(vtkTexture* val);
  virtual void SetGradientEnvironmentalBG(int val);
  virtual void SetTexturedEnvironmentalBG(int val);
  virtual void SetBackgroundMode(int val);
 
 
  void AddLight(vtkLight*);
  void RemoveLight(vtkLight*);
 
 
  void SetStereoCapableWindow(int val);
  void SetStereoRender(int val);
  vtkSetMacro(StereoType, int);
  vtkSetMacro(ServerStereoType, int);
  void SetMultiSamples(int val);
  void SetAlphaBitPlanes(int val);
  void SetStencilCapable(int val);
 
  void SetParallelProjection(int mode);
 
 
  virtual void SetCamera2DManipulators(const int manipulators[9]);
  virtual void SetCamera3DManipulators(const int manipulators[9]);
  void SetCameraManipulators(vtkPVInteractorStyle* style, const int manipulators[9]);
  virtual void SetReverseMouseWheelZoomDirection(bool reverse);
  virtual void SetMouseWheelZoomsToCursor(bool value);
  virtual void SetCamera2DMouseWheelMotionFactor(double factor);
  virtual void SetCamera3DMouseWheelMotionFactor(double factor);
 
  virtual void SynchronizeGeometryBounds();
 
  void Update() override;
 
  virtual void UpdateLOD();
 
 
  vtkGetMacro(UseLODForInteractiveRender, bool);
 
 
  vtkGetMacro(UseDistributedRenderingForRender, bool);
 
 
  vtkGetMacro(UseDistributedRenderingForLODRender, bool);
 
 
  vtkGetMacro(StillRenderProcesses, vtkTypeUInt32);
 
 
  vtkGetMacro(InteractiveRenderProcesses, vtkTypeUInt32);
 
  int GetDataDistributionMode(bool low_res);
 
  void Deliver(int use_lod, unsigned int size, unsigned int* representation_ids) override;
 
  bool GetUseOrderedCompositing();
 
  bool GetRenderEmptyImages();
 
 
  vtkSetMacro(UseFXAA, bool);
  vtkGetMacro(UseFXAA, bool);
 
 
  void SetFXAARelativeContrastThreshold(double val);
  void SetFXAAHardContrastThreshold(double val);
  void SetFXAASubpixelBlendLimit(double val);
  void SetFXAASubpixelContrastThreshold(double val);
  void SetFXAAUseHighQualityEndpoints(bool val);
  void SetFXAAEndpointSearchIterations(int val);
 
  enum GenericFilmicPresets
  {
    Custom = 0,
    Default = 1,
    Uncharted2 = 2
  };
 
 
  void SetUseToneMapping(bool v);
  vtkGetMacro(UseToneMapping, bool);
  void SetToneMappingType(int);
  void SetExposure(double);
  void SetContrast(double);
  void SetShoulder(double);
  void SetMidIn(double);
  void SetMidOut(double);
  void SetHdrMax(double);
  void SetUseACES(bool);
  void SetGenericFilmicPresets(int t);
 
 
  vtkSetMacro(UseSSAO, bool);
  vtkGetMacro(UseSSAO, bool);
  vtkSetMacro(UseSSAODefaultPresets, bool);
  vtkSetMacro(Radius, double);
  vtkSetMacro(KernelSize, int);
  vtkSetMacro(Bias, double);
  vtkSetMacro(Blur, bool);
 
  void CopyViewUpdateOptions(vtkPVRenderView* otherView);
 
 
  void AddPropToRenderer(vtkProp* prop);
  void RemovePropFromRenderer(vtkProp* prop);
 
 
  bool BeginValuePassForRendering(int fieldAssociation, const char* arrayName, int component);
  void EndValuePassForRendering();
  vtkSmartPointer<vtkFloatArray> GrabValuePassResult();
 
 
  void CaptureZBuffer();
  vtkFloatArray* GetCapturedZBuffer();
 
 
  void SetEnableOSPRay(bool);
  bool GetEnableOSPRay();
 
  void SetShadows(bool);
  bool GetShadows();
 
  void SetAmbientOcclusionSamples(int);
  int GetAmbientOcclusionSamples();
 
  void SetRouletteDepth(int);
  int GetRouletteDepth();
 
  PARAVIEW_DEPRECATED_IN_5_11_0("Use vtkVolumeProperty::SetScatteringAnisotropy instead")
  void SetVolumeAnisotropy(double);
  PARAVIEW_DEPRECATED_IN_5_11_0("Use vtkVolumeProperty::GetScatteringAnisotropy instead")
  double GetVolumeAnisotropy();
 
 
  void SetSamplesPerPixel(int);
  int GetSamplesPerPixel();
 
  void SetMaxFrames(int);
  int GetMaxFrames();
 
  bool GetOSPRayContinueStreaming();
 
  void SetDenoise(bool);
  bool GetDenoise();
 
 
  void SetLightScale(double);
  double GetLightScale();
 
  void SetOSPRayRendererType(std::string);
 
  void SetBackgroundNorth(double x, double y, double z);
  void SetBackgroundEast(double x, double y, double z);
 
  virtual void SetMaterialLibrary(vtkPVMaterialLibrary*);
  void SetViewTime(double value) override;
 
  void SetTimeCacheSize(int);
  int GetTimeCacheSize();
 
 
  static vtkPVCameraCollection* GetDiscreteCameras(
    vtkInformation* info, vtkPVDataRepresentation* repr);
  static void SetDiscreteCameras(
    vtkInformation* info, vtkPVDataRepresentation* repr, vtkPVCameraCollection* style);
 
  // Get the RenderViewBase used by this
  vtkGetObjectMacro(RenderView, vtkRenderViewBase);
 
  void ScaleRendererViewports(const double viewport[4]) override;
 
  void SynchronizeMaximumIds(vtkIdType* maxPointId, vtkIdType* maxCellId);
 
  void SetHardwareSelector(vtkPVHardwareSelector* selector);
 
protected:
  vtkPVRenderView();
  ~vtkPVRenderView() override;
 
  virtual void Render(bool interactive, bool skip_rendering);
 
  virtual void AboutToRenderOnLocalProcess(bool interactive) { (void)interactive; }
 
  bool ShouldUseDistributedRendering(double geometry_size, bool using_lod);
 
  bool ShouldUseLODRendering(double geometry);
 
  bool IsProcessRenderingGeometriesForCompositing(bool using_distributed_rendering);
 
  void SetLastSelection(vtkSelection*);
 
  virtual void UpdateCenterAxes();
 
  bool GetLocalProcessDoesRendering(bool using_distributed_rendering);
 
  bool TestCollaborationCounter();
 
  void SynchronizeForCollaboration();
 
  virtual void BuildAnnotationText(ostream& str);
 
 
  vtkGetMacro(SynchronizationCounter, unsigned int);
 
 
  vtkGetMacro(MakingSelection, bool);
 
  virtual bool PrepareSelect(int fieldAssociation, const char* array = nullptr);
 
  virtual void PostSelect(vtkSelection* sel, const char* array = nullptr);
 
  virtual void UpdateBackground(vtkRenderer* renderer = nullptr);
 
  void ConfigureTexture(vtkTexture* texture);
 
  virtual void SetupAndSetRenderer(vtkRenderer* ren);
 
  vtkLightKit* LightKit;
  vtkRenderViewBase* RenderView;
  vtkRenderer* NonCompositedRenderer;
  vtkPVSynchronizedRenderer* SynchronizedRenderers;
  vtkSmartPointer<vtkRenderWindowInteractor> Interactor;
  vtkInteractorStyleRubberBand3D* RubberBandStyle;
  vtkInteractorStyleRubberBandZoom* RubberBandZoom;
  vtkInteractorStyleDrawPolygon* PolygonStyle;
  vtkPVCenterAxesActor* CenterAxes;
  vtkPVAxesWidget* OrientationWidget;
  vtkSmartPointer<vtkPVHardwareSelector> Selector;
  vtkSelection* LastSelection;
  vtkSmartPointer<vtkPVGridAxes3DActor> GridAxes3DActor;
  vtkSmartPointer<vtkLegendScaleActor> LegendGridActor;
  vtkNew<vtkSkybox> Skybox;
  vtkNew<vtkCameraOrientationWidget> CameraOrientationWidget;
 
  int StillRenderImageReductionFactor;
  int InteractiveRenderImageReductionFactor;
  int InteractionMode;
  bool ShowAnnotation;
  bool UpdateAnnotation;
 
  // this ivar can be used to suppress the render within
  // a StillRender or InteractiveRender. This is useful
  // in cases where you want the representations mappers
  // to be setup for rendering and have their data ready
  // but not actually do the render. For example if you
  // want to export the scene but not render it you must
  // turn on SuppressRendering and then call StillRender
  bool SuppressRendering;
 
  // 2D and 3D interactor style
  vtkPVInteractorStyle* TwoDInteractorStyle;
  vtkPVInteractorStyle* ThreeDInteractorStyle;
 
  bool ReverseMouseWheelZoomDirection = false;
 
  // Active interactor style either [TwoDInteractorStyle, ThreeDInteractorStyle]
  vtkPVInteractorStyle* InteractorStyle;
 
  vtkWeakPointer<vtkPVCameraCollection> DiscreteCameras;
 
  // Used in collaboration mode to ensure that views are in the same state
  // (as far as representations added/removed goes) before rendering.
  unsigned int SynchronizationCounter;
 
  // In mega-bytes.
  double RemoteRenderingThreshold;
  double LODRenderingThreshold;
  vtkBoundingBox GeometryBounds;
 
  bool UseInteractiveRenderingForScreenshots;
  bool NeedsOrderedCompositing;
  bool RenderEmptyImages;
 
  bool UseFXAA;
  vtkNew<vtkFXAAOptions> FXAAOptions;
 
  bool UseToneMapping;
 
  bool UseSSAO;
  bool UseSSAODefaultPresets;
  double Radius;
  int KernelSize;
  double Bias;
  bool Blur;
 
  double LODResolution;
  bool UseLightKit;
 
  bool UsedLODForLastRender;
  bool UseLODForInteractiveRender;
  bool UseOutlineForLODRendering;
  bool UseDistributedRenderingForRender;
  bool UseDistributedRenderingForLODRender;
 
  vtkTypeUInt32 StillRenderProcesses;
  vtkTypeUInt32 InteractiveRenderProcesses;
 
  vtkTimeStamp PriorityQueueBuildTimeStamp;
 
  bool LockBounds;
 
private:
  vtkPVRenderView(const vtkPVRenderView&) = delete;
  void operator=(const vtkPVRenderView&) = delete;
 
  bool MakingSelection;
  int PreviousSwapBuffers;
  void OnSelectionChangedEvent();
  void OnPolygonSelectionEvent();
  void FinishSelection(vtkSelection*, const char*);
 
  // This flag is set to false when not all processes cannot render e.g. cannot
  // open the DISPLAY etc.
  bool RemoteRenderingAvailable;
 
  // Flags used to maintain rendering modes requested by representations.
  bool DistributedRenderingRequired;
  bool NonDistributedRenderingRequired;
  bool DistributedRenderingRequiredLOD;
  bool NonDistributedRenderingRequiredLOD;
 
  // Cached value for parallel projection set on camera.
  int ParallelProjection;
 
  // Cached state. Is currently ignored for distributed rendering.
  bool UseHiddenLineRemoval;
 
  class vtkInternals;
  vtkInternals* Internals;
 
  vtkNew<vtkTextRepresentation> Annotation;
  void UpdateAnnotationText();
 
  vtkNew<vtkOrderedCompositingHelper> OrderedCompositingHelper;
 
  int StereoType;
  int ServerStereoType;
  void UpdateStereoProperties();
 
  int BackgroundColorMode;
  bool UseEnvironmentLighting;
  bool UseRenderViewSettingsForBackground;
  double Background[3];
  double Background2[3];
 
  vtkSmartPointer<vtkCuller> Culler;
  vtkNew<vtkTimerLog> Timer;
 
  int ForceDataDistributionMode;
  int PreviousDiscreteCameraIndex;
  vtkSmartPointer<vtkTexture> EnvironmentalBGTexture;
  bool UseTexturedEnvironmentalBG;
};
 
#endif