vtkPVRenderView.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
2 // SPDX-License-Identifier: BSD-3-Clause
15 #ifndef vtkPVRenderView_h
16 #define vtkPVRenderView_h
17 
18 #include "vtkBoundingBox.h" // needed for iVar
19 #include "vtkNew.h" // needed for iVar
20 #include "vtkPVView.h"
21 #include "vtkRemotingViewsModule.h" //needed for exports
22 #include "vtkSmartPointer.h" // needed for iVar
23 #include "vtkWeakPointer.h" // needed for iVar
24 
25 class vtkAlgorithmOutput;
26 class vtkCamera;
27 class vtkCameraOrientationWidget;
28 class vtkCuller;
30 class vtkFloatArray;
31 class vtkFXAAOptions;
39 class vtkLight;
40 class vtkLightKit;
41 class vtkMatrix4x4;
43 class vtkProp;
44 class vtkPVAxesWidget;
53 class vtkRenderer;
54 class vtkRenderViewBase;
55 class vtkRenderWindow;
57 class vtkSkybox;
59 class vtkTexture;
60 class vtkTimerLog;
62 
64 {
65  //*****************************************************************
66 public:
67  static vtkPVRenderView* New();
68  vtkTypeMacro(vtkPVRenderView, vtkPVView);
69  void PrintSelf(ostream& os, vtkIndent indent) override;
70 
72  {
73  INTERACTION_MODE_UNINTIALIZED = -1,
74  INTERACTION_MODE_3D = 0,
75  INTERACTION_MODE_2D, // not implemented yet.
78  INTERACTION_MODE_POLYGON
79  };
80 
82 
93  virtual void SetInteractionMode(int mode);
94  vtkGetMacro(InteractionMode, int);
96 
98 
102  void SetSize(int, int) override;
103  void SetPosition(int, int) override;
105 
107 
112  vtkGetObjectMacro(NonCompositedRenderer, vtkRenderer);
114 
118  enum
119  {
120  DEFAULT_RENDERER = 0,
121  NON_COMPOSITED_RENDERER = 1,
122  };
123 
129  virtual vtkRenderer* GetRenderer(int rendererType = DEFAULT_RENDERER);
130 
132 
136  vtkCamera* GetActiveCamera();
137  virtual void SetActiveCamera(vtkCamera*);
139 
143  vtkRenderWindowInteractor* GetInteractor();
144 
150  virtual void SetupInteractor(vtkRenderWindowInteractor*);
151 
153 
156  vtkGetObjectMacro(InteractorStyle, vtkPVInteractorStyle);
158 
160 
166  void ResetCamera();
167  void ResetCamera(double bounds[6]);
168  void ResetCameraScreenSpace(double offsetRatio = 0.9);
169  void ResetCameraScreenSpace(double* bounds, double offsetRatio = 0.9);
170  // void ResetCameraScreenSpace(double offsetRatio, double bounds[6]);
172 
174 
180  double* ComputeVisibleBounds(vtkPVDataRepresentation* pvrepr) VTK_SIZEHINT(6);
181  double LastRepresentationVisibleBounds[6];
183 
189  void StillRender() override;
190 
197  void InteractiveRender() override;
198 
200 
208  vtkSetMacro(SuppressRendering, bool);
209  vtkGetMacro(SuppressRendering, bool);
210  vtkBooleanMacro(SuppressRendering, bool);
212 
214 
222  vtkSetClampMacro(StillRenderImageReductionFactor, int, 1, 20);
223  vtkGetMacro(StillRenderImageReductionFactor, int);
225 
227 
233  vtkSetClampMacro(InteractiveRenderImageReductionFactor, int, 1, 20);
234  vtkGetMacro(InteractiveRenderImageReductionFactor, int);
236 
238 
243  vtkSetMacro(RemoteRenderingThreshold, double);
244  vtkGetMacro(RemoteRenderingThreshold, double);
246 
248 
253  vtkSetMacro(LODRenderingThreshold, double);
254  vtkGetMacro(LODRenderingThreshold, double);
256 
258 
264  vtkSetClampMacro(LODResolution, double, 0.0, 1.0);
265  vtkGetMacro(LODResolution, double);
267 
269 
275  vtkSetMacro(UseOutlineForLODRendering, bool);
276  vtkGetMacro(UseOutlineForLODRendering, bool);
278 
287  void ConfigureCompressor(const char* configuration);
288 
293  virtual void ResetCameraClippingRange();
294 
296 
300  void SetUseLightKit(bool enable);
301  vtkGetMacro(UseLightKit, bool);
302  vtkBooleanMacro(UseLightKit, bool);
304 
306  void StreamingUpdate(const double view_planes[24]);
307  void DeliverStreamedPieces(unsigned int size, unsigned int* representation_ids);
309 
313  static vtkInformationIntegerKey* USE_LOD();
314 
318  static vtkInformationDoubleKey* LOD_RESOLUTION();
319 
324  static vtkInformationIntegerKey* USE_OUTLINE_FOR_LOD();
325 
332  static vtkInformationIntegerKey* RENDER_EMPTY_IMAGES();
333 
338  static vtkInformationIntegerKey* NEED_ORDERED_COMPOSITING();
339 
344  static vtkInformationDoubleVectorKey* VIEW_PLANES();
345 
349  static vtkInformationRequestKey* REQUEST_STREAMING_UPDATE();
350 
354  static vtkInformationRequestKey* REQUEST_PROCESS_STREAMED_PIECE();
355 
357 
364  void SelectCells(int region[4], const char* array = nullptr);
365  void SelectCells(int region0, int region1, int region2, int region3, const char* array = nullptr)
366  {
367  int r[4] = { region0, region1, region2, region3 };
368  this->SelectCells(r, array);
369  }
370  void SelectPoints(int region[4], const char* array = nullptr);
371  void SelectPoints(int region0, int region1, int region2, int region3, const char* array = nullptr)
372  {
373  int r[4] = { region0, region1, region2, region3 };
374  this->SelectPoints(r, array);
375  }
376  void Select(int field_association, int region[4], const char* array = nullptr);
378 
380 
390  void SelectPolygonPoints(int* polygon2DArray, vtkIdType arrayLen);
391  void SelectPolygonCells(int* polygon2DArray, vtkIdType arrayLen);
392  void SelectPolygon(int field_association, int* polygon2DArray, vtkIdType arrayLen);
394 
396 
400  vtkGetObjectMacro(LastSelection, vtkSelection);
402 
404 
408  vtkSetMacro(UseInteractiveRenderingForScreenshots, bool);
409  vtkBooleanMacro(UseInteractiveRenderingForScreenshots, bool);
410  vtkGetMacro(UseInteractiveRenderingForScreenshots, bool);
412 
414 
417  vtkGetMacro(RemoteRenderingAvailable, bool);
418  void RemoteRenderingAvailableOff() { this->RemoteRenderingAvailable = false; }
420 
422 
425  void NVPipeAvailableOn();
426  void NVPipeAvailableOff();
428 
430 
433  vtkGetMacro(UsedLODForLastRender, bool);
435 
441  void InvalidateCachedSelection();
442 
444 
449  static vtkAlgorithmOutput* GetPieceProducer(
451  static vtkAlgorithmOutput* GetPieceProducerLOD(
452  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
453  static void SetRedistributionMode(
454  vtkInformation* info, vtkPVDataRepresentation* repr, int mode, int port = 0);
455  static void SetRedistributionModeToSplitBoundaryCells(
456  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
457  static void SetRedistributionModeToDuplicateBoundaryCells(
458  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
459  static void SetRedistributionModeToUniquelyAssignBoundaryCells(
460  vtkInformation* info, vtkPVDataRepresentation* repr, int port = 0);
461  static void SetGeometryBounds(vtkInformation* info, vtkPVDataRepresentation* repr,
462  const double bounds[6], vtkMatrix4x4* transform = nullptr, int port = 0);
463  static void SetStreamable(vtkInformation* info, vtkPVDataRepresentation* repr, bool streamable);
464  static void SetNextStreamedPiece(
466  static vtkDataObject* GetCurrentStreamedPiece(
469 
471 
498  enum
499  {
500  USE_BOUNDS_FOR_REDISTRIBUTION = 0x01,
501  DATA_IS_REDISTRIBUTABLE = 0x02,
502  USE_DATA_FOR_LOAD_BALANCING = 0x40,
503  };
504  static void SetOrderedCompositingConfiguration(vtkInformation* info,
505  vtkPVDataRepresentation* repr, int config, const double* bounds = nullptr, int port = 0);
507 
512  void SetMaxClipBounds(double bds[6]);
513 
515 
519  void SetLockBounds(bool nv);
520  vtkGetMacro(LockBounds, bool);
522 
528  static void SetDeliverToAllProcesses(
529  vtkInformation* info, vtkPVDataRepresentation* repr, bool clone);
530 
540  static void SetDeliverToClientAndRenderingProcesses(vtkInformation* info,
541  vtkPVDataRepresentation* repr, bool deliver_to_client, bool gather_before_delivery,
542  int port = 0);
543 
545 
553  static void SetRequiresDistributedRendering(
554  vtkInformation* info, vtkPVDataRepresentation* repr, bool value, bool for_lod = false);
556  vtkInformation* info, vtkPVDataRepresentation* repr, bool value)
557  {
558  vtkPVRenderView::SetRequiresDistributedRendering(info, repr, value, true);
559  }
561 
563 
575  static void SetForceDataDistributionMode(vtkInformation* info, int flag);
576  bool IsForceDataDistributionModeSet() const { return this->ForceDataDistributionMode != -1; }
577  int GetForceDataDistributionMode() const { return this->ForceDataDistributionMode; }
579 
581 
586  int RegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
587  void UnRegisterPropForHardwareSelection(vtkPVDataRepresentation* repr, vtkProp* prop);
589 
591 
594  void SetShowAnnotation(bool val);
595  vtkSetMacro(UpdateAnnotation, bool);
597 
599 
602  void SetAnnotationColor(double r, double g, double b);
604 
608  virtual void SetGridAxes3DActor(vtkPVGridAxes3DActor*);
609 
613  virtual void SetLegendGridActor(vtkLegendScaleActor*);
614 
616 
619  virtual void SetOrientationAxesInteractivity(bool);
620  virtual void SetOrientationAxesVisibility(bool);
621 
622  void SetOrientationAxesLabelColor(double r, double g, double b);
623  void SetOrientationAxesOutlineColor(double r, double g, double b);
624 
625  void SetOrientationAxesXColor(double r, double g, double b);
626  void SetOrientationAxesYColor(double r, double g, double b);
627  void SetOrientationAxesZColor(double r, double g, double b);
628 
629  void SetOrientationAxesXVisibility(bool vis);
630  void SetOrientationAxesYVisibility(bool vis);
631  void SetOrientationAxesZVisibility(bool vis);
632 
633  void SetOrientationAxesXLabelText(const char* text);
634  void SetOrientationAxesYLabelText(const char* text);
635  void SetOrientationAxesZLabelText(const char* text);
637 
639 
642  void SetCameraOrientationWidgetVisibility(bool visible);
643  void SetCameraOrientationWidgetSize(int size);
644  void SetCameraOrientationWidgetPadding(int padding[2]);
645  void SetCameraOrientationWidgetAnchor(int anchor);
647 
651  virtual void SetCenterAxesVisibility(bool);
652 
654 
657  virtual void SetCenterOfRotation(double x, double y, double z);
658  virtual void SetRotationFactor(double factor);
660 
662 
665  void SetKeyLightWarmth(double val);
666  void SetKeyLightIntensity(double val);
667  void SetKeyLightElevation(double val);
668  void SetKeyLightAzimuth(double val);
669  void SetFillLightWarmth(double val);
670  void SetKeyToFillRatio(double val);
671  void SetFillLightElevation(double val);
672  void SetFillLightAzimuth(double val);
673  void SetBackLightWarmth(double val);
674  void SetKeyToBackRatio(double val);
675  void SetBackLightElevation(double val);
676  void SetBackLightAzimuth(double val);
677  void SetHeadLightWarmth(double val);
678  void SetKeyToHeadRatio(double val);
679  void SetMaintainLuminance(int val);
681 
683 
686  vtkSetMacro(UseHiddenLineRemoval, bool);
687  virtual void SetUseDepthPeeling(int val);
688  virtual void SetUseDepthPeelingForVolumes(bool val);
689  virtual void SetMaximumNumberOfPeels(int val);
690  virtual void SetBackgroundTexture(vtkTexture* val);
692 
694 
698  vtkSetMacro(UseRenderViewSettingsForBackground, bool);
699  vtkGetMacro(UseRenderViewSettingsForBackground, bool);
701 
703  {
709  };
710 
712 
717  vtkSetClampMacro(BackgroundColorMode, int, DEFAULT, STEREO_SKYBOX);
718  vtkSetVector3Macro(Background, double);
719  vtkGetVector3Macro(Background, double);
720  vtkSetVector3Macro(Background2, double);
721  vtkGetVector3Macro(Background2, double);
722  vtkSetMacro(UseEnvironmentLighting, bool);
724 
726 
729  virtual void SetEnvironmentalBG(double r, double g, double b);
730  virtual void SetEnvironmentalBG2(double r, double g, double b);
731  virtual void SetEnvironmentalBGTexture(vtkTexture* val);
732  virtual void SetGradientEnvironmentalBG(int val);
733  virtual void SetTexturedEnvironmentalBG(int val);
734  virtual void SetBackgroundMode(int val);
736 
738 
741  void AddLight(vtkLight*);
742  void RemoveLight(vtkLight*);
744 
746 
749  void SetStereoCapableWindow(int val);
750  void SetStereoRender(int val);
751  vtkSetMacro(StereoType, int);
752  vtkSetMacro(ServerStereoType, int);
753  void SetMultiSamples(int val);
754  void SetAlphaBitPlanes(int val);
755  void SetStencilCapable(int val);
757 
761  void SetParallelProjection(int mode);
762 
764 
767  virtual void SetCamera2DManipulators(const int manipulators[9]);
768  virtual void SetCamera3DManipulators(const int manipulators[9]);
769  void SetCameraManipulators(vtkPVInteractorStyle* style, const int manipulators[9]);
770  virtual void SetReverseMouseWheelZoomDirection(bool reverse);
771  virtual void SetMouseWheelZoomsToCursor(bool value);
772  virtual void SetCamera2DMouseWheelMotionFactor(double factor);
773  virtual void SetCamera3DMouseWheelMotionFactor(double factor);
775 
781  virtual void SynchronizeGeometryBounds();
782 
790  void Update() override;
791 
795  virtual void UpdateLOD();
796 
798 
803  vtkGetMacro(UseLODForInteractiveRender, bool);
805 
807 
812  vtkGetMacro(UseDistributedRenderingForRender, bool);
814 
816 
821  vtkGetMacro(UseDistributedRenderingForLODRender, bool);
823 
825 
830  vtkGetMacro(StillRenderProcesses, vtkTypeUInt32);
832 
834 
839  vtkGetMacro(InteractiveRenderProcesses, vtkTypeUInt32);
841 
845  int GetDataDistributionMode(bool low_res);
846 
852  void Deliver(int use_lod, unsigned int size, unsigned int* representation_ids) override;
853 
862  bool GetUseOrderedCompositing();
863 
868  bool GetRenderEmptyImages();
869 
871 
874  vtkSetMacro(UseFXAA, bool);
875  vtkGetMacro(UseFXAA, bool);
877 
879 
882  void SetFXAARelativeContrastThreshold(double val);
883  void SetFXAAHardContrastThreshold(double val);
884  void SetFXAASubpixelBlendLimit(double val);
885  void SetFXAASubpixelContrastThreshold(double val);
886  void SetFXAAUseHighQualityEndpoints(bool val);
887  void SetFXAAEndpointSearchIterations(int val);
889 
894  {
895  Custom = 0,
896  Default = 1,
897  Uncharted2 = 2
898  };
899 
901 
904  void SetUseToneMapping(bool v);
905  vtkGetMacro(UseToneMapping, bool);
906  void SetToneMappingType(int);
907  void SetExposure(double);
908  void SetContrast(double);
909  void SetShoulder(double);
910  void SetMidIn(double);
911  void SetMidOut(double);
912  void SetHdrMax(double);
913  void SetUseACES(bool);
914  void SetGenericFilmicPresets(int t);
916 
918 
921  vtkSetMacro(UseSSAO, bool);
922  vtkGetMacro(UseSSAO, bool);
923  vtkSetMacro(UseSSAODefaultPresets, bool);
924  vtkSetMacro(Radius, double);
925  vtkSetMacro(KernelSize, int);
926  vtkSetMacro(Bias, double);
927  vtkSetMacro(Blur, bool);
929 
936  void CopyViewUpdateOptions(vtkPVRenderView* otherView);
937 
939 
942  void AddPropToRenderer(vtkProp* prop);
943  void RemovePropFromRenderer(vtkProp* prop);
945 
947 
961  bool BeginValuePassForRendering(int fieldAssociation, const char* arrayName, int component);
962  void EndValuePassForRendering();
963  vtkSmartPointer<vtkFloatArray> GrabValuePassResult();
965 
967 
970  void CaptureZBuffer();
971  vtkFloatArray* GetCapturedZBuffer();
973 
975 
978  void SetEnableOSPRay(bool);
979  bool GetEnableOSPRay();
982 
985  void SetShadows(bool);
986  bool GetShadows();
989 
992  void SetAmbientOcclusionSamples(int);
993  int GetAmbientOcclusionSamples();
996 
999  void SetRouletteDepth(int);
1000  int GetRouletteDepth();
1002 
1004 
1007  void SetSamplesPerPixel(int);
1008  int GetSamplesPerPixel();
1011 
1014  void SetMaxFrames(int);
1015  int GetMaxFrames();
1017 
1020  bool GetOSPRayContinueStreaming();
1022 
1025  void SetDenoise(bool);
1026  bool GetDenoise();
1028 
1030 
1033  void SetLightScale(double);
1034  double GetLightScale();
1036 
1040  void SetOSPRayRendererType(std::string);
1042 
1045  void SetBackgroundNorth(double x, double y, double z);
1046  void SetBackgroundEast(double x, double y, double z);
1048 
1051  virtual void SetMaterialLibrary(vtkPVMaterialLibrary*);
1052  void SetViewTime(double value) override;
1054 
1057  void SetTimeCacheSize(int);
1058  int GetTimeCacheSize();
1060 
1062 
1086  static vtkPVCameraCollection* GetDiscreteCameras(
1088  static void SetDiscreteCameras(
1091 
1092  // Get the RenderViewBase used by this
1093  vtkGetObjectMacro(RenderView, vtkRenderViewBase);
1094 
1098  void ScaleRendererViewports(const double viewport[4]) override;
1099 
1104  void SynchronizeMaximumIds(vtkIdType* maxPointId, vtkIdType* maxCellId);
1105 
1109  void SetHardwareSelector(vtkPVHardwareSelector* selector);
1110 
1111 protected:
1112  vtkPVRenderView();
1113  ~vtkPVRenderView() override;
1114 
1118  virtual void Render(bool interactive, bool skip_rendering);
1119 
1124  virtual void AboutToRenderOnLocalProcess(bool interactive) { (void)interactive; }
1125 
1132  bool ShouldUseDistributedRendering(double geometry_size, bool using_lod);
1133 
1137  bool ShouldUseLODRendering(double geometry);
1138 
1143  bool IsProcessRenderingGeometriesForCompositing(bool using_distributed_rendering);
1144 
1148  void SetLastSelection(vtkSelection*);
1149 
1154  virtual void UpdateCenterAxes();
1155 
1160  bool GetLocalProcessDoesRendering(bool using_distributed_rendering);
1161 
1166  bool TestCollaborationCounter();
1167 
1172  void SynchronizeForCollaboration();
1173 
1178  virtual void BuildAnnotationText(ostream& str);
1179 
1181 
1185  vtkGetMacro(SynchronizationCounter, unsigned int);
1187 
1189 
1192  vtkGetMacro(MakingSelection, bool);
1194 
1199  virtual bool PrepareSelect(int fieldAssociation, const char* array = nullptr);
1200 
1204  virtual void PostSelect(vtkSelection* sel, const char* array = nullptr);
1205 
1210  virtual void UpdateBackground(vtkRenderer* renderer = nullptr);
1211 
1215  void ConfigureTexture(vtkTexture* texture);
1216 
1222  virtual void SetupAndSetRenderer(vtkRenderer* ren);
1223 
1240 
1246 
1247  // this ivar can be used to suppress the render within
1248  // a StillRender or InteractiveRender. This is useful
1249  // in cases where you want the representations mappers
1250  // to be setup for rendering and have their data ready
1251  // but not actually do the render. For example if you
1252  // want to export the scene but not render it you must
1253  // turn on SuppressRendering and then call StillRender
1255 
1256  // 2D and 3D interactor style
1259 
1260  bool ReverseMouseWheelZoomDirection = false;
1261 
1262  // Active interactor style either [TwoDInteractorStyle, ThreeDInteractorStyle]
1264 
1266 
1267  // Used in collaboration mode to ensure that views are in the same state
1268  // (as far as representations added/removed goes) before rendering.
1270 
1271  // In mega-bytes.
1275 
1279 
1280  bool UseFXAA;
1282 
1284 
1285  bool UseSSAO;
1287  double Radius;
1289  double Bias;
1290  bool Blur;
1291 
1294 
1300 
1301  vtkTypeUInt32 StillRenderProcesses;
1303 
1309 
1311 
1312 private:
1313  vtkPVRenderView(const vtkPVRenderView&) = delete;
1314  void operator=(const vtkPVRenderView&) = delete;
1315 
1316  bool MakingSelection;
1317  int PreviousSwapBuffers;
1318  void OnSelectionChangedEvent();
1319  void OnPolygonSelectionEvent();
1320  void FinishSelection(vtkSelection*, const char*);
1321 
1322  // This flag is set to false when not all processes cannot render e.g. cannot
1323  // open the DISPLAY etc.
1324  bool RemoteRenderingAvailable;
1325 
1326  // Flags used to maintain rendering modes requested by representations.
1327  bool DistributedRenderingRequired;
1328  bool NonDistributedRenderingRequired;
1329  bool DistributedRenderingRequiredLOD;
1330  bool NonDistributedRenderingRequiredLOD;
1331 
1332  // Cached value for parallel projection set on camera.
1333  int ParallelProjection;
1334 
1335  // Cached state. Is currently ignored for distributed rendering.
1336  bool UseHiddenLineRemoval;
1337 
1338  class vtkInternals;
1339  vtkInternals* Internals;
1340 
1341  vtkNew<vtkTextRepresentation> Annotation;
1342  void UpdateAnnotationText();
1343 
1344  vtkNew<vtkOrderedCompositingHelper> OrderedCompositingHelper;
1345 
1346  int StereoType;
1347  int ServerStereoType;
1348  void UpdateStereoProperties();
1349 
1350  int BackgroundColorMode;
1351  bool UseEnvironmentLighting;
1352  bool UseRenderViewSettingsForBackground;
1353  double Background[3];
1354  double Background2[3];
1355 
1357  vtkNew<vtkTimerLog> Timer;
1358 
1359  int ForceDataDistributionMode;
1360  int PreviousDiscreteCameraIndex;
1361  vtkSmartPointer<vtkTexture> EnvironmentalBGTexture;
1362  bool UseTexturedEnvironmentalBG;
1363 };
1364 
1365 #endif
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
vtkSmartPointer< vtkPVHardwareSelector > Selector
#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:32
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.
vtkSmartPointer< vtkLegendScaleActor > LegendGridActor
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
vtkNew< vtkCameraOrientationWidget > CameraOrientationWidget
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.
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