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 "vtkPVView.h"
33 #include "vtkRemotingViewsModule.h" //needed for exports
34 #include "vtkSmartPointer.h" // needed for iVar
35 #include "vtkWeakPointer.h" // needed for iVar
36 
37 class vtkAlgorithmOutput;
38 class vtkCamera;
39 class vtkCuller;
41 class vtkFloatArray;
42 class vtkFXAAOptions;
49 class vtkLight;
50 class vtkLightKit;
51 class vtkMatrix4x4;
53 class vtkProp;
54 class vtkPVAxesWidget;
63 class vtkRenderer;
64 class vtkRenderViewBase;
65 class vtkRenderWindow;
67 class vtkSkybox;
69 class vtkTexture;
70 class vtkTimerLog;
72 
74 {
75  //*****************************************************************
76 public:
77  static vtkPVRenderView* New();
78  vtkTypeMacro(vtkPVRenderView, vtkPVView);
79  void PrintSelf(ostream& os, vtkIndent indent) override;
80 
82  {
83  INTERACTION_MODE_UNINTIALIZED = -1,
84  INTERACTION_MODE_3D = 0,
85  INTERACTION_MODE_2D, // not implemented yet.
88  INTERACTION_MODE_POLYGON
89  };
90 
92 
103  virtual void SetInteractionMode(int mode);
104  vtkGetMacro(InteractionMode, int);
106 
108 
112  void SetSize(int, int) override;
113  void SetPosition(int, int) override;
115 
117 
122  vtkGetObjectMacro(NonCompositedRenderer, vtkRenderer);
124 
128  enum
129  {
130  DEFAULT_RENDERER = 0,
131  NON_COMPOSITED_RENDERER = 1,
132  };
133 
139  virtual vtkRenderer* GetRenderer(int rendererType = DEFAULT_RENDERER);
140 
142 
146  vtkCamera* GetActiveCamera();
147  virtual void SetActiveCamera(vtkCamera*);
149 
153  vtkRenderWindowInteractor* GetInteractor();
154 
160  virtual void SetupInteractor(vtkRenderWindowInteractor*);
161 
163 
166  vtkGetObjectMacro(InteractorStyle, vtkPVInteractorStyle);
168 
170 
174  void ResetCamera();
175  void ResetCamera(double bounds[6]);
176  void ResetCameraScreenSpace();
177  void ResetCameraScreenSpace(double bounds[6]);
179 
181 
187  double* ComputeVisibleBounds(vtkPVDataRepresentation* pvrepr) VTK_SIZEHINT(6);
188  double LastRepresentationVisibleBounds[6];
190 
196  void StillRender() override;
197 
204  void InteractiveRender() override;
205 
207 
215  vtkSetMacro(SuppressRendering, bool);
216  vtkGetMacro(SuppressRendering, bool);
217  vtkBooleanMacro(SuppressRendering, bool);
219 
221 
229  vtkSetClampMacro(StillRenderImageReductionFactor, int, 1, 20);
230  vtkGetMacro(StillRenderImageReductionFactor, int);
232 
234 
240  vtkSetClampMacro(InteractiveRenderImageReductionFactor, int, 1, 20);
241  vtkGetMacro(InteractiveRenderImageReductionFactor, int);
243 
245 
250  vtkSetMacro(RemoteRenderingThreshold, double);
251  vtkGetMacro(RemoteRenderingThreshold, double);
253 
255 
260  vtkSetMacro(LODRenderingThreshold, double);
261  vtkGetMacro(LODRenderingThreshold, double);
263 
265 
271  vtkSetClampMacro(LODResolution, double, 0.0, 1.0);
272  vtkGetMacro(LODResolution, double);
274 
276 
282  vtkSetMacro(UseOutlineForLODRendering, bool);
283  vtkGetMacro(UseOutlineForLODRendering, bool);
285 
294  void ConfigureCompressor(const char* configuration);
295 
300  virtual void ResetCameraClippingRange();
301 
303 
307  void SetUseLightKit(bool enable);
308  vtkGetMacro(UseLightKit, bool);
309  vtkBooleanMacro(UseLightKit, bool);
311 
313  void StreamingUpdate(const double view_planes[24]);
314  void DeliverStreamedPieces(unsigned int size, unsigned int* representation_ids);
316 
320  static vtkInformationIntegerKey* USE_LOD();
321 
325  static vtkInformationDoubleKey* LOD_RESOLUTION();
326 
331  static vtkInformationIntegerKey* USE_OUTLINE_FOR_LOD();
332 
339  static vtkInformationIntegerKey* RENDER_EMPTY_IMAGES();
340 
345  static vtkInformationIntegerKey* NEED_ORDERED_COMPOSITING();
346 
351  static vtkInformationDoubleVectorKey* VIEW_PLANES();
352 
356  static vtkInformationRequestKey* REQUEST_STREAMING_UPDATE();
357 
361  static vtkInformationRequestKey* REQUEST_PROCESS_STREAMED_PIECE();
362 
364 
371  void SelectCells(int region[4], const char* array = nullptr);
372  void SelectCells(int region0, int region1, int region2, int region3, const char* array = nullptr)
373  {
374  int r[4] = { region0, region1, region2, region3 };
375  this->SelectCells(r, array);
376  }
377  void SelectPoints(int region[4], const char* array = nullptr);
378  void SelectPoints(int region0, int region1, int region2, int region3, const char* array = nullptr)
379  {
380  int r[4] = { region0, region1, region2, region3 };
381  this->SelectPoints(r, array);
382  }
383  void Select(int field_association, int region[4], const char* array = nullptr);
385 
387 
397  void SelectPolygonPoints(int* polygon2DArray, vtkIdType arrayLen);
398  void SelectPolygonCells(int* polygon2DArray, vtkIdType arrayLen);
399  void SelectPolygon(int field_association, int* polygon2DArray, vtkIdType arrayLen);
401 
403 
407  vtkGetObjectMacro(LastSelection, vtkSelection);
409 
411 
415  vtkSetMacro(UseInteractiveRenderingForScreenshots, bool);
416  vtkBooleanMacro(UseInteractiveRenderingForScreenshots, bool);
417  vtkGetMacro(UseInteractiveRenderingForScreenshots, bool);
419 
421 
424  vtkGetMacro(RemoteRenderingAvailable, bool);
425  void RemoteRenderingAvailableOff() { this->RemoteRenderingAvailable = false; }
427 
429 
432  void NVPipeAvailableOn();
433  void NVPipeAvailableOff();
435 
437 
440  vtkGetMacro(UsedLODForLastRender, bool);
442 
448  void InvalidateCachedSelection();
449 
451 
456  static vtkAlgorithmOutput* GetPieceProducer(
458  static vtkAlgorithmOutput* GetPieceProducerLOD(
459  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
460  static void SetRedistributionMode(
461  vtkInformation* info, vtkPVDataRepresentation* repr, int mode, int port = 0);
462  static void SetRedistributionModeToSplitBoundaryCells(
463  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
464  static void SetRedistributionModeToDuplicateBoundaryCells(
465  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
466  static void SetRedistributionModeToUniquelyAssignBoundaryCells(
467  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
468  static void SetGeometryBounds(vtkInformation* info, vtkPVDataRepresentation* repr,
469  const double bounds[6], vtkMatrix4x4* transform = nullptr, int port = 0);
470  static void SetStreamable(vtkInformation* info, vtkPVDataRepresentation* repr, bool streamable);
471  static void SetNextStreamedPiece(
473  static vtkDataObject* GetCurrentStreamedPiece(
476 
478 
505  enum
506  {
507  USE_BOUNDS_FOR_REDISTRIBUTION = 0x01,
508  DATA_IS_REDISTRIBUTABLE = 0x02,
509  USE_DATA_FOR_LOAD_BALANCING = 0x40,
510  };
511  static void SetOrderedCompositingConfiguration(vtkInformation* info,
512  vtkPVDataRepresentation* repr, int config, const double* bounds = nullptr, int port = 0);
514 
519  void SetMaxClipBounds(double bds[6]);
520 
522 
526  void SetLockBounds(bool nv);
527  vtkGetMacro(LockBounds, bool);
529 
535  static void SetDeliverToAllProcesses(
536  vtkInformation* info, vtkPVDataRepresentation* repr, bool clone);
537 
547  static void SetDeliverToClientAndRenderingProcesses(vtkInformation* info,
548  vtkPVDataRepresentation* repr, bool deliver_to_client, bool gather_before_delivery,
549  int port = 0);
550 
552 
560  static void SetRequiresDistributedRendering(
561  vtkInformation* info, vtkPVDataRepresentation* repr, bool value, bool for_lod = false);
563  vtkInformation* info, vtkPVDataRepresentation* repr, bool value)
564  {
565  vtkPVRenderView::SetRequiresDistributedRendering(info, repr, value, true);
566  }
568 
570 
582  static void SetForceDataDistributionMode(vtkInformation* info, int flag);
583  bool IsForceDataDistributionModeSet() const { return this->ForceDataDistributionMode != -1; }
584  int GetForceDataDistributionMode() const { return this->ForceDataDistributionMode; }
586 
588 
593  int RegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
594  void UnRegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
596 
598 
601  void SetShowAnnotation(bool val);
602  vtkSetMacro(UpdateAnnotation, bool);
604 
606 
609  void SetAnnotationColor(double r, double g, double b);
611 
615  virtual void SetGridAxes3DActor(vtkPVGridAxes3DActor*);
616 
617  //*****************************************************************
618  // Forwarded to orientation axes widget.
619  virtual void SetOrientationAxesInteractivity(bool);
620  virtual void SetOrientationAxesVisibility(bool);
621  void SetOrientationAxesLabelColor(double r, double g, double b);
622  void SetOrientationAxesOutlineColor(double r, double g, double b);
623 
624  //*****************************************************************
625  // Forwarded to center axes.
626  virtual void SetCenterAxesVisibility(bool);
627 
628  //*****************************************************************
629  // Forward to vtkPVInteractorStyle instances.
630  virtual void SetCenterOfRotation(double x, double y, double z);
631  virtual void SetRotationFactor(double factor);
632 
633  //*****************************************************************
634  // Forward to vtkLightKit.
635  void SetKeyLightWarmth(double val);
636  void SetKeyLightIntensity(double val);
637  void SetKeyLightElevation(double val);
638  void SetKeyLightAzimuth(double val);
639  void SetFillLightWarmth(double val);
640  void SetKeyToFillRatio(double val);
641  void SetFillLightElevation(double val);
642  void SetFillLightAzimuth(double val);
643  void SetBackLightWarmth(double val);
644  void SetKeyToBackRatio(double val);
645  void SetBackLightElevation(double val);
646  void SetBackLightAzimuth(double val);
647  void SetHeadLightWarmth(double val);
648  void SetKeyToHeadRatio(double val);
649  void SetMaintainLuminance(int val);
650 
651  //*****************************************************************
652  // Forward to 3D renderer.
653  vtkSetMacro(UseHiddenLineRemoval, bool);
654  virtual void SetUseDepthPeeling(int val);
655  virtual void SetUseDepthPeelingForVolumes(bool val);
656  virtual void SetMaximumNumberOfPeels(int val);
657  virtual void SetBackgroundTexture(vtkTexture* val);
658 
660 
664  vtkSetMacro(UseRenderViewSettingsForBackground, bool);
665  vtkGetMacro(UseRenderViewSettingsForBackground, bool);
667 
669  {
675  };
676 
678 
681  vtkSetClampMacro(BackgroundColorMode, int, DEFAULT, STEREO_SKYBOX);
682  vtkSetVector3Macro(Background, double);
683  vtkGetVector3Macro(Background, double);
684  vtkSetVector3Macro(Background2, double);
685  vtkGetVector3Macro(Background2, double);
686  vtkSetMacro(UseEnvironmentLighting, bool);
688 
689  //*****************************************************************
690  // Entry point for environmental backgrounds
691  virtual void SetEnvironmentalBG(double r, double g, double b);
692  virtual void SetEnvironmentalBG2(double r, double g, double b);
693  virtual void SetEnvironmentalBGTexture(vtkTexture* val);
694  virtual void SetGradientEnvironmentalBG(int val);
695  virtual void SetTexturedEnvironmentalBG(int val);
696  virtual void SetBackgroundMode(int val);
697 
698  //*****************************************************************
699  // Entry point for dynamic lights
700  void AddLight(vtkLight*);
701  void RemoveLight(vtkLight*);
702 
703  //*****************************************************************
704  // Forward to vtkRenderWindow.
705  void SetStereoCapableWindow(int val);
706  void SetStereoRender(int val);
707  vtkSetMacro(StereoType, int);
708  vtkSetMacro(ServerStereoType, int);
709  void SetMultiSamples(int val);
710  void SetAlphaBitPlanes(int val);
711  void SetStencilCapable(int val);
712 
713  //*****************************************************************
714  // Forward to vtkCamera.
715  void SetParallelProjection(int mode);
716 
717  //*****************************************************************
718  // Forwarded to vtkPVInteractorStyle if present on local processes.
719  virtual void SetCamera2DManipulators(const int manipulators[9]);
720  virtual void SetCamera3DManipulators(const int manipulators[9]);
721  void SetCameraManipulators(vtkPVInteractorStyle* style, const int manipulators[9]);
722  virtual void SetReverseMouseWheelZoomDirection(bool reverse);
723  virtual void SetMouseWheelZoomsToCursor(bool value);
724  virtual void SetCamera2DMouseWheelMotionFactor(double factor);
725  virtual void SetCamera3DMouseWheelMotionFactor(double factor);
726 
734  void Update() override;
735 
739  virtual void UpdateLOD();
740 
742 
747  vtkGetMacro(UseLODForInteractiveRender, bool);
749 
751 
756  vtkGetMacro(UseDistributedRenderingForRender, bool);
758 
760 
765  vtkGetMacro(UseDistributedRenderingForLODRender, bool);
767 
769 
774  vtkGetMacro(StillRenderProcesses, vtkTypeUInt32);
776 
778 
783  vtkGetMacro(InteractiveRenderProcesses, vtkTypeUInt32);
785 
789  int GetDataDistributionMode(bool low_res);
790 
796  void Deliver(int use_lod, unsigned int size, unsigned int* representation_ids) override;
797 
806  bool GetUseOrderedCompositing();
807 
812  bool GetRenderEmptyImages();
813 
815 
818  vtkSetMacro(UseFXAA, bool);
819  vtkGetMacro(UseFXAA, bool);
821 
823 
826  void SetFXAARelativeContrastThreshold(double val);
827  void SetFXAAHardContrastThreshold(double val);
828  void SetFXAASubpixelBlendLimit(double val);
829  void SetFXAASubpixelContrastThreshold(double val);
830  void SetFXAAUseHighQualityEndpoints(bool val);
831  void SetFXAAEndpointSearchIterations(int val);
833 
838  {
839  Custom = 0,
840  Default = 1,
841  Uncharted2 = 2
842  };
843 
845 
848  void SetUseToneMapping(bool v);
849  vtkGetMacro(UseToneMapping, bool);
850  void SetToneMappingType(int);
851  void SetExposure(double);
852  void SetContrast(double);
853  void SetShoulder(double);
854  void SetMidIn(double);
855  void SetMidOut(double);
856  void SetHdrMax(double);
857  void SetUseACES(bool);
858  void SetGenericFilmicPresets(int t);
860 
862 
865  vtkSetMacro(UseSSAO, bool);
866  vtkGetMacro(UseSSAO, bool);
867  vtkSetMacro(UseSSAODefaultPresets, bool);
868  vtkSetMacro(Radius, double);
869  vtkSetMacro(KernelSize, int);
870  vtkSetMacro(Bias, double);
871  vtkSetMacro(Blur, bool);
873 
880  void CopyViewUpdateOptions(vtkPVRenderView* otherView);
881 
883 
886  void AddPropToRenderer(vtkProp* prop);
887  void RemovePropFromRenderer(vtkProp* prop);
889 
891 
905  bool BeginValuePassForRendering(int fieldAssociation, const char* arrayName, int component);
906  void EndValuePassForRendering();
907  vtkSmartPointer<vtkFloatArray> GrabValuePassResult();
909 
911 
914  void CaptureZBuffer();
915  vtkFloatArray* GetCapturedZBuffer();
917 
919 
922  void SetEnableOSPRay(bool);
923  bool GetEnableOSPRay();
925 
926 
929  void SetShadows(bool);
930  bool GetShadows();
932 
933 
936  void SetAmbientOcclusionSamples(int);
937  int GetAmbientOcclusionSamples();
939 
940 
943  void SetRouletteDepth(int);
944  int GetRouletteDepth();
946 
947 
950  void SetVolumeAnisotropy(double);
951  double GetVolumeAnisotropy();
953 
954 
957  void SetSamplesPerPixel(int);
958  int GetSamplesPerPixel();
960 
961 
964  void SetMaxFrames(int);
965  int GetMaxFrames();
967 
970  bool GetOSPRayContinueStreaming();
972 
975  void SetDenoise(bool);
976  bool GetDenoise();
978 
980 
983  void SetLightScale(double);
984  double GetLightScale();
986 
990  void SetOSPRayRendererType(std::string);
992 
995  void SetBackgroundNorth(double x, double y, double z);
996  void SetBackgroundEast(double x, double y, double z);
998 
1001  virtual void SetMaterialLibrary(vtkPVMaterialLibrary*);
1002  void SetViewTime(double value) override;
1004 
1007  void SetTimeCacheSize(int);
1008  int GetTimeCacheSize();
1010 
1012 
1036  static vtkPVCameraCollection* GetDiscreteCameras(
1038  static void SetDiscreteCameras(
1041 
1042  // Get the RenderViewBase used by this
1043  vtkGetObjectMacro(RenderView, vtkRenderViewBase);
1044 
1048  void ScaleRendererViewports(const double viewport[4]) override;
1049 
1054  void SynchronizeMaximumIds(vtkIdType* maxPointId, vtkIdType* maxCellId);
1055 
1056 protected:
1057  vtkPVRenderView();
1058  ~vtkPVRenderView() override;
1059 
1063  virtual void Render(bool interactive, bool skip_rendering);
1064 
1069  virtual void AboutToRenderOnLocalProcess(bool interactive) { (void)interactive; }
1070 
1077  bool ShouldUseDistributedRendering(double geometry_size, bool using_lod);
1078 
1082  bool ShouldUseLODRendering(double geometry);
1083 
1088  bool IsProcessRenderingGeometriesForCompositing(bool using_distributed_rendering);
1089 
1094  void SynchronizeGeometryBounds();
1095 
1099  void SetLastSelection(vtkSelection*);
1100 
1105  virtual void UpdateCenterAxes();
1106 
1111  bool GetLocalProcessDoesRendering(bool using_distributed_rendering);
1112 
1117  bool TestCollaborationCounter();
1118 
1123  void SynchronizeForCollaboration();
1124 
1129  virtual void BuildAnnotationText(ostream& str);
1130 
1132 
1136  vtkGetMacro(SynchronizationCounter, unsigned int);
1138 
1140 
1143  vtkGetMacro(MakingSelection, bool);
1145 
1150  bool PrepareSelect(int fieldAssociation, const char* array = nullptr);
1151 
1155  void PostSelect(vtkSelection* sel, const char* array = nullptr);
1156 
1161  virtual void UpdateBackground(vtkRenderer* renderer = nullptr);
1162 
1166  void ConfigureTexture(vtkTexture* texture);
1167 
1182 
1188 
1189  // this ivar can be used to suppress the render within
1190  // a StillRender or InteractiveRender. This is useful
1191  // in cases where you want the representations mappers
1192  // to be setup for rendering and have their data ready
1193  // but not actually do the render. For example if you
1194  // want to export the scene but not render it you must
1195  // turn on SuppressRendering and then call StillRender
1197 
1198  // 2D and 3D interactor style
1201 
1202  bool ReverseMouseWheelZoomDirection = false;
1203 
1204  // Active interactor style either [TwoDInteractorStyle, ThreeDInteractorStyle]
1206 
1208 
1209  // Used in collaboration mode to ensure that views are in the same state
1210  // (as far as representations added/removed goes) before rendering.
1212 
1213  // In mega-bytes.
1217 
1221 
1222  bool UseFXAA;
1224 
1226 
1227  bool UseSSAO;
1229  double Radius;
1231  double Bias;
1232  bool Blur;
1233 
1236 
1242 
1243  vtkTypeUInt32 StillRenderProcesses;
1245 
1251 
1253 
1254 private:
1255  vtkPVRenderView(const vtkPVRenderView&) = delete;
1256  void operator=(const vtkPVRenderView&) = delete;
1257 
1258  bool MakingSelection;
1259  int PreviousSwapBuffers;
1260  void OnSelectionChangedEvent();
1261  void OnPolygonSelectionEvent();
1262  void FinishSelection(vtkSelection*, const char*);
1263 
1264  // This flag is set to false when not all processes cannot render e.g. cannot
1265  // open the DISPLAY etc.
1266  bool RemoteRenderingAvailable;
1267 
1268  // Flags used to maintain rendering modes requested by representations.
1269  bool DistributedRenderingRequired;
1270  bool NonDistributedRenderingRequired;
1271  bool DistributedRenderingRequiredLOD;
1272  bool NonDistributedRenderingRequiredLOD;
1273 
1274  // Cached value for parallel projection set on camera.
1275  int ParallelProjection;
1276 
1277  // Cached state. Is currently ignored for distributed rendering.
1278  bool UseHiddenLineRemoval;
1279 
1280  class vtkInternals;
1281  vtkInternals* Internals;
1282 
1283  vtkNew<vtkTextRepresentation> Annotation;
1284  void UpdateAnnotationText();
1285 
1286  vtkNew<vtkOrderedCompositingHelper> OrderedCompositingHelper;
1287 
1288  int StereoType;
1289  int ServerStereoType;
1290  void UpdateStereoProperties();
1291 
1292  int BackgroundColorMode;
1293  bool UseEnvironmentLighting;
1294  bool UseRenderViewSettingsForBackground;
1295  double Background[3];
1296  double Background2[3];
1297 
1299  vtkNew<vtkTimerLog> Timer;
1300 
1301  int ForceDataDistributionMode;
1302  int PreviousDiscreteCameraIndex;
1303  vtkSmartPointer<vtkTexture> EnvironmentalBGTexture;
1304  bool UseTexturedEnvironmentalBG;
1305 };
1306 
1307 #endif
vtkPVHardwareSelector * Selector
static void SetRequiresDistributedRenderingLOD(vtkInformation *info, vtkPVDataRepresentation *repr, bool value)
Some representation only work when remote rendering or local rendering.
vtkPVInteractorStyle * InteractorStyle
coordinates rendering between corresponding renderers across multiple processes
static vtkView * New()
vtkPVInteractorStyle * TwoDInteractorStyle
vtkSelection * LastSelection
#define VTKREMOTINGVIEWS_EXPORT
virtual void SetViewTime(double value)
Get/Set the time this view is showing.
manages visual material definitions
vtkPVDataRepresentation adds some ParaView specific API to data representations.
vtkRenderViewBase * RenderView
virtual void AboutToRenderOnLocalProcess(bool interactive)
Called just before the local process renders.
bool UseDistributedRenderingForLODRender
virtual void Deliver(int use_lod, unsigned int size, unsigned int *representation_ids)
Called on all processes to request data-delivery for the list of representations. ...
double RemoteRenderingThreshold
vtkPVSynchronizedRenderer * SynchronizedRenderers
void Update() override
Overridden to not call Update() directly on the input representations, instead use ProcessViewRequest...
info
virtual void ScaleRendererViewports(const double viewport[4])
vtkViewLayout calls this method to update the total viewport available for this view.
int vtkIdType
vtkHardwareSelector subclass with paraview specific logic to avoid recapturing buffers unless needed...
vtkSmartPointer< vtkPVGridAxes3DActor > GridAxes3DActor
int GetForceDataDistributionMode() const
This is an temporary/experimental option and may be removed without notice.
baseclass for all ParaView views.
Definition: vtkPVView.h:44
int InteractiveRenderImageReductionFactor
void SelectCells(int region0, int region1, int region2, int region3, const char *array=nullptr)
Make a selection.
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
bool IsForceDataDistributionModeSet() const
This is an temporary/experimental option and may be removed without notice.
vtkTypeUInt32 StillRenderProcesses
A widget to manipulate vtkPVAxesWidget.
vtkNew< vtkSkybox > Skybox
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.
mode
unsigned int SynchronizationCounter
collection of cameras used by vtkPVRenderView for cases where one wants to limit interactions to a fi...
vtkInteractorStyleDrawPolygon * PolygonStyle
void SelectPoints(int region0, int region1, int region2, int region3, const char *array=nullptr)
Make a selection.
GenericFilmicPresets
Defines tone mapping generic filmic presets.
vtkTimeStamp PriorityQueueBuildTimeStamp
Keeps track of the time when the priority-queue for streaming was generated.
Background
vtkBoundingBox GeometryBounds
virtual void SetPosition(int, int)
Set the position on this view in the multiview configuration.
vtkRenderer * NonCompositedRenderer
vtkWeakPointer< vtkPVCameraCollection > DiscreteCameras
bool UseDistributedRenderingForRender
int StillRenderImageReductionFactor
vtkPVCenterAxesActor * CenterAxes
void PrintSelf(ostream &os, vtkIndent indent) override
virtual void StillRender()=0
Triggers a high-resolution render.
vtkPVCenterAxesActor is an actor for the center-axes used in ParaView.
port
Render View for ParaView.
interactive manipulation of the camera
vtkLightKit * LightKit
virtual void InteractiveRender()=0
Triggers a interactive render.
vtkSmartPointer< vtkRenderWindowInteractor > Interactor
vtkInteractorStyleRubberBand3D * RubberBandStyle
vtkPVInteractorStyle * ThreeDInteractorStyle
ParaView extensions for vtkGridAxes3DActor.
helper to assist in determine process order when rendering
vtkTypeUInt32 InteractiveRenderProcesses