ParaView
vtkPVRenderView.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: ParaView
4  Module: vtkPVRenderView.h
5 
6  Copyright (c) Kitware, Inc.
7  All rights reserved.
8  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
27 #ifndef vtkPVRenderView_h
28 #define vtkPVRenderView_h
29 
30 #include "vtkBoundingBox.h" // needed for iVar
31 #include "vtkNew.h" // needed for iVar
32 #include "vtkPVClientServerCoreRenderingModule.h" //needed for exports
33 #include "vtkPVView.h"
34 #include "vtkSmartPointer.h" // needed for iVar
35 
36 class vtkAlgorithmOutput;
37 class vtkCamera;
38 class vtkCuller;
39 class vtkExtentTranslator;
40 class vtkFloatArray;
41 class vtkFXAAOptions;
42 class vtkInformationDoubleKey;
43 class vtkInformationDoubleVectorKey;
44 class vtkInformationIntegerKey;
45 class vtkInteractorStyleDrawPolygon;
46 class vtkInteractorStyleRubberBand3D;
47 class vtkInteractorStyleRubberBandZoom;
48 class vtkLight;
49 class vtkLightKit;
50 class vtkMatrix4x4;
52 class vtkPVAxesWidget;
60 class vtkProp;
61 class vtkRenderViewBase;
62 class vtkRenderWindow;
63 class vtkRenderWindowInteractor;
64 class vtkRenderer;
65 class vtkTextRepresentation;
66 class vtkTexture;
67 class vtkTimerLog;
68 class vtkWindowToImageFilter;
69 
70 class VTKPVCLIENTSERVERCORERENDERING_EXPORT vtkPVRenderView : public vtkPVView
71 {
72  //*****************************************************************
73 public:
74  static vtkPVRenderView* New();
75  vtkTypeMacro(vtkPVRenderView, vtkPVView);
76  void PrintSelf(ostream& os, vtkIndent indent);
77 
79  {
80  INTERACTION_MODE_UNINTIALIZED = -1,
81  INTERACTION_MODE_3D = 0,
82  INTERACTION_MODE_2D, // not implemented yet.
85  INTERACTION_MODE_POLYGON
86  };
87 
89 
99  virtual void SetInteractionMode(int mode);
100  vtkGetMacro(InteractionMode, int);
102 
108  virtual void Initialize(unsigned int id);
109 
111 
115  virtual void SetSize(int, int);
116  virtual void SetPosition(int, int);
118 
120 
125  vtkGetObjectMacro(NonCompositedRenderer, vtkRenderer);
127 
131  enum
132  {
133  DEFAULT_RENDERER = 0,
134  NON_COMPOSITED_RENDERER = 1,
135  };
136 
142  virtual vtkRenderer* GetRenderer(int rendererType = DEFAULT_RENDERER);
143 
145 
149  vtkCamera* GetActiveCamera();
150  virtual void SetActiveCamera(vtkCamera*);
152 
156  vtkRenderWindow* GetRenderWindow();
157 
161  vtkRenderWindowInteractor* GetInteractor();
162 
168  virtual void SetupInteractor(vtkRenderWindowInteractor*);
169 
171 
174  vtkGetObjectMacro(InteractorStyle, vtkPVInteractorStyle);
176 
178 
182  void ResetCamera();
183  void ResetCamera(double bounds[6]);
185 
190  virtual void StillRender();
191 
197  virtual void InteractiveRender();
198 
200 
208  vtkSetClampMacro(StillRenderImageReductionFactor, int, 1, 20);
209  vtkGetMacro(StillRenderImageReductionFactor, int);
211 
213 
219  vtkSetClampMacro(InteractiveRenderImageReductionFactor, int, 1, 20);
220  vtkGetMacro(InteractiveRenderImageReductionFactor, int);
222 
224 
229  vtkSetMacro(RemoteRenderingThreshold, double);
230  vtkGetMacro(RemoteRenderingThreshold, double);
232 
234 
239  vtkSetMacro(LODRenderingThreshold, double);
240  vtkGetMacro(LODRenderingThreshold, double);
242 
244 
250  vtkSetClampMacro(LODResolution, double, 0.0, 1.0);
251  vtkGetMacro(LODResolution, double);
253 
255 
261  vtkSetMacro(UseOutlineForLODRendering, bool);
262  vtkGetMacro(UseOutlineForLODRendering, bool);
264 
273  void ConfigureCompressor(const char* configuration);
274 
279  virtual void ResetCameraClippingRange();
280 
282 
286  void SetUseLightKit(bool enable);
287  vtkGetMacro(UseLightKit, bool);
288  vtkBooleanMacro(UseLightKit, bool);
290 
292  void StreamingUpdate(const double view_planes[24]);
293  void DeliverStreamedPieces(unsigned int size, unsigned int* representation_ids);
295 
299  static vtkInformationIntegerKey* USE_LOD();
300 
304  static vtkInformationDoubleKey* LOD_RESOLUTION();
305 
310  static vtkInformationIntegerKey* USE_OUTLINE_FOR_LOD();
311 
318  static vtkInformationIntegerKey* RENDER_EMPTY_IMAGES();
319 
324  static vtkInformationIntegerKey* NEED_ORDERED_COMPOSITING();
325 
330  static vtkInformationDoubleVectorKey* VIEW_PLANES();
331 
335  static vtkInformationRequestKey* REQUEST_STREAMING_UPDATE();
336 
340  static vtkInformationRequestKey* REQUEST_PROCESS_STREAMED_PIECE();
341 
343 
348  void SelectCells(int region[4]);
349  void SelectCells(int region0, int region1, int region2, int region3)
350  {
351  int r[4] = { region0, region1, region2, region3 };
352  this->SelectCells(r);
353  }
354  void SelectPoints(int region[4]);
355  void SelectPoints(int region0, int region1, int region2, int region3)
356  {
357  int r[4] = { region0, region1, region2, region3 };
358  this->SelectPoints(r);
359  }
360  void Select(int field_association, int region[4]);
362 
364 
372  void SelectPolygonPoints(int* polygon2DArray, vtkIdType arrayLen);
373  void SelectPolygonCells(int* polygon2DArray, vtkIdType arrayLen);
374  void SelectPolygon(int field_association, int* polygon2DArray, vtkIdType arrayLen);
376 
378 
381  vtkGetObjectMacro(LastSelection, vtkSelection);
383 
385 
389  vtkSetMacro(UseInteractiveRenderingForScreenshots, bool);
390  vtkBooleanMacro(UseInteractiveRenderingForScreenshots, bool);
391  vtkGetMacro(UseInteractiveRenderingForScreenshots, bool);
393 
395 
399  vtkSetMacro(UseOffscreenRenderingForScreenshots, bool);
400  vtkBooleanMacro(UseOffscreenRenderingForScreenshots, bool);
401  vtkGetMacro(UseOffscreenRenderingForScreenshots, bool);
403 
405 
413  virtual void SetUseOffscreenRendering(bool);
414  vtkBooleanMacro(UseOffscreenRendering, bool);
415  vtkGetMacro(UseOffscreenRendering, bool);
417 
419 
424  virtual void SetEGLDeviceIndex(int);
425  vtkGetMacro(EGLDeviceIndex, int);
427 
429 
432  vtkGetMacro(RemoteRenderingAvailable, bool);
433  void RemoteRenderingAvailableOff() { this->RemoteRenderingAvailable = false; }
435 
437 
440  vtkGetMacro(UsedLODForLastRender, bool);
442 
448  void InvalidateCachedSelection();
449 
454  double GetZbufferDataAtPoint(int x, int y);
455 
457 
462  static void SetPiece(vtkInformation* info, vtkPVDataRepresentation* repr, vtkDataObject* data,
463  unsigned long trueSize = 0);
464  static vtkAlgorithmOutput* GetPieceProducer(vtkInformation* info, vtkPVDataRepresentation* repr);
465  static void SetPieceLOD(vtkInformation* info, vtkPVDataRepresentation* repr, vtkDataObject* data);
466  static vtkAlgorithmOutput* GetPieceProducerLOD(
467  vtkInformation* info, vtkPVDataRepresentation* repr);
468  static void MarkAsRedistributable(
469  vtkInformation* info, vtkPVDataRepresentation* repr, bool value = true);
470  static void SetGeometryBounds(
471  vtkInformation* info, double bounds[6], vtkMatrix4x4* transform = NULL);
472  static void SetStreamable(vtkInformation* info, vtkPVDataRepresentation* repr, bool streamable);
473  static void SetNextStreamedPiece(
474  vtkInformation* info, vtkPVDataRepresentation* repr, vtkDataObject* piece);
475  static vtkDataObject* GetCurrentStreamedPiece(
476  vtkInformation* info, vtkPVDataRepresentation* repr);
478 
483  void SetMaxClipBounds(double bds[6]);
484 
486 
490  void SetLockBounds(bool nv);
491  vtkGetMacro(LockBounds, bool);
493 
499  static void SetDeliverToAllProcesses(
500  vtkInformation* info, vtkPVDataRepresentation* repr, bool clone);
501 
511  static void SetDeliverToClientAndRenderingProcesses(vtkInformation* info,
512  vtkPVDataRepresentation* repr, bool deliver_to_client, bool gather_before_delivery);
513 
515 
519  static void SetOrderedCompositingInformation(vtkInformation* info, vtkPVDataRepresentation* repr,
520  vtkExtentTranslator* translator, const int whole_extents[6], const double origin[3],
521  const double spacing[3]);
522  static void SetOrderedCompositingInformation(vtkInformation* info, const double bounds[6]);
523  void ClearOrderedCompositingInformation();
525 
527 
535  static void SetRequiresDistributedRendering(
536  vtkInformation* info, vtkPVDataRepresentation* repr, bool value, bool for_lod = false);
538  vtkInformation* info, vtkPVDataRepresentation* repr, bool value)
539  {
540  vtkPVRenderView::SetRequiresDistributedRendering(info, repr, value, true);
541  }
543 
556  static void SetForceDataDistributionMode(vtkInformation* info, int flag);
557 
559 
564  void RegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
565  void UnRegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
567 
569 
572  void SetLightSwitch(bool enable);
573  bool GetLightSwitch();
574  vtkBooleanMacro(LightSwitch, bool);
576 
578 
581  void SetShowAnnotation(bool val);
582  vtkSetMacro(UpdateAnnotation, bool);
584 
586 
589  void SetAnnotationColor(double r, double g, double b);
591 
595  virtual void SetGridAxes3DActor(vtkPVGridAxes3DActor*);
596 
597  //*****************************************************************
598  // Forwarded to orientation axes widget.
599  virtual void SetOrientationAxesInteractivity(bool);
600  virtual void SetOrientationAxesVisibility(bool);
601  void SetOrientationAxesLabelColor(double r, double g, double b);
602  void SetOrientationAxesOutlineColor(double r, double g, double b);
603 
604  //*****************************************************************
605  // Forwarded to center axes.
606  virtual void SetCenterAxesVisibility(bool);
607 
608  //*****************************************************************
609  // Forward to vtkPVInteractorStyle instances.
610  virtual void SetCenterOfRotation(double x, double y, double z);
611  virtual void SetRotationFactor(double factor);
612 
613  //*****************************************************************
614  // Forward to vtkLightKit.
615  void SetKeyLightWarmth(double val);
616  void SetKeyLightIntensity(double val);
617  void SetKeyLightElevation(double val);
618  void SetKeyLightAzimuth(double val);
619  void SetFillLightWarmth(double val);
620  void SetKeyToFillRatio(double val);
621  void SetFillLightElevation(double val);
622  void SetFillLightAzimuth(double val);
623  void SetBackLightWarmth(double val);
624  void SetKeyToBackRatio(double val);
625  void SetBackLightElevation(double val);
626  void SetBackLightAzimuth(double val);
627  void SetHeadLightWarmth(double val);
628  void SetKeyToHeadRatio(double val);
629  void SetMaintainLuminance(int val);
630 
631  //*****************************************************************
632  // Forward to 3D renderer.
633  vtkSetMacro(UseHiddenLineRemoval, bool) virtual void SetUseDepthPeeling(int val);
634  virtual void SetMaximumNumberOfPeels(int val);
635  virtual void SetBackground(double r, double g, double b);
636  virtual void SetBackground2(double r, double g, double b);
637  virtual void SetBackgroundTexture(vtkTexture* val);
638  virtual void SetGradientBackground(int val);
639  virtual void SetTexturedBackground(int val);
640 
641  //*****************************************************************
642  // Forward to vtkLight.
643  void SetAmbientColor(double r, double g, double b);
644  void SetSpecularColor(double r, double g, double b);
645  void SetDiffuseColor(double r, double g, double b);
646  void SetIntensity(double val);
647  void SetLightType(int val);
648 
649  //*****************************************************************
650  // Forward to vtkRenderWindow.
651  void SetStereoCapableWindow(int val);
652  void SetStereoRender(int val);
653  vtkSetMacro(StereoType, int);
654  vtkSetMacro(ServerStereoType, int);
655  void SetMultiSamples(int val);
656  void SetAlphaBitPlanes(int val);
657  void SetStencilCapable(int val);
658 
659  //*****************************************************************
660  // Forward to vtkCamera.
661  void SetParallelProjection(int mode);
662 
663  //*****************************************************************
664  // Forwarded to vtkPVInteractorStyle if present on local processes.
665  virtual void SetCamera2DManipulators(const int manipulators[9]);
666  virtual void SetCamera3DManipulators(const int manipulators[9]);
667  void SetCameraManipulators(vtkPVInteractorStyle* style, const int manipulators[9]);
668 
676  virtual void Update();
677 
681  virtual void UpdateLOD();
682 
684 
689  vtkGetMacro(UseLODForInteractiveRender, bool);
691 
693 
698  vtkGetMacro(UseDistributedRenderingForStillRender, bool);
700 
702 
707  vtkGetMacro(UseDistributedRenderingForInteractiveRender, bool);
709 
711 
716  vtkGetMacro(StillRenderProcesses, vtkTypeUInt32);
718 
720 
725  vtkGetMacro(InteractiveRenderProcesses, vtkTypeUInt32);
727 
731  int GetDataDistributionMode(bool use_remote_rendering);
732 
736  vtkPVDataDeliveryManager* GetDeliveryManager();
737 
743  void Deliver(int use_lod, unsigned int size, unsigned int* representation_ids);
744 
753  bool GetUseOrderedCompositing();
754 
759  bool GetRenderEmptyImages();
760 
762 
765  vtkSetMacro(UseFXAA, bool) vtkGetMacro(UseFXAA, bool)
767 
769 
772  void SetFXAARelativeContrastThreshold(double val);
773  void SetFXAAHardContrastThreshold(double val);
774  void SetFXAASubpixelBlendLimit(double val);
775  void SetFXAASubpixelContrastThreshold(double val);
776  void SetFXAAUseHighQualityEndpoints(bool val);
777  void SetFXAAEndpointSearchIterations(int val);
779 
783  unsigned long GetUpdateTimeStamp() { return this->UpdateTimeStamp; }
784 
791  void CopyViewUpdateOptions(vtkPVRenderView* otherView);
792 
794 
797  void AddPropToRenderer(vtkProp* prop);
798  void RemovePropFromRenderer(vtkProp* prop);
800 
802 
807  void SetDrawCells(bool choice);
808  void SetArrayNameToDraw(const char* name);
809  void SetArrayNumberToDraw(int fieldAttributeType);
810  void SetArrayComponentToDraw(int comp);
811  void SetScalarRange(double min, double max);
812  void BeginValueCapture();
813  void EndValueCapture();
815 
817 
820  void SetValueRenderingModeCommand(int mode);
821  int GetValueRenderingModeCommand();
823 
825 
833  void CaptureValuesFloat();
834  vtkFloatArray* GetCapturedValuesFloat();
836 
838 
842  void StartCaptureLuminance();
843  void StopCaptureLuminance();
845 
847 
850  void CaptureZBuffer();
851  vtkFloatArray* GetCapturedZBuffer();
853 
855 
858  void SetEnableOSPRay(bool);
859  bool GetEnableOSPRay();
861 
862 
865  void SetShadows(bool);
866  bool GetShadows();
868 
869 
872  void SetAmbientOcclusionSamples(int);
873  int GetAmbientOcclusionSamples();
875 
876 
879  void SetSamplesPerPixel(int);
880  int GetSamplesPerPixel();
882 
883 
886  void SetMaxFrames(int);
887  int GetMaxFrames();
889 
890 
893  void SetLightScale(double);
894  double GetLightScale();
896 
897 protected:
898  vtkPVRenderView();
899  ~vtkPVRenderView();
900 
902 
910  virtual void AddRepresentationInternal(vtkDataRepresentation* rep);
911  virtual void RemoveRepresentationInternal(vtkDataRepresentation* rep);
913 
917  virtual void Render(bool interactive, bool skip_rendering);
918 
923  virtual void AboutToRenderOnLocalProcess(bool interactive) { (void)interactive; }
924 
931  bool ShouldUseDistributedRendering(double geometry_size, bool using_lod);
932 
936  bool ShouldUseLODRendering(double geometry);
937 
942  bool IsProcessRenderingGeometriesForCompositing(bool using_distributed_rendering);
943 
948  void SynchronizeGeometryBounds();
949 
953  void SetLastSelection(vtkSelection*);
954 
959  virtual void UpdateCenterAxes();
960 
965  bool GetLocalProcessDoesRendering(bool using_distributed_rendering);
966 
971  bool TestCollaborationCounter();
972 
977  void SynchronizeForCollaboration();
978 
983  virtual void BuildAnnotationText(ostream& str);
984 
986 
990  vtkGetMacro(SynchronizationCounter, unsigned int);
992 
994 
997  vtkGetMacro(MakingSelection, bool);
999 
1004  bool PrepareSelect(int fieldAssociation);
1005 
1009  void PostSelect(vtkSelection* sel);
1010 
1011  vtkLight* Light;
1012  vtkLightKit* LightKit;
1013  vtkRenderViewBase* RenderView;
1016  vtkSmartPointer<vtkRenderWindowInteractor> Interactor;
1017  vtkInteractorStyleRubberBand3D* RubberBandStyle;
1018  vtkInteractorStyleRubberBandZoom* RubberBandZoom;
1019  vtkInteractorStyleDrawPolygon* PolygonStyle;
1023  vtkSelection* LastSelection;
1024  vtkSmartPointer<vtkPVGridAxes3DActor> GridAxes3DActor;
1025 
1031 
1032  // 2D and 3D interactor style
1035 
1036  // Active interactor style either [TwoDInteractorStyle, ThreeDInteractorStyle]
1038 
1039  // Used in collaboration mode to ensure that views are in the same state
1040  // (as far as representations added/removed goes) before rendering.
1042 
1043  // In mega-bytes.
1046  vtkBoundingBox GeometryBounds;
1047 
1054 
1055  bool UseFXAA;
1056  vtkNew<vtkFXAAOptions> FXAAOptions;
1057 
1060 
1066 
1067  vtkTypeUInt32 StillRenderProcesses;
1069 
1073  vtkTimeStamp UpdateTimeStamp;
1074 
1080 
1082 
1083 private:
1084  vtkPVRenderView(const vtkPVRenderView&) VTK_DELETE_FUNCTION;
1085  void operator=(const vtkPVRenderView&) VTK_DELETE_FUNCTION;
1086 
1087  bool MakingSelection;
1088  int PreviousSwapBuffers;
1089  void OnSelectionChangedEvent();
1090  void OnPolygonSelectionEvent();
1091  void FinishSelection(vtkSelection*);
1092 
1093  // This flag is set to false when not all processes cannot render e.g. cannot
1094  // open the DISPLAY etc.
1095  bool RemoteRenderingAvailable;
1096 
1097  // Flags used to maintain rendering modes requested by representations.
1098  bool DistributedRenderingRequired;
1099  bool NonDistributedRenderingRequired;
1100  bool DistributedRenderingRequiredLOD;
1101  bool NonDistributedRenderingRequiredLOD;
1102 
1103  // Cached value for parallel projection set on camera.
1104  int ParallelProjection;
1105 
1106  // Cached state. Is currently ignored for distributed rendering.
1107  bool UseHiddenLineRemoval;
1108 
1109  class vtkInternals;
1110  vtkInternals* Internals;
1111 
1112  vtkNew<vtkTextRepresentation> Annotation;
1113  void UpdateAnnotationText();
1114 
1115  vtkNew<vtkPartitionOrderingInterface> PartitionOrdering;
1116 
1117  bool OrientationWidgetVisibility;
1118 
1119  int StereoType;
1120  int ServerStereoType;
1121  void UpdateStereoProperties();
1122 
1123  vtkSmartPointer<vtkCuller> Culler;
1124  vtkNew<vtkTimerLog> Timer;
1125 
1126  int ForceDataDistributionMode;
1127 };
1128 
1129 #endif
vtkPVHardwareSelector * Selector
static void SetRequiresDistributedRenderingLOD(vtkInformation *info, vtkPVDataRepresentation *repr, bool value)
Some representation only work when remote rendering or local rendering.
manager for data-delivery.
vtkPVInteractorStyle * InteractorStyle
void PrintSelf(ostream &os, vtkIndent indent)
synchronizes and composites renderers among processes in ParaView configurations. ...
vtkPVInteractorStyle * TwoDInteractorStyle
vtkSelection * LastSelection
vtkPVDataRepresentation adds some ParaView specific API to data representations.
vtkRenderViewBase * RenderView
virtual void AboutToRenderOnLocalProcess(bool interactive)
Called just before the local process renders.
double RemoteRenderingThreshold
vtkPVSynchronizedRenderer * SynchronizedRenderers
bool UseOffscreenRenderingForScreenshots
vtkHardwareSelector subclass with paraview sepecific logic to avoid recapturing buffers unless needed...
vtkTimeStamp UpdateTimeStamp
Keeps track of the time when vtkPVRenderView::Update() was called.
vtkSmartPointer< vtkPVGridAxes3DActor > GridAxes3DActor
baseclass for all ParaView views.
Definition: vtkPVView.h:38
int InteractiveRenderImageReductionFactor
void RemoteRenderingAvailableOff()
Returns if remote-rendering is possible on the current group of processes.
virtual void SetSize(int, int)
Set the size of this view in the multiview configuration.
bool UseInteractiveRenderingForScreenshots
vtkNew< vtkFXAAOptions > FXAAOptions
vtkTypeUInt32 StillRenderProcesses
A widget to manipulate an axe.
vtkInteractorStyleRubberBandZoom * RubberBandZoom
vtkPVAxesWidget * OrientationWidget
double LODRenderingThreshold
static void SetRequiresDistributedRendering(vtkInformation *info, vtkPVDataRepresentation *repr, bool value, bool for_lod=false)
Some representation only work when remote rendering or local rendering.
virtual void AddRepresentationInternal(vtkDataRepresentation *rep)
Overridden to check that the representation has View setup properly.
unsigned int SynchronizationCounter
vtkInteractorStyleDrawPolygon * PolygonStyle
vtkTimeStamp PriorityQueueBuildTimeStamp
Keeps track of the time when the priority-queue for streaming was generated.
void SelectCells(int region0, int region1, int region2, int region3)
Make a selection.
vtkBoundingBox GeometryBounds
Interface for ordering compositing.
virtual void SetPosition(int, int)
Set the position on this view in the multiview configuration.
virtual void Initialize(unsigned int id)
Initialize the view with an identifier.
vtkRenderer * NonCompositedRenderer
int StillRenderImageReductionFactor
vtkPVCenterAxesActor * CenterAxes
virtual void StillRender()=0
Triggers a high-resolution render.
vtkPVCenterAxesActor is an actor for the center-axes used in ParaView.
void SelectPoints(int region0, int region1, int region2, int region3)
Make a selection.
bool UseDistributedRenderingForStillRender
Render View for ParaView.
interactive manipulation of the camera
bool UseDistributedRenderingForInteractiveRender
virtual void Update()
Overridden to not call Update() directly on the input representations, instead use ProcessViewRequest...
vtkLightKit * LightKit
virtual void InteractiveRender()=0
Triggers a interactive render.
vtkSmartPointer< vtkRenderWindowInteractor > Interactor
unsigned long GetUpdateTimeStamp()
Provides access to the time when Update() was last called.
vtkInteractorStyleRubberBand3D * RubberBandStyle
vtkPVInteractorStyle * ThreeDInteractorStyle
ParaView extensions for vtkGridAxes3DActor.
vtkTypeUInt32 InteractiveRenderProcesses