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 
73 class VTKREMOTINGVIEWS_EXPORT vtkPVRenderView : public vtkPVView
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]);
177 
183  void StillRender() override;
184 
191  void InteractiveRender() override;
192 
194 
202  vtkSetMacro(SuppressRendering, bool);
203  vtkGetMacro(SuppressRendering, bool);
204  vtkBooleanMacro(SuppressRendering, bool);
206 
208 
216  vtkSetClampMacro(StillRenderImageReductionFactor, int, 1, 20);
217  vtkGetMacro(StillRenderImageReductionFactor, int);
219 
221 
227  vtkSetClampMacro(InteractiveRenderImageReductionFactor, int, 1, 20);
228  vtkGetMacro(InteractiveRenderImageReductionFactor, int);
230 
232 
237  vtkSetMacro(RemoteRenderingThreshold, double);
238  vtkGetMacro(RemoteRenderingThreshold, double);
240 
242 
247  vtkSetMacro(LODRenderingThreshold, double);
248  vtkGetMacro(LODRenderingThreshold, double);
250 
252 
258  vtkSetClampMacro(LODResolution, double, 0.0, 1.0);
259  vtkGetMacro(LODResolution, double);
261 
263 
269  vtkSetMacro(UseOutlineForLODRendering, bool);
270  vtkGetMacro(UseOutlineForLODRendering, bool);
272 
281  void ConfigureCompressor(const char* configuration);
282 
287  virtual void ResetCameraClippingRange();
288 
290 
294  void SetUseLightKit(bool enable);
295  vtkGetMacro(UseLightKit, bool);
296  vtkBooleanMacro(UseLightKit, bool);
298 
300  void StreamingUpdate(const double view_planes[24]);
301  void DeliverStreamedPieces(unsigned int size, unsigned int* representation_ids);
303 
307  static vtkInformationIntegerKey* USE_LOD();
308 
312  static vtkInformationDoubleKey* LOD_RESOLUTION();
313 
318  static vtkInformationIntegerKey* USE_OUTLINE_FOR_LOD();
319 
326  static vtkInformationIntegerKey* RENDER_EMPTY_IMAGES();
327 
332  static vtkInformationIntegerKey* NEED_ORDERED_COMPOSITING();
333 
338  static vtkInformationDoubleVectorKey* VIEW_PLANES();
339 
343  static vtkInformationRequestKey* REQUEST_STREAMING_UPDATE();
344 
348  static vtkInformationRequestKey* REQUEST_PROCESS_STREAMED_PIECE();
349 
351 
358  void SelectCells(int region[4], const char* array = nullptr);
359  void SelectCells(int region0, int region1, int region2, int region3, const char* array = nullptr)
360  {
361  int r[4] = { region0, region1, region2, region3 };
362  this->SelectCells(r, array);
363  }
364  void SelectPoints(int region[4], const char* array = nullptr);
365  void SelectPoints(int region0, int region1, int region2, int region3, const char* array = nullptr)
366  {
367  int r[4] = { region0, region1, region2, region3 };
368  this->SelectPoints(r, array);
369  }
370  void Select(int field_association, int region[4], const char* array = nullptr);
372 
374 
384  void SelectPolygonPoints(int* polygon2DArray, vtkIdType arrayLen);
385  void SelectPolygonCells(int* polygon2DArray, vtkIdType arrayLen);
386  void SelectPolygon(int field_association, int* polygon2DArray, vtkIdType arrayLen);
388 
390 
394  vtkGetObjectMacro(LastSelection, vtkSelection);
396 
398 
402  vtkSetMacro(UseInteractiveRenderingForScreenshots, bool);
403  vtkBooleanMacro(UseInteractiveRenderingForScreenshots, bool);
404  vtkGetMacro(UseInteractiveRenderingForScreenshots, bool);
406 
408 
411  vtkGetMacro(RemoteRenderingAvailable, bool);
412  void RemoteRenderingAvailableOff() { this->RemoteRenderingAvailable = false; }
414 
416 
419  void NVPipeAvailableOn();
420  void NVPipeAvailableOff();
422 
424 
427  vtkGetMacro(UsedLODForLastRender, bool);
429 
435  void InvalidateCachedSelection();
436 
438 
443  static vtkAlgorithmOutput* GetPieceProducer(
445  static vtkAlgorithmOutput* GetPieceProducerLOD(
446  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
447  static void SetRedistributionMode(
448  vtkInformation* info, vtkPVDataRepresentation* repr, int mode, int port = 0);
449  static void SetRedistributionModeToSplitBoundaryCells(
450  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
451  static void SetRedistributionModeToDuplicateBoundaryCells(
452  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
453  static void SetRedistributionModeToUniquelyAssignBoundaryCells(
454  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
455  static void SetGeometryBounds(vtkInformation* info, vtkPVDataRepresentation* repr,
456  const double bounds[6], vtkMatrix4x4* transform = nullptr, int port = 0);
457  static void SetStreamable(vtkInformation* info, vtkPVDataRepresentation* repr, bool streamable);
458  static void SetNextStreamedPiece(
460  static vtkDataObject* GetCurrentStreamedPiece(
463 
465 
473  VTK_LEGACY(static void MarkAsRedistributable(
474  vtkInformation* info, vtkPVDataRepresentation* repr, bool value = true, int port = 0));
475  VTK_LEGACY(static void SetOrderedCompositingInformation(vtkInformation* info,
476  vtkPVDataRepresentation* repr, vtkExtentTranslator* translator, const int whole_extents[6],
477  const double origin[3], const double spacing[3]));
478  VTK_LEGACY(
479  static void SetOrderedCompositingInformation(vtkInformation* info, const double bounds[6]));
481 
483 
510  enum
511  {
512  USE_BOUNDS_FOR_REDISTRIBUTION = 0x01,
513  DATA_IS_REDISTRIBUTABLE = 0x02,
514  USE_DATA_FOR_LOAD_BALANCING = 0x40,
515  };
516  static void SetOrderedCompositingConfiguration(vtkInformation* info,
517  vtkPVDataRepresentation* repr, int config, const double* bounds = nullptr, int port = 0);
519 
524  void SetMaxClipBounds(double bds[6]);
525 
527 
531  void SetLockBounds(bool nv);
532  vtkGetMacro(LockBounds, bool);
534 
540  static void SetDeliverToAllProcesses(
541  vtkInformation* info, vtkPVDataRepresentation* repr, bool clone);
542 
552  static void SetDeliverToClientAndRenderingProcesses(vtkInformation* info,
553  vtkPVDataRepresentation* repr, bool deliver_to_client, bool gather_before_delivery,
554  int port = 0);
555 
557 
565  static void SetRequiresDistributedRendering(
566  vtkInformation* info, vtkPVDataRepresentation* repr, bool value, bool for_lod = false);
568  vtkInformation* info, vtkPVDataRepresentation* repr, bool value)
569  {
570  vtkPVRenderView::SetRequiresDistributedRendering(info, repr, value, true);
571  }
573 
575 
587  static void SetForceDataDistributionMode(vtkInformation* info, int flag);
588  bool IsForceDataDistributionModeSet() const { return this->ForceDataDistributionMode != -1; }
589  int GetForceDataDistributionMode() const { return this->ForceDataDistributionMode; }
591 
593 
598  int RegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
599  void UnRegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
601 
603 
606  void SetShowAnnotation(bool val);
607  vtkSetMacro(UpdateAnnotation, bool);
609 
611 
614  void SetAnnotationColor(double r, double g, double b);
616 
620  virtual void SetGridAxes3DActor(vtkPVGridAxes3DActor*);
621 
622  //*****************************************************************
623  // Forwarded to orientation axes widget.
624  virtual void SetOrientationAxesInteractivity(bool);
625  virtual void SetOrientationAxesVisibility(bool);
626  void SetOrientationAxesLabelColor(double r, double g, double b);
627  void SetOrientationAxesOutlineColor(double r, double g, double b);
628 
629  //*****************************************************************
630  // Forwarded to center axes.
631  virtual void SetCenterAxesVisibility(bool);
632 
633  //*****************************************************************
634  // Forward to vtkPVInteractorStyle instances.
635  virtual void SetCenterOfRotation(double x, double y, double z);
636  virtual void SetRotationFactor(double factor);
637 
638  //*****************************************************************
639  // Forward to vtkLightKit.
640  void SetKeyLightWarmth(double val);
641  void SetKeyLightIntensity(double val);
642  void SetKeyLightElevation(double val);
643  void SetKeyLightAzimuth(double val);
644  void SetFillLightWarmth(double val);
645  void SetKeyToFillRatio(double val);
646  void SetFillLightElevation(double val);
647  void SetFillLightAzimuth(double val);
648  void SetBackLightWarmth(double val);
649  void SetKeyToBackRatio(double val);
650  void SetBackLightElevation(double val);
651  void SetBackLightAzimuth(double val);
652  void SetHeadLightWarmth(double val);
653  void SetKeyToHeadRatio(double val);
654  void SetMaintainLuminance(int val);
655 
656  //*****************************************************************
657  // Forward to 3D renderer.
658  vtkSetMacro(UseHiddenLineRemoval, bool) virtual void SetUseDepthPeeling(int val);
659  virtual void SetUseDepthPeelingForVolumes(bool val);
660  virtual void SetMaximumNumberOfPeels(int val);
661  virtual void SetBackground(double r, double g, double b);
662  virtual void SetBackground2(double r, double g, double b);
663  virtual void SetBackgroundTexture(vtkTexture* val);
664  virtual void SetGradientBackground(int val);
665  virtual void SetTexturedBackground(int val);
666  virtual void SetSkyboxBackground(int val);
667  virtual void SetUseEnvironmentLighting(bool val);
668 
669  //*****************************************************************
670  // Entry point for environmental backgrounds
671  virtual void SetEnvironmentalBG(double r, double g, double b);
672  virtual void SetEnvironmentalBG2(double r, double g, double b);
673  virtual void SetEnvironmentalBGTexture(vtkTexture* val);
674  virtual void SetGradientEnvironmentalBG(int val);
675  virtual void SetTexturedEnvironmentalBG(int val);
676  virtual void SetBackgroundMode(int val);
677 
678  //*****************************************************************
679  // Entry point for dynamic lights
680  void AddLight(vtkLight*);
681  void RemoveLight(vtkLight*);
682 
683  //*****************************************************************
684  // Forward to vtkRenderWindow.
685  void SetStereoCapableWindow(int val);
686  void SetStereoRender(int val);
687  vtkSetMacro(StereoType, int);
688  vtkSetMacro(ServerStereoType, int);
689  void SetMultiSamples(int val);
690  void SetAlphaBitPlanes(int val);
691  void SetStencilCapable(int val);
692 
693  //*****************************************************************
694  // Forward to vtkCamera.
695  void SetParallelProjection(int mode);
696 
697  //*****************************************************************
698  // Forwarded to vtkPVInteractorStyle if present on local processes.
699  virtual void SetCamera2DManipulators(const int manipulators[9]);
700  virtual void SetCamera3DManipulators(const int manipulators[9]);
701  void SetCameraManipulators(vtkPVInteractorStyle* style, const int manipulators[9]);
702  virtual void SetCamera2DMouseWheelMotionFactor(double factor);
703  virtual void SetCamera3DMouseWheelMotionFactor(double factor);
704 
712  void Update() override;
713 
717  virtual void UpdateLOD();
718 
720 
725  vtkGetMacro(UseLODForInteractiveRender, bool);
727 
729 
734  vtkGetMacro(UseDistributedRenderingForRender, bool);
736 
738 
743  vtkGetMacro(UseDistributedRenderingForLODRender, bool);
745 
747 
752  vtkGetMacro(StillRenderProcesses, vtkTypeUInt32);
754 
756 
761  vtkGetMacro(InteractiveRenderProcesses, vtkTypeUInt32);
763 
767  int GetDataDistributionMode(bool low_res);
768 
774  void Deliver(int use_lod, unsigned int size, unsigned int* representation_ids) override;
775 
784  bool GetUseOrderedCompositing();
785 
790  bool GetRenderEmptyImages();
791 
793 
796  vtkSetMacro(UseFXAA, bool);
797  vtkGetMacro(UseFXAA, bool);
799 
801 
804  void SetFXAARelativeContrastThreshold(double val);
805  void SetFXAAHardContrastThreshold(double val);
806  void SetFXAASubpixelBlendLimit(double val);
807  void SetFXAASubpixelContrastThreshold(double val);
808  void SetFXAAUseHighQualityEndpoints(bool val);
809  void SetFXAAEndpointSearchIterations(int val);
811 
816  {
817  Custom = 0,
818  Default = 1,
819  Uncharted2 = 2
820  };
821 
823 
826  void SetUseToneMapping(bool v);
827  vtkGetMacro(UseToneMapping, bool);
828  void SetToneMappingType(int);
829  void SetExposure(double);
830  void SetContrast(double);
831  void SetShoulder(double);
832  void SetMidIn(double);
833  void SetMidOut(double);
834  void SetHdrMax(double);
835  void SetUseACES(bool);
836  void SetGenericFilmicPresets(int t);
838 
840 
843  vtkSetMacro(UseSSAO, bool);
844  vtkGetMacro(UseSSAO, bool);
845  vtkSetMacro(UseSSAODefaultPresets, bool);
846  vtkSetMacro(Radius, double);
847  vtkSetMacro(KernelSize, int);
848  vtkSetMacro(Bias, double);
849  vtkSetMacro(Blur, bool);
851 
858  void CopyViewUpdateOptions(vtkPVRenderView* otherView);
859 
861 
864  void AddPropToRenderer(vtkProp* prop);
865  void RemovePropFromRenderer(vtkProp* prop);
867 
869 
874  void SetDrawCells(bool choice);
875  void SetArrayNameToDraw(const char* name);
876  void SetArrayNumberToDraw(int fieldAttributeType);
877  void SetArrayComponentToDraw(int comp);
878  void SetScalarRange(double min, double max);
879  void BeginValueCapture();
880  void EndValueCapture();
882 
884 
888  void SetValueRenderingModeCommand(int mode);
889  int GetValueRenderingModeCommand();
891 
893 
901  void CaptureValuesFloat();
902  vtkFloatArray* GetCapturedValuesFloat();
904 
906 
910  void StartCaptureLuminance();
911  void StopCaptureLuminance();
913 
915 
918  void CaptureZBuffer();
919  vtkFloatArray* GetCapturedZBuffer();
921 
923 
926  void SetEnableOSPRay(bool);
927  bool GetEnableOSPRay();
929 
930 
933  void SetShadows(bool);
934  bool GetShadows();
936 
937 
940  void SetAmbientOcclusionSamples(int);
941  int GetAmbientOcclusionSamples();
943 
944 
947  void SetRouletteDepth(int);
948  int GetRouletteDepth();
950 
951 
954  void SetVolumeAnisotropy(double);
955  double GetVolumeAnisotropy();
957 
958 
961  void SetSamplesPerPixel(int);
962  int GetSamplesPerPixel();
964 
965 
968  void SetMaxFrames(int);
969  int GetMaxFrames();
971 
974  bool GetOSPRayContinueStreaming();
976 
979  void SetDenoise(bool);
980  bool GetDenoise();
982 
984 
987  void SetLightScale(double);
988  double GetLightScale();
990 
994  void SetOSPRayRendererType(std::string);
996 
999  void SetBackgroundNorth(double x, double y, double z);
1000  void SetBackgroundEast(double x, double y, double z);
1002 
1005  virtual void SetMaterialLibrary(vtkPVMaterialLibrary*);
1006  void SetViewTime(double value) override;
1008 
1011  void SetTimeCacheSize(int);
1012  int GetTimeCacheSize();
1014 
1016 
1040  static vtkPVCameraCollection* GetDiscreteCameras(
1042  static void SetDiscreteCameras(
1045 
1046  // Get the RenderViewBase used by this
1047  vtkGetObjectMacro(RenderView, vtkRenderViewBase);
1048 
1052  void ScaleRendererViewports(const double viewport[4]) override;
1053 
1058  void SynchronizeMaximumIds(vtkIdType* maxPointId, vtkIdType* maxCellId);
1059 
1060 protected:
1061  vtkPVRenderView();
1062  ~vtkPVRenderView() override;
1063 
1067  virtual void Render(bool interactive, bool skip_rendering);
1068 
1073  virtual void AboutToRenderOnLocalProcess(bool interactive) { (void)interactive; }
1074 
1081  bool ShouldUseDistributedRendering(double geometry_size, bool using_lod);
1082 
1086  bool ShouldUseLODRendering(double geometry);
1087 
1092  bool IsProcessRenderingGeometriesForCompositing(bool using_distributed_rendering);
1093 
1098  void SynchronizeGeometryBounds();
1099 
1103  void SetLastSelection(vtkSelection*);
1104 
1109  virtual void UpdateCenterAxes();
1110 
1115  bool GetLocalProcessDoesRendering(bool using_distributed_rendering);
1116 
1121  bool TestCollaborationCounter();
1122 
1127  void SynchronizeForCollaboration();
1128 
1133  virtual void BuildAnnotationText(ostream& str);
1134 
1136 
1140  vtkGetMacro(SynchronizationCounter, unsigned int);
1142 
1144 
1147  vtkGetMacro(MakingSelection, bool);
1149 
1154  bool PrepareSelect(int fieldAssociation, const char* array = nullptr);
1155 
1159  void PostSelect(vtkSelection* sel, const char* array = nullptr);
1160 
1164  void UpdateSkybox();
1165 
1169  void ConfigureTexture(vtkTexture* texture);
1170 
1185  bool NeedSkybox = false;
1186 
1192 
1193  // this ivar can be used to suppress the render within
1194  // a StillRender or InteractiveRender. This is useful
1195  // in cases where you want the representations mappers
1196  // to be setup for rendering and have their data ready
1197  // but not actually do the render. For example if you
1198  // want to export the scene but not render it you must
1199  // turn on SuppressRendering and then call StillRender
1201 
1202  // 2D and 3D interactor style
1205 
1206  // Active interactor style either [TwoDInteractorStyle, ThreeDInteractorStyle]
1208 
1210 
1211  // Used in collaboration mode to ensure that views are in the same state
1212  // (as far as representations added/removed goes) before rendering.
1214 
1215  // In mega-bytes.
1219 
1223 
1224  bool UseFXAA;
1226 
1228 
1229  bool UseSSAO;
1231  double Radius;
1233  double Bias;
1234  bool Blur;
1235 
1238 
1244 
1245  vtkTypeUInt32 StillRenderProcesses;
1247 
1253 
1255 
1256 private:
1257  vtkPVRenderView(const vtkPVRenderView&) = delete;
1258  void operator=(const vtkPVRenderView&) = delete;
1259 
1260  bool MakingSelection;
1261  int PreviousSwapBuffers;
1262  void OnSelectionChangedEvent();
1263  void OnPolygonSelectionEvent();
1264  void FinishSelection(vtkSelection*, const char*);
1265 
1266  // This flag is set to false when not all processes cannot render e.g. cannot
1267  // open the DISPLAY etc.
1268  bool RemoteRenderingAvailable;
1269 
1270  // Flags used to maintain rendering modes requested by representations.
1271  bool DistributedRenderingRequired;
1272  bool NonDistributedRenderingRequired;
1273  bool DistributedRenderingRequiredLOD;
1274  bool NonDistributedRenderingRequiredLOD;
1275 
1276  // Cached value for parallel projection set on camera.
1277  int ParallelProjection;
1278 
1279  // Cached state. Is currently ignored for distributed rendering.
1280  bool UseHiddenLineRemoval;
1281 
1282  class vtkInternals;
1283  vtkInternals* Internals;
1284 
1285  vtkNew<vtkTextRepresentation> Annotation;
1286  void UpdateAnnotationText();
1287 
1288  vtkNew<vtkOrderedCompositingHelper> OrderedCompositingHelper;
1289 
1290  int StereoType;
1291  int ServerStereoType;
1292  void UpdateStereoProperties();
1293 
1295  vtkNew<vtkTimerLog> Timer;
1296 
1297  int ForceDataDistributionMode;
1298  int PreviousDiscreteCameraIndex;
1299 };
1300 
1301 #endif
vtkPVHardwareSelector * Selector
static void SetRequiresDistributedRenderingLOD(vtkInformation *info, vtkPVDataRepresentation *repr, bool value)
Some representation only work when remote rendering or local rendering.
vtkPVInteractorStyle * InteractorStyle
style
coordinates rendering between corresponding renderers across multiple processes
static vtkView * New()
vtkPVInteractorStyle * TwoDInteractorStyle
vtkSelection * LastSelection
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.
#define VTK_LEGACY(method)
Definition: vtkLegacy.h:52
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.
size
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.
value
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.
spacing
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